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