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