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

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