dlls/wintrust/crypt.c

   1 /*
   2  * WinTrust Cryptography functions
   3  *
   4  * Copyright 2006 James Hawkins
   5  * Copyright 2000-2002 Stuart Caie
   6  * Copyright 2002 Patrik Stridvall
   7  * Copyright 2003 Greg Turner
   8  * Copyright 2008 Juan Lang
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  23  */
  24
  25 #include <stdarg.h>
  26 #include <stdio.h>
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "wintrust.h"
  30 #include "mscat.h"
  31 #include "mssip.h"
  32 #include "imagehlp.h"
  33 #include "winternl.h"
  34
  35 #include "wine/debug.h"
  36 #include "wine/unicode.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(wintrust);
  39
  40 #define CATADMIN_MAGIC 0x43415441 /* 'CATA' */
  41 #define CRYPTCAT_MAGIC 0x43415443 /* 'CATC' */
  42 #define CATINFO_MAGIC  0x43415449 /* 'CATI' */
  43
  44 struct cryptcat
  45 {
  46     DWORD     magic;
  47     HANDLE    msg;
  48     DWORD     encoding;
  49     CTL_INFO *inner;
  50     DWORD     inner_len;
  51     GUID      subject;
  52     DWORD     attr_count;
  53     CRYPTCATATTRIBUTE *attr;
  54 };
  55
  56 struct catadmin
  57 {
  58     DWORD magic;
  59     WCHAR path[MAX_PATH];
  60     HANDLE find;
  61 };
  62
  63 struct catinfo
  64 {
  65     DWORD magic;
  66     WCHAR file[MAX_PATH];
  67 };
  68
  69 static HCATINFO create_catinfo(const WCHAR *filename)
  70 {
  71     struct catinfo *ci;
  72
  73     if (!(ci = HeapAlloc(GetProcessHeap(), 0, sizeof(*ci))))
  74     {
  75         SetLastError(ERROR_OUTOFMEMORY);
  76         return INVALID_HANDLE_VALUE;
  77     }
  78     strcpyW(ci->file, filename);
  79     ci->magic = CATINFO_MAGIC;
  80     return ci;
  81 }
  82
  83 /***********************************************************************
  84  *      CryptCATAdminAcquireContext (WINTRUST.@)
  85  *
  86  * Get a catalog administrator context handle.
  87  *
  88  * PARAMS
  89  *   catAdmin  [O] Pointer to the context handle.
  90  *   sys       [I] Pointer to a GUID for the needed subsystem.
  91  *   dwFlags   [I] Reserved.
  92  *
  93  * RETURNS
  94  *   Success: TRUE. catAdmin contains the context handle.
  95  *   Failure: FALSE.
  96  *
  97  */
  98 BOOL WINAPI CryptCATAdminAcquireContext(HCATADMIN *catAdmin,
  99                                         const GUID *sys, DWORD dwFlags)
 100 {
 101     static const WCHAR catroot[] =
 102         {'\\','c','a','t','r','o','o','t',0};
 103     static const WCHAR fmt[] =
 104         {'%','s','\\','{','%','0','8','x','-','%','0','4','x','-','%','0',
 105          '4','x','-','%','0','2','x','%','0','2','x','-','%','0','2','x',
 106          '%','0','2','x','%','0','2','x','%','0','2','x','%','0','2','x',
 107          '%','0','2','x','}',0};
 108     static const GUID defsys =
 109         {0x127d0a1d,0x4ef2,0x11d1,{0x86,0x08,0x00,0xc0,0x4f,0xc2,0x95,0xee}};
 110
 111     WCHAR catroot_dir[MAX_PATH];
 112     struct catadmin *ca;
 113
 114     TRACE("%p %s %x\n", catAdmin, debugstr_guid(sys), dwFlags);
 115
 116     if (!catAdmin)
 117     {
 118         SetLastError(ERROR_INVALID_PARAMETER);
 119         return FALSE;
 120     }
 121     if (!(ca = HeapAlloc(GetProcessHeap(), 0, sizeof(*ca))))
 122     {
 123         SetLastError(ERROR_OUTOFMEMORY);
 124         return FALSE;
 125     }
 126
 127     GetSystemDirectoryW(catroot_dir, MAX_PATH);
 128     strcatW(catroot_dir, catroot);
 129
 130     /* create the directory if it doesn't exist */
 131     CreateDirectoryW(catroot_dir, NULL);
 132
 133     if (!sys) sys = &defsys;
 134     sprintfW(ca->path, fmt, catroot_dir, sys->Data1, sys->Data2,
 135              sys->Data3, sys->Data4[0], sys->Data4[1], sys->Data4[2],
 136              sys->Data4[3], sys->Data4[4], sys->Data4[5], sys->Data4[6],
 137              sys->Data4[7]);
 138
 139     /* create the directory if it doesn't exist */
 140     CreateDirectoryW(ca->path, NULL);
 141
 142     ca->magic = CATADMIN_MAGIC;
 143     ca->find = INVALID_HANDLE_VALUE;
 144
 145     *catAdmin = ca;
 146     return TRUE;
 147 }
 148
 149 /***********************************************************************
 150  *             CryptCATAdminAddCatalog (WINTRUST.@)
 151  */
 152 HCATINFO WINAPI CryptCATAdminAddCatalog(HCATADMIN catAdmin, PWSTR catalogFile,
 153                                         PWSTR selectBaseName, DWORD flags)
 154 {
 155     static const WCHAR slashW[] = {'\\',0};
 156     struct catadmin *ca = catAdmin;
 157     struct catinfo *ci;
 158     WCHAR *target;
 159     DWORD len;
 160
 161     TRACE("%p %s %s %d\n", catAdmin, debugstr_w(catalogFile),
 162           debugstr_w(selectBaseName), flags);
 163
 164     if (!selectBaseName)
 165     {
 166         FIXME("NULL basename not handled\n");
 167         SetLastError(ERROR_INVALID_PARAMETER);
 168         return NULL;
 169     }
 170     if (!ca || ca->magic != CATADMIN_MAGIC || !catalogFile || flags)
 171     {
 172         SetLastError(ERROR_INVALID_PARAMETER);
 173         return NULL;
 174     }
 175
 176     len = strlenW(ca->path) + strlenW(selectBaseName) + 2;
 177     if (!(target = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR))))
 178     {
 179         SetLastError(ERROR_OUTOFMEMORY);
 180         return NULL;
 181     }
 182     strcpyW(target, ca->path);
 183     strcatW(target, slashW);
 184     strcatW(target, selectBaseName);
 185
 186     if (!CopyFileW(catalogFile, target, FALSE))
 187     {
 188         HeapFree(GetProcessHeap(), 0, target);
 189         return NULL;
 190     }
 191     if (!(ci = HeapAlloc(GetProcessHeap(), 0, sizeof(*ci))))
 192     {
 193         HeapFree(GetProcessHeap(), 0, target);
 194         SetLastError(ERROR_OUTOFMEMORY);
 195         return NULL;
 196     }
 197     ci->magic = CATINFO_MAGIC;
 198     strcpyW(ci->file, target);
 199
 200     HeapFree(GetProcessHeap(), 0, target);
 201     return ci;
 202 }
 203
 204 /***********************************************************************
 205  *             CryptCATAdminCalcHashFromFileHandle (WINTRUST.@)
 206  */
 207 BOOL WINAPI CryptCATAdminCalcHashFromFileHandle(HANDLE hFile, DWORD* pcbHash,
 208                                                 BYTE* pbHash, DWORD dwFlags )
 209 {
 210     BOOL ret = FALSE;
 211
 212     TRACE("%p %p %p %x\n", hFile, pcbHash, pbHash, dwFlags);
 213
 214     if (!hFile || !pcbHash || dwFlags)
 215     {
 216         SetLastError(ERROR_INVALID_PARAMETER);
 217         return FALSE;
 218     }
 219     if (*pcbHash < 20)
 220     {
 221         *pcbHash = 20;
 222         SetLastError(ERROR_INSUFFICIENT_BUFFER);
 223         return TRUE;
 224     }
 225
 226     *pcbHash = 20;
 227     if (pbHash)
 228     {
 229         HCRYPTPROV prov;
 230         HCRYPTHASH hash;
 231         DWORD bytes_read;
 232         BYTE *buffer;
 233
 234         if (!(buffer = HeapAlloc(GetProcessHeap(), 0, 4096)))
 235         {
 236             SetLastError(ERROR_OUTOFMEMORY);
 237             return FALSE;
 238         }
 239         ret = CryptAcquireContextW(&prov, NULL, MS_DEF_PROV_W, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);
 240         if (!ret)
 241         {
 242             HeapFree(GetProcessHeap(), 0, buffer);
 243             return FALSE;
 244         }
 245         ret = CryptCreateHash(prov, CALG_SHA1, 0, 0, &hash);
 246         if (!ret)
 247         {
 248             HeapFree(GetProcessHeap(), 0, buffer);
 249             CryptReleaseContext(prov, 0);
 250             return FALSE;
 251         }
 252         while ((ret = ReadFile(hFile, buffer, 4096, &bytes_read, NULL)) && bytes_read)
 253         {
 254             CryptHashData(hash, buffer, bytes_read, 0);
 255         }
 256         if (ret) ret = CryptGetHashParam(hash, HP_HASHVAL, pbHash, pcbHash, 0);
 257
 258         HeapFree(GetProcessHeap(), 0, buffer);
 259         CryptDestroyHash(hash);
 260         CryptReleaseContext(prov, 0);
 261     }
 262     return ret;
 263 }
 264
 265 /***********************************************************************
 266  *             CryptCATAdminEnumCatalogFromHash (WINTRUST.@)
 267  */
 268 HCATINFO WINAPI CryptCATAdminEnumCatalogFromHash(HCATADMIN hCatAdmin, BYTE* pbHash,
 269                                                  DWORD cbHash, DWORD dwFlags,
 270                                                  HCATINFO* phPrevCatInfo )
 271 {
 272     static const WCHAR slashW[] = {'\\',0};
 273     static const WCHAR globW[]  = {'\\','*','.','c','a','t',0};
 274
 275     struct catadmin *ca = hCatAdmin;
 276     WIN32_FIND_DATAW data;
 277     HCATINFO prev = NULL;
 278     HCRYPTPROV prov;
 279     DWORD size;
 280     BOOL ret;
 281
 282     TRACE("%p %p %d %x %p\n", hCatAdmin, pbHash, cbHash, dwFlags, phPrevCatInfo);
 283
 284     if (!ca || ca->magic != CATADMIN_MAGIC || !pbHash || cbHash != 20 || dwFlags)
 285     {
 286         SetLastError(ERROR_INVALID_PARAMETER);
 287         return NULL;
 288     }
 289     if (phPrevCatInfo) prev = *phPrevCatInfo;
 290
 291     ret = CryptAcquireContextW(&prov, NULL, MS_DEF_PROV_W, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);
 292     if (!ret) return NULL;
 293
 294     if (!prev)
 295     {
 296         WCHAR *path;
 297
 298         size = strlenW(ca->path) * sizeof(WCHAR) + sizeof(globW);
 299         if (!(path = HeapAlloc(GetProcessHeap(), 0, size)))
 300         {
 301             CryptReleaseContext(prov, 0);
 302             SetLastError(ERROR_OUTOFMEMORY);
 303             return NULL;
 304         }
 305         strcpyW(path, ca->path);
 306         strcatW(path, globW);
 307
 308         FindClose(ca->find);
 309         ca->find = FindFirstFileW(path, &data);
 310
 311         HeapFree(GetProcessHeap(), 0, path);
 312         if (ca->find == INVALID_HANDLE_VALUE)
 313         {
 314             CryptReleaseContext(prov, 0);
 315             return NULL;
 316         }
 317     }
 318     else if (!FindNextFileW(ca->find, &data))
 319     {
 320         CryptCATAdminReleaseCatalogContext(hCatAdmin, prev, 0);
 321         CryptReleaseContext(prov, 0);
 322         return NULL;
 323     }
 324
 325     while (1)
 326     {
 327         WCHAR *filename;
 328         CRYPTCATMEMBER *member = NULL;
 329         struct catinfo *ci;
 330         HANDLE hcat;
 331
 332         size = (strlenW(ca->path) + strlenW(data.cFileName) + 2) * sizeof(WCHAR);
 333         if (!(filename = HeapAlloc(GetProcessHeap(), 0, size)))
 334         {
 335             SetLastError(ERROR_OUTOFMEMORY);
 336             return NULL;
 337         }
 338         strcpyW(filename, ca->path);
 339         strcatW(filename, slashW);
 340         strcatW(filename, data.cFileName);
 341
 342         hcat = CryptCATOpen(filename, CRYPTCAT_OPEN_EXISTING, prov, 0, 0);
 343         if (hcat == INVALID_HANDLE_VALUE)
 344         {
 345             WARN("couldn't open %s (%u)\n", debugstr_w(filename), GetLastError());
 346             continue;
 347         }
 348         while ((member = CryptCATEnumerateMember(hcat, member)))
 349         {
 350             if (member->pIndirectData->Digest.cbData != cbHash)
 351             {
 352                 WARN("amount of hash bytes differs: %u/%u\n", member->pIndirectData->Digest.cbData, cbHash);
 353                 continue;
 354             }
 355             if (!memcmp(member->pIndirectData->Digest.pbData, pbHash, cbHash))
 356             {
 357                 TRACE("file %s matches\n", debugstr_w(data.cFileName));
 358
 359                 CryptCATClose(hcat);
 360                 CryptReleaseContext(prov, 0);
 361                 if (!phPrevCatInfo)
 362                 {
 363                     FindClose(ca->find);
 364                     ca->find = INVALID_HANDLE_VALUE;
 365                 }
 366                 ci = create_catinfo(filename);
 367                 HeapFree(GetProcessHeap(), 0, filename);
 368                 return ci;
 369             }
 370         }
 371         CryptCATClose(hcat);
 372         HeapFree(GetProcessHeap(), 0, filename);
 373
 374         if (!FindNextFileW(ca->find, &data))
 375         {
 376             FindClose(ca->find);
 377             ca->find = INVALID_HANDLE_VALUE;
 378             CryptReleaseContext(prov, 0);
 379             return NULL;
 380         }
 381     }
 382     return NULL;
 383 }
 384
 385 /***********************************************************************
 386  *      CryptCATAdminReleaseCatalogContext (WINTRUST.@)
 387  *
 388  * Release a catalog context handle.
 389  *
 390  * PARAMS
 391  *   hCatAdmin [I] Context handle.
 392  *   hCatInfo  [I] Catalog handle.
 393  *   dwFlags   [I] Reserved.
 394  *
 395  * RETURNS
 396  *   Success: TRUE.
 397  *   Failure: FALSE.
 398  *
 399  */
 400 BOOL WINAPI CryptCATAdminReleaseCatalogContext(HCATADMIN hCatAdmin,
 401                                                HCATINFO hCatInfo,
 402                                                DWORD dwFlags)
 403 {
 404     struct catinfo *ci = hCatInfo;
 405     struct catadmin *ca = hCatAdmin;
 406
 407     TRACE("%p %p %x\n", hCatAdmin, hCatInfo, dwFlags);
 408
 409     if (!ca || ca->magic != CATADMIN_MAGIC || !ci || ci->magic != CATINFO_MAGIC)
 410     {
 411         SetLastError(ERROR_INVALID_PARAMETER);
 412         return FALSE;
 413     }
 414     ci->magic = 0;
 415     return HeapFree(GetProcessHeap(), 0, ci);
 416 }
 417
 418 /***********************************************************************
 419  *      CryptCATAdminReleaseContext (WINTRUST.@)
 420  *
 421  * Release a catalog administrator context handle.
 422  *
 423  * PARAMS
 424  *   catAdmin  [I] Context handle.
 425  *   dwFlags   [I] Reserved.
 426  *
 427  * RETURNS
 428  *   Success: TRUE.
 429  *   Failure: FALSE.
 430  *
 431  */
 432 BOOL WINAPI CryptCATAdminReleaseContext(HCATADMIN hCatAdmin, DWORD dwFlags )
 433 {
 434     struct catadmin *ca = hCatAdmin;
 435
 436     TRACE("%p %x\n", hCatAdmin, dwFlags);
 437
 438     if (!ca || ca->magic != CATADMIN_MAGIC)
 439     {
 440         SetLastError(ERROR_INVALID_PARAMETER);
 441         return FALSE;
 442     }
 443     if (ca->find != INVALID_HANDLE_VALUE) FindClose(ca->find);
 444     ca->magic = 0;
 445     return HeapFree(GetProcessHeap(), 0, ca);
 446 }
 447
 448 /***********************************************************************
 449  *      CryptCATAdminRemoveCatalog (WINTRUST.@)
 450  *
 451  * Remove a catalog file.
 452  *
 453  * PARAMS
 454  *   catAdmin         [I] Context handle.
 455  *   pwszCatalogFile  [I] Catalog file.
 456  *   dwFlags          [I] Reserved.
 457  *
 458  * RETURNS
 459  *   Success: TRUE.
 460  *   Failure: FALSE.
 461  *
 462  */
 463 BOOL WINAPI CryptCATAdminRemoveCatalog(HCATADMIN hCatAdmin, LPCWSTR pwszCatalogFile, DWORD dwFlags)
 464 {
 465     struct catadmin *ca = hCatAdmin;
 466
 467     TRACE("%p %s %x\n", hCatAdmin, debugstr_w(pwszCatalogFile), dwFlags);
 468
 469     if (!ca || ca->magic != CATADMIN_MAGIC)
 470     {
 471         SetLastError(ERROR_INVALID_PARAMETER);
 472         return FALSE;
 473     }
 474     return DeleteFileW(pwszCatalogFile);
 475 }
 476
 477 /***********************************************************************
 478  *      CryptCATAdminResolveCatalogPath  (WINTRUST.@)
 479  */
 480 BOOL WINAPI CryptCATAdminResolveCatalogPath(HCATADMIN hcatadmin, WCHAR *catalog_file,
 481                                             CATALOG_INFO *info, DWORD flags)
 482 {
 483     static const WCHAR slashW[] = {'\\',0};
 484     struct catadmin *ca = hcatadmin;
 485
 486     TRACE("%p %s %p %x\n", hcatadmin, debugstr_w(catalog_file), info, flags);
 487
 488     if (!ca || ca->magic != CATADMIN_MAGIC || !info || info->cbStruct != sizeof(*info) || flags)
 489     {
 490         SetLastError(ERROR_INVALID_PARAMETER);
 491         return FALSE;
 492     }
 493     strcpyW(info->wszCatalogFile, ca->path);
 494     strcatW(info->wszCatalogFile, slashW);
 495     strcatW(info->wszCatalogFile, catalog_file);
 496
 497     return TRUE;
 498 }
 499
 500 /***********************************************************************
 501  *      CryptCATClose  (WINTRUST.@)
 502  */
 503 BOOL WINAPI CryptCATClose(HANDLE hCatalog)
 504 {
 505     struct cryptcat *cc = hCatalog;
 506
 507     TRACE("(%p)\n", hCatalog);
 508
 509     if (!hCatalog || hCatalog == INVALID_HANDLE_VALUE || cc->magic != CRYPTCAT_MAGIC)
 510     {
 511         SetLastError(ERROR_INVALID_PARAMETER);
 512         return FALSE;
 513     }
 514     HeapFree(GetProcessHeap(), 0, cc->attr);
 515     HeapFree(GetProcessHeap(), 0, cc->inner);
 516     CryptMsgClose(cc->msg);
 517
 518     cc->magic = 0;
 519     HeapFree(GetProcessHeap(), 0, cc);
 520     return TRUE;
 521 }
 522
 523 /***********************************************************************
 524  *      CryptCATEnumerateMember  (WINTRUST.@)
 525  */
 526 CRYPTCATMEMBER * WINAPI CryptCATEnumerateMember(HANDLE hCatalog, CRYPTCATMEMBER *prev)
 527 {
 528     struct cryptcat *cc = hCatalog;
 529     CRYPTCATMEMBER *member = prev;
 530     CTL_ENTRY *entry;
 531     DWORD size, i;
 532
 533     TRACE("%p, %p\n", hCatalog, prev);
 534
 535     if (!hCatalog || hCatalog == INVALID_HANDLE_VALUE || cc->magic != CRYPTCAT_MAGIC)
 536     {
 537         SetLastError(ERROR_INVALID_PARAMETER);
 538         return NULL;
 539     }
 540
 541     /* dumping the contents makes me think that dwReserved is the iteration number */
 542     if (!member)
 543     {
 544         if (!(member = HeapAlloc(GetProcessHeap(), 0, sizeof(*member))))
 545         {
 546             SetLastError(ERROR_OUTOFMEMORY);
 547             return NULL;
 548         }
 549         member->cbStruct = sizeof(*member);
 550         member->pwszFileName = member->pwszReferenceTag = NULL;
 551         member->dwReserved = 0;
 552         member->hReserved = NULL;
 553         member->gSubjectType = cc->subject;
 554         member->fdwMemberFlags = 0;
 555         member->pIndirectData = NULL;
 556         member->dwCertVersion = cc->inner->dwVersion;
 557     }
 558     else member->dwReserved++;
 559
 560     if (member->dwReserved >= cc->inner->cCTLEntry)
 561     {
 562         SetLastError(ERROR_INVALID_PARAMETER);
 563         goto error;
 564     }
 565
 566     /* list them backwards, like native */
 567     entry = &cc->inner->rgCTLEntry[cc->inner->cCTLEntry - member->dwReserved - 1];
 568
 569     member->sEncodedIndirectData.cbData = member->sEncodedMemberInfo.cbData = 0;
 570     member->sEncodedIndirectData.pbData = member->sEncodedMemberInfo.pbData = NULL;
 571     HeapFree(GetProcessHeap(), 0, member->pIndirectData);
 572     member->pIndirectData = NULL;
 573
 574     for (i = 0; i < entry->cAttribute; i++)
 575     {
 576         CRYPT_ATTRIBUTE *attr = entry->rgAttribute + i;
 577
 578         if (attr->cValue != 1)
 579         {
 580             ERR("Can't handle attr->cValue of %u\n", attr->cValue);
 581             continue;
 582         }
 583         if (!strcmp(attr->pszObjId, CAT_MEMBERINFO_OBJID))
 584         {
 585             CAT_MEMBERINFO *mi;
 586             BOOL ret;
 587
 588             member->sEncodedMemberInfo.cbData = attr->rgValue->cbData;
 589             member->sEncodedMemberInfo.pbData = attr->rgValue->pbData;
 590
 591             CryptDecodeObject(cc->encoding, CAT_MEMBERINFO_OBJID, attr->rgValue->pbData, attr->rgValue->cbData, 0, NULL, &size);
 592
 593             if (!(mi = HeapAlloc(GetProcessHeap(), 0, size)))
 594             {
 595                 SetLastError(ERROR_OUTOFMEMORY);
 596                 goto error;
 597             }
 598             ret = CryptDecodeObject(cc->encoding, CAT_MEMBERINFO_OBJID, attr->rgValue->pbData, attr->rgValue->cbData, 0, mi, &size);
 599             if (ret)
 600             {
 601                 UNICODE_STRING guid;
 602
 603                 member->dwCertVersion = mi->dwCertVersion;
 604                 RtlInitUnicodeString(&guid, mi->pwszSubjGuid);
 605                 if (RtlGUIDFromString(&guid, &member->gSubjectType))
 606                 {
 607                     HeapFree(GetProcessHeap(), 0, mi);
 608                     goto error;
 609                 }
 610             }
 611             HeapFree(GetProcessHeap(), 0, mi);
 612             if (!ret) goto error;
 613         }
 614         else if (!strcmp(attr->pszObjId, SPC_INDIRECT_DATA_OBJID))
 615         {
 616             /* SPC_INDIRECT_DATA_CONTENT is equal to SIP_INDIRECT_DATA */
 617
 618             member->sEncodedIndirectData.cbData = attr->rgValue->cbData;
 619             member->sEncodedIndirectData.pbData = attr->rgValue->pbData;
 620
 621             CryptDecodeObject(cc->encoding, SPC_INDIRECT_DATA_OBJID, attr->rgValue->pbData, attr->rgValue->cbData, 0, NULL, &size);
 622
 623             if (!(member->pIndirectData = HeapAlloc(GetProcessHeap(), 0, size)))
 624             {
 625                 SetLastError(ERROR_OUTOFMEMORY);
 626                 goto error;
 627             }
 628             CryptDecodeObject(cc->encoding, SPC_INDIRECT_DATA_OBJID, attr->rgValue->pbData, attr->rgValue->cbData, 0, member->pIndirectData, &size);
 629         }
 630         else
 631             /* this object id should probably be handled in CryptCATEnumerateAttr */
 632             FIXME("unhandled object id \"%s\"\n", attr->pszObjId);
 633     }
 634
 635     if (!member->sEncodedMemberInfo.cbData || !member->sEncodedIndirectData.cbData)
 636     {
 637         ERR("Corrupted catalog entry?\n");
 638         SetLastError(CRYPT_E_ATTRIBUTES_MISSING);
 639         goto error;
 640     }
 641     size = (2 * member->pIndirectData->Digest.cbData + 1) * sizeof(WCHAR);
 642     if (member->pwszReferenceTag)
 643         member->pwszReferenceTag = HeapReAlloc(GetProcessHeap(), 0, member->pwszReferenceTag, size);
 644     else
 645         member->pwszReferenceTag = HeapAlloc(GetProcessHeap(), 0, size);
 646
 647     if (!member->pwszReferenceTag)
 648     {
 649         SetLastError(ERROR_OUTOFMEMORY);
 650         goto error;
 651     }
 652     /* FIXME: reference tag is usually the file hash but doesn't have to be */
 653     for (i = 0; i < member->pIndirectData->Digest.cbData; i++)
 654     {
 655         DWORD sub;
 656
 657         sub = member->pIndirectData->Digest.pbData[i] >> 4;
 658         member->pwszReferenceTag[i * 2] = (sub < 10 ? '0' + sub : 'A' + sub - 10);
 659         sub = member->pIndirectData->Digest.pbData[i] & 0xf;
 660         member->pwszReferenceTag[i * 2 + 1] = (sub < 10 ? '0' + sub : 'A' + sub - 10);
 661     }
 662     member->pwszReferenceTag[i * 2] = 0;
 663     return member;
 664
 665 error:
 666     HeapFree(GetProcessHeap(), 0, member->pIndirectData);
 667     HeapFree(GetProcessHeap(), 0, member->pwszReferenceTag);
 668     HeapFree(GetProcessHeap(), 0, member);
 669     return NULL;
 670 }
 671
 672 static CTL_INFO *decode_inner_content(HANDLE hmsg, DWORD encoding, DWORD *len)
 673 {
 674     DWORD size;
 675     LPSTR oid = NULL;
 676     BYTE *buffer = NULL;
 677     CTL_INFO *inner = NULL;
 678
 679     if (!CryptMsgGetParam(hmsg, CMSG_INNER_CONTENT_TYPE_PARAM, 0, NULL, &size)) return NULL;
 680     if (!(oid = HeapAlloc(GetProcessHeap(), 0, size)))
 681     {
 682         SetLastError(ERROR_OUTOFMEMORY);
 683         return NULL;
 684     }
 685     if (!CryptMsgGetParam(hmsg, CMSG_INNER_CONTENT_TYPE_PARAM, 0, oid, &size)) goto out;
 686     if (!CryptMsgGetParam(hmsg, CMSG_CONTENT_PARAM, 0, NULL, &size)) goto out;
 687     if (!(buffer = HeapAlloc(GetProcessHeap(), 0, size)))
 688     {
 689         SetLastError(ERROR_OUTOFMEMORY);
 690         goto out;
 691     }
 692     if (!CryptMsgGetParam(hmsg, CMSG_CONTENT_PARAM, 0, buffer, &size)) goto out;
 693     if (!CryptDecodeObject(encoding, oid, buffer, size, 0, NULL, &size)) goto out;
 694     if (!(inner = HeapAlloc(GetProcessHeap(), 0, size)))
 695     {
 696         SetLastError(ERROR_OUTOFMEMORY);
 697         goto out;
 698     }
 699     if (!CryptDecodeObject(encoding, oid, buffer, size, 0, inner, &size)) goto out;
 700     *len = size;
 701
 702 out:
 703     HeapFree(GetProcessHeap(), 0, oid);
 704     HeapFree(GetProcessHeap(), 0, buffer);
 705     return inner;
 706 }
 707
 708 /***********************************************************************
 709  *      CryptCATCatalogInfoFromContext  (WINTRUST.@)
 710  */
 711 BOOL WINAPI CryptCATCatalogInfoFromContext(HCATINFO hcatinfo, CATALOG_INFO *info, DWORD flags)
 712 {
 713     struct catinfo *ci = hcatinfo;
 714
 715     TRACE("%p, %p, %x\n", hcatinfo, info, flags);
 716
 717     if (!hcatinfo || hcatinfo == INVALID_HANDLE_VALUE || ci->magic != CATINFO_MAGIC ||
 718         flags || !info || info->cbStruct != sizeof(*info))
 719     {
 720         SetLastError(ERROR_INVALID_PARAMETER);
 721         return FALSE;
 722     }
 723     strcpyW(info->wszCatalogFile, ci->file);
 724     return TRUE;
 725 }
 726
 727 /***********************************************************************
 728  *      CryptCATOpen  (WINTRUST.@)
 729  */
 730 HANDLE WINAPI CryptCATOpen(LPWSTR pwszFileName, DWORD fdwOpenFlags, HCRYPTPROV hProv,
 731                            DWORD dwPublicVersion, DWORD dwEncodingType)
 732 {
 733     HANDLE file, hmsg;
 734     BYTE *buffer = NULL;
 735     DWORD size, flags = OPEN_EXISTING;
 736     struct cryptcat *cc;
 737
 738     TRACE("%s, %x, %lx, %x, %x\n", debugstr_w(pwszFileName), fdwOpenFlags,
 739           hProv, dwPublicVersion, dwEncodingType);
 740
 741     if (!pwszFileName)
 742     {
 743         SetLastError(ERROR_INVALID_PARAMETER);
 744         return INVALID_HANDLE_VALUE;
 745     }
 746
 747     if (!dwPublicVersion) dwPublicVersion = 0x00000100;
 748     if (!dwEncodingType)  dwEncodingType  = X509_ASN_ENCODING | PKCS_7_ASN_ENCODING;
 749
 750     if (fdwOpenFlags & CRYPTCAT_OPEN_ALWAYS)    flags |= OPEN_ALWAYS;
 751     if (fdwOpenFlags & CRYPTCAT_OPEN_CREATENEW) flags |= CREATE_NEW;
 752
 753     file = CreateFileW(pwszFileName, GENERIC_READ, FILE_SHARE_READ, NULL, flags, 0, NULL);
 754     if (file == INVALID_HANDLE_VALUE) return INVALID_HANDLE_VALUE;
 755
 756     size = GetFileSize(file, NULL);
 757     if (!(buffer = HeapAlloc(GetProcessHeap(), 0, size)))
 758     {
 759         CloseHandle(file);
 760         SetLastError(ERROR_OUTOFMEMORY);
 761         return INVALID_HANDLE_VALUE;
 762     }
 763     if (!(hmsg = CryptMsgOpenToDecode(dwEncodingType, 0, 0, hProv, NULL, NULL)))
 764     {
 765         CloseHandle(file);
 766         HeapFree(GetProcessHeap(), 0, buffer);
 767         return INVALID_HANDLE_VALUE;
 768     }
 769     if (!ReadFile(file, buffer, size, &size, NULL) || !CryptMsgUpdate(hmsg, buffer, size, TRUE))
 770     {
 771         CloseHandle(file);
 772         HeapFree(GetProcessHeap(), 0, buffer);
 773         CryptMsgClose(hmsg);
 774         return INVALID_HANDLE_VALUE;
 775     }
 776     HeapFree(GetProcessHeap(), 0, buffer);
 777     CloseHandle(file);
 778
 779     size = sizeof(DWORD);
 780     if (!(cc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*cc))))
 781     {
 782         CryptMsgClose(hmsg);
 783         SetLastError(ERROR_OUTOFMEMORY);
 784         return INVALID_HANDLE_VALUE;
 785     }
 786
 787     cc->msg = hmsg;
 788     cc->encoding = dwEncodingType;
 789     if (CryptMsgGetParam(hmsg, CMSG_ATTR_CERT_COUNT_PARAM, 0, &cc->attr_count, &size))
 790     {
 791         DWORD i, sum = 0;
 792         BYTE *p;
 793
 794         for (i = 0; i < cc->attr_count; i++)
 795         {
 796             if (!CryptMsgGetParam(hmsg, CMSG_ATTR_CERT_PARAM, i, NULL, &size))
 797             {
 798                 CryptMsgClose(hmsg);
 799                 return INVALID_HANDLE_VALUE;
 800             }
 801             sum += size;
 802         }
 803         if (!(cc->attr = HeapAlloc(GetProcessHeap(), 0, sizeof(*cc->attr) * cc->attr_count + sum)))
 804         {
 805             CryptMsgClose(hmsg);
 806             SetLastError(ERROR_OUTOFMEMORY);
 807             return INVALID_HANDLE_VALUE;
 808         }
 809         p = (BYTE *)(cc->attr + cc->attr_count);
 810         for (i = 0; i < cc->attr_count; i++)
 811         {
 812             if (!CryptMsgGetParam(hmsg, CMSG_ATTR_CERT_PARAM, i, NULL, &size))
 813             {
 814                 CryptMsgClose(hmsg);
 815                 HeapFree(GetProcessHeap(), 0, cc->attr);
 816                 return INVALID_HANDLE_VALUE;
 817             }
 818             if (!CryptMsgGetParam(hmsg, CMSG_ATTR_CERT_PARAM, i, p, &size))
 819             {
 820                 CryptMsgClose(hmsg);
 821                 HeapFree(GetProcessHeap(), 0, cc->attr);
 822                 return INVALID_HANDLE_VALUE;
 823             }
 824             p += size;
 825         }
 826         cc->inner = decode_inner_content(hmsg, dwEncodingType, &cc->inner_len);
 827         if (!cc->inner || !CryptSIPRetrieveSubjectGuid(pwszFileName, NULL, &cc->subject))
 828         {
 829             CryptMsgClose(hmsg);
 830             HeapFree(GetProcessHeap(), 0, cc->attr);
 831             HeapFree(GetProcessHeap(), 0, cc->inner);
 832             HeapFree(GetProcessHeap(), 0, cc);
 833             return INVALID_HANDLE_VALUE;
 834         }
 835         cc->magic = CRYPTCAT_MAGIC;
 836         return cc;
 837     }
 838     return INVALID_HANDLE_VALUE;
 839 }
 840
 841 /***********************************************************************
 842  *      CryptSIPCreateIndirectData  (WINTRUST.@)
 843  */
 844 BOOL WINAPI CryptSIPCreateIndirectData(SIP_SUBJECTINFO* pSubjectInfo, DWORD* pcbIndirectData,
 845                                        SIP_INDIRECT_DATA* pIndirectData)
 846 {
 847     FIXME("(%p %p %p) stub\n", pSubjectInfo, pcbIndirectData, pIndirectData);
 848
 849     return FALSE;
 850 }
 851
 852 static BOOL WINTRUST_GetSignedMsgFromPEFile(SIP_SUBJECTINFO *pSubjectInfo,
 853  DWORD *pdwEncodingType, DWORD dwIndex, DWORD *pcbSignedDataMsg,
 854  BYTE *pbSignedDataMsg)
 855 {
 856     BOOL ret;
 857     WIN_CERTIFICATE *pCert = NULL;
 858
 859     TRACE("(%p %p %d %p %p)\n", pSubjectInfo, pdwEncodingType, dwIndex,
 860           pcbSignedDataMsg, pbSignedDataMsg);
 861
 862     if (!pbSignedDataMsg)
 863     {
 864         WIN_CERTIFICATE cert;
 865
 866         /* app hasn't passed buffer, just get the length */
 867         ret = ImageGetCertificateHeader(pSubjectInfo->hFile, dwIndex, &cert);
 868         if (ret)
 869             *pcbSignedDataMsg = cert.dwLength;
 870     }
 871     else
 872     {
 873         DWORD len = 0;
 874
 875         ret = ImageGetCertificateData(pSubjectInfo->hFile, dwIndex, NULL, &len);
 876         if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
 877             goto error;
 878         pCert = HeapAlloc(GetProcessHeap(), 0, len);
 879         if (!pCert)
 880         {
 881             ret = FALSE;
 882             goto error;
 883         }
 884         ret = ImageGetCertificateData(pSubjectInfo->hFile, dwIndex, pCert,
 885          &len);
 886         if (!ret)
 887             goto error;
 888         if (*pcbSignedDataMsg < pCert->dwLength)
 889         {
 890             *pcbSignedDataMsg = pCert->dwLength;
 891             SetLastError(ERROR_INSUFFICIENT_BUFFER);
 892             ret = FALSE;
 893         }
 894         else
 895         {
 896             memcpy(pbSignedDataMsg, pCert->bCertificate, pCert->dwLength);
 897             switch (pCert->wCertificateType)
 898             {
 899             case WIN_CERT_TYPE_X509:
 900                 *pdwEncodingType = X509_ASN_ENCODING;
 901                 break;
 902             case WIN_CERT_TYPE_PKCS_SIGNED_DATA:
 903                 *pdwEncodingType = X509_ASN_ENCODING | PKCS_7_ASN_ENCODING;
 904                 break;
 905             default:
 906                 FIXME("don't know what to do for encoding type %d\n",
 907                  pCert->wCertificateType);
 908                 *pdwEncodingType = 0;
 909             }
 910         }
 911     }
 912 error:
 913     HeapFree(GetProcessHeap(), 0, pCert);
 914     return ret;
 915 }
 916
 917 /* structure offsets */
 918 #define cfhead_Signature         (0x00)
 919 #define cfhead_CabinetSize       (0x08)
 920 #define cfhead_MinorVersion      (0x18)
 921 #define cfhead_MajorVersion      (0x19)
 922 #define cfhead_Flags             (0x1E)
 923 #define cfhead_SIZEOF            (0x24)
 924 #define cfheadext_HeaderReserved (0x00)
 925 #define cfheadext_SIZEOF         (0x04)
 926 #define cfsigninfo_CertOffset    (0x04)
 927 #define cfsigninfo_CertSize      (0x08)
 928 #define cfsigninfo_SIZEOF        (0x0C)
 929
 930 /* flags */
 931 #define cfheadRESERVE_PRESENT          (0x0004)
 932
 933 /* endian-neutral reading of little-endian data */
 934 #define EndGetI32(a)  ((((a)[3])<<24)|(((a)[2])<<16)|(((a)[1])<<8)|((a)[0]))
 935 #define EndGetI16(a)  ((((a)[1])<<8)|((a)[0]))
 936
 937 /* For documentation purposes only:  this is the structure in the reserved
 938  * area of a signed cabinet file.  The cert offset indicates where in the
 939  * cabinet file the signature resides, and the count indicates its size.
 940  */
 941 typedef struct _CAB_SIGNINFO
 942 {
 943     WORD unk0; /* always 0? */
 944     WORD unk1; /* always 0x0010? */
 945     DWORD dwCertOffset;
 946     DWORD cbCertBlock;
 947 } CAB_SIGNINFO, *PCAB_SIGNINFO;
 948
 949 static BOOL WINTRUST_GetSignedMsgFromCabFile(SIP_SUBJECTINFO *pSubjectInfo,
 950  DWORD *pdwEncodingType, DWORD dwIndex, DWORD *pcbSignedDataMsg,
 951  BYTE *pbSignedDataMsg)
 952 {
 953     int header_resv;
 954     LONG base_offset, cabsize;
 955     USHORT flags;
 956     BYTE buf[64];
 957     DWORD cert_offset, cert_size, dwRead;
 958
 959     TRACE("(%p %p %d %p %p)\n", pSubjectInfo, pdwEncodingType, dwIndex,
 960           pcbSignedDataMsg, pbSignedDataMsg);
 961
 962     /*
 963      * FIXME: I just noticed that I am memorizing the initial file pointer
 964      * offset and restoring it before reading in the rest of the header
 965      * information in the cabinet.  Perhaps that's correct -- that is, perhaps
 966      * this API is supposed to support "streaming" cabinets which are embedded
 967      * in other files, or cabinets which begin at file offsets other than zero.
 968      * Otherwise, I should instead go to the absolute beginning of the file.
 969      * (Either way, the semantics of wine's FDICopy require me to leave the
 970      * file pointer where it is afterwards -- If Windows does not do so, we
 971      * ought to duplicate the native behavior in the FDIIsCabinet API, not here.
 972      *
 973      * So, the answer lies in Windows; will native cabinet.dll recognize a
 974      * cabinet "file" embedded in another file?  Note that cabextract.c does
 975      * support this, which implies that Microsoft's might.  I haven't tried it
 976      * yet so I don't know.  ATM, most of wine's FDI cabinet routines (except
 977      * this one) would not work in this way.  To fix it, we could just make the
 978      * various references to absolute file positions in the code relative to an
 979      * initial "beginning" offset.  Because the FDICopy API doesn't take a
 980      * file-handle like this one, we would therein need to search through the
 981      * file for the beginning of the cabinet (as we also do in cabextract.c).
 982      * Note that this limits us to a maximum of one cabinet per. file: the first.
 983      *
 984      * So, in summary: either the code below is wrong, or the rest of fdi.c is
 985      * wrong... I cannot imagine that both are correct ;)  One of these flaws
 986      * should be fixed after determining the behavior on Windows.   We ought
 987      * to check both FDIIsCabinet and FDICopy for the right behavior.
 988      *
 989      * -gmt
 990      */
 991
 992     /* get basic offset & size info */
 993     base_offset = SetFilePointer(pSubjectInfo->hFile, 0L, NULL, SEEK_CUR);
 994
 995     if (SetFilePointer(pSubjectInfo->hFile, 0, NULL, SEEK_END) == INVALID_SET_FILE_POINTER)
 996     {
 997         TRACE("seek error\n");
 998         return FALSE;
 999     }
1000
1001     cabsize = SetFilePointer(pSubjectInfo->hFile, 0L, NULL, SEEK_CUR);
1002     if ((cabsize == -1) || (base_offset == -1) ||
1003      (SetFilePointer(pSubjectInfo->hFile, base_offset, NULL, SEEK_SET) == INVALID_SET_FILE_POINTER))
1004     {
1005         TRACE("seek error\n");
1006         return FALSE;
1007     }
1008
1009     /* read in the CFHEADER */
1010     if (!ReadFile(pSubjectInfo->hFile, buf, cfhead_SIZEOF, &dwRead, NULL) ||
1011      dwRead != cfhead_SIZEOF)
1012     {
1013         TRACE("reading header failed\n");
1014         return FALSE;
1015     }
1016
1017     /* check basic MSCF signature */
1018     if (EndGetI32(buf+cfhead_Signature) != 0x4643534d)
1019     {
1020         WARN("cabinet signature not present\n");
1021         return FALSE;
1022     }
1023
1024     /* Ignore the number of folders and files and the set and cabinet IDs */
1025
1026     /* check the header revision */
1027     if ((buf[cfhead_MajorVersion] > 1) ||
1028         (buf[cfhead_MajorVersion] == 1 && buf[cfhead_MinorVersion] > 3))
1029     {
1030         WARN("cabinet format version > 1.3\n");
1031         return FALSE;
1032     }
1033
1034     /* pull the flags out */
1035     flags = EndGetI16(buf+cfhead_Flags);
1036
1037     if (!(flags & cfheadRESERVE_PRESENT))
1038     {
1039         TRACE("no header present, not signed\n");
1040         return FALSE;
1041     }
1042
1043     if (!ReadFile(pSubjectInfo->hFile, buf, cfheadext_SIZEOF, &dwRead, NULL) ||
1044      dwRead != cfheadext_SIZEOF)
1045     {
1046         ERR("bunk reserve-sizes?\n");
1047         return FALSE;
1048     }
1049
1050     header_resv = EndGetI16(buf+cfheadext_HeaderReserved);
1051     if (!header_resv)
1052     {
1053         TRACE("no header_resv, not signed\n");
1054         return FALSE;
1055     }
1056     else if (header_resv < cfsigninfo_SIZEOF)
1057     {
1058         TRACE("header_resv too small, not signed\n");
1059         return FALSE;
1060     }
1061
1062     if (header_resv > 60000)
1063     {
1064         WARN("WARNING; header reserved space > 60000\n");
1065     }
1066
1067     if (!ReadFile(pSubjectInfo->hFile, buf, cfsigninfo_SIZEOF, &dwRead, NULL) ||
1068      dwRead != cfsigninfo_SIZEOF)
1069     {
1070         ERR("couldn't read reserve\n");
1071         return FALSE;
1072     }
1073
1074     cert_offset = EndGetI32(buf+cfsigninfo_CertOffset);
1075     TRACE("cert_offset: %d\n", cert_offset);
1076     cert_size = EndGetI32(buf+cfsigninfo_CertSize);
1077     TRACE("cert_size: %d\n", cert_size);
1078
1079     /* The redundant checks are to avoid wraparound */
1080     if (cert_offset > cabsize || cert_size > cabsize ||
1081      cert_offset + cert_size > cabsize)
1082     {
1083         WARN("offset beyond file, not attempting to read\n");
1084         return FALSE;
1085     }
1086
1087     SetFilePointer(pSubjectInfo->hFile, base_offset, NULL, SEEK_SET);
1088     if (!pbSignedDataMsg)
1089     {
1090         *pcbSignedDataMsg = cert_size;
1091         return TRUE;
1092     }
1093     if (*pcbSignedDataMsg < cert_size)
1094     {
1095         *pcbSignedDataMsg = cert_size;
1096         SetLastError(ERROR_INSUFFICIENT_BUFFER);
1097         return FALSE;
1098     }
1099     if (SetFilePointer(pSubjectInfo->hFile, cert_offset, NULL, SEEK_SET) == INVALID_SET_FILE_POINTER)
1100     {
1101         ERR("couldn't seek to cert location\n");
1102         return FALSE;
1103     }
1104     if (!ReadFile(pSubjectInfo->hFile, pbSignedDataMsg, cert_size, &dwRead,
1105      NULL) || dwRead != cert_size)
1106     {
1107         ERR("couldn't read cert\n");
1108         return FALSE;
1109     }
1110     /* The encoding of the files I've seen appears to be in ASN.1
1111      * format, and there isn't a field indicating the type, so assume it
1112      * always is.
1113      */
1114     *pdwEncodingType = X509_ASN_ENCODING | PKCS_7_ASN_ENCODING;
1115     return TRUE;
1116 }
1117
1118 static BOOL WINTRUST_GetSignedMsgFromCatFile(SIP_SUBJECTINFO *pSubjectInfo,
1119  DWORD *pdwEncodingType, DWORD dwIndex, DWORD *pcbSignedDataMsg,
1120  BYTE *pbSignedDataMsg)
1121 {
1122     BOOL ret;
1123
1124     TRACE("(%p %p %d %p %p)\n", pSubjectInfo, pdwEncodingType, dwIndex,
1125           pcbSignedDataMsg, pbSignedDataMsg);
1126
1127     if (!pbSignedDataMsg)
1128     {
1129         *pcbSignedDataMsg = GetFileSize(pSubjectInfo->hFile, NULL);
1130          ret = TRUE;
1131     }
1132     else
1133     {
1134         DWORD len = GetFileSize(pSubjectInfo->hFile, NULL);
1135
1136         if (*pcbSignedDataMsg < len)
1137         {
1138             *pcbSignedDataMsg = len;
1139             SetLastError(ERROR_INSUFFICIENT_BUFFER);
1140             ret = FALSE;
1141         }
1142         else
1143         {
1144             ret = ReadFile(pSubjectInfo->hFile, pbSignedDataMsg, len,
1145              pcbSignedDataMsg, NULL);
1146             if (ret)
1147                 *pdwEncodingType = X509_ASN_ENCODING | PKCS_7_ASN_ENCODING;
1148         }
1149     }
1150     return ret;
1151 }
1152
1153 /***********************************************************************
1154  *      CryptSIPGetSignedDataMsg  (WINTRUST.@)
1155  */
1156 BOOL WINAPI CryptSIPGetSignedDataMsg(SIP_SUBJECTINFO* pSubjectInfo, DWORD* pdwEncodingType,
1157                                        DWORD dwIndex, DWORD* pcbSignedDataMsg, BYTE* pbSignedDataMsg)
1158 {
1159     static const GUID unknown = { 0xC689AAB8, 0x8E78, 0x11D0, { 0x8C,0x47,
1160      0x00,0xC0,0x4F,0xC2,0x95,0xEE } };
1161     static const GUID cabGUID = { 0xC689AABA, 0x8E78, 0x11D0, { 0x8C,0x47,
1162      0x00,0xC0,0x4F,0xC2,0x95,0xEE } };
1163     static const GUID catGUID = { 0xDE351A43, 0x8E59, 0x11D0, { 0x8C,0x47,
1164      0x00,0xC0,0x4F,0xC2,0x95,0xEE }};
1165     BOOL ret;
1166
1167     TRACE("(%p %p %d %p %p)\n", pSubjectInfo, pdwEncodingType, dwIndex,
1168           pcbSignedDataMsg, pbSignedDataMsg);
1169
1170     if (!memcmp(pSubjectInfo->pgSubjectType, &unknown, sizeof(unknown)))
1171         ret = WINTRUST_GetSignedMsgFromPEFile(pSubjectInfo, pdwEncodingType,
1172          dwIndex, pcbSignedDataMsg, pbSignedDataMsg);
1173     else if (!memcmp(pSubjectInfo->pgSubjectType, &cabGUID, sizeof(cabGUID)))
1174         ret = WINTRUST_GetSignedMsgFromCabFile(pSubjectInfo, pdwEncodingType,
1175          dwIndex, pcbSignedDataMsg, pbSignedDataMsg);
1176     else if (!memcmp(pSubjectInfo->pgSubjectType, &catGUID, sizeof(catGUID)))
1177         ret = WINTRUST_GetSignedMsgFromCatFile(pSubjectInfo, pdwEncodingType,
1178          dwIndex, pcbSignedDataMsg, pbSignedDataMsg);
1179     else
1180     {
1181         FIXME("unimplemented for subject type %s\n",
1182          debugstr_guid(pSubjectInfo->pgSubjectType));
1183         ret = FALSE;
1184     }
1185
1186     TRACE("returning %d\n", ret);
1187     return ret;
1188 }
1189
1190 /***********************************************************************
1191  *      CryptSIPPutSignedDataMsg  (WINTRUST.@)
1192  */
1193 BOOL WINAPI CryptSIPPutSignedDataMsg(SIP_SUBJECTINFO* pSubjectInfo, DWORD pdwEncodingType,
1194                                        DWORD* pdwIndex, DWORD cbSignedDataMsg, BYTE* pbSignedDataMsg)
1195 {
1196     FIXME("(%p %d %p %d %p) stub\n", pSubjectInfo, pdwEncodingType, pdwIndex,
1197           cbSignedDataMsg, pbSignedDataMsg);
1198
1199     return FALSE;
1200 }
1201
1202 /***********************************************************************
1203  *      CryptSIPRemoveSignedDataMsg  (WINTRUST.@)
1204  */
1205 BOOL WINAPI CryptSIPRemoveSignedDataMsg(SIP_SUBJECTINFO* pSubjectInfo,
1206                                        DWORD dwIndex)
1207 {
1208     FIXME("(%p %d) stub\n", pSubjectInfo, dwIndex);
1209
1210     return FALSE;
1211 }
1212
1213 /***********************************************************************
1214  *      CryptSIPVerifyIndirectData  (WINTRUST.@)
1215  */
1216 BOOL WINAPI CryptSIPVerifyIndirectData(SIP_SUBJECTINFO* pSubjectInfo,
1217                                        SIP_INDIRECT_DATA* pIndirectData)
1218 {
1219     FIXME("(%p %p) stub\n", pSubjectInfo, pIndirectData);
1220
1221     return FALSE;
1222 }