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

   1 /*
   2  * Copyright 2007 Juan Lang
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "config.h"
  20 #include "wine/port.h"
  21
  22 #include <stdarg.h>
  23 #define NONAMELESSUNION
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "wincrypt.h"
  27 #include "snmp.h"
  28
  29 #include "wine/debug.h"
  30 #include "wine/exception.h"
  31 #include "crypt32_private.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(crypt);
  34
  35 /* Called when a message's ref count reaches zero.  Free any message-specific
  36  * data here.
  37  */
  38 typedef void (*CryptMsgCloseFunc)(HCRYPTMSG msg);
  39
  40 typedef BOOL (*CryptMsgGetParamFunc)(HCRYPTMSG hCryptMsg, DWORD dwParamType,
  41  DWORD dwIndex, void *pvData, DWORD *pcbData);
  42
  43 typedef BOOL (*CryptMsgUpdateFunc)(HCRYPTMSG hCryptMsg, const BYTE *pbData,
  44  DWORD cbData, BOOL fFinal);
  45
  46 typedef BOOL (*CryptMsgControlFunc)(HCRYPTMSG hCryptMsg, DWORD dwFlags,
  47  DWORD dwCtrlType, const void *pvCtrlPara);
  48
  49 static BOOL CRYPT_DefaultMsgControl(HCRYPTMSG hCryptMsg, DWORD dwFlags,
  50  DWORD dwCtrlType, const void *pvCtrlPara)
  51 {
  52     TRACE("(%p, %08x, %d, %p)\n", hCryptMsg, dwFlags, dwCtrlType, pvCtrlPara);
  53     SetLastError(E_INVALIDARG);
  54     return FALSE;
  55 }
  56
  57 typedef enum _CryptMsgState {
  58     MsgStateInit,
  59     MsgStateUpdated,
  60     MsgStateDataFinalized,
  61     MsgStateFinalized
  62 } CryptMsgState;
  63
  64 typedef struct _CryptMsgBase
  65 {
  66     LONG                 ref;
  67     DWORD                open_flags;
  68     BOOL                 streamed;
  69     CMSG_STREAM_INFO     stream_info;
  70     CryptMsgState        state;
  71     CryptMsgCloseFunc    close;
  72     CryptMsgUpdateFunc   update;
  73     CryptMsgGetParamFunc get_param;
  74     CryptMsgControlFunc  control;
  75 } CryptMsgBase;
  76
  77 static inline void CryptMsgBase_Init(CryptMsgBase *msg, DWORD dwFlags,
  78  PCMSG_STREAM_INFO pStreamInfo, CryptMsgCloseFunc close,
  79  CryptMsgGetParamFunc get_param, CryptMsgUpdateFunc update,
  80  CryptMsgControlFunc control)
  81 {
  82     msg->ref = 1;
  83     msg->open_flags = dwFlags;
  84     if (pStreamInfo)
  85     {
  86         msg->streamed = TRUE;
  87         msg->stream_info = *pStreamInfo;
  88     }
  89     else
  90     {
  91         msg->streamed = FALSE;
  92         memset(&msg->stream_info, 0, sizeof(msg->stream_info));
  93     }
  94     msg->close = close;
  95     msg->get_param = get_param;
  96     msg->update = update;
  97     msg->control = control;
  98     msg->state = MsgStateInit;
  99 }
 100
 101 typedef struct _CDataEncodeMsg
 102 {
 103     CryptMsgBase base;
 104     DWORD        bare_content_len;
 105     LPBYTE       bare_content;
 106 } CDataEncodeMsg;
 107
 108 static const BYTE empty_data_content[] = { 0x04,0x00 };
 109
 110 static void CDataEncodeMsg_Close(HCRYPTMSG hCryptMsg)
 111 {
 112     CDataEncodeMsg *msg = hCryptMsg;
 113
 114     if (msg->bare_content != empty_data_content)
 115         LocalFree(msg->bare_content);
 116 }
 117
 118 static BOOL WINAPI CRYPT_EncodeContentLength(DWORD dwCertEncodingType,
 119  LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
 120  PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
 121 {
 122     DWORD dataLen = *(DWORD *)pvStructInfo;
 123     DWORD lenBytes;
 124     BOOL ret = TRUE;
 125
 126     /* Trick:  report bytes needed based on total message length, even though
 127      * the message isn't available yet.  The caller will use the length
 128      * reported here to encode its length.
 129      */
 130     CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
 131     if (!pbEncoded)
 132         *pcbEncoded = 1 + lenBytes + dataLen;
 133     else
 134     {
 135         if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
 136          pcbEncoded, 1 + lenBytes)))
 137         {
 138             if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
 139                 pbEncoded = *(BYTE **)pbEncoded;
 140             *pbEncoded++ = ASN_OCTETSTRING;
 141             CRYPT_EncodeLen(dataLen, pbEncoded,
 142              &lenBytes);
 143         }
 144     }
 145     return ret;
 146 }
 147
 148 static BOOL CRYPT_EncodeDataContentInfoHeader(CDataEncodeMsg *msg,
 149  CRYPT_DATA_BLOB *header)
 150 {
 151     BOOL ret;
 152
 153     if (msg->base.streamed && msg->base.stream_info.cbContent == 0xffffffff)
 154     {
 155         static const BYTE headerValue[] = { 0x30,0x80,0x06,0x09,0x2a,0x86,0x48,
 156          0x86,0xf7,0x0d,0x01,0x07,0x01,0xa0,0x80,0x24,0x80 };
 157
 158         header->pbData = LocalAlloc(0, sizeof(headerValue));
 159         if (header->pbData)
 160         {
 161             header->cbData = sizeof(headerValue);
 162             memcpy(header->pbData, headerValue, sizeof(headerValue));
 163             ret = TRUE;
 164         }
 165         else
 166             ret = FALSE;
 167     }
 168     else
 169     {
 170         struct AsnConstructedItem constructed = { 0,
 171          &msg->base.stream_info.cbContent, CRYPT_EncodeContentLength };
 172         struct AsnEncodeSequenceItem items[2] = {
 173          { szOID_RSA_data, CRYPT_AsnEncodeOid, 0 },
 174          { &constructed,   CRYPT_AsnEncodeConstructed, 0 },
 175         };
 176
 177         ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items,
 178          sizeof(items) / sizeof(items[0]), CRYPT_ENCODE_ALLOC_FLAG, NULL,
 179          (LPBYTE)&header->pbData, &header->cbData);
 180         if (ret)
 181         {
 182             /* Trick:  subtract the content length from the reported length,
 183              * as the actual content hasn't come yet.
 184              */
 185             header->cbData -= msg->base.stream_info.cbContent;
 186         }
 187     }
 188     return ret;
 189 }
 190
 191 static BOOL CDataEncodeMsg_Update(HCRYPTMSG hCryptMsg, const BYTE *pbData,
 192  DWORD cbData, BOOL fFinal)
 193 {
 194     CDataEncodeMsg *msg = hCryptMsg;
 195     BOOL ret = FALSE;
 196
 197     if (msg->base.state == MsgStateFinalized)
 198         SetLastError(CRYPT_E_MSG_ERROR);
 199     else if (msg->base.streamed)
 200     {
 201         __TRY
 202         {
 203             if (msg->base.state != MsgStateUpdated)
 204             {
 205                 CRYPT_DATA_BLOB header;
 206
 207                 ret = CRYPT_EncodeDataContentInfoHeader(msg, &header);
 208                 if (ret)
 209                 {
 210                     ret = msg->base.stream_info.pfnStreamOutput(
 211                      msg->base.stream_info.pvArg, header.pbData, header.cbData,
 212                      FALSE);
 213                     LocalFree(header.pbData);
 214                 }
 215             }
 216             /* Curiously, every indefinite-length streamed update appears to
 217              * get its own tag and length, regardless of fFinal.
 218              */
 219             if (msg->base.stream_info.cbContent == 0xffffffff)
 220             {
 221                 BYTE *header;
 222                 DWORD headerLen;
 223
 224                 ret = CRYPT_EncodeContentLength(X509_ASN_ENCODING, NULL,
 225                  &cbData, CRYPT_ENCODE_ALLOC_FLAG, NULL, (BYTE *)&header,
 226                  &headerLen);
 227                 if (ret)
 228                 {
 229                     ret = msg->base.stream_info.pfnStreamOutput(
 230                      msg->base.stream_info.pvArg, header, headerLen,
 231                      FALSE);
 232                     LocalFree(header);
 233                 }
 234             }
 235             if (!fFinal)
 236             {
 237                 ret = msg->base.stream_info.pfnStreamOutput(
 238                  msg->base.stream_info.pvArg, (BYTE *)pbData, cbData,
 239                  FALSE);
 240                 msg->base.state = MsgStateUpdated;
 241             }
 242             else
 243             {
 244                 msg->base.state = MsgStateFinalized;
 245                 if (msg->base.stream_info.cbContent == 0xffffffff)
 246                 {
 247                     BYTE indefinite_trailer[6] = { 0 };
 248
 249                     ret = msg->base.stream_info.pfnStreamOutput(
 250                      msg->base.stream_info.pvArg, (BYTE *)pbData, cbData,
 251                      FALSE);
 252                     if (ret)
 253                         ret = msg->base.stream_info.pfnStreamOutput(
 254                          msg->base.stream_info.pvArg, indefinite_trailer,
 255                          sizeof(indefinite_trailer), TRUE);
 256                 }
 257                 else
 258                     ret = msg->base.stream_info.pfnStreamOutput(
 259                      msg->base.stream_info.pvArg, (BYTE *)pbData, cbData, TRUE);
 260             }
 261         }
 262         __EXCEPT_PAGE_FAULT
 263         {
 264             SetLastError(STATUS_ACCESS_VIOLATION);
 265             ret = FALSE;
 266         }
 267         __ENDTRY;
 268     }
 269     else
 270     {
 271         if (!fFinal)
 272         {
 273             if (msg->base.open_flags & CMSG_DETACHED_FLAG)
 274                 SetLastError(E_INVALIDARG);
 275             else
 276                 SetLastError(CRYPT_E_MSG_ERROR);
 277         }
 278         else
 279         {
 280             msg->base.state = MsgStateFinalized;
 281             if (!cbData)
 282                 SetLastError(E_INVALIDARG);
 283             else
 284             {
 285                 CRYPT_DATA_BLOB blob = { cbData, (LPBYTE)pbData };
 286
 287                 /* non-streamed data messages don't allow non-final updates,
 288                  * don't bother checking whether data already exist, they can't.
 289                  */
 290                 ret = CryptEncodeObjectEx(X509_ASN_ENCODING, X509_OCTET_STRING,
 291                  &blob, CRYPT_ENCODE_ALLOC_FLAG, NULL, &msg->bare_content,
 292                  &msg->bare_content_len);
 293             }
 294         }
 295     }
 296     return ret;
 297 }
 298
 299 static BOOL CRYPT_CopyParam(void *pvData, DWORD *pcbData, const void *src,
 300  DWORD len)
 301 {
 302     BOOL ret = TRUE;
 303
 304     if (!pvData)
 305         *pcbData = len;
 306     else if (*pcbData < len)
 307     {
 308         *pcbData = len;
 309         SetLastError(ERROR_MORE_DATA);
 310         ret = FALSE;
 311     }
 312     else
 313     {
 314         *pcbData = len;
 315         memcpy(pvData, src, len);
 316     }
 317     return ret;
 318 }
 319
 320 static BOOL CDataEncodeMsg_GetParam(HCRYPTMSG hCryptMsg, DWORD dwParamType,
 321  DWORD dwIndex, void *pvData, DWORD *pcbData)
 322 {
 323     CDataEncodeMsg *msg = hCryptMsg;
 324     BOOL ret = FALSE;
 325
 326     switch (dwParamType)
 327     {
 328     case CMSG_CONTENT_PARAM:
 329         if (msg->base.streamed)
 330             SetLastError(E_INVALIDARG);
 331         else
 332         {
 333             CRYPT_CONTENT_INFO info;
 334             char rsa_data[] = "1.2.840.113549.1.7.1";
 335
 336             info.pszObjId = rsa_data;
 337             info.Content.cbData = msg->bare_content_len;
 338             info.Content.pbData = msg->bare_content;
 339             ret = CryptEncodeObject(X509_ASN_ENCODING, PKCS_CONTENT_INFO, &info,
 340              pvData, pcbData);
 341         }
 342         break;
 343     case CMSG_BARE_CONTENT_PARAM:
 344         if (msg->base.streamed)
 345             SetLastError(E_INVALIDARG);
 346         else
 347             ret = CRYPT_CopyParam(pvData, pcbData, msg->bare_content,
 348              msg->bare_content_len);
 349         break;
 350     default:
 351         SetLastError(CRYPT_E_INVALID_MSG_TYPE);
 352     }
 353     return ret;
 354 }
 355
 356 static HCRYPTMSG CDataEncodeMsg_Open(DWORD dwFlags, const void *pvMsgEncodeInfo,
 357  LPSTR pszInnerContentObjID, PCMSG_STREAM_INFO pStreamInfo)
 358 {
 359     CDataEncodeMsg *msg;
 360
 361     if (pvMsgEncodeInfo)
 362     {
 363         SetLastError(E_INVALIDARG);
 364         return NULL;
 365     }
 366     msg = CryptMemAlloc(sizeof(CDataEncodeMsg));
 367     if (msg)
 368     {
 369         CryptMsgBase_Init((CryptMsgBase *)msg, dwFlags, pStreamInfo,
 370          CDataEncodeMsg_Close, CDataEncodeMsg_GetParam, CDataEncodeMsg_Update,
 371          CRYPT_DefaultMsgControl);
 372         msg->bare_content_len = sizeof(empty_data_content);
 373         msg->bare_content = (LPBYTE)empty_data_content;
 374     }
 375     return msg;
 376 }
 377
 378 typedef struct _CHashEncodeMsg
 379 {
 380     CryptMsgBase    base;
 381     HCRYPTPROV      prov;
 382     HCRYPTHASH      hash;
 383     CRYPT_DATA_BLOB data;
 384 } CHashEncodeMsg;
 385
 386 static void CHashEncodeMsg_Close(HCRYPTMSG hCryptMsg)
 387 {
 388     CHashEncodeMsg *msg = hCryptMsg;
 389
 390     CryptMemFree(msg->data.pbData);
 391     CryptDestroyHash(msg->hash);
 392     if (msg->base.open_flags & CMSG_CRYPT_RELEASE_CONTEXT_FLAG)
 393         CryptReleaseContext(msg->prov, 0);
 394 }
 395
 396 static BOOL CRYPT_EncodePKCSDigestedData(CHashEncodeMsg *msg, void *pvData,
 397  DWORD *pcbData)
 398 {
 399     BOOL ret;
 400     ALG_ID algID;
 401     DWORD size = sizeof(algID);
 402
 403     ret = CryptGetHashParam(msg->hash, HP_ALGID, (BYTE *)&algID, &size, 0);
 404     if (ret)
 405     {
 406         CRYPT_DIGESTED_DATA digestedData = { 0 };
 407         char oid_rsa_data[] = szOID_RSA_data;
 408
 409         digestedData.version = CMSG_HASHED_DATA_PKCS_1_5_VERSION;
 410         digestedData.DigestAlgorithm.pszObjId = (LPSTR)CertAlgIdToOID(algID);
 411         /* FIXME: what about digestedData.DigestAlgorithm.Parameters? */
 412         /* Quirk:  OID is only encoded messages if an update has happened */
 413         if (msg->base.state != MsgStateInit)
 414             digestedData.ContentInfo.pszObjId = oid_rsa_data;
 415         if (!(msg->base.open_flags & CMSG_DETACHED_FLAG) && msg->data.cbData)
 416         {
 417             ret = CRYPT_AsnEncodeOctets(0, NULL, &msg->data,
 418              CRYPT_ENCODE_ALLOC_FLAG, NULL,
 419              (LPBYTE)&digestedData.ContentInfo.Content.pbData,
 420              &digestedData.ContentInfo.Content.cbData);
 421         }
 422         if (msg->base.state == MsgStateFinalized)
 423         {
 424             size = sizeof(DWORD);
 425             ret = CryptGetHashParam(msg->hash, HP_HASHSIZE,
 426              (LPBYTE)&digestedData.hash.cbData, &size, 0);
 427             if (ret)
 428             {
 429                 digestedData.hash.pbData = CryptMemAlloc(
 430                  digestedData.hash.cbData);
 431                 ret = CryptGetHashParam(msg->hash, HP_HASHVAL,
 432                  digestedData.hash.pbData, &digestedData.hash.cbData, 0);
 433             }
 434         }
 435         if (ret)
 436             ret = CRYPT_AsnEncodePKCSDigestedData(&digestedData, pvData,
 437              pcbData);
 438         CryptMemFree(digestedData.hash.pbData);
 439         LocalFree(digestedData.ContentInfo.Content.pbData);
 440     }
 441     return ret;
 442 }
 443
 444 static BOOL CHashEncodeMsg_GetParam(HCRYPTMSG hCryptMsg, DWORD dwParamType,
 445  DWORD dwIndex, void *pvData, DWORD *pcbData)
 446 {
 447     CHashEncodeMsg *msg = hCryptMsg;
 448     BOOL ret = FALSE;
 449
 450     TRACE("(%p, %d, %d, %p, %p)\n", hCryptMsg, dwParamType, dwIndex,
 451      pvData, pcbData);
 452
 453     switch (dwParamType)
 454     {
 455     case CMSG_BARE_CONTENT_PARAM:
 456         if (msg->base.streamed)
 457             SetLastError(E_INVALIDARG);
 458         else
 459             ret = CRYPT_EncodePKCSDigestedData(msg, pvData, pcbData);
 460         break;
 461     case CMSG_CONTENT_PARAM:
 462     {
 463         CRYPT_CONTENT_INFO info;
 464
 465         ret = CryptMsgGetParam(hCryptMsg, CMSG_BARE_CONTENT_PARAM, 0, NULL,
 466          &info.Content.cbData);
 467         if (ret)
 468         {
 469             info.Content.pbData = CryptMemAlloc(info.Content.cbData);
 470             if (info.Content.pbData)
 471             {
 472                 ret = CryptMsgGetParam(hCryptMsg, CMSG_BARE_CONTENT_PARAM, 0,
 473                  info.Content.pbData, &info.Content.cbData);
 474                 if (ret)
 475                 {
 476                     char oid_rsa_hashed[] = szOID_RSA_hashedData;
 477
 478                     info.pszObjId = oid_rsa_hashed;
 479                     ret = CryptEncodeObjectEx(X509_ASN_ENCODING,
 480                      PKCS_CONTENT_INFO, &info, 0, NULL, pvData, pcbData);
 481                 }
 482                 CryptMemFree(info.Content.pbData);
 483             }
 484             else
 485                 ret = FALSE;
 486         }
 487         break;
 488     }
 489     case CMSG_COMPUTED_HASH_PARAM:
 490         ret = CryptGetHashParam(msg->hash, HP_HASHVAL, pvData, pcbData, 0);
 491         break;
 492     case CMSG_VERSION_PARAM:
 493         if (msg->base.state != MsgStateFinalized)
 494             SetLastError(CRYPT_E_MSG_ERROR);
 495         else
 496         {
 497             DWORD version = CMSG_HASHED_DATA_PKCS_1_5_VERSION;
 498
 499             /* Since the data are always encoded as octets, the version is
 500              * always 0 (see rfc3852, section 7)
 501              */
 502             ret = CRYPT_CopyParam(pvData, pcbData, &version, sizeof(version));
 503         }
 504         break;
 505     default:
 506         SetLastError(CRYPT_E_INVALID_MSG_TYPE);
 507     }
 508     return ret;
 509 }
 510
 511 static BOOL CHashEncodeMsg_Update(HCRYPTMSG hCryptMsg, const BYTE *pbData,
 512  DWORD cbData, BOOL fFinal)
 513 {
 514     CHashEncodeMsg *msg = hCryptMsg;
 515     BOOL ret = FALSE;
 516
 517     TRACE("(%p, %p, %d, %d)\n", hCryptMsg, pbData, cbData, fFinal);
 518
 519     if (msg->base.state == MsgStateFinalized)
 520         SetLastError(CRYPT_E_MSG_ERROR);
 521     else if (msg->base.streamed || (msg->base.open_flags & CMSG_DETACHED_FLAG))
 522     {
 523         /* Doesn't do much, as stream output is never called, and you
 524          * can't get the content.
 525          */
 526         ret = CryptHashData(msg->hash, pbData, cbData, 0);
 527         msg->base.state = fFinal ? MsgStateFinalized : MsgStateUpdated;
 528     }
 529     else
 530     {
 531         if (!fFinal)
 532             SetLastError(CRYPT_E_MSG_ERROR);
 533         else
 534         {
 535             ret = CryptHashData(msg->hash, pbData, cbData, 0);
 536             if (ret)
 537             {
 538                 msg->data.pbData = CryptMemAlloc(cbData);
 539                 if (msg->data.pbData)
 540                 {
 541                     memcpy(msg->data.pbData + msg->data.cbData, pbData, cbData);
 542                     msg->data.cbData += cbData;
 543                 }
 544                 else
 545                     ret = FALSE;
 546             }
 547             msg->base.state = MsgStateFinalized;
 548         }
 549     }
 550     return ret;
 551 }
 552
 553 static HCRYPTMSG CHashEncodeMsg_Open(DWORD dwFlags, const void *pvMsgEncodeInfo,
 554  LPSTR pszInnerContentObjID, PCMSG_STREAM_INFO pStreamInfo)
 555 {
 556     CHashEncodeMsg *msg;
 557     const CMSG_HASHED_ENCODE_INFO *info = pvMsgEncodeInfo;
 558     HCRYPTPROV prov;
 559     ALG_ID algID;
 560
 561     if (info->cbSize != sizeof(CMSG_HASHED_ENCODE_INFO))
 562     {
 563         SetLastError(E_INVALIDARG);
 564         return NULL;
 565     }
 566     if (!(algID = CertOIDToAlgId(info->HashAlgorithm.pszObjId)))
 567     {
 568         SetLastError(CRYPT_E_UNKNOWN_ALGO);
 569         return NULL;
 570     }
 571     if (info->hCryptProv)
 572         prov = info->hCryptProv;
 573     else
 574     {
 575         prov = CRYPT_GetDefaultProvider();
 576         dwFlags &= ~CMSG_CRYPT_RELEASE_CONTEXT_FLAG;
 577     }
 578     msg = CryptMemAlloc(sizeof(CHashEncodeMsg));
 579     if (msg)
 580     {
 581         CryptMsgBase_Init((CryptMsgBase *)msg, dwFlags, pStreamInfo,
 582          CHashEncodeMsg_Close, CHashEncodeMsg_GetParam, CHashEncodeMsg_Update,
 583          CRYPT_DefaultMsgControl);
 584         msg->prov = prov;
 585         msg->data.cbData = 0;
 586         msg->data.pbData = NULL;
 587         if (!CryptCreateHash(prov, algID, 0, 0, &msg->hash))
 588         {
 589             CryptMsgClose(msg);
 590             msg = NULL;
 591         }
 592     }
 593     return msg;
 594 }
 595
 596 typedef struct _CMSG_SIGNER_ENCODE_INFO_WITH_CMS
 597 {
 598     DWORD                      cbSize;
 599     PCERT_INFO                 pCertInfo;
 600     HCRYPTPROV                 hCryptProv;
 601     DWORD                      dwKeySpec;
 602     CRYPT_ALGORITHM_IDENTIFIER HashAlgorithm;
 603     void                      *pvHashAuxInfo;
 604     DWORD                      cAuthAttr;
 605     PCRYPT_ATTRIBUTE           rgAuthAttr;
 606     DWORD                      cUnauthAttr;
 607     PCRYPT_ATTRIBUTE           rgUnauthAttr;
 608     CERT_ID                    SignerId;
 609     CRYPT_ALGORITHM_IDENTIFIER HashEncryptionAlgorithm;
 610     void                      *pvHashEncryptionAuxInfo;
 611 } CMSG_SIGNER_ENCODE_INFO_WITH_CMS, *PCMSG_SIGNER_ENCODE_INFO_WITH_CMS;
 612
 613 typedef struct _CMSG_SIGNED_ENCODE_INFO_WITH_CMS
 614 {
 615     DWORD                             cbSize;
 616     DWORD                             cSigners;
 617     PCMSG_SIGNER_ENCODE_INFO_WITH_CMS rgSigners;
 618     DWORD                             cCertEncoded;
 619     PCERT_BLOB                        rgCertEncoded;
 620     DWORD                             cCrlEncoded;
 621     PCRL_BLOB                         rgCrlEncoded;
 622     DWORD                             cAttrCertEncoded;
 623     PCERT_BLOB                        rgAttrCertEncoded;
 624 } CMSG_SIGNED_ENCODE_INFO_WITH_CMS, *PCMSG_SIGNED_ENCODE_INFO_WITH_CMS;
 625
 626 static BOOL CRYPT_IsValidSigner(CMSG_SIGNER_ENCODE_INFO_WITH_CMS *signer)
 627 {
 628     if (signer->cbSize != sizeof(CMSG_SIGNER_ENCODE_INFO) &&
 629      signer->cbSize != sizeof(CMSG_SIGNER_ENCODE_INFO_WITH_CMS))
 630     {
 631         SetLastError(E_INVALIDARG);
 632         return FALSE;
 633     }
 634     if (signer->cbSize == sizeof(CMSG_SIGNER_ENCODE_INFO))
 635     {
 636         if (!signer->pCertInfo->SerialNumber.cbData)
 637         {
 638             SetLastError(E_INVALIDARG);
 639             return FALSE;
 640         }
 641         if (!signer->pCertInfo->Issuer.cbData)
 642         {
 643             SetLastError(E_INVALIDARG);
 644             return FALSE;
 645         }
 646     }
 647     else if (signer->cbSize == sizeof(CMSG_SIGNER_ENCODE_INFO_WITH_CMS))
 648     {
 649         switch (signer->SignerId.dwIdChoice)
 650         {
 651         case 0:
 652             if (!signer->pCertInfo->SerialNumber.cbData)
 653             {
 654                 SetLastError(E_INVALIDARG);
 655                 return FALSE;
 656             }
 657             if (!signer->pCertInfo->Issuer.cbData)
 658             {
 659                 SetLastError(E_INVALIDARG);
 660                 return FALSE;
 661             }
 662             break;
 663         case CERT_ID_ISSUER_SERIAL_NUMBER:
 664             if (!signer->SignerId.u.IssuerSerialNumber.SerialNumber.cbData)
 665             {
 666                 SetLastError(E_INVALIDARG);
 667                 return FALSE;
 668             }
 669             if (!signer->SignerId.u.IssuerSerialNumber.Issuer.cbData)
 670             {
 671                 SetLastError(E_INVALIDARG);
 672                 return FALSE;
 673             }
 674             break;
 675         case CERT_ID_KEY_IDENTIFIER:
 676             if (!signer->SignerId.u.KeyId.cbData)
 677             {
 678                 SetLastError(E_INVALIDARG);
 679                 return FALSE;
 680             }
 681             break;
 682         default:
 683             SetLastError(E_INVALIDARG);
 684         }
 685         if (signer->HashEncryptionAlgorithm.pszObjId)
 686         {
 687             FIXME("CMSG_SIGNER_ENCODE_INFO with CMS fields unsupported\n");
 688             return FALSE;
 689         }
 690     }
 691     if (!signer->hCryptProv)
 692     {
 693         SetLastError(E_INVALIDARG);
 694         return FALSE;
 695     }
 696     if (!CertOIDToAlgId(signer->HashAlgorithm.pszObjId))
 697     {
 698         SetLastError(CRYPT_E_UNKNOWN_ALGO);
 699         return FALSE;
 700     }
 701     return TRUE;
 702 }
 703
 704 static BOOL CRYPT_ConstructBlob(CRYPT_DATA_BLOB *out, const CRYPT_DATA_BLOB *in)
 705 {
 706     BOOL ret = TRUE;
 707
 708     out->cbData = in->cbData;
 709     if (out->cbData)
 710     {
 711         out->pbData = CryptMemAlloc(out->cbData);
 712         if (out->pbData)
 713             memcpy(out->pbData, in->pbData, out->cbData);
 714         else
 715             ret = FALSE;
 716     }
 717     else
 718         out->pbData = NULL;
 719     return ret;
 720 }
 721
 722 static BOOL CRYPT_ConstructBlobArray(DWORD *outCBlobs,
 723  PCRYPT_DATA_BLOB *outPBlobs, DWORD cBlobs, const PCRYPT_DATA_BLOB pBlobs)
 724 {
 725     BOOL ret = TRUE;
 726
 727     *outCBlobs = cBlobs;
 728     if (cBlobs)
 729     {
 730         *outPBlobs = CryptMemAlloc(cBlobs * sizeof(CRYPT_DATA_BLOB));
 731         if (*outPBlobs)
 732         {
 733             DWORD i;
 734
 735             memset(*outPBlobs, 0, cBlobs * sizeof(CRYPT_DATA_BLOB));
 736             for (i = 0; ret && i < cBlobs; i++)
 737                 ret = CRYPT_ConstructBlob(&(*outPBlobs)[i], &pBlobs[i]);
 738         }
 739         else
 740             ret = FALSE;
 741     }
 742     return ret;
 743 }
 744
 745 static void CRYPT_FreeBlobArray(DWORD cBlobs, PCRYPT_DATA_BLOB blobs)
 746 {
 747     DWORD i;
 748
 749     for (i = 0; i < cBlobs; i++)
 750         CryptMemFree(blobs[i].pbData);
 751     CryptMemFree(blobs);
 752 }
 753
 754 static BOOL CRYPT_ConstructAttribute(CRYPT_ATTRIBUTE *out,
 755  const CRYPT_ATTRIBUTE *in)
 756 {
 757     BOOL ret;
 758
 759     out->pszObjId = CryptMemAlloc(strlen(in->pszObjId) + 1);
 760     if (out->pszObjId)
 761     {
 762         strcpy(out->pszObjId, in->pszObjId);
 763         ret = CRYPT_ConstructBlobArray(&out->cValue, &out->rgValue,
 764          in->cValue, in->rgValue);
 765     }
 766     else
 767         ret = FALSE;
 768     return ret;
 769 }
 770
 771 static BOOL CRYPT_ConstructAttributes(CRYPT_ATTRIBUTES *out,
 772  const CRYPT_ATTRIBUTES *in)
 773 {
 774     BOOL ret = TRUE;
 775
 776     out->cAttr = in->cAttr;
 777     if (out->cAttr)
 778     {
 779         out->rgAttr = CryptMemAlloc(out->cAttr * sizeof(CRYPT_ATTRIBUTE));
 780         if (out->rgAttr)
 781         {
 782             DWORD i;
 783
 784             memset(out->rgAttr, 0, out->cAttr * sizeof(CRYPT_ATTRIBUTE));
 785             for (i = 0; ret && i < out->cAttr; i++)
 786                 ret = CRYPT_ConstructAttribute(&out->rgAttr[i], &in->rgAttr[i]);
 787         }
 788         else
 789             ret = FALSE;
 790     }
 791     else
 792         out->rgAttr = NULL;
 793     return ret;
 794 }
 795
 796 /* Constructs a CMSG_CMS_SIGNER_INFO from a CMSG_SIGNER_ENCODE_INFO_WITH_CMS. */
 797 static BOOL CSignerInfo_Construct(CMSG_CMS_SIGNER_INFO *info,
 798  const CMSG_SIGNER_ENCODE_INFO_WITH_CMS *in)
 799 {
 800     BOOL ret;
 801
 802     if (in->cbSize == sizeof(CMSG_SIGNER_ENCODE_INFO))
 803     {
 804         info->dwVersion = CMSG_SIGNER_INFO_V1;
 805         ret = CRYPT_ConstructBlob(&info->SignerId.u.IssuerSerialNumber.Issuer,
 806          &in->pCertInfo->Issuer);
 807         if (ret)
 808             ret = CRYPT_ConstructBlob(
 809              &info->SignerId.u.IssuerSerialNumber.SerialNumber,
 810              &in->pCertInfo->SerialNumber);
 811         info->SignerId.dwIdChoice = CERT_ID_ISSUER_SERIAL_NUMBER;
 812     }
 813     else
 814     {
 815         /* Implicitly in->cbSize == sizeof(CMSG_SIGNER_ENCODE_INFO_WITH_CMS).
 816          * See CRYPT_IsValidSigner.
 817          */
 818         if (!in->SignerId.dwIdChoice)
 819         {
 820             info->dwVersion = CMSG_SIGNER_INFO_V1;
 821             ret = CRYPT_ConstructBlob(&info->SignerId.u.IssuerSerialNumber.Issuer,
 822              &in->pCertInfo->Issuer);
 823             if (ret)
 824                 ret = CRYPT_ConstructBlob(
 825                  &info->SignerId.u.IssuerSerialNumber.SerialNumber,
 826                  &in->pCertInfo->SerialNumber);
 827             info->SignerId.dwIdChoice = CERT_ID_ISSUER_SERIAL_NUMBER;
 828         }
 829         else if (in->SignerId.dwIdChoice == CERT_ID_ISSUER_SERIAL_NUMBER)
 830         {
 831             info->dwVersion = CMSG_SIGNER_INFO_V1;
 832             info->SignerId.dwIdChoice = CERT_ID_ISSUER_SERIAL_NUMBER;
 833             ret = CRYPT_ConstructBlob(&info->SignerId.u.IssuerSerialNumber.Issuer,
 834              &in->SignerId.u.IssuerSerialNumber.Issuer);
 835             if (ret)
 836                 ret = CRYPT_ConstructBlob(
 837                  &info->SignerId.u.IssuerSerialNumber.SerialNumber,
 838                  &in->SignerId.u.IssuerSerialNumber.SerialNumber);
 839         }
 840         else
 841         {
 842             /* Implicitly dwIdChoice == CERT_ID_KEY_IDENTIFIER */
 843             info->dwVersion = CMSG_SIGNER_INFO_V3;
 844             info->SignerId.dwIdChoice = CERT_ID_KEY_IDENTIFIER;
 845             ret = CRYPT_ConstructBlob(&info->SignerId.u.KeyId,
 846              &in->SignerId.u.KeyId);
 847         }
 848     }
 849     /* Assumption:  algorithm IDs will point to static strings, not
 850      * stack-based ones, so copying the pointer values is safe.
 851      */
 852     info->HashAlgorithm.pszObjId = in->HashAlgorithm.pszObjId;
 853     if (ret)
 854         ret = CRYPT_ConstructBlob(&info->HashAlgorithm.Parameters,
 855          &in->HashAlgorithm.Parameters);
 856     memset(&info->HashEncryptionAlgorithm, 0,
 857      sizeof(info->HashEncryptionAlgorithm));
 858     if (ret)
 859         ret = CRYPT_ConstructAttributes(&info->AuthAttrs,
 860          (CRYPT_ATTRIBUTES *)&in->cAuthAttr);
 861     if (ret)
 862         ret = CRYPT_ConstructAttributes(&info->UnauthAttrs,
 863          (CRYPT_ATTRIBUTES *)&in->cUnauthAttr);
 864     return ret;
 865 }
 866
 867 static void CSignerInfo_Free(CMSG_CMS_SIGNER_INFO *info)
 868 {
 869     DWORD i, j;
 870
 871     if (info->SignerId.dwIdChoice == CERT_ID_ISSUER_SERIAL_NUMBER)
 872     {
 873         CryptMemFree(info->SignerId.u.IssuerSerialNumber.Issuer.pbData);
 874         CryptMemFree(info->SignerId.u.IssuerSerialNumber.SerialNumber.pbData);
 875     }
 876     else
 877         CryptMemFree(info->SignerId.u.KeyId.pbData);
 878     CryptMemFree(info->HashAlgorithm.Parameters.pbData);
 879     CryptMemFree(info->EncryptedHash.pbData);
 880     for (i = 0; i < info->AuthAttrs.cAttr; i++)
 881     {
 882         for (j = 0; j < info->AuthAttrs.rgAttr[i].cValue; j++)
 883             CryptMemFree(info->AuthAttrs.rgAttr[i].rgValue[j].pbData);
 884         CryptMemFree(info->AuthAttrs.rgAttr[i].rgValue);
 885         CryptMemFree(info->AuthAttrs.rgAttr[i].pszObjId);
 886     }
 887     CryptMemFree(info->AuthAttrs.rgAttr);
 888     for (i = 0; i < info->UnauthAttrs.cAttr; i++)
 889     {
 890         for (j = 0; j < info->UnauthAttrs.rgAttr[i].cValue; j++)
 891             CryptMemFree(info->UnauthAttrs.rgAttr[i].rgValue[j].pbData);
 892         CryptMemFree(info->UnauthAttrs.rgAttr[i].rgValue);
 893         CryptMemFree(info->UnauthAttrs.rgAttr[i].pszObjId);
 894     }
 895     CryptMemFree(info->UnauthAttrs.rgAttr);
 896 }
 897
 898 typedef struct _CSignerHandles
 899 {
 900     HCRYPTHASH contentHash;
 901     HCRYPTHASH authAttrHash;
 902 } CSignerHandles;
 903
 904 typedef struct _CSignedMsgData
 905 {
 906     CRYPT_SIGNED_INFO *info;
 907     DWORD              cSignerHandle;
 908     CSignerHandles    *signerHandles;
 909 } CSignedMsgData;
 910
 911 /* Constructs the signer handles for the signerIndex'th signer of msg_data.
 912  * Assumes signerIndex is a valid idnex, and that msg_data's info has already
 913  * been constructed.
 914  */
 915 static BOOL CSignedMsgData_ConstructSignerHandles(CSignedMsgData *msg_data,
 916  DWORD signerIndex, HCRYPTPROV crypt_prov)
 917 {
 918     ALG_ID algID;
 919     BOOL ret;
 920
 921     algID = CertOIDToAlgId(
 922      msg_data->info->rgSignerInfo[signerIndex].HashAlgorithm.pszObjId);
 923     ret = CryptCreateHash(crypt_prov, algID, 0, 0,
 924      &msg_data->signerHandles->contentHash);
 925     if (ret && msg_data->info->rgSignerInfo[signerIndex].AuthAttrs.cAttr > 0)
 926         ret = CryptCreateHash(crypt_prov, algID, 0, 0,
 927          &msg_data->signerHandles->authAttrHash);
 928     return ret;
 929 }
 930
 931 /* Allocates a CSignedMsgData's handles.  Assumes its info has already been
 932  * constructed.
 933  */
 934 static BOOL CSignedMsgData_AllocateHandles(CSignedMsgData *msg_data)
 935 {
 936     BOOL ret = TRUE;
 937
 938     if (msg_data->info->cSignerInfo)
 939     {
 940         msg_data->signerHandles =
 941          CryptMemAlloc(msg_data->info->cSignerInfo * sizeof(CSignerHandles));
 942         if (msg_data->signerHandles)
 943         {
 944             msg_data->cSignerHandle = msg_data->info->cSignerInfo;
 945             memset(msg_data->signerHandles, 0,
 946              msg_data->info->cSignerInfo * sizeof(CSignerHandles));
 947         }
 948         else
 949         {
 950             msg_data->cSignerHandle = 0;
 951             ret = FALSE;
 952         }
 953     }
 954     else
 955     {
 956         msg_data->cSignerHandle = 0;
 957         msg_data->signerHandles = NULL;
 958     }
 959     return ret;
 960 }
 961
 962 static void CSignedMsgData_CloseHandles(CSignedMsgData *msg_data)
 963 {
 964     DWORD i;
 965
 966     for (i = 0; i < msg_data->cSignerHandle; i++)
 967     {
 968         if (msg_data->signerHandles[i].contentHash)
 969             CryptDestroyHash(msg_data->signerHandles[i].contentHash);
 970         if (msg_data->signerHandles[i].authAttrHash)
 971             CryptDestroyHash(msg_data->signerHandles[i].authAttrHash);
 972     }
 973     CryptMemFree(msg_data->signerHandles);
 974     msg_data->signerHandles = NULL;
 975     msg_data->cSignerHandle = 0;
 976 }
 977
 978 static BOOL CSignedMsgData_UpdateHash(CSignedMsgData *msg_data,
 979  const BYTE *pbData, DWORD cbData)
 980 {
 981     DWORD i;
 982     BOOL ret = TRUE;
 983
 984     for (i = 0; ret && i < msg_data->cSignerHandle; i++)
 985         ret = CryptHashData(msg_data->signerHandles[i].contentHash, pbData,
 986          cbData, 0);
 987     return ret;
 988 }
 989
 990 static BOOL CRYPT_AppendAttribute(CRYPT_ATTRIBUTES *out,
 991  const CRYPT_ATTRIBUTE *in)
 992 {
 993     BOOL ret = FALSE;
 994
 995     out->rgAttr = CryptMemRealloc(out->rgAttr,
 996      (out->cAttr + 1) * sizeof(CRYPT_ATTRIBUTE));
 997     if (out->rgAttr)
 998     {
 999         ret = CRYPT_ConstructAttribute(&out->rgAttr[out->cAttr], in);
1000         if (ret)
1001             out->cAttr++;
1002     }
1003     return ret;
1004 }
1005
1006 static BOOL CSignedMsgData_AppendMessageDigestAttribute(
1007  CSignedMsgData *msg_data, DWORD signerIndex)
1008 {
1009     BOOL ret;
1010     DWORD size;
1011     CRYPT_HASH_BLOB hash = { 0, NULL }, encodedHash = { 0, NULL };
1012     char messageDigest[] = szOID_RSA_messageDigest;
1013     CRYPT_ATTRIBUTE messageDigestAttr = { messageDigest, 1, &encodedHash };
1014
1015     size = sizeof(DWORD);
1016     ret = CryptGetHashParam(
1017      msg_data->signerHandles[signerIndex].contentHash, HP_HASHSIZE,
1018      (LPBYTE)&hash.cbData, &size, 0);
1019     if (ret)
1020     {
1021         hash.pbData = CryptMemAlloc(hash.cbData);
1022         ret = CryptGetHashParam(
1023          msg_data->signerHandles[signerIndex].contentHash, HP_HASHVAL,
1024          hash.pbData, &hash.cbData, 0);
1025         if (ret)
1026         {
1027             ret = CRYPT_AsnEncodeOctets(0, NULL, &hash, CRYPT_ENCODE_ALLOC_FLAG,
1028              NULL, (LPBYTE)&encodedHash.pbData, &encodedHash.cbData);
1029             if (ret)
1030             {
1031                 ret = CRYPT_AppendAttribute(
1032                  &msg_data->info->rgSignerInfo[signerIndex].AuthAttrs,
1033                  &messageDigestAttr);
1034                 LocalFree(encodedHash.pbData);
1035             }
1036         }
1037         CryptMemFree(hash.pbData);
1038     }
1039     return ret;
1040 }
1041
1042 typedef enum {
1043     Sign,
1044     Verify
1045 } SignOrVerify;
1046
1047 static BOOL CSignedMsgData_UpdateAuthenticatedAttributes(
1048  CSignedMsgData *msg_data, SignOrVerify flag)
1049 {
1050     DWORD i;
1051     BOOL ret = TRUE;
1052
1053     TRACE("(%p)\n", msg_data);
1054
1055     for (i = 0; ret && i < msg_data->info->cSignerInfo; i++)
1056     {
1057         if (msg_data->info->rgSignerInfo[i].AuthAttrs.cAttr)
1058         {
1059             if (flag == Sign)
1060             {
1061                 BYTE oid_rsa_data_encoded[] = { 0x06,0x09,0x2a,0x86,0x48,0x86,
1062                  0xf7,0x0d,0x01,0x07,0x01 };
1063                 CRYPT_DATA_BLOB content = { sizeof(oid_rsa_data_encoded),
1064                  oid_rsa_data_encoded };
1065                 char contentType[] = szOID_RSA_contentType;
1066                 CRYPT_ATTRIBUTE contentTypeAttr = { contentType, 1, &content };
1067
1068                 /* FIXME: does this depend on inner OID? */
1069                 ret = CRYPT_AppendAttribute(
1070                  &msg_data->info->rgSignerInfo[i].AuthAttrs, &contentTypeAttr);
1071                 if (ret)
1072                     ret = CSignedMsgData_AppendMessageDigestAttribute(msg_data,
1073                      i);
1074             }
1075             if (ret)
1076             {
1077                 LPBYTE encodedAttrs;
1078                 DWORD size;
1079
1080                 ret = CryptEncodeObjectEx(X509_ASN_ENCODING, PKCS_ATTRIBUTES,
1081                  &msg_data->info->rgSignerInfo[i].AuthAttrs,
1082                  CRYPT_ENCODE_ALLOC_FLAG, NULL, &encodedAttrs, &size);
1083                 if (ret)
1084                 {
1085                     ret = CryptHashData(
1086                      msg_data->signerHandles[i].authAttrHash, encodedAttrs,
1087                      size, 0);
1088                     LocalFree(encodedAttrs);
1089                 }
1090             }
1091         }
1092     }
1093     TRACE("returning %d\n", ret);
1094     return ret;
1095 }
1096
1097 static void CRYPT_ReverseBytes(CRYPT_HASH_BLOB *hash)
1098 {
1099     DWORD i;
1100     BYTE tmp;
1101
1102     for (i = 0; i < hash->cbData / 2; i++)
1103     {
1104         tmp = hash->pbData[hash->cbData - i - 1];
1105         hash->pbData[hash->cbData - i - 1] = hash->pbData[i];
1106         hash->pbData[i] = tmp;
1107     }
1108 }
1109
1110 static BOOL CSignedMsgData_Sign(CSignedMsgData *msg_data)
1111 {
1112     DWORD i;
1113     BOOL ret = TRUE;
1114
1115     TRACE("(%p)\n", msg_data);
1116
1117     for (i = 0; ret && i < msg_data->info->cSignerInfo; i++)
1118     {
1119         HCRYPTHASH hash;
1120
1121         if (msg_data->info->rgSignerInfo[i].AuthAttrs.cAttr)
1122             hash = msg_data->signerHandles[i].authAttrHash;
1123         else
1124             hash = msg_data->signerHandles[i].contentHash;
1125         ret = CryptSignHashW(hash, AT_SIGNATURE, NULL, 0, NULL,
1126          &msg_data->info->rgSignerInfo[i].EncryptedHash.cbData);
1127         if (ret)
1128         {
1129             msg_data->info->rgSignerInfo[i].EncryptedHash.pbData =
1130              CryptMemAlloc(
1131              msg_data->info->rgSignerInfo[i].EncryptedHash.cbData);
1132             if (msg_data->info->rgSignerInfo[i].EncryptedHash.pbData)
1133             {
1134                 ret = CryptSignHashW(hash, AT_SIGNATURE, NULL, 0,
1135                  msg_data->info->rgSignerInfo[i].EncryptedHash.pbData,
1136                  &msg_data->info->rgSignerInfo[i].EncryptedHash.cbData);
1137                 if (ret)
1138                     CRYPT_ReverseBytes(
1139                      &msg_data->info->rgSignerInfo[i].EncryptedHash);
1140             }
1141             else
1142                 ret = FALSE;
1143         }
1144     }
1145     return ret;
1146 }
1147
1148 static BOOL CSignedMsgData_Update(CSignedMsgData *msg_data,
1149  const BYTE *pbData, DWORD cbData, BOOL fFinal, SignOrVerify flag)
1150 {
1151     BOOL ret = CSignedMsgData_UpdateHash(msg_data, pbData, cbData);
1152
1153     if (ret && fFinal)
1154     {
1155         ret = CSignedMsgData_UpdateAuthenticatedAttributes(msg_data, flag);
1156         if (ret && flag == Sign)
1157             ret = CSignedMsgData_Sign(msg_data);
1158     }
1159     return ret;
1160 }
1161
1162 typedef struct _CSignedEncodeMsg
1163 {
1164     CryptMsgBase    base;
1165     LPSTR           innerOID;
1166     CRYPT_DATA_BLOB data;
1167     CSignedMsgData  msg_data;
1168 } CSignedEncodeMsg;
1169
1170 static void CSignedEncodeMsg_Close(HCRYPTMSG hCryptMsg)
1171 {
1172     CSignedEncodeMsg *msg = hCryptMsg;
1173     DWORD i;
1174
1175     CryptMemFree(msg->innerOID);
1176     CryptMemFree(msg->data.pbData);
1177     CRYPT_FreeBlobArray(msg->msg_data.info->cCertEncoded,
1178      msg->msg_data.info->rgCertEncoded);
1179     CRYPT_FreeBlobArray(msg->msg_data.info->cCrlEncoded,
1180      msg->msg_data.info->rgCrlEncoded);
1181     for (i = 0; i < msg->msg_data.info->cSignerInfo; i++)
1182         CSignerInfo_Free(&msg->msg_data.info->rgSignerInfo[i]);
1183     CSignedMsgData_CloseHandles(&msg->msg_data);
1184     CryptMemFree(msg->msg_data.info->rgSignerInfo);
1185     CryptMemFree(msg->msg_data.info);
1186 }
1187
1188 static BOOL CSignedEncodeMsg_GetParam(HCRYPTMSG hCryptMsg, DWORD dwParamType,
1189  DWORD dwIndex, void *pvData, DWORD *pcbData)
1190 {
1191     CSignedEncodeMsg *msg = hCryptMsg;
1192     BOOL ret = FALSE;
1193
1194     switch (dwParamType)
1195     {
1196     case CMSG_CONTENT_PARAM:
1197     {
1198         CRYPT_CONTENT_INFO info;
1199
1200         ret = CryptMsgGetParam(hCryptMsg, CMSG_BARE_CONTENT_PARAM, 0, NULL,
1201          &info.Content.cbData);
1202         if (ret)
1203         {
1204             info.Content.pbData = CryptMemAlloc(info.Content.cbData);
1205             if (info.Content.pbData)
1206             {
1207                 ret = CryptMsgGetParam(hCryptMsg, CMSG_BARE_CONTENT_PARAM, 0,
1208                  info.Content.pbData, &info.Content.cbData);
1209                 if (ret)
1210                 {
1211                     char oid_rsa_signed[] = szOID_RSA_signedData;
1212
1213                     info.pszObjId = oid_rsa_signed;
1214                     ret = CryptEncodeObjectEx(X509_ASN_ENCODING,
1215                      PKCS_CONTENT_INFO, &info, 0, NULL, pvData, pcbData);
1216                 }
1217                 CryptMemFree(info.Content.pbData);
1218             }
1219             else
1220                 ret = FALSE;
1221         }
1222         break;
1223     }
1224     case CMSG_BARE_CONTENT_PARAM:
1225     {
1226         CRYPT_SIGNED_INFO info;
1227         BOOL freeContent = FALSE;
1228
1229         info = *msg->msg_data.info;
1230         if (!msg->innerOID || !strcmp(msg->innerOID, szOID_RSA_data))
1231         {
1232             char oid_rsa_data[] = szOID_RSA_data;
1233
1234             /* Quirk:  OID is only encoded messages if an update has happened */
1235             if (msg->base.state != MsgStateInit)
1236                 info.content.pszObjId = oid_rsa_data;
1237             else
1238                 info.content.pszObjId = NULL;
1239             if (msg->data.cbData)
1240             {
1241                 CRYPT_DATA_BLOB blob = { msg->data.cbData, msg->data.pbData };
1242
1243                 ret = CryptEncodeObjectEx(X509_ASN_ENCODING, X509_OCTET_STRING,
1244                  &blob, CRYPT_ENCODE_ALLOC_FLAG, NULL,
1245                  &info.content.Content.pbData, &info.content.Content.cbData);
1246                 freeContent = TRUE;
1247             }
1248             else
1249             {
1250                 info.content.Content.cbData = 0;
1251                 info.content.Content.pbData = NULL;
1252                 ret = TRUE;
1253             }
1254         }
1255         else
1256         {
1257             info.content.pszObjId = msg->innerOID;
1258             info.content.Content.cbData = msg->data.cbData;
1259             info.content.Content.pbData = msg->data.pbData;
1260             ret = TRUE;
1261         }
1262         if (ret)
1263         {
1264             ret = CRYPT_AsnEncodeCMSSignedInfo(&info, pvData, pcbData);
1265             if (freeContent)
1266                 LocalFree(info.content.Content.pbData);
1267         }
1268         break;
1269     }
1270     case CMSG_COMPUTED_HASH_PARAM:
1271         if (dwIndex >= msg->msg_data.cSignerHandle)
1272             SetLastError(CRYPT_E_INVALID_INDEX);
1273         else
1274             ret = CryptGetHashParam(
1275              msg->msg_data.signerHandles[dwIndex].contentHash, HP_HASHVAL,
1276              pvData, pcbData, 0);
1277         break;
1278     case CMSG_ENCODED_SIGNER:
1279         if (dwIndex >= msg->msg_data.info->cSignerInfo)
1280             SetLastError(CRYPT_E_INVALID_INDEX);
1281         else
1282             ret = CryptEncodeObjectEx(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
1283              CMS_SIGNER_INFO, &msg->msg_data.info->rgSignerInfo[dwIndex], 0,
1284              NULL, pvData, pcbData);
1285         break;
1286     case CMSG_VERSION_PARAM:
1287         ret = CRYPT_CopyParam(pvData, pcbData, &msg->msg_data.info->version,
1288          sizeof(msg->msg_data.info->version));
1289         break;
1290     default:
1291         SetLastError(CRYPT_E_INVALID_MSG_TYPE);
1292     }
1293     return ret;
1294 }
1295
1296 static BOOL CSignedEncodeMsg_Update(HCRYPTMSG hCryptMsg, const BYTE *pbData,
1297  DWORD cbData, BOOL fFinal)
1298 {
1299     CSignedEncodeMsg *msg = hCryptMsg;
1300     BOOL ret = FALSE;
1301
1302     if (msg->base.state == MsgStateFinalized)
1303         SetLastError(CRYPT_E_MSG_ERROR);
1304     else if (msg->base.streamed || (msg->base.open_flags & CMSG_DETACHED_FLAG))
1305     {
1306         ret = CSignedMsgData_Update(&msg->msg_data, pbData, cbData, fFinal,
1307          Sign);
1308         if (msg->base.streamed)
1309             FIXME("streamed partial stub\n");
1310         msg->base.state = fFinal ? MsgStateFinalized : MsgStateUpdated;
1311     }
1312     else
1313     {
1314         if (!fFinal)
1315             SetLastError(CRYPT_E_MSG_ERROR);
1316         else
1317         {
1318             if (cbData)
1319             {
1320                 msg->data.pbData = CryptMemAlloc(cbData);
1321                 if (msg->data.pbData)
1322                 {
1323                     memcpy(msg->data.pbData, pbData, cbData);
1324                     msg->data.cbData = cbData;
1325                     ret = TRUE;
1326                 }
1327             }
1328             else
1329                 ret = TRUE;
1330             if (ret)
1331                 ret = CSignedMsgData_Update(&msg->msg_data, pbData, cbData,
1332                  fFinal, Sign);
1333             msg->base.state = MsgStateFinalized;
1334         }
1335     }
1336     return ret;
1337 }
1338
1339 static HCRYPTMSG CSignedEncodeMsg_Open(DWORD dwFlags,
1340  const void *pvMsgEncodeInfo, LPCSTR pszInnerContentObjID,
1341  PCMSG_STREAM_INFO pStreamInfo)
1342 {
1343     const CMSG_SIGNED_ENCODE_INFO_WITH_CMS *info = pvMsgEncodeInfo;
1344     DWORD i;
1345     CSignedEncodeMsg *msg;
1346
1347     if (info->cbSize != sizeof(CMSG_SIGNED_ENCODE_INFO) &&
1348      info->cbSize != sizeof(CMSG_SIGNED_ENCODE_INFO_WITH_CMS))
1349     {
1350         SetLastError(E_INVALIDARG);
1351         return NULL;
1352     }
1353     if (info->cbSize == sizeof(CMSG_SIGNED_ENCODE_INFO_WITH_CMS) &&
1354      info->cAttrCertEncoded)
1355     {
1356         FIXME("CMSG_SIGNED_ENCODE_INFO with CMS fields unsupported\n");
1357         return NULL;
1358     }
1359     for (i = 0; i < info->cSigners; i++)
1360         if (!CRYPT_IsValidSigner(&info->rgSigners[i]))
1361             return NULL;
1362     msg = CryptMemAlloc(sizeof(CSignedEncodeMsg));
1363     if (msg)
1364     {
1365         BOOL ret = TRUE;
1366
1367         CryptMsgBase_Init((CryptMsgBase *)msg, dwFlags, pStreamInfo,
1368          CSignedEncodeMsg_Close, CSignedEncodeMsg_GetParam,
1369          CSignedEncodeMsg_Update, CRYPT_DefaultMsgControl);
1370         if (pszInnerContentObjID)
1371         {
1372             msg->innerOID = CryptMemAlloc(strlen(pszInnerContentObjID) + 1);
1373             if (msg->innerOID)
1374                 strcpy(msg->innerOID, pszInnerContentObjID);
1375             else
1376                 ret = FALSE;
1377         }
1378         else
1379             msg->innerOID = NULL;
1380         msg->data.cbData = 0;
1381         msg->data.pbData = NULL;
1382         if (ret)
1383             msg->msg_data.info = CryptMemAlloc(sizeof(CRYPT_SIGNED_INFO));
1384         else
1385             msg->msg_data.info = NULL;
1386         if (msg->msg_data.info)
1387         {
1388             memset(msg->msg_data.info, 0, sizeof(CRYPT_SIGNED_INFO));
1389             msg->msg_data.info->version = CMSG_SIGNED_DATA_V1;
1390         }
1391         else
1392             ret = FALSE;
1393         if (ret)
1394         {
1395             if (info->cSigners)
1396             {
1397                 msg->msg_data.info->rgSignerInfo =
1398                  CryptMemAlloc(info->cSigners * sizeof(CMSG_CMS_SIGNER_INFO));
1399                 if (msg->msg_data.info->rgSignerInfo)
1400                 {
1401                     msg->msg_data.info->cSignerInfo = info->cSigners;
1402                     memset(msg->msg_data.info->rgSignerInfo, 0,
1403                      msg->msg_data.info->cSignerInfo *
1404                      sizeof(CMSG_CMS_SIGNER_INFO));
1405                     ret = CSignedMsgData_AllocateHandles(&msg->msg_data);
1406                     for (i = 0; ret && i < msg->msg_data.info->cSignerInfo; i++)
1407                     {
1408                         if (info->rgSigners[i].SignerId.dwIdChoice ==
1409                          CERT_ID_KEY_IDENTIFIER)
1410                             msg->msg_data.info->version = CMSG_SIGNED_DATA_V3;
1411                         ret = CSignerInfo_Construct(
1412                          &msg->msg_data.info->rgSignerInfo[i],
1413                          &info->rgSigners[i]);
1414                         if (ret)
1415                         {
1416                             ret = CSignedMsgData_ConstructSignerHandles(
1417                              &msg->msg_data, i, info->rgSigners[i].hCryptProv);
1418                             if (dwFlags & CMSG_CRYPT_RELEASE_CONTEXT_FLAG)
1419                                 CryptReleaseContext(info->rgSigners[i].hCryptProv,
1420                                  0);
1421                         }
1422                     }
1423                 }
1424                 else
1425                     ret = FALSE;
1426             }
1427             else
1428             {
1429                 msg->msg_data.info->cSignerInfo = 0;
1430                 msg->msg_data.signerHandles = NULL;
1431                 msg->msg_data.cSignerHandle = 0;
1432             }
1433         }
1434         if (ret)
1435             ret = CRYPT_ConstructBlobArray(&msg->msg_data.info->cCertEncoded,
1436              &msg->msg_data.info->rgCertEncoded, info->cCertEncoded,
1437              info->rgCertEncoded);
1438         if (ret)
1439             ret = CRYPT_ConstructBlobArray(&msg->msg_data.info->cCrlEncoded,
1440              &msg->msg_data.info->rgCrlEncoded, info->cCrlEncoded,
1441              info->rgCrlEncoded);
1442         if (!ret)
1443         {
1444             CSignedEncodeMsg_Close(msg);
1445             msg = NULL;
1446         }
1447     }
1448     return msg;
1449 }
1450
1451 HCRYPTMSG WINAPI CryptMsgOpenToEncode(DWORD dwMsgEncodingType, DWORD dwFlags,
1452  DWORD dwMsgType, const void *pvMsgEncodeInfo, LPSTR pszInnerContentObjID,
1453  PCMSG_STREAM_INFO pStreamInfo)
1454 {
1455     HCRYPTMSG msg = NULL;
1456
1457     TRACE("(%08x, %08x, %08x, %p, %s, %p)\n", dwMsgEncodingType, dwFlags,
1458      dwMsgType, pvMsgEncodeInfo, debugstr_a(pszInnerContentObjID), pStreamInfo);
1459
1460     if (GET_CMSG_ENCODING_TYPE(dwMsgEncodingType) != PKCS_7_ASN_ENCODING)
1461     {
1462         SetLastError(E_INVALIDARG);
1463         return NULL;
1464     }
1465     switch (dwMsgType)
1466     {
1467     case CMSG_DATA:
1468         msg = CDataEncodeMsg_Open(dwFlags, pvMsgEncodeInfo,
1469          pszInnerContentObjID, pStreamInfo);
1470         break;
1471     case CMSG_HASHED:
1472         msg = CHashEncodeMsg_Open(dwFlags, pvMsgEncodeInfo,
1473          pszInnerContentObjID, pStreamInfo);
1474         break;
1475     case CMSG_SIGNED:
1476         msg = CSignedEncodeMsg_Open(dwFlags, pvMsgEncodeInfo,
1477          pszInnerContentObjID, pStreamInfo);
1478         break;
1479     case CMSG_ENVELOPED:
1480         FIXME("unimplemented for type CMSG_ENVELOPED\n");
1481         break;
1482     case CMSG_SIGNED_AND_ENVELOPED:
1483     case CMSG_ENCRYPTED:
1484         /* defined but invalid, fall through */
1485     default:
1486         SetLastError(CRYPT_E_INVALID_MSG_TYPE);
1487     }
1488     return msg;
1489 }
1490
1491 typedef struct _CDecodeMsg
1492 {
1493     CryptMsgBase           base;
1494     DWORD                  type;
1495     HCRYPTPROV             crypt_prov;
1496     union {
1497         HCRYPTHASH     hash;
1498         CSignedMsgData signed_data;
1499     } u;
1500     CRYPT_DATA_BLOB        msg_data;
1501     CRYPT_DATA_BLOB        detached_data;
1502     PCONTEXT_PROPERTY_LIST properties;
1503 } CDecodeMsg;
1504
1505 static void CDecodeMsg_Close(HCRYPTMSG hCryptMsg)
1506 {
1507     CDecodeMsg *msg = hCryptMsg;
1508
1509     if (msg->base.open_flags & CMSG_CRYPT_RELEASE_CONTEXT_FLAG)
1510         CryptReleaseContext(msg->crypt_prov, 0);
1511     switch (msg->type)
1512     {
1513     case CMSG_HASHED:
1514         if (msg->u.hash)
1515             CryptDestroyHash(msg->u.hash);
1516         break;
1517     case CMSG_SIGNED:
1518         if (msg->u.signed_data.info)
1519         {
1520             LocalFree(msg->u.signed_data.info);
1521             CSignedMsgData_CloseHandles(&msg->u.signed_data);
1522         }
1523         break;
1524     }
1525     CryptMemFree(msg->msg_data.pbData);
1526     CryptMemFree(msg->detached_data.pbData);
1527     ContextPropertyList_Free(msg->properties);
1528 }
1529
1530 static BOOL CDecodeMsg_CopyData(CRYPT_DATA_BLOB *blob, const BYTE *pbData,
1531  DWORD cbData)
1532 {
1533     BOOL ret = TRUE;
1534
1535     if (cbData)
1536     {
1537         if (blob->cbData)
1538             blob->pbData = CryptMemRealloc(blob->pbData,
1539              blob->cbData + cbData);
1540         else
1541             blob->pbData = CryptMemAlloc(cbData);
1542         if (blob->pbData)
1543         {
1544             memcpy(blob->pbData + blob->cbData, pbData, cbData);
1545             blob->cbData += cbData;
1546         }
1547         else
1548             ret = FALSE;
1549     }
1550     return ret;
1551 }
1552
1553 static BOOL CDecodeMsg_DecodeDataContent(CDecodeMsg *msg, const CRYPT_DER_BLOB *blob)
1554 {
1555     BOOL ret;
1556     CRYPT_DATA_BLOB *data;
1557     DWORD size;
1558
1559     ret = CryptDecodeObjectEx(X509_ASN_ENCODING, X509_OCTET_STRING,
1560      blob->pbData, blob->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL, &data, &size);
1561     if (ret)
1562     {
1563         ret = ContextPropertyList_SetProperty(msg->properties,
1564          CMSG_CONTENT_PARAM, data->pbData, data->cbData);
1565         LocalFree(data);
1566     }
1567     return ret;
1568 }
1569
1570 static void CDecodeMsg_SaveAlgorithmID(CDecodeMsg *msg, DWORD param,
1571  const CRYPT_ALGORITHM_IDENTIFIER *id)
1572 {
1573     static const BYTE nullParams[] = { ASN_NULL, 0 };
1574     CRYPT_ALGORITHM_IDENTIFIER *copy;
1575     DWORD len = sizeof(CRYPT_ALGORITHM_IDENTIFIER);
1576
1577     /* Linearize algorithm id */
1578     len += strlen(id->pszObjId) + 1;
1579     len += id->Parameters.cbData;
1580     copy = CryptMemAlloc(len);
1581     if (copy)
1582     {
1583         copy->pszObjId =
1584          (LPSTR)((BYTE *)copy + sizeof(CRYPT_ALGORITHM_IDENTIFIER));
1585         strcpy(copy->pszObjId, id->pszObjId);
1586         copy->Parameters.pbData = (BYTE *)copy->pszObjId + strlen(id->pszObjId)
1587          + 1;
1588         /* Trick:  omit NULL parameters */
1589         if (id->Parameters.cbData == sizeof(nullParams) &&
1590          !memcmp(id->Parameters.pbData, nullParams, sizeof(nullParams)))
1591         {
1592             copy->Parameters.cbData = 0;
1593             len -= sizeof(nullParams);
1594         }
1595         else
1596             copy->Parameters.cbData = id->Parameters.cbData;
1597         if (copy->Parameters.cbData)
1598             memcpy(copy->Parameters.pbData, id->Parameters.pbData,
1599              id->Parameters.cbData);
1600         ContextPropertyList_SetProperty(msg->properties, param, (BYTE *)copy,
1601          len);
1602         CryptMemFree(copy);
1603     }
1604 }
1605
1606 static inline void CRYPT_FixUpAlgorithmID(CRYPT_ALGORITHM_IDENTIFIER *id)
1607 {
1608     id->pszObjId = (LPSTR)((BYTE *)id + sizeof(CRYPT_ALGORITHM_IDENTIFIER));
1609     id->Parameters.pbData = (BYTE *)id->pszObjId + strlen(id->pszObjId) + 1;
1610 }
1611
1612 static BOOL CDecodeMsg_DecodeHashedContent(CDecodeMsg *msg,
1613  const CRYPT_DER_BLOB *blob)
1614 {
1615     BOOL ret;
1616     CRYPT_DIGESTED_DATA *digestedData;
1617     DWORD size;
1618
1619     ret = CRYPT_AsnDecodePKCSDigestedData(blob->pbData, blob->cbData,
1620      CRYPT_DECODE_ALLOC_FLAG, NULL, (CRYPT_DIGESTED_DATA *)&digestedData,
1621      &size);
1622     if (ret)
1623     {
1624         ContextPropertyList_SetProperty(msg->properties, CMSG_VERSION_PARAM,
1625          (const BYTE *)&digestedData->version, sizeof(digestedData->version));
1626         CDecodeMsg_SaveAlgorithmID(msg, CMSG_HASH_ALGORITHM_PARAM,
1627          &digestedData->DigestAlgorithm);
1628         ContextPropertyList_SetProperty(msg->properties,
1629          CMSG_INNER_CONTENT_TYPE_PARAM,
1630          (const BYTE *)digestedData->ContentInfo.pszObjId,
1631          digestedData->ContentInfo.pszObjId ?
1632          strlen(digestedData->ContentInfo.pszObjId) + 1 : 0);
1633         if (!(msg->base.open_flags & CMSG_DETACHED_FLAG))
1634         {
1635             if (digestedData->ContentInfo.Content.cbData)
1636                 CDecodeMsg_DecodeDataContent(msg,
1637                  &digestedData->ContentInfo.Content);
1638             else
1639                 ContextPropertyList_SetProperty(msg->properties,
1640                  CMSG_CONTENT_PARAM, NULL, 0);
1641         }
1642         ContextPropertyList_SetProperty(msg->properties, CMSG_HASH_DATA_PARAM,
1643          digestedData->hash.pbData, digestedData->hash.cbData);
1644         LocalFree(digestedData);
1645     }
1646     return ret;
1647 }
1648
1649 static BOOL CDecodeMsg_DecodeSignedContent(CDecodeMsg *msg,
1650  CRYPT_DER_BLOB *blob)
1651 {
1652     BOOL ret;
1653     CRYPT_SIGNED_INFO *signedInfo;
1654     DWORD size;
1655
1656     ret = CRYPT_AsnDecodeCMSSignedInfo(blob->pbData, blob->cbData,
1657      CRYPT_DECODE_ALLOC_FLAG, NULL, (CRYPT_SIGNED_INFO *)&signedInfo,
1658      &size);
1659     if (ret)
1660         msg->u.signed_data.info = signedInfo;
1661     return ret;
1662 }
1663
1664 /* Decodes the content in blob as the type given, and updates the value
1665  * (type, parameters, etc.) of msg based on what blob contains.
1666  * It doesn't just use msg's type, to allow a recursive call from an implicitly
1667  * typed message once the outer content info has been decoded.
1668  */
1669 static BOOL CDecodeMsg_DecodeContent(CDecodeMsg *msg, CRYPT_DER_BLOB *blob,
1670  DWORD type)
1671 {
1672     BOOL ret;
1673
1674     switch (type)
1675     {
1676     case CMSG_DATA:
1677         if ((ret = CDecodeMsg_DecodeDataContent(msg, blob)))
1678             msg->type = CMSG_DATA;
1679         break;
1680     case CMSG_HASHED:
1681         if ((ret = CDecodeMsg_DecodeHashedContent(msg, blob)))
1682             msg->type = CMSG_HASHED;
1683         break;
1684     case CMSG_ENVELOPED:
1685         FIXME("unimplemented for type CMSG_ENVELOPED\n");
1686         ret = TRUE;
1687         break;
1688     case CMSG_SIGNED:
1689         if ((ret = CDecodeMsg_DecodeSignedContent(msg, blob)))
1690             msg->type = CMSG_SIGNED;
1691         break;
1692     default:
1693     {
1694         CRYPT_CONTENT_INFO *info;
1695         DWORD size;
1696
1697         ret = CryptDecodeObjectEx(X509_ASN_ENCODING, PKCS_CONTENT_INFO,
1698          msg->msg_data.pbData, msg->msg_data.cbData, CRYPT_DECODE_ALLOC_FLAG,
1699          NULL, &info, &size);
1700         if (ret)
1701         {
1702             if (!strcmp(info->pszObjId, szOID_RSA_data))
1703                 ret = CDecodeMsg_DecodeContent(msg, &info->Content, CMSG_DATA);
1704             else if (!strcmp(info->pszObjId, szOID_RSA_digestedData))
1705                 ret = CDecodeMsg_DecodeContent(msg, &info->Content,
1706                  CMSG_HASHED);
1707             else if (!strcmp(info->pszObjId, szOID_RSA_envelopedData))
1708                 ret = CDecodeMsg_DecodeContent(msg, &info->Content,
1709                  CMSG_ENVELOPED);
1710             else if (!strcmp(info->pszObjId, szOID_RSA_signedData))
1711                 ret = CDecodeMsg_DecodeContent(msg, &info->Content,
1712                  CMSG_SIGNED);
1713             else
1714             {
1715                 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
1716                 ret = FALSE;
1717             }
1718             LocalFree(info);
1719         }
1720     }
1721     }
1722     return ret;
1723 }
1724
1725 static BOOL CDecodeMsg_FinalizeHashedContent(CDecodeMsg *msg,
1726  CRYPT_DER_BLOB *blob)
1727 {
1728     CRYPT_ALGORITHM_IDENTIFIER *hashAlgoID = NULL;
1729     DWORD size = 0;
1730     ALG_ID algID = 0;
1731     BOOL ret;
1732
1733     CryptMsgGetParam(msg, CMSG_HASH_ALGORITHM_PARAM, 0, NULL, &size);
1734     hashAlgoID = CryptMemAlloc(size);
1735     ret = CryptMsgGetParam(msg, CMSG_HASH_ALGORITHM_PARAM, 0, hashAlgoID,
1736      &size);
1737     if (ret)
1738         algID = CertOIDToAlgId(hashAlgoID->pszObjId);
1739     ret = CryptCreateHash(msg->crypt_prov, algID, 0, 0, &msg->u.hash);
1740     if (ret)
1741     {
1742         CRYPT_DATA_BLOB content;
1743
1744         if (msg->base.open_flags & CMSG_DETACHED_FLAG)
1745         {
1746             /* Unlike for non-detached messages, the data were never stored as
1747              * the content param, but were saved in msg->detached_data instead.
1748              */
1749             content.pbData = msg->detached_data.pbData;
1750             content.cbData = msg->detached_data.cbData;
1751         }
1752         else
1753             ret = ContextPropertyList_FindProperty(msg->properties,
1754              CMSG_CONTENT_PARAM, &content);
1755         if (ret)
1756             ret = CryptHashData(msg->u.hash, content.pbData, content.cbData, 0);
1757     }
1758     CryptMemFree(hashAlgoID);
1759     return ret;
1760 }
1761
1762 static BOOL CDecodeMsg_FinalizeSignedContent(CDecodeMsg *msg,
1763  CRYPT_DER_BLOB *blob)
1764 {
1765     BOOL ret;
1766     DWORD i, size;
1767
1768     ret = CSignedMsgData_AllocateHandles(&msg->u.signed_data);
1769     for (i = 0; ret && i < msg->u.signed_data.info->cSignerInfo; i++)
1770         ret = CSignedMsgData_ConstructSignerHandles(&msg->u.signed_data, i,
1771          msg->crypt_prov);
1772     if (ret)
1773     {
1774         CRYPT_DATA_BLOB *content;
1775
1776         /* Now that we have all the content, update the hash handles with
1777          * it.  If the message is a detached message, the content is stored
1778          * in msg->detached_data rather than in the signed message's
1779          * content.
1780          */
1781         if (msg->base.open_flags & CMSG_DETACHED_FLAG)
1782             content = &msg->detached_data;
1783         else
1784             content = &msg->u.signed_data.info->content.Content;
1785         if (content->cbData)
1786         {
1787             /* If the message is not detached, have to decode the message's
1788              * content if the type is szOID_RSA_data.
1789              */
1790             if (!(msg->base.open_flags & CMSG_DETACHED_FLAG) &&
1791              !strcmp(msg->u.signed_data.info->content.pszObjId,
1792              szOID_RSA_data))
1793             {
1794                 CRYPT_DATA_BLOB *blob;
1795
1796                 ret = CryptDecodeObjectEx(X509_ASN_ENCODING,
1797                  X509_OCTET_STRING, content->pbData, content->cbData,
1798                  CRYPT_DECODE_ALLOC_FLAG, NULL, &blob, &size);
1799                 if (ret)
1800                 {
1801                     ret = CSignedMsgData_Update(&msg->u.signed_data,
1802                      blob->pbData, blob->cbData, TRUE, Verify);
1803                     LocalFree(blob);
1804                 }
1805             }
1806             else
1807                 ret = CSignedMsgData_Update(&msg->u.signed_data,
1808                  content->pbData, content->cbData, TRUE, Verify);
1809         }
1810     }
1811     return ret;
1812 }
1813
1814 static BOOL CDecodeMsg_FinalizeContent(CDecodeMsg *msg, CRYPT_DER_BLOB *blob)
1815 {
1816     BOOL ret = FALSE;
1817
1818     switch (msg->type)
1819     {
1820     case CMSG_HASHED:
1821         ret = CDecodeMsg_FinalizeHashedContent(msg, blob);
1822         break;
1823     case CMSG_SIGNED:
1824         ret = CDecodeMsg_FinalizeSignedContent(msg, blob);
1825         break;
1826     default:
1827         ret = TRUE;
1828     }
1829     return ret;
1830 }
1831
1832 static BOOL CDecodeMsg_Update(HCRYPTMSG hCryptMsg, const BYTE *pbData,
1833  DWORD cbData, BOOL fFinal)
1834 {
1835     CDecodeMsg *msg = hCryptMsg;
1836     BOOL ret = FALSE;
1837
1838     TRACE("(%p, %p, %d, %d)\n", hCryptMsg, pbData, cbData, fFinal);
1839
1840     if (msg->base.state == MsgStateFinalized)
1841         SetLastError(CRYPT_E_MSG_ERROR);
1842     else if (msg->base.streamed)
1843     {
1844         FIXME("(%p, %p, %d, %d): streamed update stub\n", hCryptMsg, pbData,
1845          cbData, fFinal);
1846         switch (msg->base.state)
1847         {
1848         case MsgStateInit:
1849             ret = CDecodeMsg_CopyData(&msg->msg_data, pbData, cbData);
1850             if (fFinal)
1851             {
1852                 if (msg->base.open_flags & CMSG_DETACHED_FLAG)
1853                     msg->base.state = MsgStateDataFinalized;
1854                 else
1855                     msg->base.state = MsgStateFinalized;
1856             }
1857             else
1858                 msg->base.state = MsgStateUpdated;
1859             break;
1860         case MsgStateUpdated:
1861             ret = CDecodeMsg_CopyData(&msg->msg_data, pbData, cbData);
1862             if (fFinal)
1863             {
1864                 if (msg->base.open_flags & CMSG_DETACHED_FLAG)
1865                     msg->base.state = MsgStateDataFinalized;
1866                 else
1867                     msg->base.state = MsgStateFinalized;
1868             }
1869             break;
1870         case MsgStateDataFinalized:
1871             ret = CDecodeMsg_CopyData(&msg->detached_data, pbData, cbData);
1872             if (fFinal)
1873                 msg->base.state = MsgStateFinalized;
1874             break;
1875         default:
1876             SetLastError(CRYPT_E_MSG_ERROR);
1877             break;
1878         }
1879     }
1880     else
1881     {
1882         if (!fFinal)
1883             SetLastError(CRYPT_E_MSG_ERROR);
1884         else
1885         {
1886             switch (msg->base.state)
1887             {
1888             case MsgStateInit:
1889                 ret = CDecodeMsg_CopyData(&msg->msg_data, pbData, cbData);
1890                 if (msg->base.open_flags & CMSG_DETACHED_FLAG)
1891                     msg->base.state = MsgStateDataFinalized;
1892                 else
1893                     msg->base.state = MsgStateFinalized;
1894                 break;
1895             case MsgStateDataFinalized:
1896                 ret = CDecodeMsg_CopyData(&msg->detached_data, pbData, cbData);
1897                 msg->base.state = MsgStateFinalized;
1898                 break;
1899             default:
1900                 SetLastError(CRYPT_E_MSG_ERROR);
1901             }
1902         }
1903     }
1904     if (ret && fFinal &&
1905      ((msg->base.open_flags & CMSG_DETACHED_FLAG && msg->base.state ==
1906      MsgStateDataFinalized) ||
1907      (!(msg->base.open_flags & CMSG_DETACHED_FLAG) && msg->base.state ==
1908      MsgStateFinalized)))
1909         ret = CDecodeMsg_DecodeContent(msg, &msg->msg_data, msg->type);
1910     if (ret && msg->base.state == MsgStateFinalized)
1911         ret = CDecodeMsg_FinalizeContent(msg, &msg->msg_data);
1912     return ret;
1913 }
1914
1915 static BOOL CDecodeHashMsg_GetParam(CDecodeMsg *msg, DWORD dwParamType,
1916  DWORD dwIndex, void *pvData, DWORD *pcbData)
1917 {
1918     BOOL ret = FALSE;
1919
1920     switch (dwParamType)
1921     {
1922     case CMSG_TYPE_PARAM:
1923         ret = CRYPT_CopyParam(pvData, pcbData, &msg->type, sizeof(msg->type));
1924         break;
1925     case CMSG_HASH_ALGORITHM_PARAM:
1926     {
1927         CRYPT_DATA_BLOB blob;
1928
1929         ret = ContextPropertyList_FindProperty(msg->properties, dwParamType,
1930          &blob);
1931         if (ret)
1932         {
1933             ret = CRYPT_CopyParam(pvData, pcbData, blob.pbData, blob.cbData);
1934             if (ret && pvData)
1935                 CRYPT_FixUpAlgorithmID(pvData);
1936         }
1937         else
1938             SetLastError(CRYPT_E_INVALID_MSG_TYPE);
1939         break;
1940     }
1941     case CMSG_COMPUTED_HASH_PARAM:
1942         ret = CryptGetHashParam(msg->u.hash, HP_HASHVAL, pvData, pcbData, 0);
1943         break;
1944     default:
1945     {
1946         CRYPT_DATA_BLOB blob;
1947
1948         ret = ContextPropertyList_FindProperty(msg->properties, dwParamType,
1949          &blob);
1950         if (ret)
1951             ret = CRYPT_CopyParam(pvData, pcbData, blob.pbData, blob.cbData);
1952         else
1953             SetLastError(CRYPT_E_INVALID_MSG_TYPE);
1954     }
1955     }
1956     return ret;
1957 }
1958
1959 /* nextData is an in/out parameter - on input it's the memory location in
1960  * which a copy of in's data should be made, and on output it's the memory
1961  * location immediately after out's copy of in's data.
1962  */
1963 static inline void CRYPT_CopyBlob(CRYPT_DATA_BLOB *out,
1964  const CRYPT_DATA_BLOB *in, LPBYTE *nextData)
1965 {
1966     out->cbData = in->cbData;
1967     if (in->cbData)
1968     {
1969         out->pbData = *nextData;
1970         memcpy(out->pbData, in->pbData, in->cbData);
1971         *nextData += in->cbData;
1972     }
1973 }
1974
1975 static inline void CRYPT_CopyAlgorithmId(CRYPT_ALGORITHM_IDENTIFIER *out,
1976  const CRYPT_ALGORITHM_IDENTIFIER *in, LPBYTE *nextData)
1977 {
1978     if (in->pszObjId)
1979     {
1980         out->pszObjId = (LPSTR)*nextData;
1981         strcpy(out->pszObjId, in->pszObjId);
1982         *nextData += strlen(out->pszObjId) + 1;
1983     }
1984     CRYPT_CopyBlob(&out->Parameters, &in->Parameters, nextData);
1985 }
1986
1987 static inline void CRYPT_CopyAttributes(CRYPT_ATTRIBUTES *out,
1988  const CRYPT_ATTRIBUTES *in, LPBYTE *nextData)
1989 {
1990     out->cAttr = in->cAttr;
1991     if (in->cAttr)
1992     {
1993         DWORD i;
1994
1995         *nextData = POINTER_ALIGN_DWORD_PTR(*nextData);
1996         out->rgAttr = (CRYPT_ATTRIBUTE *)*nextData;
1997         *nextData += in->cAttr * sizeof(CRYPT_ATTRIBUTE);
1998         for (i = 0; i < in->cAttr; i++)
1999         {
2000             if (in->rgAttr[i].pszObjId)
2001             {
2002                 out->rgAttr[i].pszObjId = (LPSTR)*nextData;
2003                 strcpy(out->rgAttr[i].pszObjId, in->rgAttr[i].pszObjId);
2004                 *nextData += strlen(in->rgAttr[i].pszObjId) + 1;
2005             }
2006             if (in->rgAttr[i].cValue)
2007             {
2008                 DWORD j;
2009
2010                 out->rgAttr[i].cValue = in->rgAttr[i].cValue;
2011                 *nextData = POINTER_ALIGN_DWORD_PTR(*nextData);
2012                 out->rgAttr[i].rgValue = (PCRYPT_DATA_BLOB)*nextData;
2013                 *nextData += in->rgAttr[i].cValue * sizeof(CRYPT_DATA_BLOB);
2014                 for (j = 0; j < in->rgAttr[i].cValue; j++)
2015                     CRYPT_CopyBlob(&out->rgAttr[i].rgValue[j],
2016                      &in->rgAttr[i].rgValue[j], nextData);
2017             }
2018         }
2019     }
2020 }
2021
2022 static DWORD CRYPT_SizeOfAttributes(const CRYPT_ATTRIBUTES *attr)
2023 {
2024     DWORD size = attr->cAttr * sizeof(CRYPT_ATTRIBUTE), i, j;
2025
2026     for (i = 0; i < attr->cAttr; i++)
2027     {
2028         if (attr->rgAttr[i].pszObjId)
2029             size += strlen(attr->rgAttr[i].pszObjId) + 1;
2030         /* align pointer */
2031         size = ALIGN_DWORD_PTR(size);
2032         size += attr->rgAttr[i].cValue * sizeof(CRYPT_DATA_BLOB);
2033         for (j = 0; j < attr->rgAttr[i].cValue; j++)
2034             size += attr->rgAttr[i].rgValue[j].cbData;
2035     }
2036     /* align pointer again to be conservative */
2037     size = ALIGN_DWORD_PTR(size);
2038     return size;
2039 }
2040
2041 static DWORD CRYPT_SizeOfKeyIdAsIssuerAndSerial(const CRYPT_DATA_BLOB *keyId)
2042 {
2043     static char oid_key_rdn[] = szOID_KEYID_RDN;
2044     DWORD size = 0;
2045     CERT_RDN_ATTR attr;
2046     CERT_RDN rdn = { 1, &attr };
2047     CERT_NAME_INFO name = { 1, &rdn };
2048
2049     attr.pszObjId = oid_key_rdn;
2050     attr.dwValueType = CERT_RDN_OCTET_STRING;
2051     attr.Value.cbData = keyId->cbData;
2052     attr.Value.pbData = keyId->pbData;
2053     if (CryptEncodeObject(X509_ASN_ENCODING, X509_NAME, &name, NULL, &size))
2054         size++; /* Only include size of special zero serial number on success */
2055     return size;
2056 }
2057
2058 static BOOL CRYPT_CopyKeyIdAsIssuerAndSerial(CERT_NAME_BLOB *issuer,
2059  CRYPT_INTEGER_BLOB *serialNumber, const CRYPT_DATA_BLOB *keyId, DWORD encodedLen,
2060  LPBYTE *nextData)
2061 {
2062     static char oid_key_rdn[] = szOID_KEYID_RDN;
2063     CERT_RDN_ATTR attr;
2064     CERT_RDN rdn = { 1, &attr };
2065     CERT_NAME_INFO name = { 1, &rdn };
2066     BOOL ret;
2067
2068     /* Encode special zero serial number */
2069     serialNumber->cbData = 1;
2070     serialNumber->pbData = *nextData;
2071     **nextData = 0;
2072     (*nextData)++;
2073     /* Encode issuer */
2074     issuer->pbData = *nextData;
2075     attr.pszObjId = oid_key_rdn;
2076     attr.dwValueType = CERT_RDN_OCTET_STRING;
2077     attr.Value.cbData = keyId->cbData;
2078     attr.Value.pbData = keyId->pbData;
2079     ret = CryptEncodeObject(X509_ASN_ENCODING, X509_NAME, &name, *nextData,
2080      &encodedLen);
2081     if (ret)
2082     {
2083         *nextData += encodedLen;
2084         issuer->cbData = encodedLen;
2085     }
2086     return ret;
2087 }
2088
2089 static BOOL CRYPT_CopySignerInfo(void *pvData, DWORD *pcbData,
2090  const CMSG_CMS_SIGNER_INFO *in)
2091 {
2092     DWORD size = sizeof(CMSG_SIGNER_INFO), rdnSize = 0;
2093     BOOL ret;
2094
2095     TRACE("(%p, %d, %p)\n", pvData, pvData ? *pcbData : 0, in);
2096
2097     if (in->SignerId.dwIdChoice == CERT_ID_ISSUER_SERIAL_NUMBER)
2098     {
2099         size += in->SignerId.u.IssuerSerialNumber.Issuer.cbData;
2100         size += in->SignerId.u.IssuerSerialNumber.SerialNumber.cbData;
2101     }
2102     else
2103     {
2104         rdnSize = CRYPT_SizeOfKeyIdAsIssuerAndSerial(&in->SignerId.u.KeyId);
2105         size += rdnSize;
2106     }
2107     if (in->HashAlgorithm.pszObjId)
2108         size += strlen(in->HashAlgorithm.pszObjId) + 1;
2109     size += in->HashAlgorithm.Parameters.cbData;
2110     if (in->HashEncryptionAlgorithm.pszObjId)
2111         size += strlen(in->HashEncryptionAlgorithm.pszObjId) + 1;
2112     size += in->HashEncryptionAlgorithm.Parameters.cbData;
2113     size += in->EncryptedHash.cbData;
2114     /* align pointer */
2115     size = ALIGN_DWORD_PTR(size);
2116     size += CRYPT_SizeOfAttributes(&in->AuthAttrs);
2117     size += CRYPT_SizeOfAttributes(&in->UnauthAttrs);
2118     if (!pvData)
2119     {
2120         *pcbData = size;
2121         ret = TRUE;
2122     }
2123     else if (*pcbData < size)
2124     {
2125         *pcbData = size;
2126         SetLastError(ERROR_MORE_DATA);
2127         ret = FALSE;
2128     }
2129     else
2130     {
2131         LPBYTE nextData = (BYTE *)pvData + sizeof(CMSG_SIGNER_INFO);
2132         CMSG_SIGNER_INFO *out = pvData;
2133
2134         ret = TRUE;
2135         out->dwVersion = in->dwVersion;
2136         if (in->SignerId.dwIdChoice == CERT_ID_ISSUER_SERIAL_NUMBER)
2137         {
2138             CRYPT_CopyBlob(&out->Issuer,
2139              &in->SignerId.u.IssuerSerialNumber.Issuer, &nextData);
2140             CRYPT_CopyBlob(&out->SerialNumber,
2141              &in->SignerId.u.IssuerSerialNumber.SerialNumber, &nextData);
2142         }
2143         else
2144             ret = CRYPT_CopyKeyIdAsIssuerAndSerial(&out->Issuer, &out->SerialNumber,
2145              &in->SignerId.u.KeyId, rdnSize, &nextData);
2146         if (ret)
2147         {
2148             CRYPT_CopyAlgorithmId(&out->HashAlgorithm, &in->HashAlgorithm,
2149              &nextData);
2150             CRYPT_CopyAlgorithmId(&out->HashEncryptionAlgorithm,
2151              &in->HashEncryptionAlgorithm, &nextData);
2152             CRYPT_CopyBlob(&out->EncryptedHash, &in->EncryptedHash, &nextData);
2153             nextData = POINTER_ALIGN_DWORD_PTR(nextData);
2154             CRYPT_CopyAttributes(&out->AuthAttrs, &in->AuthAttrs, &nextData);
2155             CRYPT_CopyAttributes(&out->UnauthAttrs, &in->UnauthAttrs, &nextData);
2156         }
2157     }
2158     TRACE("returning %d\n", ret);
2159     return ret;
2160 }
2161
2162 static BOOL CRYPT_CopyCMSSignerInfo(void *pvData, DWORD *pcbData,
2163  const CMSG_CMS_SIGNER_INFO *in)
2164 {
2165     DWORD size = sizeof(CMSG_CMS_SIGNER_INFO);
2166     BOOL ret;
2167
2168     TRACE("(%p, %d, %p)\n", pvData, pvData ? *pcbData : 0, in);
2169
2170     if (in->SignerId.dwIdChoice == CERT_ID_ISSUER_SERIAL_NUMBER)
2171     {
2172         size += in->SignerId.u.IssuerSerialNumber.Issuer.cbData;
2173         size += in->SignerId.u.IssuerSerialNumber.SerialNumber.cbData;
2174     }
2175     else
2176         size += in->SignerId.u.KeyId.cbData;
2177     if (in->HashAlgorithm.pszObjId)
2178         size += strlen(in->HashAlgorithm.pszObjId) + 1;
2179     size += in->HashAlgorithm.Parameters.cbData;
2180     if (in->HashEncryptionAlgorithm.pszObjId)
2181         size += strlen(in->HashEncryptionAlgorithm.pszObjId) + 1;
2182     size += in->HashEncryptionAlgorithm.Parameters.cbData;
2183     size += in->EncryptedHash.cbData;
2184     /* align pointer */
2185     size = ALIGN_DWORD_PTR(size);
2186     size += CRYPT_SizeOfAttributes(&in->AuthAttrs);
2187     size += CRYPT_SizeOfAttributes(&in->UnauthAttrs);
2188     if (!pvData)
2189     {
2190         *pcbData = size;
2191         ret = TRUE;
2192     }
2193     else if (*pcbData < size)
2194     {
2195         *pcbData = size;
2196         SetLastError(ERROR_MORE_DATA);
2197         ret = FALSE;
2198     }
2199     else
2200     {
2201         LPBYTE nextData = (BYTE *)pvData + sizeof(CMSG_CMS_SIGNER_INFO);
2202         CMSG_CMS_SIGNER_INFO *out = pvData;
2203
2204         out->dwVersion = in->dwVersion;
2205         out->SignerId.dwIdChoice = in->SignerId.dwIdChoice;
2206         if (in->SignerId.dwIdChoice == CERT_ID_ISSUER_SERIAL_NUMBER)
2207         {
2208             CRYPT_CopyBlob(&out->SignerId.u.IssuerSerialNumber.Issuer,
2209              &in->SignerId.u.IssuerSerialNumber.Issuer, &nextData);
2210             CRYPT_CopyBlob(&out->SignerId.u.IssuerSerialNumber.SerialNumber,
2211              &in->SignerId.u.IssuerSerialNumber.SerialNumber, &nextData);
2212         }
2213         else
2214             CRYPT_CopyBlob(&out->SignerId.u.KeyId, &in->SignerId.u.KeyId, &nextData);
2215         CRYPT_CopyAlgorithmId(&out->HashAlgorithm, &in->HashAlgorithm,
2216          &nextData);
2217         CRYPT_CopyAlgorithmId(&out->HashEncryptionAlgorithm,
2218          &in->HashEncryptionAlgorithm, &nextData);
2219         CRYPT_CopyBlob(&out->EncryptedHash, &in->EncryptedHash, &nextData);
2220         nextData = POINTER_ALIGN_DWORD_PTR(nextData);
2221         CRYPT_CopyAttributes(&out->AuthAttrs, &in->AuthAttrs, &nextData);
2222         CRYPT_CopyAttributes(&out->UnauthAttrs, &in->UnauthAttrs, &nextData);
2223         ret = TRUE;
2224     }
2225     TRACE("returning %d\n", ret);
2226     return ret;
2227 }
2228
2229 static BOOL CRYPT_CopySignerCertInfo(void *pvData, DWORD *pcbData,
2230  const CMSG_CMS_SIGNER_INFO *in)
2231 {
2232     DWORD size = sizeof(CERT_INFO), rdnSize = 0;
2233     BOOL ret;
2234
2235     TRACE("(%p, %d, %p)\n", pvData, pvData ? *pcbData : 0, in);
2236
2237     if (in->SignerId.dwIdChoice == CERT_ID_ISSUER_SERIAL_NUMBER)
2238     {
2239         size += in->SignerId.u.IssuerSerialNumber.Issuer.cbData;
2240         size += in->SignerId.u.IssuerSerialNumber.SerialNumber.cbData;
2241     }
2242     else
2243     {
2244         rdnSize = CRYPT_SizeOfKeyIdAsIssuerAndSerial(&in->SignerId.u.KeyId);
2245         size += rdnSize;
2246     }
2247     if (!pvData)
2248     {
2249         *pcbData = size;
2250         ret = TRUE;
2251     }
2252     else if (*pcbData < size)
2253     {
2254         *pcbData = size;
2255         SetLastError(ERROR_MORE_DATA);
2256         ret = FALSE;
2257     }
2258     else
2259     {
2260         LPBYTE nextData = (BYTE *)pvData + sizeof(CERT_INFO);
2261         CERT_INFO *out = pvData;
2262
2263         memset(out, 0, sizeof(CERT_INFO));
2264         if (in->SignerId.dwIdChoice == CERT_ID_ISSUER_SERIAL_NUMBER)
2265         {
2266             CRYPT_CopyBlob(&out->Issuer,
2267              &in->SignerId.u.IssuerSerialNumber.Issuer, &nextData);
2268             CRYPT_CopyBlob(&out->SerialNumber,
2269              &in->SignerId.u.IssuerSerialNumber.SerialNumber, &nextData);
2270             ret = TRUE;
2271         }
2272         else
2273             ret = CRYPT_CopyKeyIdAsIssuerAndSerial(&out->Issuer, &out->SerialNumber,
2274              &in->SignerId.u.KeyId, rdnSize, &nextData);
2275     }
2276     TRACE("returning %d\n", ret);
2277     return ret;
2278 }
2279
2280 static BOOL CDecodeSignedMsg_GetParam(CDecodeMsg *msg, DWORD dwParamType,
2281  DWORD dwIndex, void *pvData, DWORD *pcbData)
2282 {
2283     BOOL ret = FALSE;
2284
2285     switch (dwParamType)
2286     {
2287     case CMSG_TYPE_PARAM:
2288         ret = CRYPT_CopyParam(pvData, pcbData, &msg->type, sizeof(msg->type));
2289         break;
2290     case CMSG_CONTENT_PARAM:
2291         if (msg->u.signed_data.info)
2292         {
2293             if (!strcmp(msg->u.signed_data.info->content.pszObjId,
2294              szOID_RSA_data))
2295             {
2296                 CRYPT_DATA_BLOB *blob;
2297                 DWORD size;
2298
2299                 ret = CryptDecodeObjectEx(X509_ASN_ENCODING, X509_OCTET_STRING,
2300                  msg->u.signed_data.info->content.Content.pbData,
2301                  msg->u.signed_data.info->content.Content.cbData,
2302                  CRYPT_DECODE_ALLOC_FLAG, NULL, &blob, &size);
2303                 if (ret)
2304                 {
2305                     ret = CRYPT_CopyParam(pvData, pcbData, blob->pbData,
2306                      blob->cbData);
2307                     LocalFree(blob);
2308                 }
2309             }
2310             else
2311                 ret = CRYPT_CopyParam(pvData, pcbData,
2312                  msg->u.signed_data.info->content.Content.pbData,
2313                  msg->u.signed_data.info->content.Content.cbData);
2314         }
2315         else
2316             SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2317         break;
2318     case CMSG_INNER_CONTENT_TYPE_PARAM:
2319         if (msg->u.signed_data.info)
2320             ret = CRYPT_CopyParam(pvData, pcbData,
2321              msg->u.signed_data.info->content.pszObjId,
2322              strlen(msg->u.signed_data.info->content.pszObjId) + 1);
2323         else
2324             SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2325         break;
2326     case CMSG_SIGNER_COUNT_PARAM:
2327         if (msg->u.signed_data.info)
2328             ret = CRYPT_CopyParam(pvData, pcbData,
2329              &msg->u.signed_data.info->cSignerInfo, sizeof(DWORD));
2330         else
2331             SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2332         break;
2333     case CMSG_SIGNER_INFO_PARAM:
2334         if (msg->u.signed_data.info)
2335         {
2336             if (dwIndex >= msg->u.signed_data.info->cSignerInfo)
2337                 SetLastError(CRYPT_E_INVALID_INDEX);
2338             else
2339                 ret = CRYPT_CopySignerInfo(pvData, pcbData,
2340                  &msg->u.signed_data.info->rgSignerInfo[dwIndex]);
2341         }
2342         else
2343             SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2344         break;
2345     case CMSG_SIGNER_CERT_INFO_PARAM:
2346         if (msg->u.signed_data.info)
2347         {
2348             if (dwIndex >= msg->u.signed_data.info->cSignerInfo)
2349                 SetLastError(CRYPT_E_INVALID_INDEX);
2350             else
2351                 ret = CRYPT_CopySignerCertInfo(pvData, pcbData,
2352                  &msg->u.signed_data.info->rgSignerInfo[dwIndex]);
2353         }
2354         else
2355             SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2356         break;
2357     case CMSG_CERT_COUNT_PARAM:
2358         if (msg->u.signed_data.info)
2359             ret = CRYPT_CopyParam(pvData, pcbData,
2360              &msg->u.signed_data.info->cCertEncoded, sizeof(DWORD));
2361         else
2362             SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2363         break;
2364     case CMSG_CERT_PARAM:
2365         if (msg->u.signed_data.info)
2366         {
2367             if (dwIndex >= msg->u.signed_data.info->cCertEncoded)
2368                 SetLastError(CRYPT_E_INVALID_INDEX);
2369             else
2370                 ret = CRYPT_CopyParam(pvData, pcbData,
2371                  msg->u.signed_data.info->rgCertEncoded[dwIndex].pbData,
2372                  msg->u.signed_data.info->rgCertEncoded[dwIndex].cbData);
2373         }
2374         else
2375             SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2376         break;
2377     case CMSG_CRL_COUNT_PARAM:
2378         if (msg->u.signed_data.info)
2379             ret = CRYPT_CopyParam(pvData, pcbData,
2380              &msg->u.signed_data.info->cCrlEncoded, sizeof(DWORD));
2381         else
2382             SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2383         break;
2384     case CMSG_CRL_PARAM:
2385         if (msg->u.signed_data.info)
2386         {
2387             if (dwIndex >= msg->u.signed_data.info->cCrlEncoded)
2388                 SetLastError(CRYPT_E_INVALID_INDEX);
2389             else
2390                 ret = CRYPT_CopyParam(pvData, pcbData,
2391                  msg->u.signed_data.info->rgCrlEncoded[dwIndex].pbData,
2392                  msg->u.signed_data.info->rgCrlEncoded[dwIndex].cbData);
2393         }
2394         else
2395             SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2396         break;
2397     case CMSG_COMPUTED_HASH_PARAM:
2398         if (msg->u.signed_data.info)
2399         {
2400             if (dwIndex >= msg->u.signed_data.cSignerHandle)
2401                 SetLastError(CRYPT_E_INVALID_INDEX);
2402             else
2403                 ret = CryptGetHashParam(
2404                  msg->u.signed_data.signerHandles[dwIndex].contentHash,
2405                  HP_HASHVAL, pvData, pcbData, 0);
2406         }
2407         else
2408             SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2409         break;
2410     case CMSG_ENCODED_SIGNER:
2411         if (msg->u.signed_data.info)
2412         {
2413             if (dwIndex >= msg->u.signed_data.info->cSignerInfo)
2414                 SetLastError(CRYPT_E_INVALID_INDEX);
2415             else
2416                 ret = CryptEncodeObjectEx(
2417                  X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, CMS_SIGNER_INFO,
2418                  &msg->u.signed_data.info->rgSignerInfo[dwIndex], 0, NULL,
2419                  pvData, pcbData);
2420         }
2421         else
2422             SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2423         break;
2424     case CMSG_ATTR_CERT_COUNT_PARAM:
2425         if (msg->u.signed_data.info)
2426         {
2427             DWORD attrCertCount = 0;
2428
2429             ret = CRYPT_CopyParam(pvData, pcbData,
2430              &attrCertCount, sizeof(DWORD));
2431         }
2432         else
2433             SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2434         break;
2435     case CMSG_ATTR_CERT_PARAM:
2436         if (msg->u.signed_data.info)
2437             SetLastError(CRYPT_E_INVALID_INDEX);
2438         else
2439             SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2440         break;
2441     case CMSG_CMS_SIGNER_INFO_PARAM:
2442         if (msg->u.signed_data.info)
2443         {
2444             if (dwIndex >= msg->u.signed_data.info->cSignerInfo)
2445                 SetLastError(CRYPT_E_INVALID_INDEX);
2446             else
2447                 ret = CRYPT_CopyCMSSignerInfo(pvData, pcbData,
2448                  &msg->u.signed_data.info->rgSignerInfo[dwIndex]);
2449         }
2450         else
2451             SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2452         break;
2453     default:
2454         FIXME("unimplemented for %d\n", dwParamType);
2455         SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2456     }
2457     return ret;
2458 }
2459
2460 static BOOL CDecodeMsg_GetParam(HCRYPTMSG hCryptMsg, DWORD dwParamType,
2461  DWORD dwIndex, void *pvData, DWORD *pcbData)
2462 {
2463     CDecodeMsg *msg = hCryptMsg;
2464     BOOL ret = FALSE;
2465
2466     switch (msg->type)
2467     {
2468     case CMSG_HASHED:
2469         ret = CDecodeHashMsg_GetParam(msg, dwParamType, dwIndex, pvData,
2470          pcbData);
2471         break;
2472     case CMSG_SIGNED:
2473         ret = CDecodeSignedMsg_GetParam(msg, dwParamType, dwIndex, pvData,
2474          pcbData);
2475         break;
2476     default:
2477         switch (dwParamType)
2478         {
2479         case CMSG_TYPE_PARAM:
2480             ret = CRYPT_CopyParam(pvData, pcbData, &msg->type,
2481              sizeof(msg->type));
2482             break;
2483         default:
2484         {
2485             CRYPT_DATA_BLOB blob;
2486
2487             ret = ContextPropertyList_FindProperty(msg->properties, dwParamType,
2488              &blob);
2489             if (ret)
2490                 ret = CRYPT_CopyParam(pvData, pcbData, blob.pbData,
2491                  blob.cbData);
2492             else
2493                 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2494         }
2495         }
2496     }
2497     return ret;
2498 }
2499
2500 static BOOL CDecodeHashMsg_VerifyHash(CDecodeMsg *msg)
2501 {
2502     BOOL ret;
2503     CRYPT_DATA_BLOB hashBlob;
2504
2505     ret = ContextPropertyList_FindProperty(msg->properties,
2506      CMSG_HASH_DATA_PARAM, &hashBlob);
2507     if (ret)
2508     {
2509         DWORD computedHashSize = 0;
2510
2511         ret = CDecodeHashMsg_GetParam(msg, CMSG_COMPUTED_HASH_PARAM, 0, NULL,
2512          &computedHashSize);
2513         if (hashBlob.cbData == computedHashSize)
2514         {
2515             LPBYTE computedHash = CryptMemAlloc(computedHashSize);
2516
2517             if (computedHash)
2518             {
2519                 ret = CDecodeHashMsg_GetParam(msg, CMSG_COMPUTED_HASH_PARAM, 0,
2520                  computedHash, &computedHashSize);
2521                 if (ret)
2522                 {
2523                     if (memcmp(hashBlob.pbData, computedHash, hashBlob.cbData))
2524                     {
2525                         SetLastError(CRYPT_E_HASH_VALUE);
2526                         ret = FALSE;
2527                     }
2528                 }
2529                 CryptMemFree(computedHash);
2530             }
2531             else
2532             {
2533                 SetLastError(ERROR_OUTOFMEMORY);
2534                 ret = FALSE;
2535             }
2536         }
2537         else
2538         {
2539             SetLastError(CRYPT_E_HASH_VALUE);
2540             ret = FALSE;
2541         }
2542     }
2543     return ret;
2544 }
2545
2546 static BOOL CDecodeSignedMsg_VerifySignatureWithKey(CDecodeMsg *msg,
2547  HCRYPTPROV prov, DWORD signerIndex, PCERT_PUBLIC_KEY_INFO keyInfo)
2548 {
2549     HCRYPTKEY key;
2550     BOOL ret;
2551
2552     if (!prov)
2553         prov = msg->crypt_prov;
2554     ret = CryptImportPublicKeyInfo(prov, X509_ASN_ENCODING, keyInfo, &key);
2555     if (ret)
2556     {
2557         HCRYPTHASH hash;
2558         CRYPT_HASH_BLOB reversedHash;
2559
2560         if (msg->u.signed_data.info->rgSignerInfo[signerIndex].AuthAttrs.cAttr)
2561             hash = msg->u.signed_data.signerHandles[signerIndex].authAttrHash;
2562         else
2563             hash = msg->u.signed_data.signerHandles[signerIndex].contentHash;
2564         ret = CRYPT_ConstructBlob(&reversedHash,
2565          &msg->u.signed_data.info->rgSignerInfo[signerIndex].EncryptedHash);
2566         if (ret)
2567         {
2568             CRYPT_ReverseBytes(&reversedHash);
2569             ret = CryptVerifySignatureW(hash, reversedHash.pbData,
2570              reversedHash.cbData, key, NULL, 0);
2571             CryptMemFree(reversedHash.pbData);
2572         }
2573         CryptDestroyKey(key);
2574     }
2575     return ret;
2576 }
2577
2578 static BOOL CDecodeSignedMsg_VerifySignature(CDecodeMsg *msg, PCERT_INFO info)
2579 {
2580     BOOL ret = FALSE;
2581     DWORD i;
2582
2583     if (!msg->u.signed_data.signerHandles)
2584     {
2585         SetLastError(NTE_BAD_SIGNATURE);
2586         return FALSE;
2587     }
2588     for (i = 0; !ret && i < msg->u.signed_data.info->cSignerInfo; i++)
2589     {
2590         PCMSG_CMS_SIGNER_INFO signerInfo =
2591          &msg->u.signed_data.info->rgSignerInfo[i];
2592
2593         if (signerInfo->SignerId.dwIdChoice == CERT_ID_ISSUER_SERIAL_NUMBER)
2594         {
2595             ret = CertCompareCertificateName(X509_ASN_ENCODING,
2596              &signerInfo->SignerId.u.IssuerSerialNumber.Issuer,
2597              &info->Issuer);
2598             if (ret)
2599             {
2600                 ret = CertCompareIntegerBlob(
2601                  &signerInfo->SignerId.u.IssuerSerialNumber.SerialNumber,
2602                  &info->SerialNumber);
2603                 if (ret)
2604                     break;
2605             }
2606         }
2607         else
2608         {
2609             FIXME("signer %d: unimplemented for key id\n", i);
2610         }
2611     }
2612     if (ret)
2613         ret = CDecodeSignedMsg_VerifySignatureWithKey(msg, 0, i,
2614          &info->SubjectPublicKeyInfo);
2615     else
2616         SetLastError(CRYPT_E_SIGNER_NOT_FOUND);
2617
2618     return ret;
2619 }
2620
2621 static BOOL CDecodeSignedMsg_VerifySignatureEx(CDecodeMsg *msg,
2622  PCMSG_CTRL_VERIFY_SIGNATURE_EX_PARA para)
2623 {
2624     BOOL ret = FALSE;
2625
2626     if (para->cbSize != sizeof(CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA))
2627         SetLastError(ERROR_INVALID_PARAMETER);
2628     else if (para->dwSignerIndex >= msg->u.signed_data.info->cSignerInfo)
2629         SetLastError(CRYPT_E_SIGNER_NOT_FOUND);
2630     else if (!msg->u.signed_data.signerHandles)
2631         SetLastError(NTE_BAD_SIGNATURE);
2632     else
2633     {
2634         switch (para->dwSignerType)
2635         {
2636         case CMSG_VERIFY_SIGNER_PUBKEY:
2637             ret = CDecodeSignedMsg_VerifySignatureWithKey(msg,
2638              para->hCryptProv, para->dwSignerIndex, para->pvSigner);
2639             break;
2640         case CMSG_VERIFY_SIGNER_CERT:
2641         {
2642             PCCERT_CONTEXT cert = para->pvSigner;
2643
2644             ret = CDecodeSignedMsg_VerifySignatureWithKey(msg, para->hCryptProv,
2645              para->dwSignerIndex, &cert->pCertInfo->SubjectPublicKeyInfo);
2646             break;
2647         }
2648         default:
2649             FIXME("unimplemented for signer type %d\n", para->dwSignerType);
2650             SetLastError(CRYPT_E_SIGNER_NOT_FOUND);
2651         }
2652     }
2653     return ret;
2654 }
2655
2656 static BOOL CDecodeMsg_Control(HCRYPTMSG hCryptMsg, DWORD dwFlags,
2657  DWORD dwCtrlType, const void *pvCtrlPara)
2658 {
2659     CDecodeMsg *msg = hCryptMsg;
2660     BOOL ret = FALSE;
2661
2662     switch (dwCtrlType)
2663     {
2664     case CMSG_CTRL_VERIFY_SIGNATURE:
2665         switch (msg->type)
2666         {
2667         case CMSG_SIGNED:
2668             ret = CDecodeSignedMsg_VerifySignature(msg, (PCERT_INFO)pvCtrlPara);
2669             break;
2670         default:
2671             SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2672         }
2673         break;
2674     case CMSG_CTRL_DECRYPT:
2675         switch (msg->type)
2676         {
2677         default:
2678             SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2679         }
2680         break;
2681     case CMSG_CTRL_VERIFY_HASH:
2682         switch (msg->type)
2683         {
2684         case CMSG_HASHED:
2685             ret = CDecodeHashMsg_VerifyHash(msg);
2686             break;
2687         default:
2688             SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2689         }
2690         break;
2691     case CMSG_CTRL_VERIFY_SIGNATURE_EX:
2692         switch (msg->type)
2693         {
2694         case CMSG_SIGNED:
2695             ret = CDecodeSignedMsg_VerifySignatureEx(msg,
2696              (PCMSG_CTRL_VERIFY_SIGNATURE_EX_PARA)pvCtrlPara);
2697             break;
2698         default:
2699             SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2700         }
2701         break;
2702     default:
2703         SetLastError(CRYPT_E_CONTROL_TYPE);
2704     }
2705     return ret;
2706 }
2707
2708 HCRYPTMSG WINAPI CryptMsgOpenToDecode(DWORD dwMsgEncodingType, DWORD dwFlags,
2709  DWORD dwMsgType, HCRYPTPROV_LEGACY hCryptProv, PCERT_INFO pRecipientInfo,
2710  PCMSG_STREAM_INFO pStreamInfo)
2711 {
2712     CDecodeMsg *msg;
2713
2714     TRACE("(%08x, %08x, %08x, %08lx, %p, %p)\n", dwMsgEncodingType,
2715      dwFlags, dwMsgType, hCryptProv, pRecipientInfo, pStreamInfo);
2716
2717     if (GET_CMSG_ENCODING_TYPE(dwMsgEncodingType) != PKCS_7_ASN_ENCODING)
2718     {
2719         SetLastError(E_INVALIDARG);
2720         return NULL;
2721     }
2722     msg = CryptMemAlloc(sizeof(CDecodeMsg));
2723     if (msg)
2724     {
2725         CryptMsgBase_Init((CryptMsgBase *)msg, dwFlags, pStreamInfo,
2726          CDecodeMsg_Close, CDecodeMsg_GetParam, CDecodeMsg_Update,
2727          CDecodeMsg_Control);
2728         msg->type = dwMsgType;
2729         if (hCryptProv)
2730             msg->crypt_prov = hCryptProv;
2731         else
2732         {
2733             msg->crypt_prov = CRYPT_GetDefaultProvider();
2734             msg->base.open_flags &= ~CMSG_CRYPT_RELEASE_CONTEXT_FLAG;
2735         }
2736         memset(&msg->u, 0, sizeof(msg->u));
2737         msg->msg_data.cbData = 0;
2738         msg->msg_data.pbData = NULL;
2739         msg->detached_data.cbData = 0;
2740         msg->detached_data.pbData = NULL;
2741         msg->properties = ContextPropertyList_Create();
2742     }
2743     return msg;
2744 }
2745
2746 HCRYPTMSG WINAPI CryptMsgDuplicate(HCRYPTMSG hCryptMsg)
2747 {
2748     TRACE("(%p)\n", hCryptMsg);
2749
2750     if (hCryptMsg)
2751     {
2752         CryptMsgBase *msg = hCryptMsg;
2753
2754         InterlockedIncrement(&msg->ref);
2755     }
2756     return hCryptMsg;
2757 }
2758
2759 BOOL WINAPI CryptMsgClose(HCRYPTMSG hCryptMsg)
2760 {
2761     TRACE("(%p)\n", hCryptMsg);
2762
2763     if (hCryptMsg)
2764     {
2765         CryptMsgBase *msg = hCryptMsg;
2766
2767         if (InterlockedDecrement(&msg->ref) == 0)
2768         {
2769             TRACE("freeing %p\n", msg);
2770             if (msg->close)
2771                 msg->close(msg);
2772             CryptMemFree(msg);
2773         }
2774     }
2775     return TRUE;
2776 }
2777
2778 BOOL WINAPI CryptMsgUpdate(HCRYPTMSG hCryptMsg, const BYTE *pbData,
2779  DWORD cbData, BOOL fFinal)
2780 {
2781     CryptMsgBase *msg = hCryptMsg;
2782
2783     TRACE("(%p, %p, %d, %d)\n", hCryptMsg, pbData, cbData, fFinal);
2784
2785     return msg->update(hCryptMsg, pbData, cbData, fFinal);
2786 }
2787
2788 BOOL WINAPI CryptMsgGetParam(HCRYPTMSG hCryptMsg, DWORD dwParamType,
2789  DWORD dwIndex, void *pvData, DWORD *pcbData)
2790 {
2791     CryptMsgBase *msg = hCryptMsg;
2792
2793     TRACE("(%p, %d, %d, %p, %p)\n", hCryptMsg, dwParamType, dwIndex,
2794      pvData, pcbData);
2795     return msg->get_param(hCryptMsg, dwParamType, dwIndex, pvData, pcbData);
2796 }
2797
2798 BOOL WINAPI CryptMsgControl(HCRYPTMSG hCryptMsg, DWORD dwFlags,
2799  DWORD dwCtrlType, const void *pvCtrlPara)
2800 {
2801     CryptMsgBase *msg = hCryptMsg;
2802
2803     TRACE("(%p, %08x, %d, %p)\n", hCryptMsg, dwFlags, dwCtrlType,
2804      pvCtrlPara);
2805     return msg->control(hCryptMsg, dwFlags, dwCtrlType, pvCtrlPara);
2806 }
2807
2808 static CERT_INFO *CRYPT_GetSignerCertInfoFromMsg(HCRYPTMSG msg,
2809  DWORD dwSignerIndex)
2810 {
2811     CERT_INFO *certInfo = NULL;
2812     DWORD size;
2813
2814     if (CryptMsgGetParam(msg, CMSG_SIGNER_CERT_INFO_PARAM, dwSignerIndex, NULL,
2815      &size))
2816     {
2817         certInfo = CryptMemAlloc(size);
2818         if (certInfo)
2819         {
2820             if (!CryptMsgGetParam(msg, CMSG_SIGNER_CERT_INFO_PARAM,
2821              dwSignerIndex, certInfo, &size))
2822             {
2823                 CryptMemFree(certInfo);
2824                 certInfo = NULL;
2825             }
2826         }
2827     }
2828     return certInfo;
2829 }
2830
2831 BOOL WINAPI CryptMsgGetAndVerifySigner(HCRYPTMSG hCryptMsg, DWORD cSignerStore,
2832  HCERTSTORE *rghSignerStore, DWORD dwFlags, PCCERT_CONTEXT *ppSigner,
2833  DWORD *pdwSignerIndex)
2834 {
2835     HCERTSTORE store;
2836     DWORD i, signerIndex = 0;
2837     PCCERT_CONTEXT signerCert = NULL;
2838     BOOL ret = FALSE;
2839
2840     TRACE("(%p, %d, %p, %08x, %p, %p)\n", hCryptMsg, cSignerStore,
2841      rghSignerStore, dwFlags, ppSigner, pdwSignerIndex);
2842
2843     /* Clear output parameters */
2844     if (ppSigner)
2845         *ppSigner = NULL;
2846     if (pdwSignerIndex && !(dwFlags & CMSG_USE_SIGNER_INDEX_FLAG))
2847         *pdwSignerIndex = 0;
2848
2849     /* Create store to search for signer certificates */
2850     store = CertOpenStore(CERT_STORE_PROV_COLLECTION, 0, 0,
2851      CERT_STORE_CREATE_NEW_FLAG, NULL);
2852     if (!(dwFlags & CMSG_TRUSTED_SIGNER_FLAG))
2853     {
2854         HCERTSTORE msgStore = CertOpenStore(CERT_STORE_PROV_MSG, 0, 0, 0,
2855          hCryptMsg);
2856
2857         CertAddStoreToCollection(store, msgStore, 0, 0);
2858         CertCloseStore(msgStore, 0);
2859     }
2860     for (i = 0; i < cSignerStore; i++)
2861         CertAddStoreToCollection(store, rghSignerStore[i], 0, 0);
2862
2863     /* Find signer cert */
2864     if (dwFlags & CMSG_USE_SIGNER_INDEX_FLAG)
2865     {
2866         CERT_INFO *signer = CRYPT_GetSignerCertInfoFromMsg(hCryptMsg,
2867          *pdwSignerIndex);
2868
2869         if (signer)
2870         {
2871             signerIndex = *pdwSignerIndex;
2872             signerCert = CertFindCertificateInStore(store, X509_ASN_ENCODING,
2873              0, CERT_FIND_SUBJECT_CERT, signer, NULL);
2874             CryptMemFree(signer);
2875         }
2876     }
2877     else
2878     {
2879         DWORD count, size = sizeof(count);
2880
2881         if (CryptMsgGetParam(hCryptMsg, CMSG_SIGNER_COUNT_PARAM, 0, &count,
2882          &size))
2883         {
2884             for (i = 0; !signerCert && i < count; i++)
2885             {
2886                 CERT_INFO *signer = CRYPT_GetSignerCertInfoFromMsg(hCryptMsg,
2887                  i);
2888
2889                 if (signer)
2890                 {
2891                     signerCert = CertFindCertificateInStore(store,
2892                      X509_ASN_ENCODING, 0, CERT_FIND_SUBJECT_CERT, signer,
2893                      NULL);
2894                     if (signerCert)
2895                         signerIndex = i;
2896                     CryptMemFree(signer);
2897                 }
2898             }
2899         }
2900         if (!signerCert)
2901             SetLastError(CRYPT_E_NO_TRUSTED_SIGNER);
2902     }
2903     if (signerCert)
2904     {
2905         if (!(dwFlags & CMSG_SIGNER_ONLY_FLAG))
2906             ret = CryptMsgControl(hCryptMsg, 0, CMSG_CTRL_VERIFY_SIGNATURE,
2907              signerCert->pCertInfo);
2908         else
2909             ret = TRUE;
2910         if (ret)
2911         {
2912             if (ppSigner)
2913                 *ppSigner = CertDuplicateCertificateContext(signerCert);
2914             if (pdwSignerIndex)
2915                 *pdwSignerIndex = signerIndex;
2916         }
2917         CertFreeCertificateContext(signerCert);
2918     }
2919
2920     CertCloseStore(store, 0);
2921     return ret;
2922 }
2923
2924 BOOL WINAPI CryptMsgVerifyCountersignatureEncodedEx(HCRYPTPROV_LEGACY hCryptProv,
2925  DWORD dwEncodingType, PBYTE pbSignerInfo, DWORD cbSignerInfo,
2926  PBYTE pbSignerInfoCountersignature, DWORD cbSignerInfoCountersignature,
2927  DWORD dwSignerType, void *pvSigner, DWORD dwFlags, void *pvReserved)
2928 {
2929     FIXME("(%08lx, %08x, %p, %d, %p, %d, %d, %p, %08x, %p): stub\n", hCryptProv,
2930      dwEncodingType, pbSignerInfo, cbSignerInfo, pbSignerInfoCountersignature,
2931      cbSignerInfoCountersignature, dwSignerType, pvSigner, dwFlags, pvReserved);
2932     return FALSE;
2933 }
2934
2935 BOOL WINAPI CryptMsgEncodeAndSignCTL(DWORD dwMsgEncodingType,
2936  PCTL_INFO pCtlInfo, PCMSG_SIGNED_ENCODE_INFO pSignInfo, DWORD dwFlags,
2937  BYTE *pbEncoded, DWORD *pcbEncoded)
2938 {
2939     BOOL ret;
2940     BYTE *pbCtlContent;
2941     DWORD cbCtlContent;
2942
2943     TRACE("(%08x, %p, %p, %08x, %p, %p)\n", dwMsgEncodingType, pCtlInfo,
2944      pSignInfo, dwFlags, pbEncoded, pcbEncoded);
2945
2946     if (dwFlags)
2947     {
2948         FIXME("unimplemented for flags %08x\n", dwFlags);
2949         return FALSE;
2950     }
2951     if ((ret = CryptEncodeObjectEx(dwMsgEncodingType, PKCS_CTL, pCtlInfo,
2952      CRYPT_ENCODE_ALLOC_FLAG, NULL, &pbCtlContent, &cbCtlContent)))
2953     {
2954         ret = CryptMsgSignCTL(dwMsgEncodingType, pbCtlContent, cbCtlContent,
2955          pSignInfo, dwFlags, pbEncoded, pcbEncoded);
2956         LocalFree(pbCtlContent);
2957     }
2958     return ret;
2959 }
2960
2961 BOOL WINAPI CryptMsgSignCTL(DWORD dwMsgEncodingType, BYTE *pbCtlContent,
2962  DWORD cbCtlContent, PCMSG_SIGNED_ENCODE_INFO pSignInfo, DWORD dwFlags,
2963  BYTE *pbEncoded, DWORD *pcbEncoded)
2964 {
2965     static char oid_ctl[] = szOID_CTL;
2966     BOOL ret;
2967     HCRYPTMSG msg;
2968
2969     TRACE("(%08x, %p, %d, %p, %08x, %p, %p)\n", dwMsgEncodingType,
2970      pbCtlContent, cbCtlContent, pSignInfo, dwFlags, pbEncoded, pcbEncoded);
2971
2972     if (dwFlags)
2973     {
2974         FIXME("unimplemented for flags %08x\n", dwFlags);
2975         return FALSE;
2976     }
2977     msg = CryptMsgOpenToEncode(dwMsgEncodingType, 0, CMSG_SIGNED, pSignInfo,
2978      oid_ctl, NULL);
2979     if (msg)
2980     {
2981         ret = CryptMsgUpdate(msg, pbCtlContent, cbCtlContent, TRUE);
2982         if (ret)
2983             ret = CryptMsgGetParam(msg, CMSG_CONTENT_PARAM, 0, pbEncoded,
2984              pcbEncoded);
2985         CryptMsgClose(msg);
2986     }
2987     else
2988         ret = FALSE;
2989     return ret;
2990 }