modules/rostests/winetests/crypt32/msg.c

   1 /*
   2  * Unit test suite for crypt32.dll's CryptMsg functions
   3  *
   4  * Copyright 2007 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 "precomp.h"
  22
  23 static BOOL have_nt = TRUE;
  24 static BOOL old_crypt32 = FALSE;
  25 static char oid_rsa_md5[] = szOID_RSA_MD5;
  26
  27 static BOOL (WINAPI * pCryptAcquireContextA)
  28                         (HCRYPTPROV *, LPCSTR, LPCSTR, DWORD, DWORD);
  29 static BOOL (WINAPI * pCryptAcquireContextW)
  30                         (HCRYPTPROV *, LPCWSTR, LPCWSTR, DWORD, DWORD);
  31
  32 static void init_function_pointers(void)
  33 {
  34     HMODULE hAdvapi32 = GetModuleHandleA("advapi32.dll");
  35
  36 #define GET_PROC(dll, func) \
  37     p ## func = (void *)GetProcAddress(dll, #func); \
  38     if(!p ## func) \
  39       trace("GetProcAddress(%s) failed\n", #func);
  40
  41     GET_PROC(hAdvapi32, CryptAcquireContextA)
  42     GET_PROC(hAdvapi32, CryptAcquireContextW)
  43
  44 #undef GET_PROC
  45 }
  46
  47 static void test_msg_open_to_encode(void)
  48 {
  49     HCRYPTMSG msg;
  50
  51     /* Crash
  52     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_ENVELOPED, NULL,
  53      NULL, NULL);
  54     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_HASHED, NULL, NULL,
  55      NULL);
  56     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_SIGNED, NULL, NULL,
  57      NULL);
  58      */
  59
  60     /* Bad encodings */
  61     SetLastError(0xdeadbeef);
  62     msg = CryptMsgOpenToEncode(0, 0, 0, NULL, NULL, NULL);
  63     ok(!msg && GetLastError() == E_INVALIDARG,
  64      "Expected E_INVALIDARG, got %x\n", GetLastError());
  65     SetLastError(0xdeadbeef);
  66     msg = CryptMsgOpenToEncode(X509_ASN_ENCODING, 0, 0, NULL, NULL, NULL);
  67     ok(!msg && GetLastError() == E_INVALIDARG,
  68      "Expected E_INVALIDARG, got %x\n", GetLastError());
  69
  70     /* Bad message types */
  71     SetLastError(0xdeadbeef);
  72     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, 0, NULL, NULL, NULL);
  73     ok(!msg && GetLastError() == CRYPT_E_INVALID_MSG_TYPE,
  74      "Expected CRYPT_E_INVALID_MSG_TYPE, got %x\n", GetLastError());
  75     SetLastError(0xdeadbeef);
  76     msg = CryptMsgOpenToEncode(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, 0, 0,
  77      NULL, NULL, NULL);
  78     ok(!msg && GetLastError() == CRYPT_E_INVALID_MSG_TYPE,
  79      "Expected CRYPT_E_INVALID_MSG_TYPE, got %x\n", GetLastError());
  80     SetLastError(0xdeadbeef);
  81     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0,
  82      CMSG_SIGNED_AND_ENVELOPED, NULL, NULL, NULL);
  83     ok(!msg && GetLastError() == CRYPT_E_INVALID_MSG_TYPE,
  84      "Expected CRYPT_E_INVALID_MSG_TYPE, got %x\n", GetLastError());
  85     SetLastError(0xdeadbeef);
  86     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_ENCRYPTED, NULL,
  87      NULL, NULL);
  88     ok(!msg && GetLastError() == CRYPT_E_INVALID_MSG_TYPE,
  89      "Expected CRYPT_E_INVALID_MSG_TYPE, got %x\n", GetLastError());
  90 }
  91
  92 static void test_msg_open_to_decode(void)
  93 {
  94     HCRYPTMSG msg;
  95     CMSG_STREAM_INFO streamInfo = { 0 };
  96
  97     SetLastError(0xdeadbeef);
  98     msg = CryptMsgOpenToDecode(0, 0, 0, 0, NULL, NULL);
  99     ok(!msg && GetLastError() == E_INVALIDARG,
 100      "Expected E_INVALIDARG, got %x\n", GetLastError());
 101
 102     /* Bad encodings */
 103     SetLastError(0xdeadbeef);
 104     msg = CryptMsgOpenToDecode(X509_ASN_ENCODING, 0, 0, 0, NULL, NULL);
 105     ok(!msg && GetLastError() == E_INVALIDARG,
 106      "Expected E_INVALIDARG, got %x\n", GetLastError());
 107     SetLastError(0xdeadbeef);
 108     msg = CryptMsgOpenToDecode(X509_ASN_ENCODING, 0, CMSG_DATA, 0, NULL, NULL);
 109     ok(!msg && GetLastError() == E_INVALIDARG,
 110      "Expected E_INVALIDARG, got %x\n", GetLastError());
 111
 112     /* The message type can be explicit... */
 113     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, CMSG_DATA, 0, NULL,
 114      NULL);
 115     ok(msg != NULL, "CryptMsgOpenToDecode failed: %x\n", GetLastError());
 116     CryptMsgClose(msg);
 117     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, CMSG_ENVELOPED, 0, NULL,
 118      NULL);
 119     ok(msg != NULL, "CryptMsgOpenToDecode failed: %x\n", GetLastError());
 120     CryptMsgClose(msg);
 121     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, CMSG_HASHED, 0, NULL,
 122      NULL);
 123     ok(msg != NULL, "CryptMsgOpenToDecode failed: %x\n", GetLastError());
 124     CryptMsgClose(msg);
 125     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, CMSG_SIGNED, 0, NULL,
 126      NULL);
 127     ok(msg != NULL, "CryptMsgOpenToDecode failed: %x\n", GetLastError());
 128     CryptMsgClose(msg);
 129     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0,
 130      CMSG_SIGNED_AND_ENVELOPED, 0, NULL, NULL);
 131     ok(msg != NULL, "CryptMsgOpenToDecode failed: %x\n", GetLastError());
 132     CryptMsgClose(msg);
 133     /* or implicit.. */
 134     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, NULL);
 135     ok(msg != NULL, "CryptMsgOpenToDecode failed: %x\n", GetLastError());
 136     CryptMsgClose(msg);
 137     /* or even invalid. */
 138     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, CMSG_ENCRYPTED, 0, NULL,
 139      NULL);
 140     ok(msg != NULL, "CryptMsgOpenToDecode failed: %x\n", GetLastError());
 141     CryptMsgClose(msg);
 142     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 1000, 0, NULL, NULL);
 143     ok(msg != NULL, "CryptMsgOpenToDecode failed: %x\n", GetLastError());
 144     CryptMsgClose(msg);
 145
 146     /* And even though the stream info parameter "must be set to NULL" for
 147      * CMSG_HASHED, it's still accepted.
 148      */
 149     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, CMSG_HASHED, 0, NULL,
 150      &streamInfo);
 151     ok(msg != NULL, "CryptMsgOpenToDecode failed: %x\n", GetLastError());
 152     CryptMsgClose(msg);
 153 }
 154
 155 static void test_msg_get_param(void)
 156 {
 157     BOOL ret;
 158     HCRYPTMSG msg;
 159     DWORD size, i, value;
 160
 161     /* Crash
 162     ret = CryptMsgGetParam(NULL, 0, 0, NULL, NULL);
 163     ret = CryptMsgGetParam(NULL, 0, 0, NULL, &size);
 164     ret = CryptMsgGetParam(msg, 0, 0, NULL, NULL);
 165      */
 166
 167     /* Decoded messages */
 168     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, NULL);
 169     ok(msg != NULL, "CryptMsgOpenToDecode failed: %x\n", GetLastError());
 170     /* For decoded messages, the type is always available */
 171     size = 0;
 172     ret = CryptMsgGetParam(msg, CMSG_TYPE_PARAM, 0, NULL, &size);
 173     ok(ret, "CryptMsgGetParam failed: %x\n", GetLastError());
 174     size = sizeof(value);
 175     ret = CryptMsgGetParam(msg, CMSG_TYPE_PARAM, 0, &value, &size);
 176     ok(ret, "CryptMsgGetParam failed: %x\n", GetLastError());
 177     /* For this (empty) message, the type isn't set */
 178     ok(value == 0, "Expected type 0, got %d\n", value);
 179     CryptMsgClose(msg);
 180
 181     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, CMSG_DATA, 0, NULL,
 182      NULL);
 183     ok(msg != NULL, "CryptMsgOpenToDecode failed: %x\n", GetLastError());
 184     /* For explicitly typed messages, the type is known. */
 185     size = sizeof(value);
 186     ret = CryptMsgGetParam(msg, CMSG_TYPE_PARAM, 0, &value, &size);
 187     ok(ret, "CryptMsgGetParam failed: %x\n", GetLastError());
 188     ok(value == CMSG_DATA, "Expected CMSG_DATA, got %d\n", value);
 189     for (i = CMSG_CONTENT_PARAM; !old_crypt32 && (i <= CMSG_CMS_SIGNER_INFO_PARAM); i++)
 190     {
 191         size = 0;
 192         ret = CryptMsgGetParam(msg, i, 0, NULL, &size);
 193         ok(!ret, "Parameter %d: expected failure\n", i);
 194     }
 195     CryptMsgClose(msg);
 196
 197     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, CMSG_ENVELOPED, 0, NULL,
 198      NULL);
 199     ok(msg != NULL, "CryptMsgOpenToDecode failed: %x\n", GetLastError());
 200     size = sizeof(value);
 201     ret = CryptMsgGetParam(msg, CMSG_TYPE_PARAM, 0, &value, &size);
 202     ok(ret, "CryptMsgGetParam failed: %x\n", GetLastError());
 203     ok(value == CMSG_ENVELOPED, "Expected CMSG_ENVELOPED, got %d\n", value);
 204     for (i = CMSG_CONTENT_PARAM; !old_crypt32 && (i <= CMSG_CMS_SIGNER_INFO_PARAM); i++)
 205     {
 206         size = 0;
 207         ret = CryptMsgGetParam(msg, i, 0, NULL, &size);
 208         ok(!ret, "Parameter %d: expected failure\n", i);
 209     }
 210     CryptMsgClose(msg);
 211
 212     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, CMSG_HASHED, 0, NULL,
 213      NULL);
 214     ok(msg != NULL, "CryptMsgOpenToDecode failed: %x\n", GetLastError());
 215     size = sizeof(value);
 216     ret = CryptMsgGetParam(msg, CMSG_TYPE_PARAM, 0, &value, &size);
 217     ok(ret, "CryptMsgGetParam failed: %x\n", GetLastError());
 218     ok(value == CMSG_HASHED, "Expected CMSG_HASHED, got %d\n", value);
 219     for (i = CMSG_CONTENT_PARAM; !old_crypt32 && (i <= CMSG_CMS_SIGNER_INFO_PARAM); i++)
 220     {
 221         size = 0;
 222         ret = CryptMsgGetParam(msg, i, 0, NULL, &size);
 223         ok(!ret, "Parameter %d: expected failure\n", i);
 224     }
 225     CryptMsgClose(msg);
 226
 227     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, CMSG_SIGNED, 0, NULL,
 228      NULL);
 229     ok(msg != NULL, "CryptMsgOpenToDecode failed: %x\n", GetLastError());
 230     size = sizeof(value);
 231     ret = CryptMsgGetParam(msg, CMSG_TYPE_PARAM, 0, &value, &size);
 232     ok(ret, "CryptMsgGetParam failed: %x\n", GetLastError());
 233     ok(value == CMSG_SIGNED, "Expected CMSG_SIGNED, got %d\n", value);
 234     for (i = CMSG_CONTENT_PARAM; !old_crypt32 && (i <= CMSG_CMS_SIGNER_INFO_PARAM); i++)
 235     {
 236         size = 0;
 237         ret = CryptMsgGetParam(msg, i, 0, NULL, &size);
 238         ok(!ret, "Parameter %d: expected failure\n", i);
 239     }
 240     CryptMsgClose(msg);
 241
 242     /* Explicitly typed messages get their types set, even if they're invalid */
 243     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, CMSG_ENCRYPTED, 0, NULL,
 244      NULL);
 245     ok(msg != NULL, "CryptMsgOpenToDecode failed: %x\n", GetLastError());
 246     size = sizeof(value);
 247     ret = CryptMsgGetParam(msg, CMSG_TYPE_PARAM, 0, &value, &size);
 248     ok(ret, "CryptMsgGetParam failed: %x\n", GetLastError());
 249     ok(value == CMSG_ENCRYPTED, "Expected CMSG_ENCRYPTED, got %d\n", value);
 250     CryptMsgClose(msg);
 251
 252     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 1000, 0, NULL, NULL);
 253     ok(msg != NULL, "CryptMsgOpenToDecode failed: %x\n", GetLastError());
 254     size = sizeof(value);
 255     ret = CryptMsgGetParam(msg, CMSG_TYPE_PARAM, 0, &value, &size);
 256     ok(ret, "CryptMsgGetParam failed: %x\n", GetLastError());
 257     ok(value == 1000, "Expected 1000, got %d\n", value);
 258     CryptMsgClose(msg);
 259 }
 260
 261 static void test_msg_close(void)
 262 {
 263     BOOL ret;
 264     HCRYPTMSG msg;
 265
 266     /* NULL succeeds.. */
 267     ret = CryptMsgClose(NULL);
 268     ok(ret, "CryptMsgClose failed: %x\n", GetLastError());
 269     /* but an arbitrary pointer crashes. */
 270     if (0)
 271         ret = CryptMsgClose((HCRYPTMSG)1);
 272     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_DATA, NULL, NULL,
 273      NULL);
 274     ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
 275     ret = CryptMsgClose(msg);
 276     ok(ret, "CryptMsgClose failed: %x\n", GetLastError());
 277 }
 278
 279 static void check_param(LPCSTR test, HCRYPTMSG msg, DWORD param,
 280  const BYTE *expected, DWORD expectedSize)
 281 {
 282     DWORD size;
 283     LPBYTE buf;
 284     BOOL ret;
 285
 286     size = 0xdeadbeef;
 287     ret = CryptMsgGetParam(msg, param, 0, NULL, &size);
 288     ok(ret || broken(GetLastError() == OSS_LIMITED /* Win9x */ ||
 289      GetLastError() == CRYPT_E_INVALID_MSG_TYPE /* Win9x, for some params */),
 290      "%s: CryptMsgGetParam failed: %08x\n", test, GetLastError());
 291     if (!ret)
 292     {
 293         win_skip("parameter %d not supported, skipping tests\n", param);
 294         return;
 295     }
 296     buf = HeapAlloc(GetProcessHeap(), 0, size);
 297     ret = CryptMsgGetParam(msg, param, 0, buf, &size);
 298     ok(ret, "%s: CryptMsgGetParam failed: %08x\n", test, GetLastError());
 299     ok(size == expectedSize, "%s: expected size %d, got %d\n", test,
 300      expectedSize, size);
 301     if (size == expectedSize && size)
 302         ok(!memcmp(buf, expected, size), "%s: unexpected data\n", test);
 303     HeapFree(GetProcessHeap(), 0, buf);
 304 }
 305
 306 static void test_data_msg_open(void)
 307 {
 308     HCRYPTMSG msg;
 309     CMSG_HASHED_ENCODE_INFO hashInfo = { 0 };
 310     CMSG_STREAM_INFO streamInfo = { 0 };
 311     char oid[] = "1.2.3";
 312
 313     /* The data message type takes no additional info */
 314     SetLastError(0xdeadbeef);
 315     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_DATA, &hashInfo,
 316      NULL, NULL);
 317     ok(!msg && GetLastError() == E_INVALIDARG,
 318      "Expected E_INVALIDARG, got %x\n", GetLastError());
 319     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_DATA, NULL, NULL,
 320      NULL);
 321     ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
 322     CryptMsgClose(msg);
 323
 324     /* An empty stream info is allowed. */
 325     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_DATA, NULL, NULL,
 326      &streamInfo);
 327     ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
 328     CryptMsgClose(msg);
 329
 330     /* Passing a bogus inner OID succeeds for a non-streamed message.. */
 331     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_DATA, NULL, oid,
 332      NULL);
 333     ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
 334     CryptMsgClose(msg);
 335     /* and still succeeds when CMSG_DETACHED_FLAG is passed.. */
 336     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, CMSG_DETACHED_FLAG,
 337      CMSG_DATA, NULL, oid, NULL);
 338     ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
 339     CryptMsgClose(msg);
 340     /* and when a stream info is given, even though you're not supposed to be
 341      * able to use anything but szOID_RSA_data when streaming is being used.
 342      */
 343     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, CMSG_DETACHED_FLAG,
 344      CMSG_DATA, NULL, oid, &streamInfo);
 345     ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
 346     CryptMsgClose(msg);
 347 }
 348
 349 static const BYTE msgData[] = { 1, 2, 3, 4 };
 350
 351 static BOOL WINAPI nop_stream_output(const void *pvArg, BYTE *pb, DWORD cb,
 352  BOOL final)
 353 {
 354     return TRUE;
 355 }
 356
 357 static const BYTE dataEmptyBareContent[] = { 0x04,0x00 };
 358
 359 static void test_data_msg_update(void)
 360 {
 361     HCRYPTMSG msg;
 362     BOOL ret;
 363     CMSG_STREAM_INFO streamInfo = { 0 };
 364
 365     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_DATA, NULL, NULL,
 366      NULL);
 367     /* Can't update a message that wasn't opened detached with final = FALSE */
 368     SetLastError(0xdeadbeef);
 369     ret = CryptMsgUpdate(msg, NULL, 0, FALSE);
 370     ok(!ret && GetLastError() == CRYPT_E_MSG_ERROR,
 371      "Expected CRYPT_E_MSG_ERROR, got %x\n", GetLastError());
 372     /* Updating it with final = TRUE succeeds */
 373     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
 374     ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
 375     /* Any subsequent update will fail, as the last was final */
 376     SetLastError(0xdeadbeef);
 377     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
 378     ok(!ret && GetLastError() == CRYPT_E_MSG_ERROR,
 379      "Expected CRYPT_E_MSG_ERROR, got %x\n", GetLastError());
 380     CryptMsgClose(msg);
 381
 382     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_DATA, NULL, NULL,
 383      NULL);
 384     /* Starting with Vista, can update a message with no data. */
 385     ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
 386     ok(ret || broken(!ret), "CryptMsgUpdate failed: %08x\n", GetLastError());
 387     if (ret)
 388     {
 389         DWORD size;
 390
 391         ret = CryptMsgGetParam(msg, CMSG_BARE_CONTENT_PARAM, 0, NULL, &size);
 392         ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
 393         if (ret)
 394         {
 395             LPBYTE buf = CryptMemAlloc(size);
 396
 397             if (buf)
 398             {
 399                 ret = CryptMsgGetParam(msg, CMSG_BARE_CONTENT_PARAM, 0, buf,
 400                  &size);
 401                 ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
 402                 if (ret)
 403                 {
 404                     ok(size == sizeof(dataEmptyBareContent),
 405                      "unexpected size %d\n", size);
 406                     ok(!memcmp(buf, dataEmptyBareContent, size),
 407                      "unexpected value\n");
 408                 }
 409                 CryptMemFree(buf);
 410             }
 411         }
 412     }
 413     CryptMsgClose(msg);
 414
 415     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, CMSG_DETACHED_FLAG,
 416      CMSG_DATA, NULL, NULL, NULL);
 417     if (have_nt)
 418     {
 419         /* Doesn't appear to be able to update CMSG-DATA with non-final updates.
 420          * On Win9x, this sometimes succeeds, sometimes fails with
 421          * GetLastError() == 0, so it's not worth checking there.
 422          */
 423         SetLastError(0xdeadbeef);
 424         ret = CryptMsgUpdate(msg, NULL, 0, FALSE);
 425         ok(!ret &&
 426          (GetLastError() == E_INVALIDARG ||
 427           broken(GetLastError() == ERROR_SUCCESS)), /* Older NT4 */
 428          "Expected E_INVALIDARG, got %x\n", GetLastError());
 429         SetLastError(0xdeadbeef);
 430         ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), FALSE);
 431         ok(!ret &&
 432          (GetLastError() == E_INVALIDARG ||
 433           broken(GetLastError() == ERROR_SUCCESS)), /* Older NT4 */
 434          "Expected E_INVALIDARG, got %x\n", GetLastError());
 435     }
 436     else
 437         skip("not updating CMSG_DATA with a non-final update\n");
 438     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
 439     ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
 440     CryptMsgClose(msg);
 441
 442     if (!old_crypt32)
 443     {
 444         /* Calling update after opening with an empty stream info (with a bogus
 445          * output function) yields an error:
 446          */
 447         /* Crashes on some Win9x */
 448         msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_DATA, NULL, NULL,
 449          &streamInfo);
 450         SetLastError(0xdeadbeef);
 451         ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), FALSE);
 452         ok(!ret && (GetLastError() == STATUS_ACCESS_VIOLATION ||
 453          GetLastError() == STATUS_ILLEGAL_INSTRUCTION /* WinME */),
 454          "Expected STATUS_ACCESS_VIOLATION or STATUS_ILLEGAL_INSTRUCTION, got %x\n",
 455          GetLastError());
 456         CryptMsgClose(msg);
 457     }
 458     /* Calling update with a valid output function succeeds, even if the data
 459      * exceeds the size specified in the stream info.
 460      */
 461     streamInfo.pfnStreamOutput = nop_stream_output;
 462     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_DATA, NULL, NULL,
 463      &streamInfo);
 464     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), FALSE);
 465     ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
 466     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
 467     ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
 468     CryptMsgClose(msg);
 469 }
 470
 471 static void test_data_msg_get_param(void)
 472 {
 473     HCRYPTMSG msg;
 474     DWORD size;
 475     BOOL ret;
 476     CMSG_STREAM_INFO streamInfo = { 0, nop_stream_output, NULL };
 477
 478     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_DATA, NULL, NULL,
 479      NULL);
 480
 481     /* Content and bare content are always gettable when not streaming */
 482     size = 0;
 483     ret = CryptMsgGetParam(msg, CMSG_CONTENT_PARAM, 0, NULL, &size);
 484     ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
 485     size = 0;
 486     ret = CryptMsgGetParam(msg, CMSG_BARE_CONTENT_PARAM, 0, NULL, &size);
 487     ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
 488     /* But for this type of message, the signer and hash aren't applicable,
 489      * and the type isn't available.
 490      */
 491     size = 0;
 492     SetLastError(0xdeadbeef);
 493     ret = CryptMsgGetParam(msg, CMSG_ENCODED_SIGNER, 0, NULL, &size);
 494     ok(!ret && GetLastError() == CRYPT_E_INVALID_MSG_TYPE,
 495      "Expected CRYPT_E_INVALID_MSG_TYPE, got %x\n", GetLastError());
 496     SetLastError(0xdeadbeef);
 497     ret = CryptMsgGetParam(msg, CMSG_COMPUTED_HASH_PARAM, 0, NULL, &size);
 498     ok(!ret && GetLastError() == CRYPT_E_INVALID_MSG_TYPE,
 499      "Expected CRYPT_E_INVALID_MSG_TYPE, got %x\n", GetLastError());
 500     ret = CryptMsgGetParam(msg, CMSG_TYPE_PARAM, 0, NULL, &size);
 501     ok(!ret && GetLastError() == CRYPT_E_INVALID_MSG_TYPE,
 502      "Expected CRYPT_E_INVALID_MSG_TYPE, got %x\n", GetLastError());
 503     CryptMsgClose(msg);
 504
 505     /* Can't get content or bare content when streaming */
 506     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_DATA, NULL,
 507      NULL, &streamInfo);
 508     SetLastError(0xdeadbeef);
 509     ret = CryptMsgGetParam(msg, CMSG_BARE_CONTENT_PARAM, 0, NULL, &size);
 510     ok((!ret && GetLastError() == E_INVALIDARG) || broken(ret /* Win9x */),
 511      "Expected E_INVALIDARG, got %x\n", GetLastError());
 512     SetLastError(0xdeadbeef);
 513     ret = CryptMsgGetParam(msg, CMSG_CONTENT_PARAM, 0, NULL, &size);
 514     ok((!ret && GetLastError() == E_INVALIDARG) || broken(ret /* Win9x */),
 515      "Expected E_INVALIDARG, got %x\n", GetLastError());
 516     CryptMsgClose(msg);
 517 }
 518
 519 static const BYTE dataEmptyContent[] = {
 520 0x30,0x0f,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x01,0xa0,0x02,
 521 0x04,0x00 };
 522 static const BYTE dataBareContent[] = { 0x04,0x04,0x01,0x02,0x03,0x04 };
 523 static const BYTE dataContent[] = {
 524 0x30,0x13,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x01,0xa0,0x06,
 525 0x04,0x04,0x01,0x02,0x03,0x04 };
 526
 527 struct update_accum
 528 {
 529     DWORD cUpdates;
 530     CRYPT_DATA_BLOB *updates;
 531 };
 532
 533 static BOOL WINAPI accumulating_stream_output(const void *pvArg, BYTE *pb,
 534  DWORD cb, BOOL final)
 535 {
 536     struct update_accum *accum = (struct update_accum *)pvArg;
 537     BOOL ret = FALSE;
 538
 539     if (accum->cUpdates)
 540         accum->updates = CryptMemRealloc(accum->updates,
 541          (accum->cUpdates + 1) * sizeof(CRYPT_DATA_BLOB));
 542     else
 543         accum->updates = CryptMemAlloc(sizeof(CRYPT_DATA_BLOB));
 544     if (accum->updates)
 545     {
 546         CRYPT_DATA_BLOB *blob = &accum->updates[accum->cUpdates];
 547
 548         blob->pbData = CryptMemAlloc(cb);
 549         if (blob->pbData)
 550         {
 551             memcpy(blob->pbData, pb, cb);
 552             blob->cbData = cb;
 553             ret = TRUE;
 554         }
 555         accum->cUpdates++;
 556     }
 557     return ret;
 558 }
 559
 560 /* The updates of a (bogus) definite-length encoded message */
 561 static BYTE u1[] = { 0x30,0x0f,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
 562  0x07,0x01,0xa0,0x02,0x04,0x00 };
 563 static BYTE u2[] = { 0x01,0x02,0x03,0x04 };
 564 static CRYPT_DATA_BLOB b1[] = {
 565     { sizeof(u1), u1 },
 566     { sizeof(u2), u2 },
 567     { sizeof(u2), u2 },
 568 };
 569 static const struct update_accum a1 = { sizeof(b1) / sizeof(b1[0]), b1 };
 570 /* The updates of a definite-length encoded message */
 571 static BYTE u3[] = { 0x30,0x13,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
 572  0x07,0x01,0xa0,0x06,0x04,0x04 };
 573 static CRYPT_DATA_BLOB b2[] = {
 574     { sizeof(u3), u3 },
 575     { sizeof(u2), u2 },
 576 };
 577 static const struct update_accum a2 = { sizeof(b2) / sizeof(b2[0]), b2 };
 578 /* The updates of an indefinite-length encoded message */
 579 static BYTE u4[] = { 0x30,0x80,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
 580  0x07,0x01,0xa0,0x80,0x24,0x80 };
 581 static BYTE u5[] = { 0x04,0x04 };
 582 static BYTE u6[] = { 0x00,0x00,0x00,0x00,0x00,0x00 };
 583 static CRYPT_DATA_BLOB b3[] = {
 584     { sizeof(u4), u4 },
 585     { sizeof(u5), u5 },
 586     { sizeof(u2), u2 },
 587     { sizeof(u5), u5 },
 588     { sizeof(u2), u2 },
 589     { sizeof(u6), u6 },
 590 };
 591 static const struct update_accum a3 = { sizeof(b3) / sizeof(b3[0]), b3 };
 592
 593 static void check_updates(LPCSTR header, const struct update_accum *expected,
 594  const struct update_accum *got)
 595 {
 596     DWORD i;
 597
 598     ok(expected->cUpdates == got->cUpdates,
 599      "%s: expected %d updates, got %d\n", header, expected->cUpdates,
 600      got->cUpdates);
 601     if (expected->cUpdates == got->cUpdates)
 602         for (i = 0; i < min(expected->cUpdates, got->cUpdates); i++)
 603         {
 604             ok(expected->updates[i].cbData == got->updates[i].cbData,
 605              "%s, update %d: expected %d bytes, got %d\n", header, i,
 606              expected->updates[i].cbData, got->updates[i].cbData);
 607             if (expected->updates[i].cbData && expected->updates[i].cbData ==
 608              got->updates[i].cbData)
 609                 ok(!memcmp(expected->updates[i].pbData, got->updates[i].pbData,
 610                  got->updates[i].cbData), "%s, update %d: unexpected value\n",
 611                  header, i);
 612         }
 613 }
 614
 615 /* Frees the updates stored in accum */
 616 static void free_updates(struct update_accum *accum)
 617 {
 618     DWORD i;
 619
 620     for (i = 0; i < accum->cUpdates; i++)
 621         CryptMemFree(accum->updates[i].pbData);
 622     CryptMemFree(accum->updates);
 623     accum->updates = NULL;
 624     accum->cUpdates = 0;
 625 }
 626
 627 static void test_data_msg_encoding(void)
 628 {
 629     HCRYPTMSG msg;
 630     BOOL ret;
 631     static char oid[] = "1.2.3";
 632     struct update_accum accum = { 0, NULL };
 633     CMSG_STREAM_INFO streamInfo = { 0, accumulating_stream_output, &accum };
 634
 635     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_DATA, NULL, NULL,
 636      NULL);
 637     check_param("data empty bare content", msg, CMSG_BARE_CONTENT_PARAM,
 638      dataEmptyBareContent, sizeof(dataEmptyBareContent));
 639     check_param("data empty content", msg, CMSG_CONTENT_PARAM, dataEmptyContent,
 640      sizeof(dataEmptyContent));
 641     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
 642     ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
 643     check_param("data bare content", msg, CMSG_BARE_CONTENT_PARAM,
 644      dataBareContent, sizeof(dataBareContent));
 645     check_param("data content", msg, CMSG_CONTENT_PARAM, dataContent,
 646      sizeof(dataContent));
 647     CryptMsgClose(msg);
 648     /* Same test, but with CMSG_BARE_CONTENT_FLAG set */
 649     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, CMSG_BARE_CONTENT_FLAG,
 650      CMSG_DATA, NULL, NULL, NULL);
 651     check_param("data empty bare content", msg, CMSG_BARE_CONTENT_PARAM,
 652      dataEmptyBareContent, sizeof(dataEmptyBareContent));
 653     check_param("data empty content", msg, CMSG_CONTENT_PARAM, dataEmptyContent,
 654      sizeof(dataEmptyContent));
 655     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
 656     ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
 657     check_param("data bare content", msg, CMSG_BARE_CONTENT_PARAM,
 658      dataBareContent, sizeof(dataBareContent));
 659     check_param("data content", msg, CMSG_CONTENT_PARAM, dataContent,
 660      sizeof(dataContent));
 661     CryptMsgClose(msg);
 662     /* The inner OID is apparently ignored */
 663     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_DATA, NULL, oid,
 664      NULL);
 665     check_param("data bogus oid bare content", msg, CMSG_BARE_CONTENT_PARAM,
 666      dataEmptyBareContent, sizeof(dataEmptyBareContent));
 667     check_param("data bogus oid content", msg, CMSG_CONTENT_PARAM,
 668      dataEmptyContent, sizeof(dataEmptyContent));
 669     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
 670     ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
 671     check_param("data bare content", msg, CMSG_BARE_CONTENT_PARAM,
 672      dataBareContent, sizeof(dataBareContent));
 673     check_param("data content", msg, CMSG_CONTENT_PARAM, dataContent,
 674      sizeof(dataContent));
 675     CryptMsgClose(msg);
 676     /* A streaming message is DER encoded if the length is not 0xffffffff, but
 677      * curiously, updates aren't validated to make sure they don't exceed the
 678      * stated length.  (The resulting output will of course fail to decode.)
 679      */
 680     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_DATA, NULL,
 681      NULL, &streamInfo);
 682     CryptMsgUpdate(msg, msgData, sizeof(msgData), FALSE);
 683     CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
 684     CryptMsgClose(msg);
 685     check_updates("bogus data message with definite length", &a1, &accum);
 686     free_updates(&accum);
 687     /* A valid definite-length encoding: */
 688     streamInfo.cbContent = sizeof(msgData);
 689     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_DATA, NULL,
 690      NULL, &streamInfo);
 691     CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
 692     CryptMsgClose(msg);
 693     check_updates("data message with definite length", &a2, &accum);
 694     free_updates(&accum);
 695     /* An indefinite-length encoding: */
 696     streamInfo.cbContent = 0xffffffff;
 697     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_DATA, NULL,
 698      NULL, &streamInfo);
 699     CryptMsgUpdate(msg, msgData, sizeof(msgData), FALSE);
 700     CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
 701     CryptMsgClose(msg);
 702     check_updates("data message with indefinite length", &a3, &accum);
 703     free_updates(&accum);
 704 }
 705
 706 static void test_data_msg(void)
 707 {
 708     test_data_msg_open();
 709     test_data_msg_update();
 710     test_data_msg_get_param();
 711     test_data_msg_encoding();
 712 }
 713
 714 static void test_hash_msg_open(void)
 715 {
 716     HCRYPTMSG msg;
 717     CMSG_HASHED_ENCODE_INFO hashInfo = { 0 };
 718     CMSG_STREAM_INFO streamInfo = { 0, nop_stream_output, NULL };
 719
 720     SetLastError(0xdeadbeef);
 721     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_HASHED, &hashInfo,
 722      NULL, NULL);
 723     ok(!msg && GetLastError() == E_INVALIDARG,
 724      "Expected E_INVALIDARG, got %x\n", GetLastError());
 725     hashInfo.cbSize = sizeof(hashInfo);
 726     SetLastError(0xdeadbeef);
 727     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_HASHED, &hashInfo,
 728      NULL, NULL);
 729     ok(!msg && GetLastError() == CRYPT_E_UNKNOWN_ALGO,
 730      "Expected CRYPT_E_UNKNOWN_ALGO, got %x\n", GetLastError());
 731     hashInfo.HashAlgorithm.pszObjId = oid_rsa_md5;
 732     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_HASHED, &hashInfo,
 733      NULL, NULL);
 734     ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
 735     CryptMsgClose(msg);
 736     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, CMSG_DETACHED_FLAG,
 737      CMSG_HASHED, &hashInfo, NULL, NULL);
 738     ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
 739     CryptMsgClose(msg);
 740     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, CMSG_DETACHED_FLAG,
 741      CMSG_HASHED, &hashInfo, NULL, &streamInfo);
 742     ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
 743     CryptMsgClose(msg);
 744 }
 745
 746 static void test_hash_msg_update(void)
 747 {
 748     HCRYPTMSG msg;
 749     BOOL ret;
 750     CMSG_HASHED_ENCODE_INFO hashInfo = { sizeof(hashInfo), 0,
 751      { oid_rsa_md5, { 0, NULL } }, NULL };
 752     CMSG_STREAM_INFO streamInfo = { 0, nop_stream_output, NULL };
 753
 754     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, CMSG_DETACHED_FLAG,
 755      CMSG_HASHED, &hashInfo, NULL, NULL);
 756     /* Detached hashed messages opened in non-streaming mode allow non-final
 757      * updates..
 758      */
 759     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), FALSE);
 760     ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
 761     /* including non-final updates with no data.. */
 762     ret = CryptMsgUpdate(msg, NULL, 0, FALSE);
 763     ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
 764     /* and final updates with no data. */
 765     ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
 766     ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
 767     /* But no updates are allowed after the final update. */
 768     SetLastError(0xdeadbeef);
 769     ret = CryptMsgUpdate(msg, NULL, 0, FALSE);
 770     ok(!ret && GetLastError() == CRYPT_E_MSG_ERROR,
 771      "Expected CRYPT_E_MSG_ERROR, got %x\n", GetLastError());
 772     SetLastError(0xdeadbeef);
 773     ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
 774     ok(!ret && GetLastError() == CRYPT_E_MSG_ERROR,
 775      "Expected CRYPT_E_MSG_ERROR, got %x\n", GetLastError());
 776     CryptMsgClose(msg);
 777     /* Non-detached messages, in contrast, don't allow non-final updates in
 778      * non-streaming mode.
 779      */
 780     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_HASHED, &hashInfo,
 781      NULL, NULL);
 782     SetLastError(0xdeadbeef);
 783     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), FALSE);
 784     ok(!ret && GetLastError() == CRYPT_E_MSG_ERROR,
 785      "Expected CRYPT_E_MSG_ERROR, got %x\n", GetLastError());
 786     /* Final updates (including empty ones) are allowed. */
 787     ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
 788     ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
 789     CryptMsgClose(msg);
 790     /* And, of course, streaming mode allows non-final updates */
 791     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_HASHED, &hashInfo,
 792      NULL, &streamInfo);
 793     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), FALSE);
 794     ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
 795     CryptMsgClose(msg);
 796     /* Setting pfnStreamOutput to NULL results in no error.  (In what appears
 797      * to be a bug, it isn't actually used - see encoding tests.)
 798      */
 799     streamInfo.pfnStreamOutput = NULL;
 800     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_HASHED, &hashInfo,
 801      NULL, &streamInfo);
 802     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), FALSE);
 803     ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
 804     CryptMsgClose(msg);
 805 }
 806
 807 static const BYTE emptyHashParam[] = {
 808 0xd4,0x1d,0x8c,0xd9,0x8f,0x00,0xb2,0x04,0xe9,0x80,0x09,0x98,0xec,0xf8,0x42,
 809 0x7e };
 810
 811 static void test_hash_msg_get_param(void)
 812 {
 813     HCRYPTMSG msg;
 814     BOOL ret;
 815     CMSG_HASHED_ENCODE_INFO hashInfo = { sizeof(hashInfo), 0,
 816      { oid_rsa_md5, { 0, NULL } }, NULL };
 817     DWORD size, value;
 818     CMSG_STREAM_INFO streamInfo = { 0, nop_stream_output, NULL };
 819     BYTE buf[16];
 820
 821     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_HASHED, &hashInfo,
 822      NULL, NULL);
 823     /* Content and bare content are always gettable for non-streamed messages */
 824     size = 0;
 825     ret = CryptMsgGetParam(msg, CMSG_CONTENT_PARAM, 0, NULL, &size);
 826     ok(ret || broken(GetLastError() == OSS_LIMITED /* Win9x */),
 827      "CryptMsgGetParam failed: %08x\n", GetLastError());
 828     size = 0;
 829     ret = CryptMsgGetParam(msg, CMSG_BARE_CONTENT_PARAM, 0, NULL, &size);
 830     ok(ret || broken(GetLastError() == OSS_LIMITED /* Win9x */),
 831      "CryptMsgGetParam failed: %08x\n", GetLastError());
 832     /* For an encoded hash message, the hash data aren't available */
 833     SetLastError(0xdeadbeef);
 834     ret = CryptMsgGetParam(msg, CMSG_HASH_DATA_PARAM, 0, NULL, &size);
 835     ok(!ret && (GetLastError() == CRYPT_E_INVALID_MSG_TYPE ||
 836      GetLastError() == OSS_LIMITED /* Win9x */),
 837      "Expected CRYPT_E_INVALID_MSG_TYPE or OSS_LIMITED, got %08x\n",
 838      GetLastError());
 839     /* The hash is also available. */
 840     size = 0;
 841     ret = CryptMsgGetParam(msg, CMSG_COMPUTED_HASH_PARAM, 0, NULL, &size);
 842     ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
 843     ok(size == sizeof(buf), "Unexpected size %d\n", size);
 844     ret = CryptMsgGetParam(msg, CMSG_COMPUTED_HASH_PARAM, 0, buf, &size);
 845     ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
 846     ok(size == sizeof(buf), "Unexpected size %d\n", size);
 847     if (size == sizeof(buf))
 848         ok(!memcmp(buf, emptyHashParam, size), "Unexpected value\n");
 849     /* By getting the hash, further updates are not allowed */
 850     SetLastError(0xdeadbeef);
 851     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
 852     ok(!ret &&
 853        (GetLastError() == NTE_BAD_HASH_STATE /* NT */ ||
 854         GetLastError() == NTE_BAD_ALGID /* 9x */ ||
 855         GetLastError() == CRYPT_E_MSG_ERROR /* Vista */ ||
 856         broken(GetLastError() == ERROR_SUCCESS) /* Some Win9x */),
 857        "Expected NTE_BAD_HASH_STATE or NTE_BAD_ALGID or CRYPT_E_MSG_ERROR, got 0x%x\n", GetLastError());
 858
 859     /* Even after a final update, the hash data aren't available */
 860     SetLastError(0xdeadbeef);
 861     ret = CryptMsgGetParam(msg, CMSG_HASH_DATA_PARAM, 0, NULL, &size);
 862     ok(!ret && GetLastError() == CRYPT_E_INVALID_MSG_TYPE,
 863      "Expected CRYPT_E_INVALID_MSG_TYPE, got %08x\n", GetLastError());
 864     /* The version is also available, and should be zero for this message. */
 865     size = 0;
 866     ret = CryptMsgGetParam(msg, CMSG_VERSION_PARAM, 0, NULL, &size);
 867     ok(ret || broken(GetLastError() == CRYPT_E_INVALID_MSG_TYPE /* Win9x */),
 868      "CryptMsgGetParam failed: %08x\n", GetLastError());
 869     size = sizeof(value);
 870     ret = CryptMsgGetParam(msg, CMSG_VERSION_PARAM, 0, &value, &size);
 871     ok(ret || broken(GetLastError() == CRYPT_E_INVALID_MSG_TYPE /* Win9x */),
 872      "CryptMsgGetParam failed: %08x\n", GetLastError());
 873     if (ret)
 874         ok(value == 0, "Expected version 0, got %d\n", value);
 875     /* As usual, the type isn't available. */
 876     ret = CryptMsgGetParam(msg, CMSG_TYPE_PARAM, 0, NULL, &size);
 877     ok(!ret, "Expected failure\n");
 878     CryptMsgClose(msg);
 879
 880     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_HASHED, &hashInfo,
 881      NULL, &streamInfo);
 882     /* Streamed messages don't allow you to get the content or bare content. */
 883     SetLastError(0xdeadbeef);
 884     ret = CryptMsgGetParam(msg, CMSG_CONTENT_PARAM, 0, NULL, &size);
 885     ok(!ret && (GetLastError() == E_INVALIDARG ||
 886      GetLastError() == OSS_LIMITED /* Win9x */),
 887      "Expected E_INVALIDARG or OSS_LIMITED, got %x\n", GetLastError());
 888     SetLastError(0xdeadbeef);
 889     ret = CryptMsgGetParam(msg, CMSG_BARE_CONTENT_PARAM, 0, NULL, &size);
 890     ok(!ret && (GetLastError() == E_INVALIDARG ||
 891      GetLastError() == OSS_LIMITED /* Win9x */),
 892      "Expected E_INVALIDARG or OSS_LIMITED, got %x\n", GetLastError());
 893     /* The hash is still available. */
 894     size = 0;
 895     ret = CryptMsgGetParam(msg, CMSG_COMPUTED_HASH_PARAM, 0, NULL, &size);
 896     ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
 897     ok(size == sizeof(buf), "Unexpected size %d\n", size);
 898     ret = CryptMsgGetParam(msg, CMSG_COMPUTED_HASH_PARAM, 0, buf, &size);
 899     ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
 900     if (size == sizeof(buf))
 901         ok(!memcmp(buf, emptyHashParam, size), "Unexpected value\n");
 902     /* After updating the hash, further updates aren't allowed on streamed
 903      * messages either.
 904      */
 905     SetLastError(0xdeadbeef);
 906     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
 907     ok(!ret &&
 908        (GetLastError() == NTE_BAD_HASH_STATE /* NT */ ||
 909         GetLastError() == NTE_BAD_ALGID /* 9x */ ||
 910         GetLastError() == CRYPT_E_MSG_ERROR /* Vista */ ||
 911         broken(GetLastError() == ERROR_SUCCESS) /* Some Win9x */),
 912        "Expected NTE_BAD_HASH_STATE or NTE_BAD_ALGID or CRYPT_E_MSG_ERROR, got 0x%x\n", GetLastError());
 913
 914     CryptMsgClose(msg);
 915 }
 916
 917 static const BYTE hashEmptyBareContent[] = {
 918 0x30,0x17,0x02,0x01,0x00,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
 919 0x02,0x05,0x05,0x00,0x30,0x02,0x06,0x00,0x04,0x00 };
 920 static const BYTE hashEmptyContent[] = {
 921 0x30,0x26,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x05,0xa0,0x19,
 922 0x30,0x17,0x02,0x01,0x00,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
 923 0x02,0x05,0x05,0x00,0x30,0x02,0x06,0x00,0x04,0x00 };
 924 static const BYTE hashBareContent[] = {
 925 0x30,0x38,0x02,0x01,0x00,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
 926 0x02,0x05,0x05,0x00,0x30,0x13,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
 927 0x07,0x01,0xa0,0x06,0x04,0x04,0x01,0x02,0x03,0x04,0x04,0x10,0x08,0xd6,0xc0,
 928 0x5a,0x21,0x51,0x2a,0x79,0xa1,0xdf,0xeb,0x9d,0x2a,0x8f,0x26,0x2f };
 929 static const BYTE hashContent[] = {
 930 0x30,0x47,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x05,0xa0,0x3a,
 931 0x30,0x38,0x02,0x01,0x00,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
 932 0x02,0x05,0x05,0x00,0x30,0x13,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
 933 0x07,0x01,0xa0,0x06,0x04,0x04,0x01,0x02,0x03,0x04,0x04,0x10,0x08,0xd6,0xc0,
 934 0x5a,0x21,0x51,0x2a,0x79,0xa1,0xdf,0xeb,0x9d,0x2a,0x8f,0x26,0x2f };
 935
 936 static const BYTE detachedHashNonFinalBareContent[] = {
 937 0x30,0x20,0x02,0x01,0x00,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
 938 0x02,0x05,0x05,0x00,0x30,0x0b,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
 939 0x07,0x01,0x04,0x00 };
 940 static const BYTE detachedHashNonFinalContent[] = {
 941 0x30,0x2f,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x05,0xa0,0x22,
 942 0x30,0x20,0x02,0x01,0x00,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
 943 0x02,0x05,0x05,0x00,0x30,0x0b,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
 944 0x07,0x01,0x04,0x00 };
 945 static const BYTE detachedHashBareContent[] = {
 946 0x30,0x30,0x02,0x01,0x00,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
 947 0x02,0x05,0x05,0x00,0x30,0x0b,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
 948 0x07,0x01,0x04,0x10,0x08,0xd6,0xc0,0x5a,0x21,0x51,0x2a,0x79,0xa1,0xdf,0xeb,
 949 0x9d,0x2a,0x8f,0x26,0x2f };
 950 static const BYTE detachedHashContent[] = {
 951 0x30,0x3f,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x05,0xa0,0x32,
 952 0x30,0x30,0x02,0x01,0x00,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
 953 0x02,0x05,0x05,0x00,0x30,0x0b,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
 954 0x07,0x01,0x04,0x10,0x08,0xd6,0xc0,0x5a,0x21,0x51,0x2a,0x79,0xa1,0xdf,0xeb,
 955 0x9d,0x2a,0x8f,0x26,0x2f };
 956
 957 static void test_hash_msg_encoding(void)
 958 {
 959     HCRYPTMSG msg;
 960     CMSG_HASHED_ENCODE_INFO hashInfo = { sizeof(hashInfo), 0 };
 961     BOOL ret;
 962     struct update_accum accum = { 0, NULL }, empty_accum = { 0, NULL };
 963     CMSG_STREAM_INFO streamInfo = { 0, accumulating_stream_output, &accum };
 964
 965     hashInfo.HashAlgorithm.pszObjId = oid_rsa_md5;
 966     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_HASHED, &hashInfo,
 967      NULL, NULL);
 968     check_param("hash empty bare content", msg, CMSG_BARE_CONTENT_PARAM,
 969      hashEmptyBareContent, sizeof(hashEmptyBareContent));
 970     check_param("hash empty content", msg, CMSG_CONTENT_PARAM,
 971      hashEmptyContent, sizeof(hashEmptyContent));
 972     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
 973     ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
 974     check_param("hash bare content", msg, CMSG_BARE_CONTENT_PARAM,
 975      hashBareContent, sizeof(hashBareContent));
 976     check_param("hash content", msg, CMSG_CONTENT_PARAM,
 977      hashContent, sizeof(hashContent));
 978     CryptMsgClose(msg);
 979     /* Same test, but with CMSG_BARE_CONTENT_FLAG set */
 980     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, CMSG_BARE_CONTENT_FLAG,
 981      CMSG_HASHED, &hashInfo, NULL, NULL);
 982     check_param("hash empty bare content", msg, CMSG_BARE_CONTENT_PARAM,
 983      hashEmptyBareContent, sizeof(hashEmptyBareContent));
 984     check_param("hash empty content", msg, CMSG_CONTENT_PARAM,
 985      hashEmptyContent, sizeof(hashEmptyContent));
 986     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
 987     ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
 988     check_param("hash bare content", msg, CMSG_BARE_CONTENT_PARAM,
 989      hashBareContent, sizeof(hashBareContent));
 990     check_param("hash content", msg, CMSG_CONTENT_PARAM,
 991      hashContent, sizeof(hashContent));
 992     CryptMsgClose(msg);
 993     /* Same test, but with CMSG_DETACHED_FLAG set */
 994     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, CMSG_DETACHED_FLAG,
 995      CMSG_HASHED, &hashInfo, NULL, NULL);
 996     check_param("detached hash empty bare content", msg,
 997      CMSG_BARE_CONTENT_PARAM, hashEmptyBareContent,
 998      sizeof(hashEmptyBareContent));
 999     check_param("detached hash empty content", msg, CMSG_CONTENT_PARAM,
1000      hashEmptyContent, sizeof(hashEmptyContent));
1001     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), FALSE);
1002     ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
1003     check_param("detached hash not final bare content", msg,
1004      CMSG_BARE_CONTENT_PARAM, detachedHashNonFinalBareContent,
1005      sizeof(detachedHashNonFinalBareContent));
1006     check_param("detached hash not final content", msg, CMSG_CONTENT_PARAM,
1007      detachedHashNonFinalContent, sizeof(detachedHashNonFinalContent));
1008     ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
1009     ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
1010     check_param("detached hash bare content", msg, CMSG_BARE_CONTENT_PARAM,
1011      detachedHashBareContent, sizeof(detachedHashBareContent));
1012     check_param("detached hash content", msg, CMSG_CONTENT_PARAM,
1013      detachedHashContent, sizeof(detachedHashContent));
1014     check_param("detached hash bare content", msg, CMSG_BARE_CONTENT_PARAM,
1015      detachedHashBareContent, sizeof(detachedHashBareContent));
1016     check_param("detached hash content", msg, CMSG_CONTENT_PARAM,
1017      detachedHashContent, sizeof(detachedHashContent));
1018     CryptMsgClose(msg);
1019     /* In what appears to be a bug, streamed updates to hash messages don't
1020      * call the output function.
1021      */
1022     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_HASHED, &hashInfo,
1023      NULL, &streamInfo);
1024     ret = CryptMsgUpdate(msg, NULL, 0, FALSE);
1025     ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
1026     ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
1027     ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
1028     CryptMsgClose(msg);
1029     check_updates("empty hash message", &empty_accum, &accum);
1030     free_updates(&accum);
1031
1032     streamInfo.cbContent = sizeof(msgData);
1033     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_HASHED, &hashInfo,
1034      NULL, &streamInfo);
1035     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
1036     ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
1037     CryptMsgClose(msg);
1038     check_updates("hash message", &empty_accum, &accum);
1039     free_updates(&accum);
1040
1041     streamInfo.cbContent = sizeof(msgData);
1042     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, CMSG_DETACHED_FLAG,
1043      CMSG_HASHED, &hashInfo, NULL, &streamInfo);
1044     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
1045     ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
1046     CryptMsgClose(msg);
1047     check_updates("detached hash message", &empty_accum, &accum);
1048     free_updates(&accum);
1049 }
1050
1051 static void test_hash_msg(void)
1052 {
1053     test_hash_msg_open();
1054     test_hash_msg_update();
1055     test_hash_msg_get_param();
1056     test_hash_msg_encoding();
1057 }
1058
1059 static const CHAR cspNameA[] = { 'W','i','n','e','C','r','y','p','t','T','e',
1060  'm','p',0 };
1061 static const WCHAR cspNameW[] = { 'W','i','n','e','C','r','y','p','t','T','e',
1062  'm','p',0 };
1063 static BYTE serialNum[] = { 1 };
1064 static BYTE encodedCommonName[] = { 0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,
1065  0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00 };
1066
1067 static void test_signed_msg_open(void)
1068 {
1069     HCRYPTMSG msg;
1070     BOOL ret;
1071     CMSG_SIGNED_ENCODE_INFO signInfo = { 0 };
1072     CMSG_SIGNER_ENCODE_INFO signer = { sizeof(signer), 0 };
1073     CERT_INFO certInfo = { 0 };
1074
1075     SetLastError(0xdeadbeef);
1076     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_SIGNED, &signInfo,
1077      NULL, NULL);
1078     ok(!msg && GetLastError() == E_INVALIDARG,
1079      "Expected E_INVALIDARG, got %x\n", GetLastError());
1080     signInfo.cbSize = sizeof(signInfo);
1081     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_SIGNED, &signInfo,
1082      NULL, NULL);
1083     ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1084     CryptMsgClose(msg);
1085
1086     signInfo.cSigners = 1;
1087     signInfo.rgSigners = &signer;
1088     /* With signer.pCertInfo unset, attempting to open this message this
1089      * crashes.
1090      */
1091     signer.pCertInfo = &certInfo;
1092     /* The cert info must contain a serial number and an issuer. */
1093     SetLastError(0xdeadbeef);
1094     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_SIGNED, &signInfo,
1095      NULL, NULL);
1096     /* NT: E_INVALIDARG, 9x: unchanged or CRYPT_E_UNKNOWN_ALGO */
1097     ok(!msg && (GetLastError() == E_INVALIDARG || GetLastError() == 0xdeadbeef
1098      || GetLastError() == CRYPT_E_UNKNOWN_ALGO),
1099      "Expected E_INVALIDARG or 0xdeadbeef or CRYPT_E_UNKNOWN_ALGO, got 0x%x\n",
1100      GetLastError());
1101
1102     certInfo.SerialNumber.cbData = sizeof(serialNum);
1103     certInfo.SerialNumber.pbData = serialNum;
1104     SetLastError(0xdeadbeef);
1105     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_SIGNED, &signInfo,
1106      NULL, NULL);
1107     /* NT: E_INVALIDARG, 9x: unchanged or CRYPT_E_UNKNOWN_ALGO */
1108     ok(!msg && (GetLastError() == E_INVALIDARG || GetLastError() == 0xdeadbeef
1109      || GetLastError() == CRYPT_E_UNKNOWN_ALGO),
1110      "Expected E_INVALIDARG or 0xdeadbeef or CRYPT_E_UNKNOWN_ALGO, got 0x%x\n",
1111      GetLastError());
1112
1113     certInfo.Issuer.cbData = sizeof(encodedCommonName);
1114     certInfo.Issuer.pbData = encodedCommonName;
1115     SetLastError(0xdeadbeef);
1116     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_SIGNED, &signInfo,
1117      NULL, NULL);
1118     ok(!msg && (GetLastError() == E_INVALIDARG ||
1119      GetLastError() == CRYPT_E_UNKNOWN_ALGO),
1120      "Expected E_INVALIDARG or CRYPT_E_UNKNOWN_ALGO, got %x\n", GetLastError());
1121
1122     /* The signer's hCryptProv must be set to something.  Whether it's usable
1123      * or not will be checked after the hash algorithm is checked (see next
1124      * test.)
1125      */
1126     signer.hCryptProv = 1;
1127     SetLastError(0xdeadbeef);
1128     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_SIGNED, &signInfo,
1129      NULL, NULL);
1130     ok(!msg && GetLastError() == CRYPT_E_UNKNOWN_ALGO,
1131      "Expected CRYPT_E_UNKNOWN_ALGO, got %x\n", GetLastError());
1132     /* The signer's hash algorithm must also be set. */
1133     signer.HashAlgorithm.pszObjId = oid_rsa_md5;
1134     SetLastError(0xdeadbeef);
1135     /* Crashes in advapi32 in wine, don't do it */
1136     if (0) {
1137         msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_SIGNED,
1138          &signInfo, NULL, NULL);
1139         ok(!msg && GetLastError() == ERROR_INVALID_PARAMETER,
1140          "Expected ERROR_INVALID_PARAMETER, got %x\n", GetLastError());
1141     }
1142     /* The signer's hCryptProv must also be valid. */
1143     ret = pCryptAcquireContextA(&signer.hCryptProv, cspNameA, NULL,
1144                                 PROV_RSA_FULL, CRYPT_NEWKEYSET);
1145     if (!ret && GetLastError() == NTE_EXISTS) {
1146         ret = pCryptAcquireContextA(&signer.hCryptProv, cspNameA, NULL,
1147                                     PROV_RSA_FULL, 0);
1148     }
1149     ok(ret, "CryptAcquireContext failed: 0x%x\n", GetLastError());
1150
1151     if (ret) {
1152         msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_SIGNED, &signInfo,
1153                                    NULL, NULL);
1154         ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1155         CryptMsgClose(msg);
1156     }
1157
1158     /* pCertInfo must still be set, but can be empty if the SignerId's issuer
1159      * and serial number are set.
1160      */
1161     certInfo.Issuer.cbData = 0;
1162     certInfo.SerialNumber.cbData = 0;
1163     signer.SignerId.dwIdChoice = CERT_ID_ISSUER_SERIAL_NUMBER;
1164     U(signer.SignerId).IssuerSerialNumber.Issuer.cbData =
1165      sizeof(encodedCommonName);
1166     U(signer.SignerId).IssuerSerialNumber.Issuer.pbData = encodedCommonName;
1167     U(signer.SignerId).IssuerSerialNumber.SerialNumber.cbData =
1168      sizeof(serialNum);
1169     U(signer.SignerId).IssuerSerialNumber.SerialNumber.pbData = serialNum;
1170     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_SIGNED, &signInfo,
1171      NULL, NULL);
1172     ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1173     CryptMsgClose(msg);
1174
1175     CryptReleaseContext(signer.hCryptProv, 0);
1176     pCryptAcquireContextA(&signer.hCryptProv, cspNameA, MS_DEF_PROV_A,
1177      PROV_RSA_FULL, CRYPT_DELETEKEYSET);
1178 }
1179
1180 static const BYTE privKey[] = {
1181  0x07, 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x52, 0x53, 0x41, 0x32, 0x00,
1182  0x02, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x79, 0x10, 0x1c, 0xd0, 0x6b, 0x10,
1183  0x18, 0x30, 0x94, 0x61, 0xdc, 0x0e, 0xcb, 0x96, 0x4e, 0x21, 0x3f, 0x79, 0xcd,
1184  0xa9, 0x17, 0x62, 0xbc, 0xbb, 0x61, 0x4c, 0xe0, 0x75, 0x38, 0x6c, 0xf3, 0xde,
1185  0x60, 0x86, 0x03, 0x97, 0x65, 0xeb, 0x1e, 0x6b, 0xdb, 0x53, 0x85, 0xad, 0x68,
1186  0x21, 0xf1, 0x5d, 0xe7, 0x1f, 0xe6, 0x53, 0xb4, 0xbb, 0x59, 0x3e, 0x14, 0x27,
1187  0xb1, 0x83, 0xa7, 0x3a, 0x54, 0xe2, 0x8f, 0x65, 0x8e, 0x6a, 0x4a, 0xcf, 0x3b,
1188  0x1f, 0x65, 0xff, 0xfe, 0xf1, 0x31, 0x3a, 0x37, 0x7a, 0x8b, 0xcb, 0xc6, 0xd4,
1189  0x98, 0x50, 0x36, 0x67, 0xe4, 0xa1, 0xe8, 0x7e, 0x8a, 0xc5, 0x23, 0xf2, 0x77,
1190  0xf5, 0x37, 0x61, 0x49, 0x72, 0x59, 0xe8, 0x3d, 0xf7, 0x60, 0xb2, 0x77, 0xca,
1191  0x78, 0x54, 0x6d, 0x65, 0x9e, 0x03, 0x97, 0x1b, 0x61, 0xbd, 0x0c, 0xd8, 0x06,
1192  0x63, 0xe2, 0xc5, 0x48, 0xef, 0xb3, 0xe2, 0x6e, 0x98, 0x7d, 0xbd, 0x4e, 0x72,
1193  0x91, 0xdb, 0x31, 0x57, 0xe3, 0x65, 0x3a, 0x49, 0xca, 0xec, 0xd2, 0x02, 0x4e,
1194  0x22, 0x7e, 0x72, 0x8e, 0xf9, 0x79, 0x84, 0x82, 0xdf, 0x7b, 0x92, 0x2d, 0xaf,
1195  0xc9, 0xe4, 0x33, 0xef, 0x89, 0x5c, 0x66, 0x99, 0xd8, 0x80, 0x81, 0x47, 0x2b,
1196  0xb1, 0x66, 0x02, 0x84, 0x59, 0x7b, 0xc3, 0xbe, 0x98, 0x45, 0x4a, 0x3d, 0xdd,
1197  0xea, 0x2b, 0xdf, 0x4e, 0xb4, 0x24, 0x6b, 0xec, 0xe7, 0xd9, 0x0c, 0x45, 0xb8,
1198  0xbe, 0xca, 0x69, 0x37, 0x92, 0x4c, 0x38, 0x6b, 0x96, 0x6d, 0xcd, 0x86, 0x67,
1199  0x5c, 0xea, 0x54, 0x94, 0xa4, 0xca, 0xa4, 0x02, 0xa5, 0x21, 0x4d, 0xae, 0x40,
1200  0x8f, 0x9d, 0x51, 0x83, 0xf2, 0x3f, 0x33, 0xc1, 0x72, 0xb4, 0x1d, 0x94, 0x6e,
1201  0x7d, 0xe4, 0x27, 0x3f, 0xea, 0xff, 0xe5, 0x9b, 0xa7, 0x5e, 0x55, 0x8e, 0x0d,
1202  0x69, 0x1c, 0x7a, 0xff, 0x81, 0x9d, 0x53, 0x52, 0x97, 0x9a, 0x76, 0x79, 0xda,
1203  0x93, 0x32, 0x16, 0xec, 0x69, 0x51, 0x1a, 0x4e, 0xc3, 0xf1, 0x72, 0x80, 0x78,
1204  0x5e, 0x66, 0x4a, 0x8d, 0x85, 0x2f, 0x3f, 0xb2, 0xa7 };
1205 static BYTE pubKey[] = {
1206 0x30,0x48,0x02,0x41,0x00,0xe2,0x54,0x3a,0xa7,0x83,0xb1,0x27,0x14,0x3e,0x59,
1207 0xbb,0xb4,0x53,0xe6,0x1f,0xe7,0x5d,0xf1,0x21,0x68,0xad,0x85,0x53,0xdb,0x6b,
1208 0x1e,0xeb,0x65,0x97,0x03,0x86,0x60,0xde,0xf3,0x6c,0x38,0x75,0xe0,0x4c,0x61,
1209 0xbb,0xbc,0x62,0x17,0xa9,0xcd,0x79,0x3f,0x21,0x4e,0x96,0xcb,0x0e,0xdc,0x61,
1210 0x94,0x30,0x18,0x10,0x6b,0xd0,0x1c,0x10,0x79,0x02,0x03,0x01,0x00,0x01 };
1211
1212 static void test_signed_msg_update(void)
1213 {
1214     HCRYPTMSG msg;
1215     BOOL ret;
1216     CMSG_SIGNED_ENCODE_INFO signInfo = { sizeof(signInfo), 0 };
1217     CMSG_SIGNER_ENCODE_INFO signer = { sizeof(signer), 0 };
1218     CERT_INFO certInfo = { 0 };
1219     HCRYPTKEY key;
1220
1221     certInfo.SerialNumber.cbData = sizeof(serialNum);
1222     certInfo.SerialNumber.pbData = serialNum;
1223     certInfo.Issuer.cbData = sizeof(encodedCommonName);
1224     certInfo.Issuer.pbData = encodedCommonName;
1225     signer.pCertInfo = &certInfo;
1226     signer.HashAlgorithm.pszObjId = oid_rsa_md5;
1227     signInfo.cSigners = 1;
1228     signInfo.rgSigners = &signer;
1229
1230     ret = pCryptAcquireContextA(&signer.hCryptProv, cspNameA, NULL,
1231                                 PROV_RSA_FULL, CRYPT_NEWKEYSET);
1232     if (!ret && GetLastError() == NTE_EXISTS) {
1233         ret = pCryptAcquireContextA(&signer.hCryptProv, cspNameA, NULL,
1234                                     PROV_RSA_FULL, 0);
1235     }
1236     ok(ret, "CryptAcquireContext failed: 0x%x\n", GetLastError());
1237
1238     if (!ret) {
1239         skip("No context for tests\n");
1240         return;
1241     }
1242
1243     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING,
1244      CMSG_DETACHED_FLAG, CMSG_SIGNED, &signInfo, NULL, NULL);
1245     ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1246     /* Detached CMSG_SIGNED allows non-final updates. */
1247     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), FALSE);
1248     ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
1249     /* Detached CMSG_SIGNED also allows non-final updates with no data. */
1250     ret = CryptMsgUpdate(msg, NULL, 0, FALSE);
1251     ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
1252     /* The final update requires a private key in the hCryptProv, in order to
1253      * generate the signature.
1254      */
1255     SetLastError(0xdeadbeef);
1256     ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
1257     ok(!ret &&
1258        (GetLastError() == NTE_BAD_KEYSET ||
1259         GetLastError() == NTE_NO_KEY ||
1260         broken(GetLastError() == ERROR_SUCCESS)), /* Some Win9x */
1261      "Expected NTE_BAD_KEYSET or NTE_NO_KEY, got %x\n", GetLastError());
1262     ret = CryptImportKey(signer.hCryptProv, privKey, sizeof(privKey),
1263      0, 0, &key);
1264     ok(ret, "CryptImportKey failed: %08x\n", GetLastError());
1265     /* The final update should be able to succeed now that a key exists, but
1266      * the previous (invalid) final update prevents it.
1267      */
1268     SetLastError(0xdeadbeef);
1269     ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
1270     ok(!ret && GetLastError() == CRYPT_E_MSG_ERROR,
1271      "Expected CRYPT_E_MSG_ERROR, got %x\n", GetLastError());
1272     CryptMsgClose(msg);
1273
1274     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING,
1275      CMSG_DETACHED_FLAG, CMSG_SIGNED, &signInfo, NULL, NULL);
1276     ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1277     /* Detached CMSG_SIGNED allows non-final updates. */
1278     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), FALSE);
1279     ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
1280     /* Detached CMSG_SIGNED also allows non-final updates with no data. */
1281     ret = CryptMsgUpdate(msg, NULL, 0, FALSE);
1282     ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
1283     /* Now that the private key exists, the final update can succeed (even
1284      * with no data.)
1285      */
1286     ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
1287     ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
1288     /* But no updates are allowed after the final update. */
1289     SetLastError(0xdeadbeef);
1290     ret = CryptMsgUpdate(msg, NULL, 0, FALSE);
1291     ok(!ret && GetLastError() == CRYPT_E_MSG_ERROR,
1292      "Expected CRYPT_E_MSG_ERROR, got %x\n", GetLastError());
1293     SetLastError(0xdeadbeef);
1294     ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
1295     ok(!ret && GetLastError() == CRYPT_E_MSG_ERROR,
1296      "Expected CRYPT_E_MSG_ERROR, got %x\n", GetLastError());
1297     CryptMsgClose(msg);
1298
1299     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_SIGNED, &signInfo,
1300      NULL, NULL);
1301     ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1302     /* Non-detached messages don't allow non-final updates.. */
1303     SetLastError(0xdeadbeef);
1304     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), FALSE);
1305     ok(!ret && GetLastError() == CRYPT_E_MSG_ERROR,
1306      "Expected CRYPT_E_MSG_ERROR, got %x\n", GetLastError());
1307     /* but they do allow final ones. */
1308     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
1309     ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
1310     CryptMsgClose(msg);
1311     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_SIGNED, &signInfo,
1312      NULL, NULL);
1313     ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1314     /* They also allow final updates with no data. */
1315     ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
1316     ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
1317     CryptMsgClose(msg);
1318
1319     CryptDestroyKey(key);
1320     CryptReleaseContext(signer.hCryptProv, 0);
1321     pCryptAcquireContextA(&signer.hCryptProv, cspNameA, NULL, PROV_RSA_FULL,
1322      CRYPT_DELETEKEYSET);
1323 }
1324
1325 static const BYTE signedEmptyBareContent[] = {
1326 0x30,0x50,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,
1327 0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x02,0x06,0x00,0x31,0x37,0x30,0x35,0x02,
1328 0x01,0x01,0x30,0x1a,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,
1329 0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x02,0x01,0x01,
1330 0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,
1331 0x04,0x06,0x00,0x05,0x00,0x04,0x00 };
1332 static const BYTE signedEmptyContent[] = {
1333 0x30,0x5f,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,0xa0,0x52,
1334 0x30,0x50,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,
1335 0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x02,0x06,0x00,0x31,0x37,0x30,0x35,0x02,
1336 0x01,0x01,0x30,0x1a,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,
1337 0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x02,0x01,0x01,
1338 0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,
1339 0x04,0x06,0x00,0x05,0x00,0x04,0x00 };
1340 static const BYTE detachedSignedBareContent[] = {
1341 0x30,0x81,0x99,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,
1342 0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x0b,0x06,0x09,0x2a,0x86,0x48,0x86,
1343 0xf7,0x0d,0x01,0x07,0x01,0x31,0x77,0x30,0x75,0x02,0x01,0x01,0x30,0x1a,0x30,
1344 0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,
1345 0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x02,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,
1346 0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x04,0x06,0x00,0x05,0x00,
1347 0x04,0x40,0x81,0xa6,0x70,0xb3,0xef,0x59,0xd1,0x66,0xd1,0x9b,0xc0,0x9a,0xb6,
1348 0x9a,0x5e,0x6d,0x6f,0x6d,0x0d,0x59,0xa9,0xaa,0x6e,0xe9,0x2c,0xa0,0x1e,0xee,
1349 0xc2,0x60,0xbc,0x59,0xbe,0x3f,0x63,0x06,0x8d,0xc9,0x11,0x1d,0x23,0x64,0x92,
1350 0xef,0x2e,0xfc,0x57,0x29,0xa4,0xaf,0xe0,0xee,0x93,0x19,0x39,0x51,0xe4,0x44,
1351 0xb8,0x0b,0x28,0xf4,0xa8,0x0d };
1352 static const BYTE detachedSignedContent[] = {
1353 0x30,0x81,0xaa,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,0xa0,
1354 0x81,0x9c,0x30,0x81,0x99,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,
1355 0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x0b,0x06,0x09,0x2a,0x86,
1356 0x48,0x86,0xf7,0x0d,0x01,0x07,0x01,0x31,0x77,0x30,0x75,0x02,0x01,0x01,0x30,
1357 0x1a,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,
1358 0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x02,0x01,0x01,0x30,0x0c,0x06,
1359 0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x04,0x06,0x00,
1360 0x05,0x00,0x04,0x40,0x81,0xa6,0x70,0xb3,0xef,0x59,0xd1,0x66,0xd1,0x9b,0xc0,
1361 0x9a,0xb6,0x9a,0x5e,0x6d,0x6f,0x6d,0x0d,0x59,0xa9,0xaa,0x6e,0xe9,0x2c,0xa0,
1362 0x1e,0xee,0xc2,0x60,0xbc,0x59,0xbe,0x3f,0x63,0x06,0x8d,0xc9,0x11,0x1d,0x23,
1363 0x64,0x92,0xef,0x2e,0xfc,0x57,0x29,0xa4,0xaf,0xe0,0xee,0x93,0x19,0x39,0x51,
1364 0xe4,0x44,0xb8,0x0b,0x28,0xf4,0xa8,0x0d };
1365 static const BYTE signedBareContent[] = {
1366 0x30,0x81,0xa1,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,
1367 0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x13,0x06,0x09,0x2a,0x86,0x48,0x86,
1368 0xf7,0x0d,0x01,0x07,0x01,0xa0,0x06,0x04,0x04,0x01,0x02,0x03,0x04,0x31,0x77,
1369 0x30,0x75,0x02,0x01,0x01,0x30,0x1a,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,
1370 0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,
1371 0x02,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,
1372 0x05,0x00,0x30,0x04,0x06,0x00,0x05,0x00,0x04,0x40,0x81,0xa6,0x70,0xb3,0xef,
1373 0x59,0xd1,0x66,0xd1,0x9b,0xc0,0x9a,0xb6,0x9a,0x5e,0x6d,0x6f,0x6d,0x0d,0x59,
1374 0xa9,0xaa,0x6e,0xe9,0x2c,0xa0,0x1e,0xee,0xc2,0x60,0xbc,0x59,0xbe,0x3f,0x63,
1375 0x06,0x8d,0xc9,0x11,0x1d,0x23,0x64,0x92,0xef,0x2e,0xfc,0x57,0x29,0xa4,0xaf,
1376 0xe0,0xee,0x93,0x19,0x39,0x51,0xe4,0x44,0xb8,0x0b,0x28,0xf4,0xa8,0x0d };
1377 static const BYTE signedContent[] = {
1378 0x30,0x81,0xb2,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,0xa0,
1379 0x81,0xa4,0x30,0x81,0xa1,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,
1380 0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x13,0x06,0x09,0x2a,0x86,
1381 0x48,0x86,0xf7,0x0d,0x01,0x07,0x01,0xa0,0x06,0x04,0x04,0x01,0x02,0x03,0x04,
1382 0x31,0x77,0x30,0x75,0x02,0x01,0x01,0x30,0x1a,0x30,0x15,0x31,0x13,0x30,0x11,
1383 0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,
1384 0x67,0x00,0x02,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
1385 0x02,0x05,0x05,0x00,0x30,0x04,0x06,0x00,0x05,0x00,0x04,0x40,0x81,0xa6,0x70,
1386 0xb3,0xef,0x59,0xd1,0x66,0xd1,0x9b,0xc0,0x9a,0xb6,0x9a,0x5e,0x6d,0x6f,0x6d,
1387 0x0d,0x59,0xa9,0xaa,0x6e,0xe9,0x2c,0xa0,0x1e,0xee,0xc2,0x60,0xbc,0x59,0xbe,
1388 0x3f,0x63,0x06,0x8d,0xc9,0x11,0x1d,0x23,0x64,0x92,0xef,0x2e,0xfc,0x57,0x29,
1389 0xa4,0xaf,0xe0,0xee,0x93,0x19,0x39,0x51,0xe4,0x44,0xb8,0x0b,0x28,0xf4,0xa8,
1390 0x0d };
1391 static const BYTE signedHash[] = {
1392 0x08,0xd6,0xc0,0x5a,0x21,0x51,0x2a,0x79,0xa1,0xdf,0xeb,0x9d,0x2a,0x8f,0x26,
1393 0x2f };
1394 static const BYTE signedKeyIdEmptyContent[] = {
1395 0x30,0x46,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,0xa0,0x39,
1396 0x30,0x37,0x02,0x01,0x03,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,
1397 0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x02,0x06,0x00,0x31,0x1e,0x30,0x1c,0x02,
1398 0x01,0x03,0x80,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
1399 0x02,0x05,0x05,0x00,0x30,0x04,0x06,0x00,0x05,0x00,0x04,0x00 };
1400 static const BYTE signedEncodedSigner[] = {
1401 0x30,0x75,0x02,0x01,0x01,0x30,0x1a,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,
1402 0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,
1403 0x02,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,
1404 0x05,0x00,0x30,0x04,0x06,0x00,0x05,0x00,0x04,0x40,0x81,0xa6,0x70,0xb3,0xef,
1405 0x59,0xd1,0x66,0xd1,0x9b,0xc0,0x9a,0xb6,0x9a,0x5e,0x6d,0x6f,0x6d,0x0d,0x59,
1406 0xa9,0xaa,0x6e,0xe9,0x2c,0xa0,0x1e,0xee,0xc2,0x60,0xbc,0x59,0xbe,0x3f,0x63,
1407 0x06,0x8d,0xc9,0x11,0x1d,0x23,0x64,0x92,0xef,0x2e,0xfc,0x57,0x29,0xa4,0xaf,
1408 0xe0,0xee,0x93,0x19,0x39,0x51,0xe4,0x44,0xb8,0x0b,0x28,0xf4,0xa8,0x0d };
1409 static const BYTE signedWithAuthAttrsBareContent[] = {
1410 0x30,0x82,0x01,0x00,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,0x86,
1411 0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x13,0x06,0x09,0x2a,0x86,0x48,
1412 0x86,0xf7,0x0d,0x01,0x07,0x01,0xa0,0x06,0x04,0x04,0x01,0x02,0x03,0x04,0x31,
1413 0x81,0xd5,0x30,0x81,0xd2,0x02,0x01,0x01,0x30,0x1a,0x30,0x15,0x31,0x13,0x30,
1414 0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,
1415 0x6e,0x67,0x00,0x02,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,
1416 0x0d,0x02,0x05,0x05,0x00,0xa0,0x5b,0x30,0x18,0x06,0x09,0x2a,0x86,0x48,0x86,
1417 0xf7,0x0d,0x01,0x09,0x03,0x31,0x0b,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,
1418 0x01,0x07,0x01,0x30,0x1e,0x06,0x03,0x55,0x04,0x03,0x31,0x17,0x30,0x15,0x31,
1419 0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,
1420 0x4c,0x61,0x6e,0x67,0x00,0x30,0x1f,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,
1421 0x01,0x09,0x04,0x31,0x12,0x04,0x10,0x08,0xd6,0xc0,0x5a,0x21,0x51,0x2a,0x79,
1422 0xa1,0xdf,0xeb,0x9d,0x2a,0x8f,0x26,0x2f,0x30,0x04,0x06,0x00,0x05,0x00,0x04,
1423 0x40,0xbf,0x65,0xde,0x7a,0x3e,0xa2,0x19,0x59,0xc3,0xc7,0x02,0x53,0xc9,0x72,
1424 0xcd,0x74,0x96,0x70,0x0b,0x3b,0xcf,0x8b,0xd9,0x17,0x5c,0xc5,0xd1,0x83,0x41,
1425 0x32,0x93,0xa6,0xf3,0x52,0x83,0x94,0xa9,0x6b,0x0a,0x92,0xcf,0xaf,0x12,0xfa,
1426 0x40,0x53,0x12,0x84,0x03,0xab,0x10,0xa2,0x3d,0xe6,0x9f,0x5a,0xbf,0xc5,0xb8,
1427 0xff,0xc6,0x33,0x63,0x34 };
1428 static BYTE cert[] = {
1429 0x30,0x7a,0x02,0x01,0x01,0x30,0x02,0x06,0x00,0x30,0x15,0x31,0x13,0x30,0x11,
1430 0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,
1431 0x67,0x00,0x30,0x22,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,
1432 0x30,0x30,0x30,0x30,0x30,0x5a,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,
1433 0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x15,0x31,0x13,0x30,0x11,0x06,
1434 0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,
1435 0x00,0x30,0x07,0x30,0x02,0x06,0x00,0x03,0x01,0x00,0xa3,0x16,0x30,0x14,0x30,
1436 0x12,0x06,0x03,0x55,0x1d,0x13,0x01,0x01,0xff,0x04,0x08,0x30,0x06,0x01,0x01,
1437 0xff,0x02,0x01,0x01 };
1438 static BYTE v1CertWithPubKey[] = {
1439 0x30,0x81,0x95,0x02,0x01,0x01,0x30,0x02,0x06,0x00,0x30,0x15,0x31,0x13,0x30,
1440 0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,
1441 0x6e,0x67,0x00,0x30,0x22,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,
1442 0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,
1443 0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x15,0x31,0x13,0x30,0x11,
1444 0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,
1445 0x67,0x00,0x30,0x22,0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
1446 0x01,0x01,0x05,0x00,0x03,0x11,0x00,0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
1447 0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0xa3,0x16,0x30,0x14,0x30,0x12,0x06,
1448 0x03,0x55,0x1d,0x13,0x01,0x01,0xff,0x04,0x08,0x30,0x06,0x01,0x01,0xff,0x02,
1449 0x01,0x01 };
1450 static const BYTE signedWithCertEmptyBareContent[] = {
1451 0x30,0x81,0xce,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,
1452 0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x02,0x06,0x00,0xa0,0x7c,0x30,0x7a,
1453 0x02,0x01,0x01,0x30,0x02,0x06,0x00,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,
1454 0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,
1455 0x30,0x22,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,
1456 0x30,0x30,0x30,0x5a,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,
1457 0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,
1458 0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x30,
1459 0x07,0x30,0x02,0x06,0x00,0x03,0x01,0x00,0xa3,0x16,0x30,0x14,0x30,0x12,0x06,
1460 0x03,0x55,0x1d,0x13,0x01,0x01,0xff,0x04,0x08,0x30,0x06,0x01,0x01,0xff,0x02,
1461 0x01,0x01,0x31,0x37,0x30,0x35,0x02,0x01,0x01,0x30,0x1a,0x30,0x15,0x31,0x13,
1462 0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,
1463 0x61,0x6e,0x67,0x00,0x02,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,
1464 0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x04,0x06,0x00,0x05,0x00,0x04,0x00 };
1465 static const BYTE signedWithCertBareContent[] = {
1466 0x30,0x82,0x01,0x1f,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,0x86,
1467 0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x13,0x06,0x09,0x2a,0x86,0x48,
1468 0x86,0xf7,0x0d,0x01,0x07,0x01,0xa0,0x06,0x04,0x04,0x01,0x02,0x03,0x04,0xa0,
1469 0x7c,0x30,0x7a,0x02,0x01,0x01,0x30,0x02,0x06,0x00,0x30,0x15,0x31,0x13,0x30,
1470 0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,
1471 0x6e,0x67,0x00,0x30,0x22,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,
1472 0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,
1473 0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x15,0x31,0x13,0x30,0x11,
1474 0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,
1475 0x67,0x00,0x30,0x07,0x30,0x02,0x06,0x00,0x03,0x01,0x00,0xa3,0x16,0x30,0x14,
1476 0x30,0x12,0x06,0x03,0x55,0x1d,0x13,0x01,0x01,0xff,0x04,0x08,0x30,0x06,0x01,
1477 0x01,0xff,0x02,0x01,0x01,0x31,0x77,0x30,0x75,0x02,0x01,0x01,0x30,0x1a,0x30,
1478 0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,
1479 0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x02,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,
1480 0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x04,0x06,0x00,0x05,0x00,
1481 0x04,0x40,0x81,0xa6,0x70,0xb3,0xef,0x59,0xd1,0x66,0xd1,0x9b,0xc0,0x9a,0xb6,
1482 0x9a,0x5e,0x6d,0x6f,0x6d,0x0d,0x59,0xa9,0xaa,0x6e,0xe9,0x2c,0xa0,0x1e,0xee,
1483 0xc2,0x60,0xbc,0x59,0xbe,0x3f,0x63,0x06,0x8d,0xc9,0x11,0x1d,0x23,0x64,0x92,
1484 0xef,0x2e,0xfc,0x57,0x29,0xa4,0xaf,0xe0,0xee,0x93,0x19,0x39,0x51,0xe4,0x44,
1485 0xb8,0x0b,0x28,0xf4,0xa8,0x0d };
1486 static BYTE crl[] = { 0x30,0x2c,0x30,0x02,0x06,0x00,0x30,0x15,0x31,0x13,0x30,
1487 0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,
1488 0x6e,0x67,0x00,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,
1489 0x30,0x30,0x30,0x30,0x5a };
1490 static const BYTE signedWithCrlEmptyBareContent[] = {
1491 0x30,0x81,0x80,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,
1492 0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x02,0x06,0x00,0xa1,0x2e,0x30,0x2c,
1493 0x30,0x02,0x06,0x00,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,
1494 0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x18,0x0f,0x31,
1495 0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x31,
1496 0x37,0x30,0x35,0x02,0x01,0x01,0x30,0x1a,0x30,0x15,0x31,0x13,0x30,0x11,0x06,
1497 0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,
1498 0x00,0x02,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,
1499 0x05,0x05,0x00,0x30,0x04,0x06,0x00,0x05,0x00,0x04,0x00 };
1500 static const BYTE signedWithCrlBareContent[] = {
1501 0x30,0x81,0xd1,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,
1502 0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x13,0x06,0x09,0x2a,0x86,0x48,0x86,
1503 0xf7,0x0d,0x01,0x07,0x01,0xa0,0x06,0x04,0x04,0x01,0x02,0x03,0x04,0xa1,0x2e,
1504 0x30,0x2c,0x30,0x02,0x06,0x00,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,
1505 0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x18,
1506 0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,
1507 0x5a,0x31,0x77,0x30,0x75,0x02,0x01,0x01,0x30,0x1a,0x30,0x15,0x31,0x13,0x30,
1508 0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,
1509 0x6e,0x67,0x00,0x02,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,
1510 0x0d,0x02,0x05,0x05,0x00,0x30,0x04,0x06,0x00,0x05,0x00,0x04,0x40,0x81,0xa6,
1511 0x70,0xb3,0xef,0x59,0xd1,0x66,0xd1,0x9b,0xc0,0x9a,0xb6,0x9a,0x5e,0x6d,0x6f,
1512 0x6d,0x0d,0x59,0xa9,0xaa,0x6e,0xe9,0x2c,0xa0,0x1e,0xee,0xc2,0x60,0xbc,0x59,
1513 0xbe,0x3f,0x63,0x06,0x8d,0xc9,0x11,0x1d,0x23,0x64,0x92,0xef,0x2e,0xfc,0x57,
1514 0x29,0xa4,0xaf,0xe0,0xee,0x93,0x19,0x39,0x51,0xe4,0x44,0xb8,0x0b,0x28,0xf4,
1515 0xa8,0x0d };
1516 static const BYTE signedWithCertAndCrlEmptyBareContent[] = {
1517 0x30,0x81,0xfe,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,
1518 0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x02,0x06,0x00,0xa0,0x7c,0x30,0x7a,
1519 0x02,0x01,0x01,0x30,0x02,0x06,0x00,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,
1520 0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,
1521 0x30,0x22,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,
1522 0x30,0x30,0x30,0x5a,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,
1523 0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,
1524 0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x30,
1525 0x07,0x30,0x02,0x06,0x00,0x03,0x01,0x00,0xa3,0x16,0x30,0x14,0x30,0x12,0x06,
1526 0x03,0x55,0x1d,0x13,0x01,0x01,0xff,0x04,0x08,0x30,0x06,0x01,0x01,0xff,0x02,
1527 0x01,0x01,0xa1,0x2e,0x30,0x2c,0x30,0x02,0x06,0x00,0x30,0x15,0x31,0x13,0x30,
1528 0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,
1529 0x6e,0x67,0x00,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,
1530 0x30,0x30,0x30,0x30,0x5a,0x31,0x37,0x30,0x35,0x02,0x01,0x01,0x30,0x1a,0x30,
1531 0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,
1532 0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x02,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,
1533 0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x04,0x06,0x00,0x05,0x00,
1534 0x04,0x00 };
1535 static const BYTE signedWithCertAndCrlBareContent[] = {
1536 0x30,0x82,0x01,0x4f,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,0x86,
1537 0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x13,0x06,0x09,0x2a,0x86,0x48,
1538 0x86,0xf7,0x0d,0x01,0x07,0x01,0xa0,0x06,0x04,0x04,0x01,0x02,0x03,0x04,0xa0,
1539 0x7c,0x30,0x7a,0x02,0x01,0x01,0x30,0x02,0x06,0x00,0x30,0x15,0x31,0x13,0x30,
1540 0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,
1541 0x6e,0x67,0x00,0x30,0x22,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,
1542 0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,
1543 0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x15,0x31,0x13,0x30,0x11,
1544 0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,
1545 0x67,0x00,0x30,0x07,0x30,0x02,0x06,0x00,0x03,0x01,0x00,0xa3,0x16,0x30,0x14,
1546 0x30,0x12,0x06,0x03,0x55,0x1d,0x13,0x01,0x01,0xff,0x04,0x08,0x30,0x06,0x01,
1547 0x01,0xff,0x02,0x01,0x01,0xa1,0x2e,0x30,0x2c,0x30,0x02,0x06,0x00,0x30,0x15,
1548 0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,
1549 0x20,0x4c,0x61,0x6e,0x67,0x00,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,
1550 0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x31,0x77,0x30,0x75,0x02,0x01,0x01,
1551 0x30,0x1a,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,
1552 0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x02,0x01,0x01,0x30,0x0c,
1553 0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x04,0x06,
1554 0x00,0x05,0x00,0x04,0x40,0x81,0xa6,0x70,0xb3,0xef,0x59,0xd1,0x66,0xd1,0x9b,
1555 0xc0,0x9a,0xb6,0x9a,0x5e,0x6d,0x6f,0x6d,0x0d,0x59,0xa9,0xaa,0x6e,0xe9,0x2c,
1556 0xa0,0x1e,0xee,0xc2,0x60,0xbc,0x59,0xbe,0x3f,0x63,0x06,0x8d,0xc9,0x11,0x1d,
1557 0x23,0x64,0x92,0xef,0x2e,0xfc,0x57,0x29,0xa4,0xaf,0xe0,0xee,0x93,0x19,0x39,
1558 0x51,0xe4,0x44,0xb8,0x0b,0x28,0xf4,0xa8,0x0d };
1559 static const BYTE signedWithCertWithPubKeyBareContent[] = {
1560 0x30,0x81,0xeb,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,
1561 0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x02,0x06,0x00,0xa0,0x81,0x98,0x30,
1562 0x81,0x95,0x02,0x01,0x01,0x30,0x02,0x06,0x00,0x30,0x15,0x31,0x13,0x30,0x11,
1563 0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,
1564 0x67,0x00,0x30,0x22,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,
1565 0x30,0x30,0x30,0x30,0x30,0x5a,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,
1566 0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x15,0x31,0x13,0x30,0x11,0x06,
1567 0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,
1568 0x00,0x30,0x22,0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x01,
1569 0x01,0x05,0x00,0x03,0x11,0x00,0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,
1570 0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0xa3,0x16,0x30,0x14,0x30,0x12,0x06,0x03,
1571 0x55,0x1d,0x13,0x01,0x01,0xff,0x04,0x08,0x30,0x06,0x01,0x01,0xff,0x02,0x01,
1572 0x01,0x31,0x37,0x30,0x35,0x02,0x01,0x01,0x30,0x1a,0x30,0x15,0x31,0x13,0x30,
1573 0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,
1574 0x6e,0x67,0x00,0x02,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,
1575 0x0d,0x02,0x05,0x05,0x00,0x30,0x04,0x06,0x00,0x05,0x00,0x04,0x00 };
1576 static BYTE v1CertWithValidPubKey[] = {
1577 0x30,0x81,0xcf,0x02,0x01,0x01,0x30,0x02,0x06,0x00,0x30,0x15,0x31,0x13,0x30,
1578 0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,
1579 0x6e,0x67,0x00,0x30,0x22,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,
1580 0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,
1581 0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x15,0x31,0x13,0x30,0x11,
1582 0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,
1583 0x67,0x00,0x30,0x5c,0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
1584 0x01,0x01,0x05,0x00,0x03,0x4b,0x00,0x30,0x48,0x02,0x41,0x00,0xe2,0x54,0x3a,
1585 0xa7,0x83,0xb1,0x27,0x14,0x3e,0x59,0xbb,0xb4,0x53,0xe6,0x1f,0xe7,0x5d,0xf1,
1586 0x21,0x68,0xad,0x85,0x53,0xdb,0x6b,0x1e,0xeb,0x65,0x97,0x03,0x86,0x60,0xde,
1587 0xf3,0x6c,0x38,0x75,0xe0,0x4c,0x61,0xbb,0xbc,0x62,0x17,0xa9,0xcd,0x79,0x3f,
1588 0x21,0x4e,0x96,0xcb,0x0e,0xdc,0x61,0x94,0x30,0x18,0x10,0x6b,0xd0,0x1c,0x10,
1589 0x79,0x02,0x03,0x01,0x00,0x01,0xa3,0x16,0x30,0x14,0x30,0x12,0x06,0x03,0x55,
1590 0x1d,0x13,0x01,0x01,0xff,0x04,0x08,0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01 };
1591 static const BYTE signedWithCertWithValidPubKeyEmptyContent[] = {
1592 0x30,0x82,0x01,0x38,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,
1593 0xa0,0x82,0x01,0x29,0x30,0x82,0x01,0x25,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,
1594 0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x02,0x06,
1595 0x00,0xa0,0x81,0xd2,0x30,0x81,0xcf,0x02,0x01,0x01,0x30,0x02,0x06,0x00,0x30,
1596 0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,
1597 0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x30,0x22,0x18,0x0f,0x31,0x36,0x30,0x31,
1598 0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x18,0x0f,0x31,0x36,
1599 0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x15,
1600 0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,
1601 0x20,0x4c,0x61,0x6e,0x67,0x00,0x30,0x5c,0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,
1602 0x86,0xf7,0x0d,0x01,0x01,0x01,0x05,0x00,0x03,0x4b,0x00,0x30,0x48,0x02,0x41,
1603 0x00,0xe2,0x54,0x3a,0xa7,0x83,0xb1,0x27,0x14,0x3e,0x59,0xbb,0xb4,0x53,0xe6,
1604 0x1f,0xe7,0x5d,0xf1,0x21,0x68,0xad,0x85,0x53,0xdb,0x6b,0x1e,0xeb,0x65,0x97,
1605 0x03,0x86,0x60,0xde,0xf3,0x6c,0x38,0x75,0xe0,0x4c,0x61,0xbb,0xbc,0x62,0x17,
1606 0xa9,0xcd,0x79,0x3f,0x21,0x4e,0x96,0xcb,0x0e,0xdc,0x61,0x94,0x30,0x18,0x10,
1607 0x6b,0xd0,0x1c,0x10,0x79,0x02,0x03,0x01,0x00,0x01,0xa3,0x16,0x30,0x14,0x30,
1608 0x12,0x06,0x03,0x55,0x1d,0x13,0x01,0x01,0xff,0x04,0x08,0x30,0x06,0x01,0x01,
1609 0xff,0x02,0x01,0x01,0x31,0x37,0x30,0x35,0x02,0x01,0x01,0x30,0x1a,0x30,0x15,
1610 0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,
1611 0x20,0x4c,0x61,0x6e,0x67,0x00,0x02,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,
1612 0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x04,0x06,0x00,0x05,0x00,0x04,
1613 0x00 };
1614 static const BYTE signedWithCertWithValidPubKeyContent[] = {
1615 0x30,0x82,0x01,0x89,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,
1616 0xa0,0x82,0x01,0x7a,0x30,0x82,0x01,0x76,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,
1617 0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x13,0x06,
1618 0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x01,0xa0,0x06,0x04,0x04,0x01,
1619 0x02,0x03,0x04,0xa0,0x81,0xd2,0x30,0x81,0xcf,0x02,0x01,0x01,0x30,0x02,0x06,
1620 0x00,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,
1621 0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x30,0x22,0x18,0x0f,0x31,0x36,
1622 0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x18,0x0f,
1623 0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,
1624 0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,
1625 0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x30,0x5c,0x30,0x0d,0x06,0x09,0x2a,
1626 0x86,0x48,0x86,0xf7,0x0d,0x01,0x01,0x01,0x05,0x00,0x03,0x4b,0x00,0x30,0x48,
1627 0x02,0x41,0x00,0xe2,0x54,0x3a,0xa7,0x83,0xb1,0x27,0x14,0x3e,0x59,0xbb,0xb4,
1628 0x53,0xe6,0x1f,0xe7,0x5d,0xf1,0x21,0x68,0xad,0x85,0x53,0xdb,0x6b,0x1e,0xeb,
1629 0x65,0x97,0x03,0x86,0x60,0xde,0xf3,0x6c,0x38,0x75,0xe0,0x4c,0x61,0xbb,0xbc,
1630 0x62,0x17,0xa9,0xcd,0x79,0x3f,0x21,0x4e,0x96,0xcb,0x0e,0xdc,0x61,0x94,0x30,
1631 0x18,0x10,0x6b,0xd0,0x1c,0x10,0x79,0x02,0x03,0x01,0x00,0x01,0xa3,0x16,0x30,
1632 0x14,0x30,0x12,0x06,0x03,0x55,0x1d,0x13,0x01,0x01,0xff,0x04,0x08,0x30,0x06,
1633 0x01,0x01,0xff,0x02,0x01,0x01,0x31,0x77,0x30,0x75,0x02,0x01,0x01,0x30,0x1a,
1634 0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,
1635 0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x02,0x01,0x01,0x30,0x0c,0x06,0x08,
1636 0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x04,0x06,0x00,0x05,
1637 0x00,0x04,0x40,0x81,0xa6,0x70,0xb3,0xef,0x59,0xd1,0x66,0xd1,0x9b,0xc0,0x9a,
1638 0xb6,0x9a,0x5e,0x6d,0x6f,0x6d,0x0d,0x59,0xa9,0xaa,0x6e,0xe9,0x2c,0xa0,0x1e,
1639 0xee,0xc2,0x60,0xbc,0x59,0xbe,0x3f,0x63,0x06,0x8d,0xc9,0x11,0x1d,0x23,0x64,
1640 0x92,0xef,0x2e,0xfc,0x57,0x29,0xa4,0xaf,0xe0,0xee,0x93,0x19,0x39,0x51,0xe4,
1641 0x44,0xb8,0x0b,0x28,0xf4,0xa8,0x0d };
1642
1643 static void test_signed_msg_encoding(void)
1644 {
1645     HCRYPTMSG msg;
1646     CMSG_SIGNED_ENCODE_INFO signInfo = { sizeof(signInfo), 0 };
1647     CMSG_SIGNER_ENCODE_INFO signer = { sizeof(signer), 0 };
1648     CERT_INFO certInfo = { 0 };
1649     CERT_BLOB encodedCert = { sizeof(cert), cert };
1650     CRL_BLOB encodedCrl = { sizeof(crl), crl };
1651     char oid_common_name[] = szOID_COMMON_NAME;
1652     CRYPT_ATTR_BLOB commonName = { sizeof(encodedCommonName),
1653      encodedCommonName };
1654     CRYPT_ATTRIBUTE attr = { oid_common_name, 1, &commonName };
1655     BOOL ret;
1656     HCRYPTKEY key;
1657     DWORD size;
1658
1659     certInfo.SerialNumber.cbData = sizeof(serialNum);
1660     certInfo.SerialNumber.pbData = serialNum;
1661     certInfo.Issuer.cbData = sizeof(encodedCommonName);
1662     certInfo.Issuer.pbData = encodedCommonName;
1663     signer.pCertInfo = &certInfo;
1664     signer.HashAlgorithm.pszObjId = oid_rsa_md5;
1665     signInfo.cSigners = 1;
1666     signInfo.rgSigners = &signer;
1667
1668     ret = pCryptAcquireContextA(&signer.hCryptProv, cspNameA, NULL,
1669                                 PROV_RSA_FULL, CRYPT_NEWKEYSET);
1670     if (!ret && GetLastError() == NTE_EXISTS) {
1671         ret = pCryptAcquireContextA(&signer.hCryptProv, cspNameA, NULL,
1672                                     PROV_RSA_FULL, 0);
1673     }
1674     ok(ret, "CryptAcquireContext failed: 0x%x\n", GetLastError());
1675
1676     if (!ret) {
1677         skip("No context for tests\n");
1678         return;
1679     }
1680
1681     ret = CryptImportKey(signer.hCryptProv, privKey, sizeof(privKey),
1682      0, 0, &key);
1683     ok(ret, "CryptImportKey failed: %08x\n", GetLastError());
1684
1685     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING,
1686      CMSG_DETACHED_FLAG, CMSG_SIGNED, &signInfo, NULL, NULL);
1687     ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1688
1689     check_param("detached signed empty bare content", msg,
1690      CMSG_BARE_CONTENT_PARAM, signedEmptyBareContent,
1691      sizeof(signedEmptyBareContent));
1692     check_param("detached signed empty content", msg, CMSG_CONTENT_PARAM,
1693      signedEmptyContent, sizeof(signedEmptyContent));
1694     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
1695     ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
1696     check_param("detached signed hash", msg, CMSG_COMPUTED_HASH_PARAM,
1697      signedHash, sizeof(signedHash));
1698     check_param("detached signed bare content", msg, CMSG_BARE_CONTENT_PARAM,
1699      detachedSignedBareContent, sizeof(detachedSignedBareContent));
1700     check_param("detached signed content", msg, CMSG_CONTENT_PARAM,
1701      detachedSignedContent, sizeof(detachedSignedContent));
1702     SetLastError(0xdeadbeef);
1703     ret = CryptMsgGetParam(msg, CMSG_COMPUTED_HASH_PARAM, 1, NULL, &size);
1704     ok(!ret && (GetLastError() == CRYPT_E_INVALID_INDEX ||
1705      broken(GetLastError() == CRYPT_E_INVALID_MSG_TYPE /* Win9x */)),
1706      "Expected CRYPT_E_INVALID_INDEX, got %x\n", GetLastError());
1707     check_param("detached signed encoded signer", msg, CMSG_ENCODED_SIGNER,
1708      signedEncodedSigner, sizeof(signedEncodedSigner));
1709
1710     CryptMsgClose(msg);
1711
1712     certInfo.SerialNumber.cbData = 0;
1713     certInfo.Issuer.cbData = 0;
1714     signer.SignerId.dwIdChoice = CERT_ID_KEY_IDENTIFIER;
1715     U(signer.SignerId).KeyId.cbData = sizeof(serialNum);
1716     U(signer.SignerId).KeyId.pbData = serialNum;
1717     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_SIGNED, &signInfo,
1718      NULL, NULL);
1719     ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1720     check_param("signed key id empty content", msg, CMSG_CONTENT_PARAM,
1721      signedKeyIdEmptyContent, sizeof(signedKeyIdEmptyContent));
1722     CryptMsgClose(msg);
1723
1724     certInfo.SerialNumber.cbData = sizeof(serialNum);
1725     certInfo.SerialNumber.pbData = serialNum;
1726     certInfo.Issuer.cbData = sizeof(encodedCommonName);
1727     certInfo.Issuer.pbData = encodedCommonName;
1728     signer.SignerId.dwIdChoice = 0;
1729     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_SIGNED, &signInfo,
1730      NULL, NULL);
1731     ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1732
1733     check_param("signed empty bare content", msg, CMSG_BARE_CONTENT_PARAM,
1734      signedEmptyBareContent, sizeof(signedEmptyBareContent));
1735     check_param("signed empty content", msg, CMSG_CONTENT_PARAM,
1736      signedEmptyContent, sizeof(signedEmptyContent));
1737     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
1738     ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
1739     check_param("signed bare content", msg, CMSG_BARE_CONTENT_PARAM,
1740      signedBareContent, sizeof(signedBareContent));
1741     check_param("signed content", msg, CMSG_CONTENT_PARAM,
1742      signedContent, sizeof(signedContent));
1743
1744     CryptMsgClose(msg);
1745
1746     signer.cAuthAttr = 1;
1747     signer.rgAuthAttr = &attr;
1748     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_SIGNED, &signInfo,
1749      NULL, NULL);
1750     ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1751
1752     CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
1753     check_param("signed with auth attrs bare content", msg,
1754      CMSG_BARE_CONTENT_PARAM, signedWithAuthAttrsBareContent,
1755      sizeof(signedWithAuthAttrsBareContent));
1756
1757     CryptMsgClose(msg);
1758
1759     signer.cAuthAttr = 0;
1760     signInfo.rgCertEncoded = &encodedCert;
1761     signInfo.cCertEncoded = 1;
1762     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_SIGNED, &signInfo,
1763      NULL, NULL);
1764     ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1765
1766     check_param("signed with cert empty bare content", msg,
1767      CMSG_BARE_CONTENT_PARAM, signedWithCertEmptyBareContent,
1768      sizeof(signedWithCertEmptyBareContent));
1769     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
1770     ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
1771     check_param("signed with cert bare content", msg, CMSG_BARE_CONTENT_PARAM,
1772      signedWithCertBareContent, sizeof(signedWithCertBareContent));
1773
1774     CryptMsgClose(msg);
1775
1776     signInfo.cCertEncoded = 0;
1777     signInfo.rgCrlEncoded = &encodedCrl;
1778     signInfo.cCrlEncoded = 1;
1779     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_SIGNED, &signInfo,
1780      NULL, NULL);
1781     ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1782
1783     check_param("signed with crl empty bare content", msg,
1784      CMSG_BARE_CONTENT_PARAM, signedWithCrlEmptyBareContent,
1785      sizeof(signedWithCrlEmptyBareContent));
1786     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
1787     ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
1788     check_param("signed with crl bare content", msg, CMSG_BARE_CONTENT_PARAM,
1789      signedWithCrlBareContent, sizeof(signedWithCrlBareContent));
1790
1791     CryptMsgClose(msg);
1792
1793     signInfo.cCertEncoded = 1;
1794     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_SIGNED, &signInfo,
1795      NULL, NULL);
1796     ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1797
1798     check_param("signed with cert and crl empty bare content", msg,
1799      CMSG_BARE_CONTENT_PARAM, signedWithCertAndCrlEmptyBareContent,
1800      sizeof(signedWithCertAndCrlEmptyBareContent));
1801     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
1802     ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
1803     check_param("signed with cert and crl bare content", msg,
1804      CMSG_BARE_CONTENT_PARAM, signedWithCertAndCrlBareContent,
1805      sizeof(signedWithCertAndCrlBareContent));
1806
1807     CryptMsgClose(msg);
1808
1809     /* Test with a cert with a (bogus) public key */
1810     signInfo.cCrlEncoded = 0;
1811     encodedCert.cbData = sizeof(v1CertWithPubKey);
1812     encodedCert.pbData = v1CertWithPubKey;
1813     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_SIGNED, &signInfo,
1814      NULL, NULL);
1815     ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1816     check_param("signedWithCertWithPubKeyBareContent", msg,
1817      CMSG_BARE_CONTENT_PARAM, signedWithCertWithPubKeyBareContent,
1818      sizeof(signedWithCertWithPubKeyBareContent));
1819     CryptMsgClose(msg);
1820
1821     encodedCert.cbData = sizeof(v1CertWithValidPubKey);
1822     encodedCert.pbData = v1CertWithValidPubKey;
1823     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_SIGNED, &signInfo,
1824      NULL, NULL);
1825     ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1826     check_param("signedWithCertWithValidPubKeyEmptyContent", msg,
1827      CMSG_CONTENT_PARAM, signedWithCertWithValidPubKeyEmptyContent,
1828      sizeof(signedWithCertWithValidPubKeyEmptyContent));
1829     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
1830     ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
1831     check_param("signedWithCertWithValidPubKeyContent", msg,
1832      CMSG_CONTENT_PARAM, signedWithCertWithValidPubKeyContent,
1833      sizeof(signedWithCertWithValidPubKeyContent));
1834     CryptMsgClose(msg);
1835
1836     CryptDestroyKey(key);
1837     CryptReleaseContext(signer.hCryptProv, 0);
1838     pCryptAcquireContextA(&signer.hCryptProv, cspNameA, NULL, PROV_RSA_FULL,
1839      CRYPT_DELETEKEYSET);
1840 }
1841
1842 static void test_signed_msg_get_param(void)
1843 {
1844     BOOL ret;
1845     HCRYPTMSG msg;
1846     DWORD size, value = 0;
1847     CMSG_SIGNED_ENCODE_INFO signInfo = { sizeof(signInfo), 0 };
1848     CMSG_SIGNER_ENCODE_INFO signer = { sizeof(signer), 0 };
1849     CERT_INFO certInfo = { 0 };
1850
1851     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_SIGNED, &signInfo,
1852      NULL, NULL);
1853     ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1854
1855     /* Content and bare content are always gettable */
1856     size = 0;
1857     ret = CryptMsgGetParam(msg, CMSG_CONTENT_PARAM, 0, NULL, &size);
1858     ok(ret || broken(!ret /* Win9x */), "CryptMsgGetParam failed: %08x\n",
1859      GetLastError());
1860     if (!ret)
1861     {
1862         skip("message parameters are broken, skipping tests\n");
1863         return;
1864     }
1865     size = 0;
1866     ret = CryptMsgGetParam(msg, CMSG_BARE_CONTENT_PARAM, 0, NULL, &size);
1867     ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
1868     /* For "signed" messages, so is the version. */
1869     size = 0;
1870     ret = CryptMsgGetParam(msg, CMSG_VERSION_PARAM, 0, NULL, &size);
1871     ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
1872     size = sizeof(value);
1873     ret = CryptMsgGetParam(msg, CMSG_VERSION_PARAM, 0, &value, &size);
1874     ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
1875     ok(value == CMSG_SIGNED_DATA_V1, "Expected version 1, got %d\n", value);
1876     /* But for this message, with no signers, the hash and signer aren't
1877      * available.
1878      */
1879     size = 0;
1880     SetLastError(0xdeadbeef);
1881     ret = CryptMsgGetParam(msg, CMSG_ENCODED_SIGNER, 0, NULL, &size);
1882     ok(!ret && GetLastError() == CRYPT_E_INVALID_INDEX,
1883      "Expected CRYPT_E_INVALID_INDEX, got %x\n", GetLastError());
1884     SetLastError(0xdeadbeef);
1885     ret = CryptMsgGetParam(msg, CMSG_COMPUTED_HASH_PARAM, 0, NULL, &size);
1886     ok(!ret && GetLastError() == CRYPT_E_INVALID_INDEX,
1887      "Expected CRYPT_E_INVALID_INDEX, got %x\n", GetLastError());
1888     /* As usual, the type isn't available. */
1889     ret = CryptMsgGetParam(msg, CMSG_TYPE_PARAM, 0, NULL, &size);
1890     ok(!ret && GetLastError() == CRYPT_E_INVALID_MSG_TYPE,
1891      "Expected CRYPT_E_INVALID_MSG_TYPE, got %x\n", GetLastError());
1892
1893     CryptMsgClose(msg);
1894
1895     certInfo.SerialNumber.cbData = sizeof(serialNum);
1896     certInfo.SerialNumber.pbData = serialNum;
1897     certInfo.Issuer.cbData = sizeof(encodedCommonName);
1898     certInfo.Issuer.pbData = encodedCommonName;
1899     signer.pCertInfo = &certInfo;
1900     signer.HashAlgorithm.pszObjId = oid_rsa_md5;
1901     signInfo.cSigners = 1;
1902     signInfo.rgSigners = &signer;
1903
1904     ret = pCryptAcquireContextA(&signer.hCryptProv, cspNameA, NULL,
1905                                 PROV_RSA_FULL, CRYPT_NEWKEYSET);
1906     if (!ret && GetLastError() == NTE_EXISTS) {
1907         ret = pCryptAcquireContextA(&signer.hCryptProv, cspNameA, NULL,
1908                                     PROV_RSA_FULL, 0);
1909     }
1910     ok(ret, "CryptAcquireContext failed: 0x%x\n", GetLastError());
1911
1912     if (!ret) {
1913         skip("No context for tests\n");
1914         return;
1915     }
1916
1917     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_SIGNED, &signInfo,
1918      NULL, NULL);
1919     ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1920
1921     /* This message, with one signer, has the hash and signer for index 0
1922      * available, but not for other indexes.
1923      */
1924     size = 0;
1925     ret = CryptMsgGetParam(msg, CMSG_ENCODED_SIGNER, 0, NULL, &size);
1926     ok(ret, "CryptMsgGetParam failed: %x\n", GetLastError());
1927     ret = CryptMsgGetParam(msg, CMSG_COMPUTED_HASH_PARAM, 0, NULL, &size);
1928     ok(ret, "CryptMsgGetParam failed: %x\n", GetLastError());
1929     size = 0;
1930     SetLastError(0xdeadbeef);
1931     ret = CryptMsgGetParam(msg, CMSG_ENCODED_SIGNER, 1, NULL, &size);
1932     ok(!ret && GetLastError() == CRYPT_E_INVALID_INDEX,
1933      "Expected CRYPT_E_INVALID_INDEX, got %x\n", GetLastError());
1934     SetLastError(0xdeadbeef);
1935     ret = CryptMsgGetParam(msg, CMSG_COMPUTED_HASH_PARAM, 1, NULL, &size);
1936     ok(!ret && GetLastError() == CRYPT_E_INVALID_INDEX,
1937      "Expected CRYPT_E_INVALID_INDEX, got %x\n", GetLastError());
1938     /* As usual, the type isn't available. */
1939     ret = CryptMsgGetParam(msg, CMSG_TYPE_PARAM, 0, NULL, &size);
1940     ok(!ret && GetLastError() == CRYPT_E_INVALID_MSG_TYPE,
1941      "Expected CRYPT_E_INVALID_MSG_TYPE, got %x\n", GetLastError());
1942
1943     CryptMsgClose(msg);
1944
1945     /* Opening the message using the CMS fields.. */
1946     certInfo.SerialNumber.cbData = 0;
1947     certInfo.Issuer.cbData = 0;
1948     signer.SignerId.dwIdChoice = CERT_ID_ISSUER_SERIAL_NUMBER;
1949     U(signer.SignerId).IssuerSerialNumber.Issuer.cbData =
1950      sizeof(encodedCommonName);
1951     U(signer.SignerId).IssuerSerialNumber.Issuer.pbData = encodedCommonName;
1952     U(signer.SignerId).IssuerSerialNumber.SerialNumber.cbData =
1953      sizeof(serialNum);
1954     U(signer.SignerId).IssuerSerialNumber.SerialNumber.pbData = serialNum;
1955     ret = pCryptAcquireContextA(&signer.hCryptProv, cspNameA, NULL,
1956      PROV_RSA_FULL, CRYPT_NEWKEYSET);
1957     if (!ret && GetLastError() == NTE_EXISTS)
1958         ret = pCryptAcquireContextA(&signer.hCryptProv, cspNameA, NULL,
1959          PROV_RSA_FULL, 0);
1960     ok(ret, "CryptAcquireContextA failed: %x\n", GetLastError());
1961     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING,
1962      CMSG_CRYPT_RELEASE_CONTEXT_FLAG, CMSG_SIGNED, &signInfo, NULL, NULL);
1963     ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
1964     /* still results in the version being 1 when the issuer and serial number
1965      * are used and no additional CMS fields are used.
1966      */
1967     size = sizeof(value);
1968     ret = CryptMsgGetParam(msg, CMSG_VERSION_PARAM, 0, &value, &size);
1969     ok(ret || broken(GetLastError() == CRYPT_E_INVALID_MSG_TYPE),
1970      "CryptMsgGetParam failed: %08x\n", GetLastError());
1971     if (ret)
1972         ok(value == CMSG_SIGNED_DATA_V1, "expected version 1, got %d\n", value);
1973     /* Apparently the encoded signer can be retrieved.. */
1974     ret = CryptMsgGetParam(msg, CMSG_ENCODED_SIGNER, 0, NULL, &size);
1975     ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
1976     /* but the signer info, CMS signer info, and cert ID can't be. */
1977     SetLastError(0xdeadbeef);
1978     ret = CryptMsgGetParam(msg, CMSG_SIGNER_INFO_PARAM, 0, NULL, &size);
1979     ok(!ret && GetLastError() == CRYPT_E_INVALID_MSG_TYPE,
1980      "expected CRYPT_E_INVALID_MSG_TYPE, got %08x\n", GetLastError());
1981     SetLastError(0xdeadbeef);
1982     ret = CryptMsgGetParam(msg, CMSG_CMS_SIGNER_INFO_PARAM, 0, NULL, &size);
1983     ok(!ret && GetLastError() == CRYPT_E_INVALID_MSG_TYPE,
1984      "expected CRYPT_E_INVALID_MSG_TYPE, got %08x\n", GetLastError());
1985     SetLastError(0xdeadbeef);
1986     ret = CryptMsgGetParam(msg, CMSG_SIGNER_CERT_ID_PARAM, 0, NULL, &size);
1987     ok(!ret && GetLastError() == CRYPT_E_INVALID_MSG_TYPE,
1988      "expected CRYPT_E_INVALID_MSG_TYPE, got %08x\n", GetLastError());
1989     CryptMsgClose(msg);
1990
1991     /* Using the KeyId field of the SignerId results in the version becoming
1992      * the CMS version.
1993      */
1994     signer.SignerId.dwIdChoice = CERT_ID_KEY_IDENTIFIER;
1995     U(signer.SignerId).KeyId.cbData = sizeof(serialNum);
1996     U(signer.SignerId).KeyId.pbData = serialNum;
1997     ret = pCryptAcquireContextA(&signer.hCryptProv, cspNameA, NULL,
1998      PROV_RSA_FULL, CRYPT_NEWKEYSET);
1999     if (!ret && GetLastError() == NTE_EXISTS)
2000         ret = pCryptAcquireContextA(&signer.hCryptProv, cspNameA, NULL,
2001          PROV_RSA_FULL, 0);
2002     ok(ret, "CryptAcquireContextA failed: %x\n", GetLastError());
2003     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING,
2004      CMSG_CRYPT_RELEASE_CONTEXT_FLAG, CMSG_SIGNED, &signInfo, NULL, NULL);
2005     ok(msg != NULL, "CryptMsgOpenToEncode failed: %x\n", GetLastError());
2006     size = sizeof(value);
2007     ret = CryptMsgGetParam(msg, CMSG_VERSION_PARAM, 0, &value, &size);
2008     ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
2009     if (ret)
2010         ok(value == CMSG_SIGNED_DATA_V3, "expected version 3, got %d\n", value);
2011     /* Even for a CMS message, the signer can be retrieved.. */
2012     ret = CryptMsgGetParam(msg, CMSG_ENCODED_SIGNER, 0, NULL, &size);
2013     ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
2014     /* but the signer info, CMS signer info, and cert ID can't be. */
2015     SetLastError(0xdeadbeef);
2016     ret = CryptMsgGetParam(msg, CMSG_SIGNER_INFO_PARAM, 0, NULL, &size);
2017     ok(!ret && GetLastError() == CRYPT_E_INVALID_MSG_TYPE,
2018      "expected CRYPT_E_INVALID_MSG_TYPE, got %08x\n", GetLastError());
2019     SetLastError(0xdeadbeef);
2020     ret = CryptMsgGetParam(msg, CMSG_CMS_SIGNER_INFO_PARAM, 0, NULL, &size);
2021     ok(!ret && GetLastError() == CRYPT_E_INVALID_MSG_TYPE,
2022      "expected CRYPT_E_INVALID_MSG_TYPE, got %08x\n", GetLastError());
2023     SetLastError(0xdeadbeef);
2024     ret = CryptMsgGetParam(msg, CMSG_SIGNER_CERT_ID_PARAM, 0, NULL, &size);
2025     ok(!ret && GetLastError() == CRYPT_E_INVALID_MSG_TYPE,
2026      "expected CRYPT_E_INVALID_MSG_TYPE, got %08x\n", GetLastError());
2027     CryptMsgClose(msg);
2028
2029     CryptReleaseContext(signer.hCryptProv, 0);
2030     pCryptAcquireContextA(&signer.hCryptProv, cspNameA, MS_DEF_PROV_A,
2031      PROV_RSA_FULL, CRYPT_DELETEKEYSET);
2032 }
2033
2034 static void test_signed_msg(void)
2035 {
2036     test_signed_msg_open();
2037     test_signed_msg_update();
2038     test_signed_msg_encoding();
2039     test_signed_msg_get_param();
2040 }
2041
2042 static char oid_rsa_rc4[] = szOID_RSA_RC4;
2043
2044 static void test_enveloped_msg_open(void)
2045 {
2046     HCRYPTMSG msg;
2047     BOOL ret;
2048     CMSG_ENVELOPED_ENCODE_INFO envelopedInfo = { 0 };
2049     PCCERT_CONTEXT context;
2050
2051     SetLastError(0xdeadbeef);
2052     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_ENVELOPED,
2053      &envelopedInfo, NULL, NULL);
2054     ok(!msg && GetLastError() == E_INVALIDARG,
2055      "expected E_INVALIDARG, got %08x\n", GetLastError());
2056
2057     envelopedInfo.cbSize = sizeof(envelopedInfo);
2058     SetLastError(0xdeadbeef);
2059     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_ENVELOPED,
2060      &envelopedInfo, NULL, NULL);
2061     ok(!msg &&
2062      (GetLastError() == CRYPT_E_UNKNOWN_ALGO ||
2063       GetLastError() == E_INVALIDARG), /* Win9x */
2064      "expected CRYPT_E_UNKNOWN_ALGO or E_INVALIDARG, got %08x\n", GetLastError());
2065
2066     envelopedInfo.ContentEncryptionAlgorithm.pszObjId = oid_rsa_rc4;
2067     SetLastError(0xdeadbeef);
2068     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_ENVELOPED,
2069      &envelopedInfo, NULL, NULL);
2070     ok(msg != NULL ||
2071      broken(!msg), /* Win9x */
2072      "CryptMsgOpenToEncode failed: %08x\n", GetLastError());
2073     CryptMsgClose(msg);
2074
2075     envelopedInfo.cRecipients = 1;
2076     if (!old_crypt32)
2077     {
2078         SetLastError(0xdeadbeef);
2079         msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_ENVELOPED,
2080          &envelopedInfo, NULL, NULL);
2081         ok(!msg && GetLastError() == E_INVALIDARG,
2082          "expected E_INVALIDARG, got %08x\n", GetLastError());
2083     }
2084
2085     context = CertCreateCertificateContext(X509_ASN_ENCODING,
2086      v1CertWithValidPubKey, sizeof(v1CertWithValidPubKey));
2087     if (context)
2088     {
2089         envelopedInfo.rgpRecipientCert = (PCERT_INFO *)&context->pCertInfo;
2090         SetLastError(0xdeadbeef);
2091         msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_ENVELOPED,
2092          &envelopedInfo, NULL, NULL);
2093         ok(msg != NULL, "CryptMsgOpenToEncode failed: %08x\n", GetLastError());
2094         CryptMsgClose(msg);
2095         SetLastError(0xdeadbeef);
2096         ret = pCryptAcquireContextA(&envelopedInfo.hCryptProv, NULL, NULL,
2097          PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);
2098         ok(ret, "CryptAcquireContextA failed: %08x\n", GetLastError());
2099         SetLastError(0xdeadbeef);
2100         msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_ENVELOPED,
2101          &envelopedInfo, NULL, NULL);
2102         ok(msg != NULL, "CryptMsgOpenToEncode failed: %08x\n", GetLastError());
2103         CryptMsgClose(msg);
2104         CryptReleaseContext(envelopedInfo.hCryptProv, 0);
2105         CertFreeCertificateContext(context);
2106     }
2107     else
2108         win_skip("failed to create certificate context, skipping tests\n");
2109 }
2110
2111 static void test_enveloped_msg_update(void)
2112 {
2113     HCRYPTMSG msg;
2114     BOOL ret;
2115     CMSG_ENVELOPED_ENCODE_INFO envelopedInfo = { sizeof(envelopedInfo), 0,
2116      { oid_rsa_rc4, { 0, NULL } }, NULL };
2117     CMSG_STREAM_INFO streamInfo = { 0, nop_stream_output, NULL };
2118
2119     SetLastError(0xdeadbeef);
2120     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_ENVELOPED,
2121      &envelopedInfo, NULL, NULL);
2122     ok(msg != NULL ||
2123      broken(!msg), /* Win9x */
2124      "CryptMsgOpenToEncode failed: %08x\n", GetLastError());
2125     if (msg)
2126     {
2127         SetLastError(0xdeadbeef);
2128         ret = CryptMsgUpdate(msg, NULL, 0, FALSE);
2129         ok(!ret && GetLastError() == CRYPT_E_MSG_ERROR,
2130          "expected CRYPT_E_MSG_ERROR, got %08x\n", GetLastError());
2131         SetLastError(0xdeadbeef);
2132         ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
2133         ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2134         SetLastError(0xdeadbeef);
2135         ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
2136         ok(!ret && GetLastError() == CRYPT_E_MSG_ERROR,
2137          "expected CRYPT_E_MSG_ERROR, got %08x\n", GetLastError());
2138         CryptMsgClose(msg);
2139     }
2140     SetLastError(0xdeadbeef);
2141     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_ENVELOPED,
2142      &envelopedInfo, NULL, NULL);
2143     ok(msg != NULL ||
2144      broken(!msg), /* Win9x */
2145      "CryptMsgOpenToEncode failed: %08x\n", GetLastError());
2146     if (msg)
2147     {
2148         SetLastError(0xdeadbeef);
2149         ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), FALSE);
2150         ok(!ret && GetLastError() == CRYPT_E_MSG_ERROR,
2151          "expected CRYPT_E_MSG_ERROR, got %08x\n", GetLastError());
2152         SetLastError(0xdeadbeef);
2153         ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
2154         ok(ret ||
2155          broken(!ret && GetLastError() == NTE_PERM), /* some NT4 */
2156          "CryptMsgUpdate failed: %08x\n", GetLastError());
2157         SetLastError(0xdeadbeef);
2158         ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
2159         ok(!ret && GetLastError() == CRYPT_E_MSG_ERROR,
2160          "expected CRYPT_E_MSG_ERROR, got %08x\n", GetLastError());
2161         CryptMsgClose(msg);
2162     }
2163     SetLastError(0xdeadbeef);
2164     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, CMSG_DETACHED_FLAG,
2165      CMSG_ENVELOPED, &envelopedInfo, NULL, NULL);
2166     ok(msg != NULL ||
2167      broken(!msg), /* Win9x */
2168      "CryptMsgOpenToEncode failed: %08x\n", GetLastError());
2169     if (msg)
2170     {
2171         SetLastError(0xdeadbeef);
2172         ret = CryptMsgUpdate(msg, NULL, 0, FALSE);
2173         ok(!ret && GetLastError() == E_INVALIDARG,
2174          "expected E_INVALIDARG, got %08x\n", GetLastError());
2175         SetLastError(0xdeadbeef);
2176         ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
2177         ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2178         CryptMsgClose(msg);
2179     }
2180     SetLastError(0xdeadbeef);
2181     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, CMSG_DETACHED_FLAG,
2182      CMSG_ENVELOPED, &envelopedInfo, NULL, NULL);
2183     ok(msg != NULL ||
2184      broken(!msg), /* Win9x */
2185      "CryptMsgOpenToEncode failed: %08x\n", GetLastError());
2186     if (msg)
2187     {
2188         SetLastError(0xdeadbeef);
2189         ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), FALSE);
2190         ok(!ret && GetLastError() == E_INVALIDARG,
2191          "expected E_INVALIDARG, got %08x\n", GetLastError());
2192         SetLastError(0xdeadbeef);
2193         ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
2194         ok(ret ||
2195          broken(!ret && GetLastError() == NTE_PERM), /* some NT4 */
2196          "CryptMsgUpdate failed: %08x\n", GetLastError());
2197         CryptMsgClose(msg);
2198     }
2199     SetLastError(0xdeadbeef);
2200     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_ENVELOPED,
2201      &envelopedInfo, NULL, &streamInfo);
2202     ok(msg != NULL ||
2203      broken(!msg), /* Win9x */
2204      "CryptMsgOpenToEncode failed: %08x\n", GetLastError());
2205     if (msg)
2206     {
2207         SetLastError(0xdeadbeef);
2208         ret = CryptMsgUpdate(msg, NULL, 0, FALSE);
2209         ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2210         SetLastError(0xdeadbeef);
2211         ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
2212         ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2213         CryptMsgClose(msg);
2214     }
2215     SetLastError(0xdeadbeef);
2216     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_ENVELOPED,
2217      &envelopedInfo, NULL, &streamInfo);
2218     ok(msg != NULL ||
2219      broken(!msg), /* Win9x */
2220      "CryptMsgOpenToEncode failed: %08x\n", GetLastError());
2221     if (msg)
2222     {
2223         SetLastError(0xdeadbeef);
2224         ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), FALSE);
2225         ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2226         SetLastError(0xdeadbeef);
2227         ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
2228         ok(ret ||
2229          broken(!ret && GetLastError() == NTE_PERM), /* some NT4 */
2230          "CryptMsgUpdate failed: %08x\n", GetLastError());
2231         CryptMsgClose(msg);
2232     }
2233 }
2234
2235 static const BYTE envelopedEmptyBareContent[] = {
2236 0x30,0x22,0x02,0x01,0x00,0x31,0x00,0x30,0x1b,0x06,0x09,0x2a,0x86,0x48,0x86,
2237 0xf7,0x0d,0x01,0x07,0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
2238 0x03,0x04,0x05,0x00,0x80,0x00 };
2239 static const BYTE envelopedEmptyContent[] = {
2240 0x30,0x31,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x03,0xa0,0x24,
2241 0x30,0x22,0x02,0x01,0x00,0x31,0x00,0x30,0x1b,0x06,0x09,0x2a,0x86,0x48,0x86,
2242 0xf7,0x0d,0x01,0x07,0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
2243 0x03,0x04,0x05,0x00,0x80,0x00 };
2244
2245 static void test_enveloped_msg_encoding(void)
2246 {
2247     HCRYPTMSG msg;
2248     CMSG_ENVELOPED_ENCODE_INFO envelopedInfo = { sizeof(envelopedInfo), 0,
2249      { oid_rsa_rc4, { 0, NULL } }, NULL };
2250
2251     SetLastError(0xdeadbeef);
2252     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_ENVELOPED,
2253      &envelopedInfo, NULL, NULL);
2254     ok(msg != NULL ||
2255      broken(!msg), /* Win9x */
2256      "CryptMsgOpenToEncode failed: %08x\n", GetLastError());
2257     if (msg)
2258     {
2259         check_param("enveloped empty bare content", msg,
2260          CMSG_BARE_CONTENT_PARAM, envelopedEmptyBareContent,
2261          sizeof(envelopedEmptyBareContent));
2262         check_param("enveloped empty content", msg, CMSG_CONTENT_PARAM,
2263          envelopedEmptyContent, sizeof(envelopedEmptyContent));
2264         CryptMsgClose(msg);
2265     }
2266 }
2267
2268 static void test_enveloped_msg(void)
2269 {
2270     test_enveloped_msg_open();
2271     test_enveloped_msg_update();
2272     test_enveloped_msg_encoding();
2273 }
2274
2275 static CRYPT_DATA_BLOB b4 = { 0, NULL };
2276 static const struct update_accum a4 = { 1, &b4 };
2277
2278 static const BYTE bogusOIDContent[] = {
2279 0x30,0x0f,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x07,0xa0,0x02,
2280 0x04,0x00 };
2281 static const BYTE bogusHashContent[] = {
2282 0x30,0x47,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x05,0xa0,0x3a,
2283 0x30,0x38,0x02,0x01,0x00,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
2284 0x02,0x05,0x05,0x00,0x30,0x13,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
2285 0x07,0x01,0xa0,0x06,0x04,0x04,0x01,0x02,0x03,0x04,0x04,0x10,0x00,0xd6,0xc0,
2286 0x5a,0x21,0x51,0x2a,0x79,0xa1,0xdf,0xeb,0x9d,0x2a,0x8f,0x26,0x2f };
2287 static const BYTE envelopedBareContentWithoutData[] = {
2288 0x30,0x81,0xdb,0x02,0x01,0x00,0x31,0x81,0xba,0x30,0x81,0xb7,0x02,0x01,0x00,
2289 0x30,0x20,0x30,0x0c,0x31,0x0a,0x30,0x08,0x06,0x03,0x55,0x04,0x03,0x13,0x01,
2290 0x4e,0x02,0x10,0x63,0x75,0x75,0x7a,0x53,0x36,0xa9,0xba,0x41,0xa5,0xcc,0x01,
2291 0x7f,0x76,0x4c,0xd9,0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
2292 0x01,0x01,0x05,0x00,0x04,0x81,0x80,0x87,0x46,0x26,0x56,0xe3,0xf3,0xa5,0x5b,
2293 0xd4,0x2c,0x03,0xcc,0x52,0x7e,0xf7,0x55,0xf1,0x34,0x9f,0x63,0xf6,0x04,0x9f,
2294 0xc5,0x13,0xf1,0xc9,0x57,0x0a,0xbc,0xa9,0x33,0xd2,0xf2,0x93,0xb6,0x5c,0x94,
2295 0xc3,0x49,0xd6,0xd6,0x6d,0xc4,0x91,0x38,0x80,0xdd,0x0d,0x82,0xef,0xe5,0x72,
2296 0x55,0x40,0x0a,0xdd,0x35,0xfe,0xdc,0x87,0x47,0x92,0xb1,0xbd,0x05,0xc9,0x18,
2297 0x0e,0xde,0x4b,0x00,0x70,0x40,0x31,0x1f,0x5d,0x6c,0x8f,0x3a,0xfb,0x9a,0xc3,
2298 0xb3,0x06,0xe7,0x68,0x3f,0x20,0x14,0x1c,0xf9,0x28,0x4b,0x0f,0x01,0x01,0xb6,
2299 0xfe,0x07,0xe5,0xd8,0xf0,0x7c,0x17,0xbc,0xec,0xfb,0xd7,0x73,0x8a,0x71,0x49,
2300 0x79,0x62,0xe4,0xbf,0xb5,0xe3,0x56,0xa6,0xb4,0x49,0x1e,0xdc,0xaf,0xd7,0x0e,
2301 0x30,0x19,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x01,0x30,0x0c,
2302 0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x03,0x04,0x05,0x00 };
2303
2304 static void test_decode_msg_update(void)
2305 {
2306     HCRYPTMSG msg;
2307     BOOL ret;
2308     CMSG_STREAM_INFO streamInfo = { 0 };
2309     DWORD i;
2310     struct update_accum accum = { 0, NULL };
2311
2312     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, NULL);
2313     /* Update with a full message in a final update */
2314     ret = CryptMsgUpdate(msg, dataEmptyContent, sizeof(dataEmptyContent), TRUE);
2315     ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
2316     /* Can't update after a final update */
2317     SetLastError(0xdeadbeef);
2318     ret = CryptMsgUpdate(msg, dataEmptyContent, sizeof(dataEmptyContent), TRUE);
2319     ok(!ret && GetLastError() == CRYPT_E_MSG_ERROR,
2320      "Expected CRYPT_E_MSG_ERROR, got %x\n", GetLastError());
2321     CryptMsgClose(msg);
2322
2323     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, NULL);
2324     /* Can't send a non-final update without streaming */
2325     SetLastError(0xdeadbeef);
2326     ret = CryptMsgUpdate(msg, dataEmptyContent, sizeof(dataEmptyContent),
2327      FALSE);
2328     ok(!ret && GetLastError() == CRYPT_E_MSG_ERROR,
2329      "Expected CRYPT_E_MSG_ERROR, got %x\n", GetLastError());
2330     /* A subsequent final update succeeds */
2331     ret = CryptMsgUpdate(msg, dataEmptyContent, sizeof(dataEmptyContent), TRUE);
2332     ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
2333     CryptMsgClose(msg);
2334
2335     if (!old_crypt32)
2336     {
2337         msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, &streamInfo);
2338         /* Updating a message that has a NULL stream callback fails */
2339         SetLastError(0xdeadbeef);
2340         /* Crashes on some Win9x */
2341         ret = CryptMsgUpdate(msg, dataEmptyContent, sizeof(dataEmptyContent),
2342          FALSE);
2343         todo_wine
2344         ok(!ret && (GetLastError() == STATUS_ACCESS_VIOLATION ||
2345          GetLastError() == STATUS_ILLEGAL_INSTRUCTION /* WinME */),
2346          "Expected STATUS_ACCESS_VIOLATION or STATUS_ILLEGAL_INSTRUCTION, got %x\n",
2347          GetLastError());
2348         /* Changing the callback pointer after the fact yields the same error (so
2349          * the message must copy the stream info, not just store a pointer to it)
2350          */
2351         streamInfo.pfnStreamOutput = nop_stream_output;
2352         SetLastError(0xdeadbeef);
2353         ret = CryptMsgUpdate(msg, dataEmptyContent, sizeof(dataEmptyContent),
2354          FALSE);
2355         todo_wine
2356         ok(!ret && (GetLastError() == STATUS_ACCESS_VIOLATION ||
2357          GetLastError() == STATUS_ILLEGAL_INSTRUCTION /* WinME */),
2358          "Expected STATUS_ACCESS_VIOLATION or STATUS_ILLEGAL_INSTRUCTION, got %x\n",
2359          GetLastError());
2360         CryptMsgClose(msg);
2361     }
2362
2363     /* Empty non-final updates are allowed when streaming.. */
2364     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, &streamInfo);
2365     ret = CryptMsgUpdate(msg, NULL, 0, FALSE);
2366     ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
2367     /* but final updates aren't when not enough data has been received. */
2368     SetLastError(0xdeadbeef);
2369     ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
2370     todo_wine
2371     ok(!ret && GetLastError() == CRYPT_E_STREAM_INSUFFICIENT_DATA,
2372      "Expected CRYPT_E_STREAM_INSUFFICIENT_DATA, got %x\n", GetLastError());
2373     CryptMsgClose(msg);
2374
2375     /* Updating the message byte by byte is legal */
2376     streamInfo.pfnStreamOutput = accumulating_stream_output;
2377     streamInfo.pvArg = &accum;
2378     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, &streamInfo);
2379     for (i = 0, ret = TRUE; ret && i < sizeof(dataEmptyContent); i++)
2380         ret = CryptMsgUpdate(msg, &dataEmptyContent[i], 1, FALSE);
2381     ok(ret, "CryptMsgUpdate failed on byte %d: %x\n", i, GetLastError());
2382     ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
2383     ok(ret, "CryptMsgUpdate failed on byte %d: %x\n", i, GetLastError());
2384     CryptMsgClose(msg);
2385     todo_wine
2386     check_updates("byte-by-byte empty content", &a4, &accum);
2387     free_updates(&accum);
2388
2389     /* Decoding bogus content fails in non-streaming mode.. */
2390     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, NULL);
2391     SetLastError(0xdeadbeef);
2392     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
2393     ok(!ret && (GetLastError() == CRYPT_E_ASN1_BADTAG ||
2394      GetLastError() == OSS_PDU_MISMATCH /* Win9x */),
2395      "Expected CRYPT_E_ASN1_BADTAG or OSS_PDU_MISMATCH, got %x\n",
2396      GetLastError());
2397     CryptMsgClose(msg);
2398     /* and as the final update in streaming mode.. */
2399     streamInfo.pfnStreamOutput = nop_stream_output;
2400     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, &streamInfo);
2401     SetLastError(0xdeadbeef);
2402     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
2403     ok(!ret && (GetLastError() == CRYPT_E_ASN1_BADTAG ||
2404      GetLastError() == OSS_PDU_MISMATCH /* Win9x */),
2405      "Expected CRYPT_E_ASN1_BADTAG or OSS_PDU_MISMATCH, got %x\n",
2406      GetLastError());
2407     CryptMsgClose(msg);
2408     /* and even as a non-final update in streaming mode. */
2409     streamInfo.pfnStreamOutput = nop_stream_output;
2410     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, &streamInfo);
2411     SetLastError(0xdeadbeef);
2412     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), FALSE);
2413     todo_wine
2414     ok(!ret && (GetLastError() == CRYPT_E_ASN1_BADTAG ||
2415      GetLastError() == OSS_PDU_MISMATCH /* Win9x */),
2416      "Expected CRYPT_E_ASN1_BADTAG or OSS_PDU_MISMATCH, got %x\n",
2417      GetLastError());
2418     CryptMsgClose(msg);
2419
2420     /* An empty message can be opened with undetermined type.. */
2421     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, NULL);
2422     ret = CryptMsgUpdate(msg, dataEmptyContent, sizeof(dataEmptyContent),
2423      TRUE);
2424     ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
2425     CryptMsgClose(msg);
2426     /* but decoding it as an explicitly typed message fails. */
2427     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, CMSG_DATA, 0, NULL,
2428      NULL);
2429     SetLastError(0xdeadbeef);
2430     ret = CryptMsgUpdate(msg, dataEmptyContent, sizeof(dataEmptyContent),
2431      TRUE);
2432     ok(!ret && (GetLastError() == CRYPT_E_ASN1_BADTAG ||
2433      GetLastError() == OSS_PDU_MISMATCH /* Win9x */),
2434      "Expected CRYPT_E_ASN1_BADTAG or OSS_PDU_MISMATCH, got %x\n",
2435      GetLastError());
2436     CryptMsgClose(msg);
2437     /* On the other hand, decoding the bare content of an empty message fails
2438      * with unspecified type..
2439      */
2440     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, NULL);
2441     SetLastError(0xdeadbeef);
2442     ret = CryptMsgUpdate(msg, dataEmptyBareContent,
2443      sizeof(dataEmptyBareContent), TRUE);
2444     ok(!ret && (GetLastError() == CRYPT_E_ASN1_BADTAG ||
2445      GetLastError() == OSS_PDU_MISMATCH /* Win9x */),
2446      "Expected CRYPT_E_ASN1_BADTAG or OSS_PDU_MISMATCH, got %x\n",
2447      GetLastError());
2448     CryptMsgClose(msg);
2449     /* but succeeds with explicit type. */
2450     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, CMSG_DATA, 0, NULL,
2451      NULL);
2452     ret = CryptMsgUpdate(msg, dataEmptyBareContent,
2453      sizeof(dataEmptyBareContent), TRUE);
2454     ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
2455     CryptMsgClose(msg);
2456
2457     /* Decoding valid content with an unsupported OID fails */
2458     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, NULL);
2459     SetLastError(0xdeadbeef);
2460     ret = CryptMsgUpdate(msg, bogusOIDContent, sizeof(bogusOIDContent), TRUE);
2461     ok(!ret && GetLastError() == CRYPT_E_INVALID_MSG_TYPE,
2462      "Expected CRYPT_E_INVALID_MSG_TYPE, got %x\n", GetLastError());
2463     CryptMsgClose(msg);
2464
2465     /* Similarly, opening an empty hash with unspecified type succeeds.. */
2466     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, NULL);
2467     SetLastError(0xdeadbeef);
2468     ret = CryptMsgUpdate(msg, hashEmptyContent, sizeof(hashEmptyContent), TRUE);
2469     ok(ret || broken(GetLastError() == OSS_DATA_ERROR /* Win9x */),
2470      "CryptMsgUpdate failed: %08x\n", GetLastError());
2471     CryptMsgClose(msg);
2472     /* while with specified type it fails. */
2473     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, CMSG_HASHED, 0, NULL,
2474      NULL);
2475     SetLastError(0xdeadbeef);
2476     ret = CryptMsgUpdate(msg, hashEmptyContent, sizeof(hashEmptyContent), TRUE);
2477     ok(!ret && (GetLastError() == CRYPT_E_ASN1_BADTAG ||
2478      GetLastError() == OSS_PDU_MISMATCH /* some Win9x */ ||
2479      GetLastError() == OSS_DATA_ERROR /* some Win9x */),
2480      "Expected CRYPT_E_ASN1_BADTAG or OSS_PDU_MISMATCH or OSS_DATA_ERROR, got %x\n",
2481      GetLastError());
2482     CryptMsgClose(msg);
2483     /* On the other hand, decoding the bare content of an empty hash message
2484      * fails with unspecified type..
2485      */
2486     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, NULL);
2487     SetLastError(0xdeadbeef);
2488     ret = CryptMsgUpdate(msg, hashEmptyBareContent,
2489      sizeof(hashEmptyBareContent), TRUE);
2490     ok(!ret && (GetLastError() == CRYPT_E_ASN1_BADTAG ||
2491      GetLastError() == OSS_PDU_MISMATCH /* some Win9x */ ||
2492      GetLastError() == OSS_DATA_ERROR /* some Win9x */),
2493      "Expected CRYPT_E_ASN1_BADTAG or OSS_PDU_MISMATCH or OSS_DATA_ERROR, got %x\n",
2494      GetLastError());
2495     CryptMsgClose(msg);
2496     /* but succeeds with explicit type. */
2497     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, CMSG_HASHED, 0, NULL,
2498      NULL);
2499     ret = CryptMsgUpdate(msg, hashEmptyBareContent,
2500      sizeof(hashEmptyBareContent), TRUE);
2501     ok(ret || broken(GetLastError() == OSS_DATA_ERROR /* win9x */),
2502      "CryptMsgUpdate failed: %x\n", GetLastError());
2503     CryptMsgClose(msg);
2504
2505     /* And again, opening a (non-empty) hash message with unspecified type
2506      * succeeds..
2507      */
2508     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, NULL);
2509     SetLastError(0xdeadbeef);
2510     ret = CryptMsgUpdate(msg, hashContent, sizeof(hashContent), TRUE);
2511     ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2512     CryptMsgClose(msg);
2513     /* while with specified type it fails.. */
2514     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, CMSG_HASHED, 0, NULL,
2515      NULL);
2516     SetLastError(0xdeadbeef);
2517     ret = CryptMsgUpdate(msg, hashContent, sizeof(hashContent), TRUE);
2518     ok(!ret && (GetLastError() == CRYPT_E_ASN1_BADTAG ||
2519      GetLastError() == OSS_PDU_MISMATCH /* some Win9x */ ||
2520      GetLastError() == OSS_DATA_ERROR /* some Win9x */),
2521      "Expected CRYPT_E_ASN1_BADTAG or OSS_PDU_MISMATCH or OSS_DATA_ERROR, got %x\n",
2522      GetLastError());
2523     CryptMsgClose(msg);
2524     /* and decoding the bare content of a non-empty hash message fails with
2525      * unspecified type..
2526      */
2527     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, NULL);
2528     SetLastError(0xdeadbeef);
2529     ret = CryptMsgUpdate(msg, hashBareContent, sizeof(hashBareContent), TRUE);
2530     ok(!ret && (GetLastError() == CRYPT_E_ASN1_BADTAG ||
2531      GetLastError() == OSS_PDU_MISMATCH /* some Win9x */ ||
2532      GetLastError() == OSS_DATA_ERROR /* some Win9x */),
2533      "Expected CRYPT_E_ASN1_BADTAG or OSS_PDU_MISMATCH or OSS_DATA_ERROR, got %x\n",
2534      GetLastError());
2535     CryptMsgClose(msg);
2536     /* but succeeds with explicit type. */
2537     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, CMSG_HASHED, 0, NULL,
2538      NULL);
2539     ret = CryptMsgUpdate(msg, hashBareContent, sizeof(hashBareContent), TRUE);
2540     ok(ret, "CryptMsgUpdate failed: %x\n", GetLastError());
2541     CryptMsgClose(msg);
2542
2543     /* Opening a (non-empty) hash message with unspecified type and a bogus
2544      * hash value succeeds..
2545      */
2546     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, NULL);
2547     SetLastError(0xdeadbeef);
2548     ret = CryptMsgUpdate(msg, bogusHashContent, sizeof(bogusHashContent), TRUE);
2549     ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2550     CryptMsgClose(msg);
2551
2552     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, NULL);
2553     ret = CryptMsgUpdate(msg, signedContent, sizeof(signedContent), TRUE);
2554     ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2555     CryptMsgClose(msg);
2556     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, NULL);
2557     SetLastError(0xdeadbeef);
2558     ret = CryptMsgUpdate(msg, signedWithCertAndCrlBareContent,
2559      sizeof(signedWithCertAndCrlBareContent), TRUE);
2560     ok(!ret && (GetLastError() == CRYPT_E_ASN1_BADTAG ||
2561      GetLastError() == OSS_DATA_ERROR /* Win9x */),
2562      "Expected CRYPT_E_ASN1_BADTAG or OSS_DATA_ERROR, got %08x\n",
2563      GetLastError());
2564     CryptMsgClose(msg);
2565     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, CMSG_SIGNED, 0, NULL,
2566      NULL);
2567     ret = CryptMsgUpdate(msg, signedWithCertAndCrlBareContent,
2568      sizeof(signedWithCertAndCrlBareContent), TRUE);
2569     ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2570     CryptMsgClose(msg);
2571
2572     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, CMSG_DETACHED_FLAG, 0, 0,
2573      NULL, NULL);
2574     /* The first update succeeds.. */
2575     ret = CryptMsgUpdate(msg, detachedSignedContent,
2576      sizeof(detachedSignedContent), TRUE);
2577     ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2578     /* as does a second (probably to update the detached portion).. */
2579     ret = CryptMsgUpdate(msg, detachedSignedContent,
2580      sizeof(detachedSignedContent), TRUE);
2581     ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2582     /* while a third fails. */
2583     ret = CryptMsgUpdate(msg, detachedSignedContent,
2584      sizeof(detachedSignedContent), TRUE);
2585     ok(!ret && GetLastError() == CRYPT_E_MSG_ERROR,
2586      "expected CRYPT_E_MSG_ERROR, got %08x\n", GetLastError());
2587     CryptMsgClose(msg);
2588
2589     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, CMSG_DETACHED_FLAG, 0, 0, NULL, &streamInfo);
2590     ret = CryptMsgUpdate(msg, detachedSignedContent, sizeof(detachedSignedContent), FALSE);
2591     ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2592     ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
2593     ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2594     ret = CryptMsgUpdate(msg, detachedSignedContent, sizeof(detachedSignedContent), FALSE);
2595     ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2596     ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
2597     ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2598
2599     ret = CryptMsgUpdate(msg, detachedSignedContent, sizeof(detachedSignedContent), TRUE);
2600     ok(!ret && GetLastError() == CRYPT_E_MSG_ERROR,
2601      "expected CRYPT_E_MSG_ERROR, got %08x\n", GetLastError());
2602     CryptMsgClose(msg);
2603
2604     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, CMSG_ENVELOPED, 0, NULL,
2605      NULL);
2606     SetLastError(0xdeadbeef);
2607     ret = CryptMsgUpdate(msg, envelopedEmptyBareContent,
2608      sizeof(envelopedEmptyBareContent), TRUE);
2609     ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2610     CryptMsgClose(msg);
2611
2612     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, CMSG_ENVELOPED, 0, NULL,
2613      NULL);
2614     SetLastError(0xdeadbeef);
2615     ret = CryptMsgUpdate(msg, envelopedEmptyContent,
2616      sizeof(envelopedEmptyContent), TRUE);
2617     ok(!ret &&
2618      (GetLastError() == CRYPT_E_ASN1_BADTAG ||
2619       GetLastError() == OSS_DATA_ERROR), /* Win9x */
2620      "expected CRYPT_E_ASN1_BADTAG, got %08x\n", GetLastError());
2621     CryptMsgClose(msg);
2622
2623     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, NULL);
2624     SetLastError(0xdeadbeef);
2625     ret = CryptMsgUpdate(msg, envelopedEmptyBareContent,
2626      sizeof(envelopedEmptyBareContent), TRUE);
2627     ok(!ret &&
2628      (GetLastError() == CRYPT_E_ASN1_BADTAG ||
2629       GetLastError() == OSS_DATA_ERROR), /* Win9x */
2630      "expected CRYPT_E_ASN1_BADTAG, got %08x\n", GetLastError());
2631     CryptMsgClose(msg);
2632
2633     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, NULL);
2634     SetLastError(0xdeadbeef);
2635     ret = CryptMsgUpdate(msg, envelopedEmptyContent,
2636      sizeof(envelopedEmptyContent), TRUE);
2637     ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2638     CryptMsgClose(msg);
2639
2640     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, CMSG_ENVELOPED, 0, NULL,
2641      NULL);
2642     SetLastError(0xdeadbeef);
2643     ret = CryptMsgUpdate(msg, envelopedBareContentWithoutData,
2644      sizeof(envelopedBareContentWithoutData), TRUE);
2645     ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2646     CryptMsgClose(msg);
2647 }
2648
2649 static const BYTE hashParam[] = { 0x08,0xd6,0xc0,0x5a,0x21,0x51,0x2a,0x79,0xa1,
2650  0xdf,0xeb,0x9d,0x2a,0x8f,0x26,0x2f };
2651
2652 static void compare_signer_info(const CMSG_SIGNER_INFO *got,
2653  const CMSG_SIGNER_INFO *expected)
2654 {
2655     ok(got->dwVersion == expected->dwVersion, "Expected version %d, got %d\n",
2656      expected->dwVersion, got->dwVersion);
2657     ok(got->Issuer.cbData == expected->Issuer.cbData,
2658      "Expected issuer size %d, got %d\n", expected->Issuer.cbData,
2659      got->Issuer.cbData);
2660     ok(!memcmp(got->Issuer.pbData, expected->Issuer.pbData, got->Issuer.cbData),
2661      "Unexpected issuer\n");
2662     ok(got->SerialNumber.cbData == expected->SerialNumber.cbData,
2663      "Expected serial number size %d, got %d\n", expected->SerialNumber.cbData,
2664      got->SerialNumber.cbData);
2665     ok(!memcmp(got->SerialNumber.pbData, expected->SerialNumber.pbData,
2666      got->SerialNumber.cbData), "Unexpected serial number\n");
2667     /* FIXME: check more things */
2668 }
2669
2670 static void compare_cms_signer_info(const CMSG_CMS_SIGNER_INFO *got,
2671  const CMSG_CMS_SIGNER_INFO *expected)
2672 {
2673     ok(got->dwVersion == expected->dwVersion, "Expected version %d, got %d\n",
2674      expected->dwVersion, got->dwVersion);
2675     ok(got->SignerId.dwIdChoice == expected->SignerId.dwIdChoice,
2676      "Expected id choice %d, got %d\n", expected->SignerId.dwIdChoice,
2677      got->SignerId.dwIdChoice);
2678     if (got->SignerId.dwIdChoice == expected->SignerId.dwIdChoice)
2679     {
2680         if (got->SignerId.dwIdChoice == CERT_ID_ISSUER_SERIAL_NUMBER)
2681         {
2682             ok(U(got->SignerId).IssuerSerialNumber.Issuer.cbData ==
2683              U(expected->SignerId).IssuerSerialNumber.Issuer.cbData,
2684              "Expected issuer size %d, got %d\n",
2685              U(expected->SignerId).IssuerSerialNumber.Issuer.cbData,
2686              U(got->SignerId).IssuerSerialNumber.Issuer.cbData);
2687             ok(!memcmp(U(got->SignerId).IssuerSerialNumber.Issuer.pbData,
2688              U(expected->SignerId).IssuerSerialNumber.Issuer.pbData,
2689              U(got->SignerId).IssuerSerialNumber.Issuer.cbData),
2690              "Unexpected issuer\n");
2691             ok(U(got->SignerId).IssuerSerialNumber.SerialNumber.cbData ==
2692              U(expected->SignerId).IssuerSerialNumber.SerialNumber.cbData,
2693              "Expected serial number size %d, got %d\n",
2694              U(expected->SignerId).IssuerSerialNumber.SerialNumber.cbData,
2695              U(got->SignerId).IssuerSerialNumber.SerialNumber.cbData);
2696             ok(!memcmp(U(got->SignerId).IssuerSerialNumber.SerialNumber.pbData,
2697              U(expected->SignerId).IssuerSerialNumber.SerialNumber.pbData,
2698              U(got->SignerId).IssuerSerialNumber.SerialNumber.cbData),
2699              "Unexpected serial number\n");
2700         }
2701         else
2702         {
2703             ok(U(got->SignerId).KeyId.cbData == U(expected->SignerId).KeyId.cbData,
2704              "expected key id size %d, got %d\n",
2705              U(expected->SignerId).KeyId.cbData, U(got->SignerId).KeyId.cbData);
2706             ok(!memcmp(U(expected->SignerId).KeyId.pbData,
2707              U(got->SignerId).KeyId.pbData, U(got->SignerId).KeyId.cbData),
2708              "unexpected key id\n");
2709         }
2710     }
2711     /* FIXME: check more things */
2712 }
2713
2714 static const BYTE signedWithCertAndCrlComputedHash[] = {
2715 0x08,0xd6,0xc0,0x5a,0x21,0x51,0x2a,0x79,0xa1,0xdf,0xeb,0x9d,0x2a,0x8f,0x26,
2716 0x2f };
2717 static BYTE keyIdIssuer[] = {
2718 0x30,0x13,0x31,0x11,0x30,0x0f,0x06,0x0a,0x2b,0x06,0x01,0x04,0x01,0x82,0x37,
2719 0x0a,0x07,0x01,0x04,0x01,0x01 };
2720 static const BYTE publicPrivateKeyPair[] = {
2721 0x07,0x02,0x00,0x00,0x00,0xa4,0x00,0x00,0x52,0x53,0x41,0x32,0x00,0x04,0x00,
2722 0x00,0x01,0x00,0x01,0x00,0x21,0x65,0x5d,0x97,0x19,0x3f,0xd0,0xd0,0x76,0x5b,
2723 0xb1,0x10,0x4e,0xcc,0x14,0xb5,0x92,0x0f,0x60,0xad,0xb6,0x74,0x8d,0x94,0x50,
2724 0xfd,0x14,0x5e,0xbc,0xf1,0x93,0xbf,0x24,0x21,0x64,0x9d,0xc7,0x77,0x04,0x54,
2725 0xd1,0xbd,0x3e,0xd8,0x3b,0x2a,0x8b,0x95,0x70,0xdf,0x19,0x20,0xed,0x76,0x39,
2726 0xfa,0x64,0x04,0xc6,0xf7,0x33,0x7b,0xaa,0x94,0x67,0x74,0xbc,0x6b,0xd5,0xa7,
2727 0x69,0x99,0x99,0x47,0x88,0xc0,0x7e,0x36,0xf1,0xc5,0x7d,0xa8,0xd8,0x07,0x48,
2728 0xe6,0x05,0x4f,0xf4,0x1f,0x37,0xd7,0xc7,0xa7,0x00,0x20,0xb3,0xe5,0x40,0x17,
2729 0x86,0x43,0x77,0xe0,0x32,0x39,0x11,0x9c,0xd9,0xd8,0x53,0x9b,0x45,0x42,0x54,
2730 0x65,0xca,0x15,0xbe,0xb2,0x44,0xf1,0xd0,0xf3,0xb6,0x4a,0x19,0xc8,0x3d,0x33,
2731 0x63,0x93,0x4f,0x7c,0x67,0xc6,0x58,0x6d,0xf6,0xb7,0x20,0xd8,0x30,0xcc,0x52,
2732 0xaa,0x68,0x66,0xf6,0x86,0xf8,0xe0,0x3a,0x73,0x0e,0x9d,0xc5,0x03,0x60,0x9e,
2733 0x08,0xe9,0x5e,0xd4,0x5e,0xcc,0xbb,0xc1,0x48,0xad,0x9d,0xbb,0xfb,0x26,0x61,
2734 0xa8,0x0e,0x9c,0xba,0xf1,0xd0,0x0b,0x5f,0x87,0xd4,0xb5,0xd2,0xdf,0x41,0xcb,
2735 0x7a,0xec,0xb5,0x87,0x59,0x6a,0x9d,0xb3,0x6c,0x06,0xee,0x1f,0xc5,0xae,0x02,
2736 0xa8,0x7f,0x33,0x6e,0x30,0x50,0x6d,0x65,0xd0,0x1f,0x00,0x47,0x43,0x25,0x90,
2737 0x4a,0xa8,0x74,0x8c,0x23,0x8b,0x15,0x8a,0x74,0xd2,0x03,0xa6,0x1c,0xc1,0x7e,
2738 0xbb,0xb1,0xa6,0x80,0x05,0x2b,0x62,0xfb,0x89,0xe5,0xba,0xc6,0xcc,0x12,0xce,
2739 0xa8,0xe9,0xc4,0xb5,0x9d,0xd8,0x11,0xdd,0x95,0x90,0x71,0xb0,0xfe,0xaa,0x14,
2740 0xce,0xd5,0xd0,0x5a,0x88,0x47,0xda,0x31,0xda,0x26,0x11,0x66,0xd1,0xd5,0xc5,
2741 0x1b,0x08,0xbe,0xc6,0xf3,0x15,0xbf,0x80,0x78,0xcf,0x55,0xe0,0x61,0xee,0xf5,
2742 0x71,0x1e,0x2f,0x0e,0xb3,0x67,0xf7,0xa1,0x86,0x04,0xcf,0x4b,0xc1,0x2f,0x94,
2743 0x73,0xd1,0x5d,0x0c,0xee,0x10,0x58,0xbb,0x74,0x0c,0x61,0x02,0x15,0x69,0x68,
2744 0xe0,0x21,0x3e,0xa6,0x27,0x22,0x8c,0xc8,0x61,0xbc,0xba,0xa9,0x4b,0x2e,0x71,
2745 0x77,0x74,0xdc,0x63,0x05,0x32,0x7a,0x93,0x4f,0xbf,0xc7,0xa5,0x3a,0xe3,0x25,
2746 0x4d,0x67,0xcf,0x78,0x1b,0x85,0x22,0x6c,0xfe,0x5c,0x34,0x0e,0x27,0x12,0xbc,
2747 0xd5,0x33,0x1a,0x75,0x8a,0x9c,0x40,0x39,0xe8,0xa0,0xc9,0xae,0xf8,0xaf,0x9a,
2748 0xc6,0x62,0x47,0xf3,0x5b,0xdf,0x5e,0xcd,0xc6,0xc0,0x5c,0xd7,0x0e,0x04,0x64,
2749 0x3d,0xdd,0x57,0xef,0xf6,0xcd,0xdf,0xd2,0x7e,0x17,0x6c,0x0a,0x47,0x5e,0x77,
2750 0x4b,0x02,0x49,0x78,0xc0,0xf7,0x09,0x6e,0xdf,0x96,0x04,0x51,0x74,0x3d,0x68,
2751 0x99,0x43,0x8e,0x03,0x16,0x46,0xa4,0x04,0x84,0x01,0x6e,0xd4,0xca,0x5c,0xab,
2752 0xb0,0xd3,0x82,0xf1,0xb9,0xba,0x51,0x99,0x03,0xe9,0x7f,0xdf,0x30,0x3b,0xf9,
2753 0x18,0xbb,0x80,0x7f,0xf0,0x89,0xbb,0x6d,0x98,0x95,0xb7,0xfd,0xd8,0xdf,0xed,
2754 0xf3,0x16,0x6f,0x96,0x4f,0xfd,0x54,0x66,0x6d,0x90,0xba,0xf5,0xcc,0xce,0x01,
2755 0x34,0x34,0x51,0x07,0x66,0x20,0xfb,0x4a,0x3c,0x7e,0x19,0xf8,0x8e,0x35,0x0e,
2756 0x07,0x48,0x74,0x38,0xd2,0x18,0xaa,0x2e,0x90,0x5e,0x0e,0xcc,0x50,0x6e,0x71,
2757 0x6f,0x54,0xdb,0xbf,0x7b,0xb4,0xf4,0x79,0x6a,0x21,0xa3,0x6d,0xdf,0x61,0xc0,
2758 0x8f,0xb3,0xb6,0xe1,0x8a,0x65,0x21,0x6e,0xf6,0x5b,0x80,0xf0,0xfb,0x28,0x87,
2759 0x13,0x06,0xd6,0xbc,0x28,0x5c,0xda,0xc5,0x13,0x13,0x44,0x8d,0xf4,0xa8,0x7b,
2760 0x5c,0x2a,0x7f,0x11,0x16,0x4e,0x52,0x41,0xe9,0xe7,0x8e };
2761 static const BYTE envelopedMessage[] = {
2762 0x30,0x81,0xf2,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x03,0xa0,
2763 0x81,0xe4,0x30,0x81,0xe1,0x02,0x01,0x00,0x31,0x81,0xba,0x30,0x81,0xb7,0x02,
2764 0x01,0x00,0x30,0x20,0x30,0x0c,0x31,0x0a,0x30,0x08,0x06,0x03,0x55,0x04,0x03,
2765 0x13,0x01,0x4e,0x02,0x10,0x63,0x75,0x75,0x7a,0x53,0x36,0xa9,0xba,0x41,0xa5,
2766 0xcc,0x01,0x7f,0x76,0x4c,0xd9,0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,
2767 0x0d,0x01,0x01,0x01,0x05,0x00,0x04,0x81,0x80,0xc2,0x0d,0x59,0x87,0xb3,0x65,
2768 0xd2,0x64,0xcd,0xba,0xe3,0xaf,0x1e,0xa1,0xd3,0xdd,0xb3,0x53,0xfc,0x2f,0xae,
2769 0xdc,0x6d,0x2a,0x81,0x84,0x38,0x6f,0xdf,0x81,0xb1,0x65,0xba,0xac,0x59,0xb1,
2770 0x19,0x12,0x3f,0xde,0x12,0xce,0x77,0x42,0x71,0x67,0xa9,0x78,0x38,0x95,0x51,
2771 0xbb,0x66,0x78,0xbf,0xaf,0x0a,0x98,0x4b,0xba,0xa5,0xf0,0x8b,0x9f,0xef,0xcf,
2772 0x40,0x05,0xa1,0xd6,0x10,0xae,0xbf,0xb9,0xbd,0x4d,0x22,0x39,0x33,0x63,0x2b,
2773 0x0b,0xd3,0x0c,0xb5,0x4b,0xe8,0xfe,0x15,0xa8,0xa5,0x2c,0x86,0x33,0x80,0x6e,
2774 0x4c,0x7a,0x99,0x3c,0x6b,0x4b,0x60,0xfd,0x8e,0xb2,0xf3,0x82,0x2f,0x3e,0x1e,
2775 0xba,0xb9,0x78,0x24,0x32,0xab,0xa4,0x10,0x1a,0x38,0x94,0x10,0x8d,0xf8,0x70,
2776 0x3e,0x4e,0x30,0x1f,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x01,
2777 0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x03,0x04,0x05,0x00,0x80,
2778 0x04,0x5f,0x80,0xf2,0x17 };
2779 static const BYTE envelopedBareMessage[] = {
2780 0x30,0x81,0xe1,0x02,0x01,0x00,0x31,0x81,0xba,0x30,0x81,0xb7,0x02,0x01,0x00,
2781 0x30,0x20,0x30,0x0c,0x31,0x0a,0x30,0x08,0x06,0x03,0x55,0x04,0x03,0x13,0x01,
2782 0x4e,0x02,0x10,0x63,0x75,0x75,0x7a,0x53,0x36,0xa9,0xba,0x41,0xa5,0xcc,0x01,
2783 0x7f,0x76,0x4c,0xd9,0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
2784 0x01,0x01,0x05,0x00,0x04,0x81,0x80,0x69,0x79,0x12,0x6b,0xa1,0x2f,0xe9,0x0d,
2785 0x34,0x79,0x77,0xe9,0x15,0xf2,0xff,0x0c,0x9a,0xf2,0x87,0xbd,0x12,0xc4,0x2d,
2786 0x9e,0x81,0xc7,0x3c,0x74,0x05,0xdc,0x13,0xaf,0xe9,0xa2,0xba,0x72,0xe9,0xa5,
2787 0x2b,0x81,0x39,0xd3,0x62,0xaa,0x78,0xc3,0x90,0x4f,0x06,0xf0,0xdb,0x18,0x5e,
2788 0xe1,0x2e,0x19,0xa3,0xc2,0xac,0x1e,0xf1,0xbf,0xe6,0x03,0x00,0x96,0xfa,0xd2,
2789 0x66,0x73,0xd0,0x45,0x55,0x57,0x71,0xff,0x3a,0x0c,0xad,0xce,0xde,0x68,0xd4,
2790 0x45,0x20,0xc8,0x44,0x4d,0x5d,0xa2,0x98,0x79,0xb1,0x81,0x0f,0x8a,0xfc,0x70,
2791 0xa5,0x18,0xd2,0x30,0x65,0x22,0x84,0x02,0x24,0x48,0xf7,0xa4,0xe0,0xa5,0x6c,
2792 0xa8,0xa4,0xd0,0x86,0x4b,0x6e,0x9b,0x18,0xab,0x78,0xfa,0x76,0x12,0xce,0x55,
2793 0x30,0x1f,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x01,0x30,0x0c,
2794 0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x03,0x04,0x05,0x00,0x80,0x04,0x2c,
2795 0x2d,0xa3,0x6e };
2796 static const BYTE envelopedMessageWith3Recps[] = {
2797 0x30,0x82,0x02,0x69,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x03,
2798 0xa0,0x82,0x02,0x5a,0x30,0x82,0x02,0x56,0x02,0x01,0x00,0x31,0x82,0x02,0x2e,
2799 0x30,0x81,0xb7,0x02,0x01,0x00,0x30,0x20,0x30,0x0c,0x31,0x0a,0x30,0x08,0x06,
2800 0x03,0x55,0x04,0x03,0x13,0x01,0x4e,0x02,0x10,0x63,0x75,0x75,0x7a,0x53,0x36,
2801 0xa9,0xba,0x41,0xa5,0xcc,0x01,0x7f,0x76,0x4c,0xd9,0x30,0x0d,0x06,0x09,0x2a,
2802 0x86,0x48,0x86,0xf7,0x0d,0x01,0x01,0x01,0x05,0x00,0x04,0x81,0x80,0xa4,0x2e,
2803 0xe5,0x56,0x60,0xc5,0x64,0x07,0x29,0xaf,0x5c,0x38,0x3d,0x4b,0xec,0xbd,0xba,
2804 0x97,0x60,0x17,0xed,0xd7,0x21,0x7b,0x19,0x94,0x95,0xf1,0xb2,0x84,0x06,0x1f,
2805 0xc5,0x83,0xb3,0x5d,0xc8,0x2c,0x1c,0x0f,0xf7,0xfd,0x58,0x8b,0x0f,0x25,0xb5,
2806 0x9f,0x7f,0x43,0x8f,0x5f,0x81,0x16,0x4a,0x62,0xfb,0x47,0xb5,0x36,0x72,0x21,
2807 0x29,0xd4,0x9e,0x27,0x35,0xf4,0xd0,0xd4,0xc0,0xa3,0x7a,0x47,0xbe,0xc9,0xae,
2808 0x08,0x17,0x6a,0xb5,0x63,0x38,0xa1,0xdc,0xf5,0xc1,0x8d,0x97,0x56,0xb4,0xc0,
2809 0x2d,0x2b,0xec,0x3d,0xbd,0xce,0xd1,0x52,0x3e,0x29,0x34,0xe2,0x9a,0x00,0x96,
2810 0x4c,0x85,0xaf,0x0f,0xfb,0x10,0x1d,0xf8,0x08,0x27,0x10,0x04,0x04,0xbf,0xae,
2811 0x36,0xd0,0x6a,0x49,0xe7,0x43,0x30,0x81,0xb7,0x02,0x01,0x00,0x30,0x20,0x30,
2812 0x0c,0x31,0x0a,0x30,0x08,0x06,0x03,0x55,0x04,0x03,0x13,0x01,0x4e,0x02,0x10,
2813 0xc2,0x8f,0xc4,0x5e,0x8d,0x3b,0x01,0x8c,0x4b,0x23,0xcb,0x93,0x77,0xab,0xb6,
2814 0xe1,0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x01,0x01,0x05,
2815 0x00,0x04,0x81,0x80,0x4b,0x22,0x8a,0xfa,0xa6,0xb6,0x01,0xe9,0xb5,0x54,0xcf,
2816 0xa7,0x81,0x54,0xf9,0x08,0x42,0x8a,0x75,0x19,0x9c,0xc9,0x27,0x68,0x08,0xf9,
2817 0x53,0xa7,0x60,0xf8,0xdd,0xba,0xfb,0x4f,0x63,0x8a,0x15,0x6a,0x5b,0xf6,0xe3,
2818 0x4e,0x29,0xa9,0xc8,0x1d,0x63,0x92,0x8f,0x95,0x91,0x95,0x71,0xb5,0x5d,0x02,
2819 0xe5,0xa0,0x07,0x67,0x36,0xe5,0x2d,0x7b,0xcd,0xe1,0xf2,0xa4,0xc6,0x24,0x70,
2820 0xac,0xd7,0xaf,0x63,0xb2,0x04,0x02,0x8d,0xae,0x2f,0xdc,0x7e,0x6c,0x84,0xd3,
2821 0xe3,0x66,0x54,0x3b,0x05,0xd8,0x77,0x40,0xe4,0x6b,0xbd,0xa9,0x8d,0x4d,0x74,
2822 0x15,0xfd,0x74,0xf7,0xd3,0xc0,0xc9,0xf1,0x20,0x0e,0x08,0x13,0xcc,0xb0,0x94,
2823 0x53,0x01,0xd4,0x5f,0x95,0x32,0xeb,0xe8,0x73,0x9f,0x6a,0xd1,0x30,0x81,0xb7,
2824 0x02,0x01,0x00,0x30,0x20,0x30,0x0c,0x31,0x0a,0x30,0x08,0x06,0x03,0x55,0x04,
2825 0x03,0x13,0x01,0x58,0x02,0x10,0x1c,0xf2,0x1f,0xec,0x6b,0xdc,0x36,0xbf,0x4a,
2826 0xd7,0xe1,0x6c,0x84,0x85,0xcd,0x2e,0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,0x86,
2827 0xf7,0x0d,0x01,0x01,0x01,0x05,0x00,0x04,0x81,0x80,0x47,0x21,0xf9,0xe7,0x98,
2828 0x7f,0xe7,0x49,0x3f,0x16,0xb8,0x4c,0x8b,0x7d,0x5d,0x56,0xa7,0x31,0xfd,0xa5,
2829 0xcd,0x43,0x70,0x58,0xf1,0x33,0xfb,0xe6,0xc8,0xbb,0x6f,0x0a,0x89,0xa4,0xb9,
2830 0x3e,0x3a,0xc5,0x85,0x46,0x54,0x73,0x37,0xa3,0xbd,0x36,0xc3,0xce,0x40,0xf3,
2831 0xd7,0x92,0x54,0x8e,0x60,0x1f,0xa2,0xa7,0x03,0xc2,0x49,0xa9,0x02,0x28,0xc8,
2832 0xa5,0xa7,0x42,0xcd,0x29,0x85,0x34,0xa7,0xa9,0xe8,0x8c,0x3d,0xb3,0xd0,0xac,
2833 0x7d,0x31,0x5d,0xb4,0xcb,0x7e,0xad,0x62,0xfd,0x04,0x7b,0xa1,0x93,0xb5,0xbc,
2834 0x08,0x4f,0x36,0xd7,0x5a,0x95,0xbc,0xff,0x47,0x0f,0x84,0x21,0x24,0xdf,0xc5,
2835 0xfe,0xc8,0xe5,0x0b,0xc4,0xc4,0x5c,0x1a,0x50,0x31,0x91,0xce,0xf6,0x11,0xf1,
2836 0x0e,0x28,0xce,0x30,0x1f,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,
2837 0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x03,0x04,0x05,0x00,
2838 0x80,0x04,0x4e,0x99,0x9d,0x4c };
2839 static const BYTE serialNumber[] = {
2840 0x2e,0xcd,0x85,0x84,0x6c,0xe1,0xd7,0x4a,0xbf,0x36,0xdc,0x6b,0xec,0x1f,0xf2,
2841 0x1c };
2842 static const BYTE issuer[] = {
2843 0x30,0x0c,0x31,0x0a,0x30,0x08,0x06,0x03,0x55,0x04,0x03,0x13,0x01,0x58 };
2844
2845 static void test_decode_msg_get_param(void)
2846 {
2847     HCRYPTMSG msg;
2848     HCRYPTPROV hCryptProv;
2849     HCRYPTKEY key = 0;
2850     BOOL ret;
2851     DWORD size = 0, value;
2852     LPBYTE buf;
2853     CMSG_CTRL_DECRYPT_PARA decryptPara = { sizeof(decryptPara), 0 };
2854
2855     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, NULL);
2856     SetLastError(0xdeadbeef);
2857     ret = CryptMsgGetParam(msg, CMSG_CONTENT_PARAM, 0, NULL, &size);
2858     ok(!ret && GetLastError() == CRYPT_E_INVALID_MSG_TYPE,
2859      "Expected CRYPT_E_INVALID_MSG_TYPE, got %x\n", GetLastError());
2860     ret = CryptMsgUpdate(msg, dataContent, sizeof(dataContent), TRUE);
2861     ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2862     check_param("data content", msg, CMSG_CONTENT_PARAM, msgData,
2863      sizeof(msgData));
2864     CryptMsgClose(msg);
2865
2866     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, NULL);
2867     ret = CryptMsgUpdate(msg, hashEmptyContent, sizeof(hashEmptyContent), TRUE);
2868     if (ret)
2869     {
2870         /* Crashes on some Win9x */
2871         check_param("empty hash content", msg, CMSG_CONTENT_PARAM, NULL, 0);
2872         check_param("empty hash hash data", msg, CMSG_HASH_DATA_PARAM, NULL, 0);
2873         check_param("empty hash computed hash", msg, CMSG_COMPUTED_HASH_PARAM,
2874          emptyHashParam, sizeof(emptyHashParam));
2875     }
2876     CryptMsgClose(msg);
2877     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, NULL);
2878     ret = CryptMsgUpdate(msg, hashContent, sizeof(hashContent), TRUE);
2879     ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2880     check_param("hash content", msg, CMSG_CONTENT_PARAM, msgData,
2881      sizeof(msgData));
2882     check_param("hash hash data", msg, CMSG_HASH_DATA_PARAM, hashParam,
2883      sizeof(hashParam));
2884     check_param("hash computed hash", msg, CMSG_COMPUTED_HASH_PARAM,
2885      hashParam, sizeof(hashParam));
2886     /* Curiously, on NT-like systems, getting the hash of index 1 succeeds,
2887      * even though there's only one hash.
2888      */
2889     ret = CryptMsgGetParam(msg, CMSG_COMPUTED_HASH_PARAM, 1, NULL, &size);
2890     ok(ret || GetLastError() == OSS_DATA_ERROR /* Win9x */,
2891      "CryptMsgGetParam failed: %08x\n", GetLastError());
2892     if (ret)
2893         buf = CryptMemAlloc(size);
2894     else
2895         buf = NULL;
2896     if (buf)
2897     {
2898         ret = CryptMsgGetParam(msg, CMSG_COMPUTED_HASH_PARAM, 1, buf, &size);
2899         ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
2900         ok(size == sizeof(hashParam), "Unexpected size %d\n", size);
2901         ok(!memcmp(buf, hashParam, size), "Unexpected value\n");
2902         CryptMemFree(buf);
2903     }
2904     check_param("hash inner OID", msg, CMSG_INNER_CONTENT_TYPE_PARAM,
2905      (const BYTE *)szOID_RSA_data, strlen(szOID_RSA_data) + 1);
2906     value = CMSG_HASHED_DATA_V0;
2907     check_param("hash version", msg, CMSG_VERSION_PARAM, (const BYTE *)&value,
2908      sizeof(value));
2909     CryptMsgClose(msg);
2910
2911     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, NULL);
2912     ret = CryptMsgUpdate(msg, signedContent, sizeof(signedContent), TRUE);
2913     ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2914     check_param("signed content", msg, CMSG_CONTENT_PARAM, msgData,
2915      sizeof(msgData));
2916     check_param("inner content", msg, CMSG_INNER_CONTENT_TYPE_PARAM,
2917      (const BYTE *)szOID_RSA_data, strlen(szOID_RSA_data) + 1);
2918     size = sizeof(value);
2919     value = 2112;
2920     ret = CryptMsgGetParam(msg, CMSG_SIGNER_COUNT_PARAM, 0, &value, &size);
2921     ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
2922     ok(value == 1, "Expected 1 signer, got %d\n", value);
2923     size = 0;
2924     ret = CryptMsgGetParam(msg, CMSG_SIGNER_INFO_PARAM, 0, NULL, &size);
2925     ok(ret || broken(GetLastError() == OSS_DATA_ERROR /* Win9x */),
2926      "CryptMsgGetParam failed: %08x\n", GetLastError());
2927     if (ret)
2928         buf = CryptMemAlloc(size);
2929     else
2930         buf = NULL;
2931     if (buf)
2932     {
2933         CMSG_SIGNER_INFO signer = { 0 };
2934
2935         signer.dwVersion = 1;
2936         signer.Issuer.cbData = sizeof(encodedCommonName);
2937         signer.Issuer.pbData = encodedCommonName;
2938         signer.SerialNumber.cbData = sizeof(serialNum);
2939         signer.SerialNumber.pbData = serialNum;
2940         signer.HashAlgorithm.pszObjId = oid_rsa_md5;
2941         CryptMsgGetParam(msg, CMSG_SIGNER_INFO_PARAM, 0, buf, &size);
2942         compare_signer_info((CMSG_SIGNER_INFO *)buf, &signer);
2943         CryptMemFree(buf);
2944     }
2945     /* Getting the CMS signer info of a PKCS7 message is possible. */
2946     size = 0;
2947     ret = CryptMsgGetParam(msg, CMSG_CMS_SIGNER_INFO_PARAM, 0, NULL, &size);
2948     ok(ret || broken(GetLastError() == CRYPT_E_INVALID_MSG_TYPE /* Win9x */),
2949      "CryptMsgGetParam failed: %08x\n", GetLastError());
2950     if (ret)
2951         buf = CryptMemAlloc(size);
2952     else
2953         buf = NULL;
2954     if (buf)
2955     {
2956         CMSG_CMS_SIGNER_INFO signer = { 0 };
2957
2958         signer.dwVersion = 1;
2959         signer.SignerId.dwIdChoice = CERT_ID_ISSUER_SERIAL_NUMBER;
2960         U(signer.SignerId).IssuerSerialNumber.Issuer.cbData =
2961          sizeof(encodedCommonName);
2962         U(signer.SignerId).IssuerSerialNumber.Issuer.pbData = encodedCommonName;
2963         U(signer.SignerId).IssuerSerialNumber.SerialNumber.cbData =
2964          sizeof(serialNum);
2965         U(signer.SignerId).IssuerSerialNumber.SerialNumber.pbData = serialNum;
2966         signer.HashAlgorithm.pszObjId = oid_rsa_md5;
2967         CryptMsgGetParam(msg, CMSG_CMS_SIGNER_INFO_PARAM, 0, buf, &size);
2968         compare_cms_signer_info((CMSG_CMS_SIGNER_INFO *)buf, &signer);
2969         CryptMemFree(buf);
2970     }
2971     /* index is ignored when getting signer count */
2972     size = sizeof(value);
2973     ret = CryptMsgGetParam(msg, CMSG_SIGNER_COUNT_PARAM, 1, &value, &size);
2974     ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
2975     ok(value == 1, "Expected 1 signer, got %d\n", value);
2976     ret = CryptMsgGetParam(msg, CMSG_CERT_COUNT_PARAM, 0, &value, &size);
2977     ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
2978     ok(value == 0, "Expected 0 certs, got %d\n", value);
2979     ret = CryptMsgGetParam(msg, CMSG_CRL_COUNT_PARAM, 0, &value, &size);
2980     ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
2981     ok(value == 0, "Expected 0 CRLs, got %d\n", value);
2982     CryptMsgClose(msg);
2983     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, CMSG_SIGNED, 0, NULL,
2984      NULL);
2985     ret = CryptMsgUpdate(msg, signedWithCertAndCrlBareContent,
2986      sizeof(signedWithCertAndCrlBareContent), TRUE);
2987     ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
2988     ret = CryptMsgGetParam(msg, CMSG_CERT_COUNT_PARAM, 0, &value, &size);
2989     ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
2990     ok(value == 1, "Expected 1 cert, got %d\n", value);
2991     check_param("cert", msg, CMSG_CERT_PARAM, cert, sizeof(cert));
2992     ret = CryptMsgGetParam(msg, CMSG_CRL_COUNT_PARAM, 0, &value, &size);
2993     ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
2994     ok(value == 1, "Expected 1 CRL, got %d\n", value);
2995     check_param("crl", msg, CMSG_CRL_PARAM, crl, sizeof(crl));
2996     check_param("signed with cert and CRL computed hash", msg,
2997      CMSG_COMPUTED_HASH_PARAM, signedWithCertAndCrlComputedHash,
2998      sizeof(signedWithCertAndCrlComputedHash));
2999     CryptMsgClose(msg);
3000
3001     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, NULL);
3002     ret = CryptMsgUpdate(msg, signedKeyIdEmptyContent,
3003      sizeof(signedKeyIdEmptyContent), TRUE);
3004     if (!ret && GetLastError() == OSS_DATA_ERROR)
3005     {
3006         CryptMsgClose(msg);
3007         win_skip("Subsequent tests crash on some Win9x\n");
3008         return;
3009     }
3010     ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
3011     size = sizeof(value);
3012     ret = CryptMsgGetParam(msg, CMSG_SIGNER_COUNT_PARAM, 0, &value, &size);
3013     ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
3014     ok(value == 1, "Expected 1 signer, got %d\n", value);
3015     /* Getting the regular (non-CMS) signer info from a CMS message is also
3016      * possible..
3017      */
3018     size = 0;
3019     ret = CryptMsgGetParam(msg, CMSG_SIGNER_INFO_PARAM, 0, NULL, &size);
3020     ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
3021     if (ret)
3022         buf = CryptMemAlloc(size);
3023     else
3024         buf = NULL;
3025     if (buf)
3026     {
3027         CMSG_SIGNER_INFO signer;
3028         BYTE zero = 0;
3029
3030         /* and here's the little oddity:  for a CMS message using the key id
3031          * variant of a SignerId, retrieving the CMSG_SIGNER_INFO param yields
3032          * a signer with a zero (not empty) serial number, and whose issuer is
3033          * an RDN with OID szOID_KEYID_RDN, value type CERT_RDN_OCTET_STRING,
3034          * and value of the key id.
3035          */
3036         signer.dwVersion = CMSG_SIGNED_DATA_V3;
3037         signer.Issuer.cbData = sizeof(keyIdIssuer);
3038         signer.Issuer.pbData = keyIdIssuer;
3039         signer.SerialNumber.cbData = 1;
3040         signer.SerialNumber.pbData = &zero;
3041         CryptMsgGetParam(msg, CMSG_SIGNER_INFO_PARAM, 0, buf, &size);
3042         compare_signer_info((CMSG_SIGNER_INFO *)buf, &signer);
3043         CryptMemFree(buf);
3044     }
3045     size = 0;
3046     ret = CryptMsgGetParam(msg, CMSG_CMS_SIGNER_INFO_PARAM, 0, NULL, &size);
3047     ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
3048     if (ret)
3049         buf = CryptMemAlloc(size);
3050     else
3051         buf = NULL;
3052     if (buf)
3053     {
3054         CMSG_CMS_SIGNER_INFO signer = { 0 };
3055
3056         signer.dwVersion = CMSG_SIGNED_DATA_V3;
3057         signer.SignerId.dwIdChoice = CERT_ID_KEY_IDENTIFIER;
3058         U(signer.SignerId).KeyId.cbData = sizeof(serialNum);
3059         U(signer.SignerId).KeyId.pbData = serialNum;
3060         signer.HashAlgorithm.pszObjId = oid_rsa_md5;
3061         CryptMsgGetParam(msg, CMSG_CMS_SIGNER_INFO_PARAM, 0, buf, &size);
3062         compare_cms_signer_info((CMSG_CMS_SIGNER_INFO *)buf, &signer);
3063         CryptMemFree(buf);
3064     }
3065     CryptMsgClose(msg);
3066
3067     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, CMSG_ENVELOPED, 0, NULL,
3068      NULL);
3069     CryptMsgUpdate(msg, envelopedEmptyBareContent,
3070      sizeof(envelopedEmptyBareContent), TRUE);
3071     check_param("enveloped empty bare content", msg, CMSG_CONTENT_PARAM, NULL,
3072      0);
3073     CryptMsgClose(msg);
3074
3075     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, NULL);
3076     CryptMsgUpdate(msg, envelopedEmptyContent, sizeof(envelopedEmptyContent),
3077      TRUE);
3078     check_param("enveloped empty content", msg, CMSG_CONTENT_PARAM, NULL, 0);
3079     CryptMsgClose(msg);
3080
3081     pCryptAcquireContextA(&hCryptProv, NULL, MS_ENHANCED_PROV_A, PROV_RSA_FULL,
3082      CRYPT_VERIFYCONTEXT);
3083     SetLastError(0xdeadbeef);
3084     ret = CryptImportKey(hCryptProv, publicPrivateKeyPair,
3085      sizeof(publicPrivateKeyPair), 0, 0, &key);
3086     ok(ret ||
3087      broken(!ret && GetLastError() == NTE_PERM), /* WinME and some NT4 */
3088      "CryptImportKey failed: %08x\n", GetLastError());
3089
3090     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, NULL);
3091     CryptMsgUpdate(msg, envelopedMessage, sizeof(envelopedMessage), TRUE);
3092     check_param("enveloped message before decrypting", msg, CMSG_CONTENT_PARAM,
3093      envelopedMessage + sizeof(envelopedMessage) - 4, 4);
3094     if (key)
3095     {
3096         decryptPara.hCryptProv = hCryptProv;
3097         SetLastError(0xdeadbeef);
3098         ret = CryptMsgControl(msg, 0, CMSG_CTRL_DECRYPT, &decryptPara);
3099         ok(ret, "CryptMsgControl failed: %08x\n", GetLastError());
3100         decryptPara.hCryptProv = 0;
3101         SetLastError(0xdeadbeef);
3102         ret = CryptMsgControl(msg, 0, CMSG_CTRL_DECRYPT, &decryptPara);
3103         ok(!ret && GetLastError() == CRYPT_E_ALREADY_DECRYPTED,
3104          "expected CRYPT_E_ALREADY_DECRYPTED, got %08x\n", GetLastError());
3105         check_param("enveloped message", msg, CMSG_CONTENT_PARAM, msgData,
3106          sizeof(msgData));
3107     }
3108     else
3109         win_skip("failed to import a key, skipping tests\n");
3110     CryptMsgClose(msg);
3111
3112     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, CMSG_ENVELOPED, 0, NULL,
3113      NULL);
3114     CryptMsgUpdate(msg, envelopedBareMessage, sizeof(envelopedBareMessage),
3115      TRUE);
3116     check_param("enveloped bare message before decrypting", msg,
3117      CMSG_CONTENT_PARAM, envelopedBareMessage +
3118      sizeof(envelopedBareMessage) - 4, 4);
3119     if (key)
3120     {
3121         decryptPara.hCryptProv = hCryptProv;
3122         SetLastError(0xdeadbeef);
3123         ret = CryptMsgControl(msg, 0, CMSG_CTRL_DECRYPT, &decryptPara);
3124         ok(ret, "CryptMsgControl failed: %08x\n", GetLastError());
3125         check_param("enveloped bare message", msg, CMSG_CONTENT_PARAM, msgData,
3126          sizeof(msgData));
3127     }
3128     else
3129         win_skip("failed to import a key, skipping tests\n");
3130     CryptMsgClose(msg);
3131
3132     if (key)
3133         CryptDestroyKey(key);
3134     CryptReleaseContext(hCryptProv, 0);
3135
3136     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, NULL);
3137     CryptMsgUpdate(msg, envelopedMessageWith3Recps,
3138      sizeof(envelopedMessageWith3Recps), TRUE);
3139     value = 3;
3140     check_param("recipient count", msg, CMSG_RECIPIENT_COUNT_PARAM,
3141      (const BYTE *)&value, sizeof(value));
3142     size = 0;
3143     SetLastError(0xdeadbeef);
3144     ret = CryptMsgGetParam(msg, CMSG_RECIPIENT_INFO_PARAM, 3, NULL, &size);
3145     ok(!ret && GetLastError() == CRYPT_E_INVALID_INDEX,
3146      "expected CRYPT_E_INVALID_INDEX, got %08x\n", GetLastError());
3147     size = 0;
3148     SetLastError(0xdeadbeef);
3149     ret = CryptMsgGetParam(msg, CMSG_RECIPIENT_INFO_PARAM, 2, NULL, &size);
3150     ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
3151     ok(size >= 142, "unexpected size: %u\n", size);
3152     if (ret)
3153         buf = CryptMemAlloc(size);
3154     else
3155         buf = NULL;
3156     if (buf)
3157     {
3158         CERT_INFO *certInfo = (CERT_INFO *)buf;
3159
3160         SetLastError(0xdeadbeef);
3161         ret = CryptMsgGetParam(msg, CMSG_RECIPIENT_INFO_PARAM, 2, buf, &size);
3162         ok(ret, "CryptMsgGetParam failed: %08x\n", GetLastError());
3163         ok(certInfo->SerialNumber.cbData == sizeof(serialNumber),
3164          "unexpected serial number size: %u\n", certInfo->SerialNumber.cbData);
3165         ok(!memcmp(certInfo->SerialNumber.pbData, serialNumber,
3166          sizeof(serialNumber)), "unexpected serial number\n");
3167         ok(certInfo->Issuer.cbData == sizeof(issuer),
3168          "unexpected issuer size: %u\n", certInfo->Issuer.cbData);
3169         ok(!memcmp(certInfo->Issuer.pbData, issuer, sizeof(issuer)),
3170          "unexpected issuer\n");
3171         CryptMemFree(buf);
3172     }
3173     CryptMsgClose(msg);
3174 }
3175
3176 static void test_decode_msg(void)
3177 {
3178     test_decode_msg_update();
3179     test_decode_msg_get_param();
3180 }
3181
3182 static BYTE aKey[] = { 0,1,2,3,4,5,6,7,8,9,0xa,0xb,0xc,0xd,0xe,0xf };
3183 /* aKey encoded as a X509_PUBLIC_KEY_INFO */
3184 static BYTE encodedPubKey[] = {
3185 0x30,0x1f,0x30,0x0a,0x06,0x06,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x05,0x00,0x03,
3186 0x11,0x00,0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,
3187 0x0d,0x0e,0x0f };
3188 /* a weird modulus encoded as RSA_CSP_PUBLICKEYBLOB */
3189 static BYTE mod_encoded[] = {
3190  0x30,0x10,0x02,0x09,0x00,0x80,0x00,0x00,0x01,0x01,0x01,0x01,0x01,0x02,0x03,
3191  0x01,0x00,0x01 };
3192
3193 static void test_msg_control(void)
3194 {
3195     static char oid_rsa_rsa[] = szOID_RSA_RSA;
3196     BOOL ret;
3197     HCRYPTMSG msg;
3198     DWORD i;
3199     CERT_INFO certInfo = { 0 };
3200     CMSG_HASHED_ENCODE_INFO hashInfo = { 0 };
3201     CMSG_SIGNED_ENCODE_INFO signInfo = { sizeof(signInfo), 0 };
3202     CMSG_CTRL_DECRYPT_PARA decryptPara = { sizeof(decryptPara), 0 };
3203
3204     /* Crashes
3205     ret = CryptMsgControl(NULL, 0, 0, NULL);
3206     */
3207
3208     /* Data encode messages don't allow any sort of control.. */
3209     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_DATA, NULL, NULL,
3210      NULL);
3211     /* either with no prior update.. */
3212     for (i = 1; !old_crypt32 && (i <= CMSG_CTRL_ADD_CMS_SIGNER_INFO); i++)
3213     {
3214         SetLastError(0xdeadbeef);
3215         ret = CryptMsgControl(msg, 0, i, NULL);
3216         ok(!ret && GetLastError() == E_INVALIDARG,
3217          "Expected E_INVALIDARG, got %08x\n", GetLastError());
3218     }
3219     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
3220     ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
3221     /* or after an update. */
3222     for (i = 1; !old_crypt32 && (i <= CMSG_CTRL_ADD_CMS_SIGNER_INFO); i++)
3223     {
3224         SetLastError(0xdeadbeef);
3225         ret = CryptMsgControl(msg, 0, i, NULL);
3226         ok(!ret && GetLastError() == E_INVALIDARG,
3227          "Expected E_INVALIDARG, got %08x\n", GetLastError());
3228     }
3229     CryptMsgClose(msg);
3230
3231     /* Hash encode messages don't allow any sort of control.. */
3232     hashInfo.cbSize = sizeof(hashInfo);
3233     hashInfo.HashAlgorithm.pszObjId = oid_rsa_md5;
3234     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_HASHED, &hashInfo,
3235      NULL, NULL);
3236     /* either with no prior update.. */
3237     for (i = 1; !old_crypt32 && (i <= CMSG_CTRL_ADD_CMS_SIGNER_INFO); i++)
3238     {
3239         SetLastError(0xdeadbeef);
3240         ret = CryptMsgControl(msg, 0, i, NULL);
3241         ok(!ret && GetLastError() == E_INVALIDARG,
3242          "Expected E_INVALIDARG, got %08x\n", GetLastError());
3243     }
3244     ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
3245     ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
3246     /* or after an update. */
3247     for (i = 1; !old_crypt32 && (i <= CMSG_CTRL_ADD_CMS_SIGNER_INFO); i++)
3248     {
3249         SetLastError(0xdeadbeef);
3250         ret = CryptMsgControl(msg, 0, i, NULL);
3251         ok(!ret && GetLastError() == E_INVALIDARG,
3252          "Expected E_INVALIDARG, got %08x\n", GetLastError());
3253     }
3254     CryptMsgClose(msg);
3255
3256     /* Signed encode messages likewise don't allow any sort of control.. */
3257     signInfo.cbSize = sizeof(signInfo);
3258     msg = CryptMsgOpenToEncode(PKCS_7_ASN_ENCODING, 0, CMSG_SIGNED, &signInfo,
3259      NULL, NULL);
3260     /* either before an update.. */
3261     for (i = 1; !old_crypt32 && (i <= CMSG_CTRL_ADD_CMS_SIGNER_INFO); i++)
3262     {
3263         SetLastError(0xdeadbeef);
3264         ret = CryptMsgControl(msg, 0, i, NULL);
3265         ok(!ret && GetLastError() == E_INVALIDARG,
3266          "Expected E_INVALIDARG, got %08x\n", GetLastError());
3267     }
3268     ret = CryptMsgUpdate(msg, NULL, 0, TRUE);
3269     ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
3270     /* or after an update. */
3271     for (i = 1; !old_crypt32 && (i <= CMSG_CTRL_ADD_CMS_SIGNER_INFO); i++)
3272     {
3273         SetLastError(0xdeadbeef);
3274         ret = CryptMsgControl(msg, 0, i, NULL);
3275         ok(!ret && GetLastError() == E_INVALIDARG,
3276          "Expected E_INVALIDARG, got %08x\n", GetLastError());
3277     }
3278     CryptMsgClose(msg);
3279
3280     /* Decode messages behave a bit differently. */
3281     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, NULL);
3282     /* Bad control type */
3283     SetLastError(0xdeadbeef);
3284     ret = CryptMsgControl(msg, 0, 0, NULL);
3285     ok(!ret && GetLastError() == CRYPT_E_CONTROL_TYPE,
3286      "Expected CRYPT_E_CONTROL_TYPE, got %08x\n", GetLastError());
3287     SetLastError(0xdeadbeef);
3288     ret = CryptMsgControl(msg, 1, 0, NULL);
3289     ok(!ret && GetLastError() == CRYPT_E_CONTROL_TYPE,
3290      "Expected CRYPT_E_CONTROL_TYPE, got %08x\n", GetLastError());
3291     /* Can't verify the hash of an indeterminate-type message */
3292     SetLastError(0xdeadbeef);
3293     ret = CryptMsgControl(msg, 0, CMSG_CTRL_VERIFY_HASH, NULL);
3294     ok(!ret && GetLastError() == CRYPT_E_INVALID_MSG_TYPE,
3295      "Expected CRYPT_E_INVALID_MSG_TYPE, got %08x\n", GetLastError());
3296     /* Crashes
3297     ret = CryptMsgControl(msg, 0, CMSG_CTRL_DECRYPT, NULL);
3298      */
3299     /* Can't decrypt an indeterminate-type message */
3300     ret = CryptMsgControl(msg, 0, CMSG_CTRL_DECRYPT, &decryptPara);
3301     ok(!ret && GetLastError() == CRYPT_E_INVALID_MSG_TYPE,
3302      "Expected CRYPT_E_INVALID_MSG_TYPE, got %08x\n", GetLastError());
3303     CryptMsgClose(msg);
3304
3305     if (!old_crypt32)
3306     {
3307         msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, CMSG_HASHED, 0, NULL,
3308          NULL);
3309         /* Can't verify the hash of an empty message */
3310         SetLastError(0xdeadbeef);
3311         /* Crashes on some Win9x */
3312         ret = CryptMsgControl(msg, 0, CMSG_CTRL_VERIFY_HASH, NULL);
3313         todo_wine
3314         ok(!ret && GetLastError() == STATUS_ACCESS_VIOLATION,
3315          "Expected STATUS_ACCESS_VIOLATION, got %08x\n", GetLastError());
3316         /* Crashes
3317         ret = CryptMsgControl(msg, 0, CMSG_CTRL_VERIFY_SIGNATURE, NULL);
3318          */
3319         /* Can't verify the signature of a hash message */
3320         ret = CryptMsgControl(msg, 0, CMSG_CTRL_VERIFY_SIGNATURE, &certInfo);
3321         ok(!ret && GetLastError() == CRYPT_E_INVALID_MSG_TYPE,
3322          "Expected CRYPT_E_INVALID_MSG_TYPE, got %08x\n", GetLastError());
3323         CryptMsgUpdate(msg, hashEmptyBareContent, sizeof(hashEmptyBareContent),
3324          TRUE);
3325         /* Oddly enough, this fails, crashes on some Win9x */
3326         ret = CryptMsgControl(msg, 0, CMSG_CTRL_VERIFY_HASH, NULL);
3327         ok(!ret, "Expected failure\n");
3328         CryptMsgClose(msg);
3329     }
3330     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, CMSG_HASHED, 0, NULL,
3331      NULL);
3332     CryptMsgUpdate(msg, hashBareContent, sizeof(hashBareContent), TRUE);
3333     ret = CryptMsgControl(msg, 0, CMSG_CTRL_VERIFY_HASH, NULL);
3334     ok(ret, "CryptMsgControl failed: %08x\n", GetLastError());
3335     /* Can't decrypt an indeterminate-type message */
3336     SetLastError(0xdeadbeef);
3337     ret = CryptMsgControl(msg, 0, CMSG_CTRL_DECRYPT, &decryptPara);
3338     ok(!ret && GetLastError() == CRYPT_E_INVALID_MSG_TYPE,
3339      "Expected CRYPT_E_INVALID_MSG_TYPE, got %08x\n", GetLastError());
3340     CryptMsgClose(msg);
3341
3342     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, CMSG_DETACHED_FLAG, 0, 0,
3343      NULL, NULL);
3344     /* Can't verify the hash of a detached message before it's been updated. */
3345     SetLastError(0xdeadbeef);
3346     ret = CryptMsgControl(msg, 0, CMSG_CTRL_VERIFY_HASH, NULL);
3347     ok(!ret && GetLastError() == CRYPT_E_INVALID_MSG_TYPE,
3348      "Expected CRYPT_E_INVALID_MSG_TYPE, got %08x\n", GetLastError());
3349     ret = CryptMsgUpdate(msg, detachedHashContent, sizeof(detachedHashContent),
3350      TRUE);
3351     ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
3352     /* Still can't verify the hash of a detached message with the content
3353      * of the detached hash given..
3354      */
3355     SetLastError(0xdeadbeef);
3356     ret = CryptMsgControl(msg, 0, CMSG_CTRL_VERIFY_HASH, NULL);
3357     ok(!ret && GetLastError() == CRYPT_E_HASH_VALUE,
3358      "Expected CRYPT_E_HASH_VALUE, got %08x\n", GetLastError());
3359     /* and giving the content of the message after attempting to verify the
3360      * hash fails.
3361      */
3362     SetLastError(0xdeadbeef);
3363     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
3364     todo_wine
3365     ok(!ret &&
3366        (GetLastError() == NTE_BAD_HASH_STATE ||
3367         GetLastError() == NTE_BAD_ALGID ||    /* Win9x */
3368         GetLastError() == CRYPT_E_MSG_ERROR), /* Vista */
3369      "Expected NTE_BAD_HASH_STATE or NTE_BAD_ALGID or CRYPT_E_MSG_ERROR, "
3370      "got %08x\n", GetLastError());
3371     CryptMsgClose(msg);
3372
3373     /* Finally, verifying the hash of a detached message in the correct order:
3374      * 1. Update with the detached hash message
3375      * 2. Update with the content of the message
3376      * 3. Verifying the hash of the message
3377      * succeeds.
3378      */
3379     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, CMSG_DETACHED_FLAG, 0, 0,
3380      NULL, NULL);
3381     ret = CryptMsgUpdate(msg, detachedHashContent, sizeof(detachedHashContent),
3382      TRUE);
3383     ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
3384     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
3385     ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
3386     SetLastError(0xdeadbeef);
3387     ret = CryptMsgControl(msg, 0, CMSG_CTRL_VERIFY_HASH, NULL);
3388     ok(ret, "CryptMsgControl failed: %08x\n", GetLastError());
3389     CryptMsgClose(msg);
3390
3391     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, CMSG_SIGNED, 0, NULL,
3392      NULL);
3393     /* Can't verify the hash of a signed message */
3394     SetLastError(0xdeadbeef);
3395     ret = CryptMsgControl(msg, 0, CMSG_CTRL_VERIFY_HASH, NULL);
3396     ok(!ret && GetLastError() == CRYPT_E_INVALID_MSG_TYPE,
3397      "Expected CRYPT_E_INVALID_MSG_TYPE, got %08x\n", GetLastError());
3398     /* Can't decrypt a signed message */
3399     SetLastError(0xdeadbeef);
3400     ret = CryptMsgControl(msg, 0, CMSG_CTRL_DECRYPT, &decryptPara);
3401     ok(!ret && GetLastError() == CRYPT_E_INVALID_MSG_TYPE,
3402      "Expected CRYPT_E_INVALID_MSG_TYPE, got %08x\n", GetLastError());
3403     /* Crash
3404     ret = CryptMsgControl(msg, 0, CMSG_CTRL_VERIFY_SIGNATURE, NULL);
3405     ret = CryptMsgControl(msg, 0, CMSG_CTRL_VERIFY_SIGNATURE, &certInfo);
3406      */
3407     CryptMsgUpdate(msg, signedWithCertBareContent,
3408      sizeof(signedWithCertBareContent), TRUE);
3409     /* With an empty cert info, the signer can't be found in the message (and
3410      * the signature can't be verified.
3411      */
3412     SetLastError(0xdeadbeef);
3413     ret = CryptMsgControl(msg, 0, CMSG_CTRL_VERIFY_SIGNATURE, &certInfo);
3414     ok(!ret && (GetLastError() == CRYPT_E_SIGNER_NOT_FOUND ||
3415      GetLastError() == OSS_DATA_ERROR /* Win9x */),
3416      "Expected CRYPT_E_SIGNER_NOT_FOUND or OSS_DATA_ERROR, got %08x\n",
3417      GetLastError());
3418     /* The cert info is expected to have an issuer, serial number, and public
3419      * key info set.
3420      */
3421     certInfo.SerialNumber.cbData = sizeof(serialNum);
3422     certInfo.SerialNumber.pbData = serialNum;
3423     certInfo.Issuer.cbData = sizeof(encodedCommonName);
3424     certInfo.Issuer.pbData = encodedCommonName;
3425     SetLastError(0xdeadbeef);
3426     ret = CryptMsgControl(msg, 0, CMSG_CTRL_VERIFY_SIGNATURE, &certInfo);
3427     ok(!ret && (GetLastError() == CRYPT_E_ASN1_EOD ||
3428      GetLastError() == OSS_DATA_ERROR /* Win9x */),
3429      "Expected CRYPT_E_ASN1_EOD or OSS_DATA_ERROR, got %08x\n", GetLastError());
3430     CryptMsgClose(msg);
3431     /* This cert has a public key, but it's not in a usable form */
3432     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, CMSG_SIGNED, 0, NULL,
3433      NULL);
3434     ret = CryptMsgUpdate(msg, signedWithCertWithPubKeyBareContent,
3435      sizeof(signedWithCertWithPubKeyBareContent), TRUE);
3436     if (ret)
3437     {
3438         /* Crashes on some Win9x */
3439         /* Again, cert info needs to have a public key set */
3440         SetLastError(0xdeadbeef);
3441         ret = CryptMsgControl(msg, 0, CMSG_CTRL_VERIFY_SIGNATURE, &certInfo);
3442         ok(!ret &&
3443          (GetLastError() == CRYPT_E_ASN1_EOD ||
3444           GetLastError() == TRUST_E_NOSIGNATURE /* Vista */),
3445          "Expected CRYPT_E_ASN1_EOD or TRUST_E_NOSIGNATURE, got %08x\n", GetLastError());
3446         /* The public key is supposed to be in encoded form.. */
3447         certInfo.SubjectPublicKeyInfo.Algorithm.pszObjId = oid_rsa_rsa;
3448         certInfo.SubjectPublicKeyInfo.PublicKey.cbData = sizeof(aKey);
3449         certInfo.SubjectPublicKeyInfo.PublicKey.pbData = aKey;
3450         SetLastError(0xdeadbeef);
3451         ret = CryptMsgControl(msg, 0, CMSG_CTRL_VERIFY_SIGNATURE, &certInfo);
3452         ok(!ret &&
3453          (GetLastError() == CRYPT_E_ASN1_BADTAG ||
3454           GetLastError() == TRUST_E_NOSIGNATURE /* Vista */),
3455          "Expected CRYPT_E_ASN1_BADTAG or TRUST_E_NOSIGNATURE, got %08x\n", GetLastError());
3456         /* but not as a X509_PUBLIC_KEY_INFO.. */
3457         certInfo.SubjectPublicKeyInfo.Algorithm.pszObjId = NULL;
3458         certInfo.SubjectPublicKeyInfo.PublicKey.cbData = sizeof(encodedPubKey);
3459         certInfo.SubjectPublicKeyInfo.PublicKey.pbData = encodedPubKey;
3460         SetLastError(0xdeadbeef);
3461         ret = CryptMsgControl(msg, 0, CMSG_CTRL_VERIFY_SIGNATURE, &certInfo);
3462         ok(!ret &&
3463          (GetLastError() == CRYPT_E_ASN1_BADTAG ||
3464           GetLastError() == TRUST_E_NOSIGNATURE /* Vista */),
3465          "Expected CRYPT_E_ASN1_BADTAG or TRUST_E_NOSIGNATURE, got %08x\n", GetLastError());
3466         /* This decodes successfully, but it doesn't match any key in the message */
3467         certInfo.SubjectPublicKeyInfo.PublicKey.cbData = sizeof(mod_encoded);
3468         certInfo.SubjectPublicKeyInfo.PublicKey.pbData = mod_encoded;
3469         SetLastError(0xdeadbeef);
3470         ret = CryptMsgControl(msg, 0, CMSG_CTRL_VERIFY_SIGNATURE, &certInfo);
3471         /* In Wine's rsaenh, this fails to decode because the key length is too
3472          * small.  Not sure if that's a bug in rsaenh, so leaving todo_wine for
3473          * now.
3474          */
3475         todo_wine
3476         ok(!ret &&
3477          (GetLastError() == NTE_BAD_SIGNATURE ||
3478           GetLastError() == TRUST_E_NOSIGNATURE /* Vista */),
3479          "Expected NTE_BAD_SIGNATURE or TRUST_E_NOSIGNATURE, got %08x\n", GetLastError());
3480     }
3481     CryptMsgClose(msg);
3482     /* A message with no data doesn't have a valid signature */
3483     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, NULL);
3484     ret = CryptMsgUpdate(msg, signedWithCertWithValidPubKeyEmptyContent,
3485      sizeof(signedWithCertWithValidPubKeyEmptyContent), TRUE);
3486     if (ret)
3487     {
3488         certInfo.SubjectPublicKeyInfo.Algorithm.pszObjId = oid_rsa_rsa;
3489         certInfo.SubjectPublicKeyInfo.PublicKey.cbData = sizeof(pubKey);
3490         certInfo.SubjectPublicKeyInfo.PublicKey.pbData = pubKey;
3491         SetLastError(0xdeadbeef);
3492         /* Crashes on some Win9x */
3493         ret = CryptMsgControl(msg, 0, CMSG_CTRL_VERIFY_SIGNATURE, &certInfo);
3494         ok(!ret &&
3495          (GetLastError() == NTE_BAD_SIGNATURE ||
3496           GetLastError() == TRUST_E_NOSIGNATURE /* Vista */),
3497          "Expected NTE_BAD_SIGNATURE or TRUST_E_NOSIGNATURE, got %08x\n", GetLastError());
3498     }
3499     CryptMsgClose(msg);
3500     /* Finally, this succeeds */
3501     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, NULL);
3502     CryptMsgUpdate(msg, signedWithCertWithValidPubKeyContent,
3503      sizeof(signedWithCertWithValidPubKeyContent), TRUE);
3504     ret = CryptMsgControl(msg, 0, CMSG_CTRL_VERIFY_SIGNATURE, &certInfo);
3505     ok(ret || broken(GetLastError() == OSS_DATA_ERROR /* Win9x */),
3506      "CryptMsgControl failed: %08x\n", GetLastError());
3507     CryptMsgClose(msg);
3508
3509     /* Test verifying signature of a detached signed message */
3510     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, CMSG_DETACHED_FLAG, 0, 0,
3511      NULL, NULL);
3512     ret = CryptMsgUpdate(msg, detachedSignedContent,
3513      sizeof(detachedSignedContent), TRUE);
3514     ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
3515     /* Can't verify the sig without having updated the data */
3516     SetLastError(0xdeadbeef);
3517     ret = CryptMsgControl(msg, 0, CMSG_CTRL_VERIFY_SIGNATURE, &certInfo);
3518     ok(!ret && (GetLastError() == NTE_BAD_SIGNATURE ||
3519      GetLastError() == OSS_DATA_ERROR /* Win9x */),
3520      "expected NTE_BAD_SIGNATURE or OSS_DATA_ERROR, got %08x\n",
3521      GetLastError());
3522     /* Now that the signature's been checked, can't do the final update */
3523     SetLastError(0xdeadbeef);
3524     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
3525     todo_wine
3526     ok((!ret &&
3527      (GetLastError() == NTE_BAD_HASH_STATE ||
3528       GetLastError() == NTE_BAD_ALGID ||    /* Win9x */
3529       GetLastError() == CRYPT_E_MSG_ERROR)) || /* Vista */
3530       broken(ret), /* Win9x */
3531      "expected NTE_BAD_HASH_STATE or NTE_BAD_ALGID or CRYPT_E_MSG_ERROR, "
3532      "got %08x\n", GetLastError());
3533     CryptMsgClose(msg);
3534     /* Updating with the detached portion of the message and the data of the
3535      * the message allows the sig to be verified.
3536      */
3537     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, CMSG_DETACHED_FLAG, 0, 0,
3538      NULL, NULL);
3539     ret = CryptMsgUpdate(msg, detachedSignedContent,
3540      sizeof(detachedSignedContent), TRUE);
3541     ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
3542     ret = CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
3543     ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
3544     ret = CryptMsgControl(msg, 0, CMSG_CTRL_VERIFY_SIGNATURE, &certInfo);
3545     ok(ret || broken(GetLastError() == OSS_DATA_ERROR /* Win9x */),
3546      "CryptMsgControl failed: %08x\n", GetLastError());
3547     CryptMsgClose(msg);
3548
3549     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, CMSG_ENVELOPED, 0, NULL,
3550      NULL);
3551     decryptPara.cbSize = 0;
3552     SetLastError(0xdeadbeef);
3553     ret = CryptMsgControl(msg, 0, CMSG_CTRL_DECRYPT, &decryptPara);
3554     ok(!ret && GetLastError() == E_INVALIDARG,
3555      "expected E_INVALIDARG, got %08x\n", GetLastError());
3556     decryptPara.cbSize = sizeof(decryptPara);
3557     if (!old_crypt32)
3558     {
3559         SetLastError(0xdeadbeef);
3560         ret = CryptMsgControl(msg, 0, CMSG_CTRL_DECRYPT, &decryptPara);
3561         ok(!ret && GetLastError() == CRYPT_E_INVALID_MSG_TYPE,
3562          "expected CRYPT_E_INVALID_MSG_TYPE, got %08x\n", GetLastError());
3563     }
3564     SetLastError(0xdeadbeef);
3565     ret = CryptMsgUpdate(msg, envelopedEmptyBareContent,
3566      sizeof(envelopedEmptyBareContent), TRUE);
3567     ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
3568     SetLastError(0xdeadbeef);
3569     ret = CryptMsgControl(msg, 0, CMSG_CTRL_DECRYPT, &decryptPara);
3570     ok(!ret && GetLastError() == CRYPT_E_INVALID_INDEX,
3571      "expected CRYPT_E_INVALID_INDEX, got %08x\n", GetLastError());
3572     CryptMsgClose(msg);
3573
3574     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, CMSG_ENVELOPED, 0, NULL,
3575      NULL);
3576     SetLastError(0xdeadbeef);
3577     ret = CryptMsgUpdate(msg, envelopedBareMessage,
3578      sizeof(envelopedBareMessage), TRUE);
3579     ok(ret, "CryptMsgUpdate failed: %08x\n", GetLastError());
3580     SetLastError(0xdeadbeef);
3581     ret = CryptMsgControl(msg, 0, CMSG_CTRL_DECRYPT, &decryptPara);
3582     ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
3583      "expected ERROR_INVALID_PARAMETER, got %08x\n", GetLastError());
3584     CryptMsgClose(msg);
3585 }
3586
3587 /* win9x has much less parameter checks and will crash on many tests
3588  * this code is from test_signed_msg_update()
3589  */
3590 static BOOL detect_nt(void)
3591 {
3592     BOOL ret;
3593     CMSG_SIGNER_ENCODE_INFO signer = { sizeof(signer), 0 };
3594     CERT_INFO certInfo = { 0 };
3595
3596     if (!pCryptAcquireContextW)
3597         return FALSE;
3598
3599     certInfo.SerialNumber.cbData = sizeof(serialNum);
3600     certInfo.SerialNumber.pbData = serialNum;
3601     certInfo.Issuer.cbData = sizeof(encodedCommonName);
3602     certInfo.Issuer.pbData = encodedCommonName;
3603     signer.pCertInfo = &certInfo;
3604     signer.HashAlgorithm.pszObjId = oid_rsa_md5;
3605
3606     ret = pCryptAcquireContextW(&signer.hCryptProv, cspNameW, NULL,
3607                                 PROV_RSA_FULL, CRYPT_NEWKEYSET);
3608     if (!ret && GetLastError() == NTE_EXISTS) {
3609         ret = pCryptAcquireContextW(&signer.hCryptProv, cspNameW, NULL,
3610                                     PROV_RSA_FULL, 0);
3611     }
3612
3613     if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED) return FALSE;
3614
3615     /* cleanup */
3616     CryptReleaseContext(signer.hCryptProv, 0);
3617     pCryptAcquireContextW(&signer.hCryptProv, cspNameW, NULL, PROV_RSA_FULL,
3618                           CRYPT_DELETEKEYSET);
3619
3620     return TRUE;
3621 }
3622
3623 static void test_msg_get_and_verify_signer(void)
3624 {
3625     BOOL ret;
3626     HCRYPTMSG msg;
3627     PCCERT_CONTEXT signer;
3628     DWORD signerIndex;
3629     HCERTSTORE store;
3630
3631     /* Crash */
3632     if (0)
3633     {
3634         CryptMsgGetAndVerifySigner(NULL, 0, NULL, 0, NULL, NULL);
3635         CryptMsgGetAndVerifySigner(NULL, 0, NULL, 0, NULL, &signerIndex);
3636     }
3637
3638     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, NULL);
3639     /* An empty message has no signer */
3640     SetLastError(0xdeadbeef);
3641     ret = CryptMsgGetAndVerifySigner(msg, 0, NULL, 0, NULL, NULL);
3642     ok(!ret && GetLastError() == CRYPT_E_NO_TRUSTED_SIGNER,
3643      "expected CRYPT_E_NO_TRUSTED_SIGNER, got 0x%08x\n", GetLastError());
3644     /* The signer is cleared on error */
3645     signer = (PCCERT_CONTEXT)0xdeadbeef;
3646     SetLastError(0xdeadbeef);
3647     ret = CryptMsgGetAndVerifySigner(msg, 0, NULL, 0, &signer, NULL);
3648     ok(!ret && GetLastError() == CRYPT_E_NO_TRUSTED_SIGNER,
3649      "expected CRYPT_E_NO_TRUSTED_SIGNER, got 0x%08x\n", GetLastError());
3650     ok(!signer, "expected signer to be NULL\n");
3651     /* The signer index is also cleared on error */
3652     signerIndex = 0xdeadbeef;
3653     SetLastError(0xdeadbeef);
3654     ret = CryptMsgGetAndVerifySigner(msg, 0, NULL, 0, NULL, &signerIndex);
3655     ok(!ret && GetLastError() == CRYPT_E_NO_TRUSTED_SIGNER,
3656      "expected CRYPT_E_NO_TRUSTED_SIGNER, got 0x%08x\n", GetLastError());
3657     ok(!signerIndex, "expected 0, got %d\n", signerIndex);
3658     /* An unsigned message (msgData isn't a signed message at all)
3659      * likewise has no signer.
3660      */
3661     CryptMsgUpdate(msg, msgData, sizeof(msgData), TRUE);
3662     SetLastError(0xdeadbeef);
3663     ret = CryptMsgGetAndVerifySigner(msg, 0, NULL, 0, NULL, NULL);
3664     ok(!ret && GetLastError() == CRYPT_E_NO_TRUSTED_SIGNER,
3665      "expected CRYPT_E_NO_TRUSTED_SIGNER, got 0x%08x\n", GetLastError());
3666     CryptMsgClose(msg);
3667
3668     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, NULL);
3669     /* A "signed" message created with no signer cert likewise has no signer */
3670     ret = CryptMsgUpdate(msg, signedEmptyContent, sizeof(signedEmptyContent), TRUE);
3671     if (ret)
3672     {
3673         /* Crashes on most Win9x */
3674         ret = CryptMsgGetAndVerifySigner(msg, 0, NULL, 0, NULL, NULL);
3675         ok(!ret && GetLastError() == CRYPT_E_NO_TRUSTED_SIGNER,
3676          "expected CRYPT_E_NO_TRUSTED_SIGNER, got 0x%08x\n", GetLastError());
3677     }
3678     CryptMsgClose(msg);
3679
3680     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING, 0, 0, 0, NULL, NULL);
3681     /* A signed message succeeds, .. */
3682     CryptMsgUpdate(msg, signedWithCertWithValidPubKeyContent,
3683      sizeof(signedWithCertWithValidPubKeyContent), TRUE);
3684     ret = CryptMsgGetAndVerifySigner(msg, 0, NULL, 0, NULL, NULL);
3685     ok(ret || broken(GetLastError() == OSS_DATA_ERROR /* Win9x */),
3686      "CryptMsgGetAndVerifySigner failed: 0x%08x\n", GetLastError());
3687     /* the signer index can be retrieved, .. */
3688     signerIndex = 0xdeadbeef;
3689     ret = CryptMsgGetAndVerifySigner(msg, 0, NULL, 0, NULL, &signerIndex);
3690     ok(ret || broken(GetLastError() == OSS_DATA_ERROR /* Win9x */),
3691      "CryptMsgGetAndVerifySigner failed: 0x%08x\n", GetLastError());
3692     if (ret)
3693         ok(signerIndex == 0, "expected 0, got %d\n", signerIndex);
3694     /* as can the signer cert. */
3695     signer = (PCCERT_CONTEXT)0xdeadbeef;
3696     ret = CryptMsgGetAndVerifySigner(msg, 0, NULL, 0, &signer, NULL);
3697     ok(ret || broken(GetLastError() == OSS_DATA_ERROR /* Win9x */),
3698      "CryptMsgGetAndVerifySigner failed: 0x%08x\n", GetLastError());
3699     if (ret)
3700         ok(signer != NULL && signer != (PCCERT_CONTEXT)0xdeadbeef,
3701      "expected a valid signer\n");
3702     if (signer && signer != (PCCERT_CONTEXT)0xdeadbeef)
3703         CertFreeCertificateContext(signer);
3704     /* Specifying CMSG_USE_SIGNER_INDEX_FLAG and an invalid signer index fails
3705      */
3706     signerIndex = 0xdeadbeef;
3707     SetLastError(0xdeadbeef);
3708     ret = CryptMsgGetAndVerifySigner(msg, 0, NULL, CMSG_USE_SIGNER_INDEX_FLAG,
3709      NULL, &signerIndex);
3710     ok(!ret && GetLastError() == CRYPT_E_INVALID_INDEX,
3711      "expected CRYPT_E_INVALID_INDEX, got 0x%08x\n", GetLastError());
3712     /* Specifying CMSG_TRUSTED_SIGNER_FLAG and no cert stores causes the
3713      * message signer not to be found.
3714      */
3715     SetLastError(0xdeadbeef);
3716     ret = CryptMsgGetAndVerifySigner(msg, 0, NULL, CMSG_TRUSTED_SIGNER_FLAG,
3717      NULL, NULL);
3718     ok(!ret && (GetLastError() == CRYPT_E_NO_TRUSTED_SIGNER ||
3719      broken(GetLastError() == OSS_DATA_ERROR /* Win9x */)),
3720      "expected CRYPT_E_NO_TRUSTED_SIGNER, got 0x%08x\n", GetLastError());
3721     /* Specifying CMSG_TRUSTED_SIGNER_FLAG and an empty cert store also causes
3722      * the message signer not to be found.
3723      */
3724     store = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0,
3725      CERT_STORE_CREATE_NEW_FLAG, NULL);
3726     SetLastError(0xdeadbeef);
3727     ret = CryptMsgGetAndVerifySigner(msg, 1, &store, CMSG_TRUSTED_SIGNER_FLAG,
3728      NULL, NULL);
3729     ok(!ret && (GetLastError() == CRYPT_E_NO_TRUSTED_SIGNER ||
3730      broken(GetLastError() == OSS_DATA_ERROR /* Win9x */)),
3731      "expected CRYPT_E_NO_TRUSTED_SIGNER, got 0x%08x\n", GetLastError());
3732     ret = CertAddEncodedCertificateToStore(store, X509_ASN_ENCODING,
3733      v1CertWithValidPubKey, sizeof(v1CertWithValidPubKey),
3734      CERT_STORE_ADD_ALWAYS, NULL);
3735     ok(ret || broken(GetLastError() == OSS_DATA_ERROR /* Win98 */),
3736      "CertAddEncodedCertificateToStore failed: 0x%08x\n", GetLastError());
3737     /* Specifying CMSG_TRUSTED_SIGNER_FLAG with a cert store that contains
3738      * the signer succeeds.
3739      */
3740     SetLastError(0xdeadbeef);
3741     ret = CryptMsgGetAndVerifySigner(msg, 1, &store, CMSG_TRUSTED_SIGNER_FLAG,
3742      NULL, NULL);
3743     ok(ret || broken(GetLastError() == OSS_DATA_ERROR /* Win9x */),
3744      "CryptMsgGetAndVerifySigner failed: 0x%08x\n", GetLastError());
3745     CertCloseStore(store, 0);
3746     CryptMsgClose(msg);
3747 }
3748
3749 START_TEST(msg)
3750 {
3751     init_function_pointers();
3752     have_nt = detect_nt();
3753     if (!have_nt)
3754         win_skip("Win9x crashes on some parameter checks\n");
3755
3756     /* I_CertUpdateStore can be used for verification if crypt32 is new enough */
3757     if (!GetProcAddress(GetModuleHandleA("crypt32.dll"), "I_CertUpdateStore"))
3758     {
3759         win_skip("Some tests will crash on older crypt32 implementations\n");
3760         old_crypt32 = TRUE;
3761     }
3762
3763     /* Basic parameter checking tests */
3764     test_msg_open_to_encode();
3765     test_msg_open_to_decode();
3766     test_msg_get_param();
3767     test_msg_close();
3768     test_msg_control();
3769
3770     /* Message-type specific tests */
3771     test_data_msg();
3772     test_hash_msg();
3773     test_signed_msg();
3774     test_enveloped_msg();
3775     test_decode_msg();
3776
3777     test_msg_get_and_verify_signer();
3778 }