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
  37 WINE_DEFAULT_DEBUG_CHANNEL(wintrust);
  38
  39 #define CATADMIN_MAGIC 0x43415441 /* 'CATA' */
  40 #define CRYPTCAT_MAGIC 0x43415443 /* 'CATC' */
  41 #define CATINFO_MAGIC  0x43415449 /* 'CATI' */
  42
  43 struct cryptcat
  44 {
  45     DWORD     magic;
  46     HCRYPTMSG msg;
  47     DWORD     encoding;
  48     CTL_INFO *inner;
  49     DWORD     inner_len;
  50     GUID      subject;
  51     DWORD     attr_count;
  52     CRYPTCATATTRIBUTE *attr;
  53 };
  54
  55 struct catadmin
  56 {
  57     DWORD magic;
  58     WCHAR path[MAX_PATH];
  59     HANDLE find;
  60 };
  61
  62 struct catinfo
  63 {
  64     DWORD magic;
  65     WCHAR file[MAX_PATH];
  66 };
  67
  68 static HCATINFO create_catinfo(const WCHAR *filename)
  69 {
  70     struct catinfo *ci;
  71
  72     if (!(ci = HeapAlloc(GetProcessHeap(), 0, sizeof(*ci))))
  73     {
  74         SetLastError(ERROR_OUTOFMEMORY);
  75         return INVALID_HANDLE_VALUE;
  76     }
  77     lstrcpyW(ci->file, filename);
  78     ci->magic = CATINFO_MAGIC;
  79     return ci;
  80 }
  81
  82 /***********************************************************************
  83  *      CryptCATAdminAcquireContext (WINTRUST.@)
  84  *
  85  * Get a catalog administrator context handle.
  86  *
  87  * PARAMS
  88  *   catAdmin  [O] Pointer to the context handle.
  89  *   sys       [I] Pointer to a GUID for the needed subsystem.
  90  *   dwFlags   [I] Reserved.
  91  *
  92  * RETURNS
  93  *   Success: TRUE. catAdmin contains the context handle.
  94  *   Failure: FALSE.
  95  *
  96  */
  97 BOOL WINAPI CryptCATAdminAcquireContext(HCATADMIN *catAdmin,
  98                                         const GUID *sys, DWORD dwFlags)
  99 {
 100     static const WCHAR catroot[] =
 101         {'\\','c','a','t','r','o','o','t',0};
 102     static const WCHAR fmt[] =
 103         {'%','s','\\','{','%','0','8','x','-','%','0','4','x','-','%','0',
 104          '4','x','-','%','0','2','x','%','0','2','x','-','%','0','2','x',
 105          '%','0','2','x','%','0','2','x','%','0','2','x','%','0','2','x',
 106          '%','0','2','x','}',0};
 107     static const GUID defsys =
 108         {0x127d0a1d,0x4ef2,0x11d1,{0x86,0x08,0x00,0xc0,0x4f,0xc2,0x95,0xee}};
 109
 110     WCHAR catroot_dir[MAX_PATH];
 111     struct catadmin *ca;
 112
 113     TRACE("%p %s %x\n", catAdmin, debugstr_guid(sys), dwFlags);
 114
 115     if (!catAdmin || dwFlags)
 116     {
 117         SetLastError(ERROR_INVALID_PARAMETER);
 118         return FALSE;
 119     }
 120     if (!(ca = HeapAlloc(GetProcessHeap(), 0, sizeof(*ca))))
 121     {
 122         SetLastError(ERROR_OUTOFMEMORY);
 123         return FALSE;
 124     }
 125
 126     GetSystemDirectoryW(catroot_dir, MAX_PATH);
 127     lstrcatW(catroot_dir, catroot);
 128
 129     /* create the directory if it doesn't exist */
 130     CreateDirectoryW(catroot_dir, NULL);
 131
 132     if (!sys) sys = &defsys;
 133     swprintf(ca->path, ARRAY_SIZE(ca->path), fmt, catroot_dir, sys->Data1, sys->Data2,
 134              sys->Data3, sys->Data4[0], sys->Data4[1], sys->Data4[2],
 135              sys->Data4[3], sys->Data4[4], sys->Data4[5], sys->Data4[6],
 136              sys->Data4[7]);
 137
 138     /* create the directory if it doesn't exist */
 139     CreateDirectoryW(ca->path, NULL);
 140
 141     ca->magic = CATADMIN_MAGIC;
 142     ca->find = INVALID_HANDLE_VALUE;
 143
 144     *catAdmin = ca;
 145     return TRUE;
 146 }
 147
 148 /***********************************************************************
 149  *             CryptCATAdminAcquireContext2 (WINTRUST.@)
 150  */
 151 BOOL WINAPI CryptCATAdminAcquireContext2(HCATADMIN *catAdmin, const GUID *sys, const WCHAR *algorithm,
 152                                          const CERT_STRONG_SIGN_PARA *policy, DWORD flags)
 153 {
 154     FIXME("%p %s %s %p %x stub\n", catAdmin, debugstr_guid(sys), debugstr_w(algorithm), policy, flags);
 155     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 156     return FALSE;
 157 }
 158
 159 /***********************************************************************
 160  *             CryptCATAdminAddCatalog (WINTRUST.@)
 161  */
 162 HCATINFO WINAPI CryptCATAdminAddCatalog(HCATADMIN catAdmin, PWSTR catalogFile,
 163                                         PWSTR selectBaseName, DWORD flags)
 164 {
 165     static const WCHAR slashW[] = {'\\',0};
 166     struct catadmin *ca = catAdmin;
 167     struct catinfo *ci;
 168     WCHAR *target;
 169     DWORD len;
 170
 171     TRACE("%p %s %s %d\n", catAdmin, debugstr_w(catalogFile),
 172           debugstr_w(selectBaseName), flags);
 173
 174     if (!selectBaseName)
 175     {
 176         FIXME("NULL basename not handled\n");
 177         SetLastError(ERROR_INVALID_PARAMETER);
 178         return NULL;
 179     }
 180     if (!ca || ca->magic != CATADMIN_MAGIC || !catalogFile || flags)
 181     {
 182         SetLastError(ERROR_INVALID_PARAMETER);
 183         return NULL;
 184     }
 185
 186     len = lstrlenW(ca->path) + lstrlenW(selectBaseName) + 2;
 187     if (!(target = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR))))
 188     {
 189         SetLastError(ERROR_OUTOFMEMORY);
 190         return NULL;
 191     }
 192     lstrcpyW(target, ca->path);
 193     lstrcatW(target, slashW);
 194     lstrcatW(target, selectBaseName);
 195
 196     if (!CopyFileW(catalogFile, target, FALSE))
 197     {
 198         HeapFree(GetProcessHeap(), 0, target);
 199         return NULL;
 200     }
 201     SetFileAttributesW(target, FILE_ATTRIBUTE_SYSTEM);
 202
 203     if (!(ci = HeapAlloc(GetProcessHeap(), 0, sizeof(*ci))))
 204     {
 205         HeapFree(GetProcessHeap(), 0, target);
 206         SetLastError(ERROR_OUTOFMEMORY);
 207         return NULL;
 208     }
 209     ci->magic = CATINFO_MAGIC;
 210     lstrcpyW(ci->file, target);
 211
 212     HeapFree(GetProcessHeap(), 0, target);
 213     return ci;
 214 }
 215
 216 /***********************************************************************
 217  *             CryptCATAdminCalcHashFromFileHandle (WINTRUST.@)
 218  */
 219 BOOL WINAPI CryptCATAdminCalcHashFromFileHandle(HANDLE hFile, DWORD* pcbHash,
 220                                                 BYTE* pbHash, DWORD dwFlags )
 221 {
 222     BOOL ret = FALSE;
 223
 224     TRACE("%p %p %p %x\n", hFile, pcbHash, pbHash, dwFlags);
 225
 226     if (!hFile || !pcbHash || dwFlags)
 227     {
 228         SetLastError(ERROR_INVALID_PARAMETER);
 229         return FALSE;
 230     }
 231     if (*pcbHash < 20)
 232     {
 233         *pcbHash = 20;
 234         SetLastError(ERROR_INSUFFICIENT_BUFFER);
 235         return TRUE;
 236     }
 237
 238     *pcbHash = 20;
 239     if (pbHash)
 240     {
 241         HCRYPTPROV prov;
 242         HCRYPTHASH hash;
 243         DWORD bytes_read;
 244         BYTE *buffer;
 245
 246         if (!(buffer = HeapAlloc(GetProcessHeap(), 0, 4096)))
 247         {
 248             SetLastError(ERROR_OUTOFMEMORY);
 249             return FALSE;
 250         }
 251         ret = CryptAcquireContextW(&prov, NULL, MS_DEF_PROV_W, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);
 252         if (!ret)
 253         {
 254             HeapFree(GetProcessHeap(), 0, buffer);
 255             return FALSE;
 256         }
 257         ret = CryptCreateHash(prov, CALG_SHA1, 0, 0, &hash);
 258         if (!ret)
 259         {
 260             HeapFree(GetProcessHeap(), 0, buffer);
 261             CryptReleaseContext(prov, 0);
 262             return FALSE;
 263         }
 264         while ((ret = ReadFile(hFile, buffer, 4096, &bytes_read, NULL)) && bytes_read)
 265         {
 266             CryptHashData(hash, buffer, bytes_read, 0);
 267         }
 268         if (ret) ret = CryptGetHashParam(hash, HP_HASHVAL, pbHash, pcbHash, 0);
 269
 270         HeapFree(GetProcessHeap(), 0, buffer);
 271         CryptDestroyHash(hash);
 272         CryptReleaseContext(prov, 0);
 273     }
 274     return ret;
 275 }
 276
 277 /***********************************************************************
 278  *             CryptCATAdminEnumCatalogFromHash (WINTRUST.@)
 279  */
 280 HCATINFO WINAPI CryptCATAdminEnumCatalogFromHash(HCATADMIN hCatAdmin, BYTE* pbHash,
 281                                                  DWORD cbHash, DWORD dwFlags,
 282                                                  HCATINFO* phPrevCatInfo )
 283 {
 284     static const WCHAR slashW[] = {'\\',0};
 285     static const WCHAR globW[]  = {'\\','*','.','c','a','t',0};
 286
 287     struct catadmin *ca = hCatAdmin;
 288     WIN32_FIND_DATAW data;
 289     HCATINFO prev = NULL;
 290     HCRYPTPROV prov;
 291     DWORD size;
 292     BOOL ret;
 293
 294     TRACE("%p %p %d %x %p\n", hCatAdmin, pbHash, cbHash, dwFlags, phPrevCatInfo);
 295
 296     if (!ca || ca->magic != CATADMIN_MAGIC || !pbHash || cbHash != 20 || dwFlags)
 297     {
 298         SetLastError(ERROR_INVALID_PARAMETER);
 299         return NULL;
 300     }
 301     if (phPrevCatInfo) prev = *phPrevCatInfo;
 302
 303     ret = CryptAcquireContextW(&prov, NULL, MS_DEF_PROV_W, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);
 304     if (!ret) return NULL;
 305
 306     if (!prev)
 307     {
 308         WCHAR *path;
 309
 310         size = lstrlenW(ca->path) * sizeof(WCHAR) + sizeof(globW);
 311         if (!(path = HeapAlloc(GetProcessHeap(), 0, size)))
 312         {
 313             CryptReleaseContext(prov, 0);
 314             SetLastError(ERROR_OUTOFMEMORY);
 315             return NULL;
 316         }
 317         lstrcpyW(path, ca->path);
 318         lstrcatW(path, globW);
 319
 320         FindClose(ca->find);
 321         ca->find = FindFirstFileW(path, &data);
 322
 323         HeapFree(GetProcessHeap(), 0, path);
 324         if (ca->find == INVALID_HANDLE_VALUE)
 325         {
 326             CryptReleaseContext(prov, 0);
 327             return NULL;
 328         }
 329     }
 330     else if (!FindNextFileW(ca->find, &data))
 331     {
 332         CryptCATAdminReleaseCatalogContext(hCatAdmin, prev, 0);
 333         CryptReleaseContext(prov, 0);
 334         return NULL;
 335     }
 336
 337     while (1)
 338     {
 339         WCHAR *filename;
 340         CRYPTCATMEMBER *member = NULL;
 341         struct catinfo *ci;
 342         HANDLE hcat;
 343
 344         size = (lstrlenW(ca->path) + lstrlenW(data.cFileName) + 2) * sizeof(WCHAR);
 345         if (!(filename = HeapAlloc(GetProcessHeap(), 0, size)))
 346         {
 347             SetLastError(ERROR_OUTOFMEMORY);
 348             return NULL;
 349         }
 350         lstrcpyW(filename, ca->path);
 351         lstrcatW(filename, slashW);
 352         lstrcatW(filename, data.cFileName);
 353
 354         hcat = CryptCATOpen(filename, CRYPTCAT_OPEN_EXISTING, prov, 0, 0);
 355         if (hcat == INVALID_HANDLE_VALUE)
 356         {
 357             WARN("couldn't open %s (%u)\n", debugstr_w(filename), GetLastError());
 358             continue;
 359         }
 360         while ((member = CryptCATEnumerateMember(hcat, member)))
 361         {
 362             if (member->pIndirectData->Digest.cbData != cbHash)
 363             {
 364                 WARN("amount of hash bytes differs: %u/%u\n", member->pIndirectData->Digest.cbData, cbHash);
 365                 continue;
 366             }
 367             if (!memcmp(member->pIndirectData->Digest.pbData, pbHash, cbHash))
 368             {
 369                 TRACE("file %s matches\n", debugstr_w(data.cFileName));
 370
 371                 CryptCATClose(hcat);
 372                 CryptReleaseContext(prov, 0);
 373                 if (!phPrevCatInfo)
 374                 {
 375                     FindClose(ca->find);
 376                     ca->find = INVALID_HANDLE_VALUE;
 377                 }
 378                 ci = create_catinfo(filename);
 379                 HeapFree(GetProcessHeap(), 0, filename);
 380                 return ci;
 381             }
 382         }
 383         CryptCATClose(hcat);
 384         HeapFree(GetProcessHeap(), 0, filename);
 385
 386         if (!FindNextFileW(ca->find, &data))
 387         {
 388             FindClose(ca->find);
 389             ca->find = INVALID_HANDLE_VALUE;
 390             CryptReleaseContext(prov, 0);
 391             return NULL;
 392         }
 393     }
 394     return NULL;
 395 }
 396
 397 /***********************************************************************
 398  *      CryptCATAdminReleaseCatalogContext (WINTRUST.@)
 399  *
 400  * Release a catalog context handle.
 401  *
 402  * PARAMS
 403  *   hCatAdmin [I] Context handle.
 404  *   hCatInfo  [I] Catalog handle.
 405  *   dwFlags   [I] Reserved.
 406  *
 407  * RETURNS
 408  *   Success: TRUE.
 409  *   Failure: FALSE.
 410  *
 411  */
 412 BOOL WINAPI CryptCATAdminReleaseCatalogContext(HCATADMIN hCatAdmin,
 413                                                HCATINFO hCatInfo,
 414                                                DWORD dwFlags)
 415 {
 416     struct catinfo *ci = hCatInfo;
 417     struct catadmin *ca = hCatAdmin;
 418
 419     TRACE("%p %p %x\n", hCatAdmin, hCatInfo, dwFlags);
 420
 421     if (!ca || ca->magic != CATADMIN_MAGIC || !ci || ci->magic != CATINFO_MAGIC)
 422     {
 423         SetLastError(ERROR_INVALID_PARAMETER);
 424         return FALSE;
 425     }
 426     ci->magic = 0;
 427     return HeapFree(GetProcessHeap(), 0, ci);
 428 }
 429
 430 /***********************************************************************
 431  *      CryptCATAdminReleaseContext (WINTRUST.@)
 432  *
 433  * Release a catalog administrator context handle.
 434  *
 435  * PARAMS
 436  *   catAdmin  [I] Context handle.
 437  *   dwFlags   [I] Reserved.
 438  *
 439  * RETURNS
 440  *   Success: TRUE.
 441  *   Failure: FALSE.
 442  *
 443  */
 444 BOOL WINAPI CryptCATAdminReleaseContext(HCATADMIN hCatAdmin, DWORD dwFlags )
 445 {
 446     struct catadmin *ca = hCatAdmin;
 447
 448     TRACE("%p %x\n", hCatAdmin, dwFlags);
 449
 450     if (!ca || ca->magic != CATADMIN_MAGIC)
 451     {
 452         SetLastError(ERROR_INVALID_PARAMETER);
 453         return FALSE;
 454     }
 455     if (ca->find != INVALID_HANDLE_VALUE) FindClose(ca->find);
 456     ca->magic = 0;
 457     return HeapFree(GetProcessHeap(), 0, ca);
 458 }
 459
 460 /***********************************************************************
 461  *      CryptCATAdminRemoveCatalog (WINTRUST.@)
 462  *
 463  * Remove a catalog file.
 464  *
 465  * PARAMS
 466  *   catAdmin         [I] Context handle.
 467  *   pwszCatalogFile  [I] Catalog file.
 468  *   dwFlags          [I] Reserved.
 469  *
 470  * RETURNS
 471  *   Success: TRUE.
 472  *   Failure: FALSE.
 473  *
 474  */
 475 BOOL WINAPI CryptCATAdminRemoveCatalog(HCATADMIN hCatAdmin, LPCWSTR pwszCatalogFile, DWORD dwFlags)
 476 {
 477     struct catadmin *ca = hCatAdmin;
 478
 479     TRACE("%p %s %x\n", hCatAdmin, debugstr_w(pwszCatalogFile), dwFlags);
 480
 481     if (!ca || ca->magic != CATADMIN_MAGIC)
 482     {
 483         SetLastError(ERROR_INVALID_PARAMETER);
 484         return FALSE;
 485     }
 486
 487     /* Only delete when there is a filename and no path */
 488     if (pwszCatalogFile && pwszCatalogFile[0] != 0 &&
 489         !wcschr(pwszCatalogFile, '\\') && !wcschr(pwszCatalogFile, '/') &&
 490         !wcschr(pwszCatalogFile, ':'))
 491     {
 492         static const WCHAR slashW[] = {'\\',0};
 493         WCHAR *target;
 494         DWORD len;
 495
 496         len = lstrlenW(ca->path) + lstrlenW(pwszCatalogFile) + 2;
 497         if (!(target = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR))))
 498         {
 499             SetLastError(ERROR_OUTOFMEMORY);
 500             return FALSE;
 501         }
 502         lstrcpyW(target, ca->path);
 503         lstrcatW(target, slashW);
 504         lstrcatW(target, pwszCatalogFile);
 505
 506         DeleteFileW(target);
 507
 508         HeapFree(GetProcessHeap(), 0, target);
 509     }
 510
 511     return TRUE;
 512 }
 513
 514 /***********************************************************************
 515  *      CryptCATAdminResolveCatalogPath  (WINTRUST.@)
 516  */
 517 BOOL WINAPI CryptCATAdminResolveCatalogPath(HCATADMIN hcatadmin, WCHAR *catalog_file,
 518                                             CATALOG_INFO *info, DWORD flags)
 519 {
 520     static const WCHAR slashW[] = {'\\',0};
 521     struct catadmin *ca = hcatadmin;
 522
 523     TRACE("%p %s %p %x\n", hcatadmin, debugstr_w(catalog_file), info, flags);
 524
 525     if (!ca || ca->magic != CATADMIN_MAGIC || !info || info->cbStruct != sizeof(*info) || flags)
 526     {
 527         SetLastError(ERROR_INVALID_PARAMETER);
 528         return FALSE;
 529     }
 530     lstrcpyW(info->wszCatalogFile, ca->path);
 531     lstrcatW(info->wszCatalogFile, slashW);
 532     lstrcatW(info->wszCatalogFile, catalog_file);
 533
 534     return TRUE;
 535 }
 536
 537 /***********************************************************************
 538  *      CryptCATClose  (WINTRUST.@)
 539  */
 540 BOOL WINAPI CryptCATClose(HANDLE hCatalog)
 541 {
 542     struct cryptcat *cc = hCatalog;
 543
 544     TRACE("(%p)\n", hCatalog);
 545
 546     if (!hCatalog || hCatalog == INVALID_HANDLE_VALUE || cc->magic != CRYPTCAT_MAGIC)
 547     {
 548         SetLastError(ERROR_INVALID_PARAMETER);
 549         return FALSE;
 550     }
 551     HeapFree(GetProcessHeap(), 0, cc->attr);
 552     HeapFree(GetProcessHeap(), 0, cc->inner);
 553     CryptMsgClose(cc->msg);
 554
 555     cc->magic = 0;
 556     HeapFree(GetProcessHeap(), 0, cc);
 557     return TRUE;
 558 }
 559
 560 /***********************************************************************
 561  *      CryptCATGetAttrInfo  (WINTRUST.@)
 562  */
 563 CRYPTCATATTRIBUTE * WINAPI CryptCATGetAttrInfo(HANDLE hCatalog, CRYPTCATMEMBER *member, LPWSTR tag)
 564 {
 565     struct cryptcat *cc = hCatalog;
 566
 567     FIXME("%p, %p, %s\n", hCatalog, member, debugstr_w(tag));
 568
 569     if (!hCatalog || hCatalog == INVALID_HANDLE_VALUE || cc->magic != CRYPTCAT_MAGIC)
 570     {
 571         SetLastError(ERROR_INVALID_PARAMETER);
 572         return NULL;
 573     }
 574     SetLastError(CRYPT_E_NOT_FOUND);
 575     return NULL;
 576 }
 577
 578 /***********************************************************************
 579  *      CryptCATGetCatAttrInfo  (WINTRUST.@)
 580  */
 581 CRYPTCATATTRIBUTE * WINAPI CryptCATGetCatAttrInfo(HANDLE hCatalog, LPWSTR tag)
 582 {
 583     struct cryptcat *cc = hCatalog;
 584
 585     FIXME("%p, %s\n", hCatalog, debugstr_w(tag));
 586
 587     if (!hCatalog || hCatalog == INVALID_HANDLE_VALUE || cc->magic != CRYPTCAT_MAGIC)
 588     {
 589         SetLastError(ERROR_INVALID_PARAMETER);
 590         return NULL;
 591     }
 592     SetLastError(CRYPT_E_NOT_FOUND);
 593     return NULL;
 594 }
 595
 596 CRYPTCATMEMBER * WINAPI CryptCATGetMemberInfo(HANDLE hCatalog, LPWSTR tag)
 597 {
 598     struct cryptcat *cc = hCatalog;
 599
 600     FIXME("%p, %s\n", hCatalog, debugstr_w(tag));
 601
 602     if (!hCatalog || hCatalog == INVALID_HANDLE_VALUE || cc->magic != CRYPTCAT_MAGIC)
 603     {
 604         SetLastError(ERROR_INVALID_PARAMETER);
 605         return NULL;
 606     }
 607     SetLastError(CRYPT_E_NOT_FOUND);
 608     return NULL;
 609 }
 610
 611 /***********************************************************************
 612  *      CryptCATEnumerateAttr  (WINTRUST.@)
 613  */
 614 CRYPTCATATTRIBUTE * WINAPI CryptCATEnumerateAttr(HANDLE hCatalog, CRYPTCATMEMBER *member, CRYPTCATATTRIBUTE *prev)
 615 {
 616     struct cryptcat *cc = hCatalog;
 617
 618     FIXME("%p, %p, %p\n", hCatalog, member, prev);
 619
 620     if (!hCatalog || hCatalog == INVALID_HANDLE_VALUE || cc->magic != CRYPTCAT_MAGIC)
 621     {
 622         SetLastError(ERROR_INVALID_PARAMETER);
 623         return NULL;
 624     }
 625     SetLastError(CRYPT_E_NOT_FOUND);
 626     return NULL;
 627 }
 628
 629 /***********************************************************************
 630  *      CryptCATEnumerateCatAttr  (WINTRUST.@)
 631  */
 632 CRYPTCATATTRIBUTE * WINAPI CryptCATEnumerateCatAttr(HANDLE hCatalog, CRYPTCATATTRIBUTE *prev)
 633 {
 634     struct cryptcat *cc = hCatalog;
 635
 636     FIXME("%p, %p\n", hCatalog, prev);
 637
 638     if (!hCatalog || hCatalog == INVALID_HANDLE_VALUE || cc->magic != CRYPTCAT_MAGIC)
 639     {
 640         SetLastError(ERROR_INVALID_PARAMETER);
 641         return NULL;
 642     }
 643     SetLastError(CRYPT_E_NOT_FOUND);
 644     return NULL;
 645 }
 646
 647 /***********************************************************************
 648  *      CryptCATEnumerateMember  (WINTRUST.@)
 649  */
 650 CRYPTCATMEMBER * WINAPI CryptCATEnumerateMember(HANDLE hCatalog, CRYPTCATMEMBER *prev)
 651 {
 652     struct cryptcat *cc = hCatalog;
 653     CRYPTCATMEMBER *member = prev;
 654     CTL_ENTRY *entry;
 655     DWORD size, i;
 656
 657     TRACE("%p, %p\n", hCatalog, prev);
 658
 659     if (!hCatalog || hCatalog == INVALID_HANDLE_VALUE || cc->magic != CRYPTCAT_MAGIC)
 660     {
 661         SetLastError(ERROR_INVALID_PARAMETER);
 662         return NULL;
 663     }
 664
 665     /* dumping the contents makes me think that dwReserved is the iteration number */
 666     if (!member)
 667     {
 668         if (!(member = HeapAlloc(GetProcessHeap(), 0, sizeof(*member))))
 669         {
 670             SetLastError(ERROR_OUTOFMEMORY);
 671             return NULL;
 672         }
 673         member->cbStruct = sizeof(*member);
 674         member->pwszFileName = member->pwszReferenceTag = NULL;
 675         member->dwReserved = 0;
 676         member->hReserved = NULL;
 677         member->gSubjectType = cc->subject;
 678         member->fdwMemberFlags = 0;
 679         member->pIndirectData = NULL;
 680         member->dwCertVersion = cc->inner->dwVersion;
 681     }
 682     else member->dwReserved++;
 683
 684     if (member->dwReserved >= cc->inner->cCTLEntry)
 685     {
 686         SetLastError(ERROR_INVALID_PARAMETER);
 687         goto error;
 688     }
 689
 690     /* list them backwards, like native */
 691     entry = &cc->inner->rgCTLEntry[cc->inner->cCTLEntry - member->dwReserved - 1];
 692
 693     member->sEncodedIndirectData.cbData = member->sEncodedMemberInfo.cbData = 0;
 694     member->sEncodedIndirectData.pbData = member->sEncodedMemberInfo.pbData = NULL;
 695     HeapFree(GetProcessHeap(), 0, member->pIndirectData);
 696     member->pIndirectData = NULL;
 697
 698     for (i = 0; i < entry->cAttribute; i++)
 699     {
 700         CRYPT_ATTRIBUTE *attr = entry->rgAttribute + i;
 701
 702         if (attr->cValue != 1)
 703         {
 704             ERR("Can't handle attr->cValue of %u\n", attr->cValue);
 705             continue;
 706         }
 707         if (!strcmp(attr->pszObjId, CAT_MEMBERINFO_OBJID))
 708         {
 709             CAT_MEMBERINFO *mi;
 710             BOOL ret;
 711
 712             member->sEncodedMemberInfo.cbData = attr->rgValue->cbData;
 713             member->sEncodedMemberInfo.pbData = attr->rgValue->pbData;
 714
 715             CryptDecodeObject(cc->encoding, CAT_MEMBERINFO_OBJID, attr->rgValue->pbData, attr->rgValue->cbData, 0, NULL, &size);
 716
 717             if (!(mi = HeapAlloc(GetProcessHeap(), 0, size)))
 718             {
 719                 SetLastError(ERROR_OUTOFMEMORY);
 720                 goto error;
 721             }
 722             ret = CryptDecodeObject(cc->encoding, CAT_MEMBERINFO_OBJID, attr->rgValue->pbData, attr->rgValue->cbData, 0, mi, &size);
 723             if (ret)
 724             {
 725                 UNICODE_STRING guid;
 726
 727                 member->dwCertVersion = mi->dwCertVersion;
 728                 RtlInitUnicodeString(&guid, mi->pwszSubjGuid);
 729                 if (RtlGUIDFromString(&guid, &member->gSubjectType))
 730                 {
 731                     HeapFree(GetProcessHeap(), 0, mi);
 732                     goto error;
 733                 }
 734             }
 735             HeapFree(GetProcessHeap(), 0, mi);
 736             if (!ret) goto error;
 737         }
 738         else if (!strcmp(attr->pszObjId, SPC_INDIRECT_DATA_OBJID))
 739         {
 740             /* SPC_INDIRECT_DATA_CONTENT is equal to SIP_INDIRECT_DATA */
 741
 742             member->sEncodedIndirectData.cbData = attr->rgValue->cbData;
 743             member->sEncodedIndirectData.pbData = attr->rgValue->pbData;
 744
 745             CryptDecodeObject(cc->encoding, SPC_INDIRECT_DATA_OBJID, attr->rgValue->pbData, attr->rgValue->cbData, 0, NULL, &size);
 746
 747             if (!(member->pIndirectData = HeapAlloc(GetProcessHeap(), 0, size)))
 748             {
 749                 SetLastError(ERROR_OUTOFMEMORY);
 750                 goto error;
 751             }
 752             CryptDecodeObject(cc->encoding, SPC_INDIRECT_DATA_OBJID, attr->rgValue->pbData, attr->rgValue->cbData, 0, member->pIndirectData, &size);
 753         }
 754         else
 755             /* this object id should probably be handled in CryptCATEnumerateAttr */
 756             FIXME("unhandled object id \"%s\"\n", attr->pszObjId);
 757     }
 758
 759     if (!member->sEncodedMemberInfo.cbData || !member->sEncodedIndirectData.cbData)
 760     {
 761         ERR("Corrupted catalog entry?\n");
 762         SetLastError(CRYPT_E_ATTRIBUTES_MISSING);
 763         goto error;
 764     }
 765     size = (2 * member->pIndirectData->Digest.cbData + 1) * sizeof(WCHAR);
 766     if (member->pwszReferenceTag)
 767         member->pwszReferenceTag = HeapReAlloc(GetProcessHeap(), 0, member->pwszReferenceTag, size);
 768     else
 769         member->pwszReferenceTag = HeapAlloc(GetProcessHeap(), 0, size);
 770
 771     if (!member->pwszReferenceTag)
 772     {
 773         SetLastError(ERROR_OUTOFMEMORY);
 774         goto error;
 775     }
 776     /* FIXME: reference tag is usually the file hash but doesn't have to be */
 777     for (i = 0; i < member->pIndirectData->Digest.cbData; i++)
 778     {
 779         DWORD sub;
 780
 781         sub = member->pIndirectData->Digest.pbData[i] >> 4;
 782         member->pwszReferenceTag[i * 2] = (sub < 10 ? '0' + sub : 'A' + sub - 10);
 783         sub = member->pIndirectData->Digest.pbData[i] & 0xf;
 784         member->pwszReferenceTag[i * 2 + 1] = (sub < 10 ? '0' + sub : 'A' + sub - 10);
 785     }
 786     member->pwszReferenceTag[i * 2] = 0;
 787     return member;
 788
 789 error:
 790     HeapFree(GetProcessHeap(), 0, member->pIndirectData);
 791     HeapFree(GetProcessHeap(), 0, member->pwszReferenceTag);
 792     HeapFree(GetProcessHeap(), 0, member);
 793     return NULL;
 794 }
 795
 796 static CTL_INFO *decode_inner_content(HANDLE hmsg, DWORD encoding, DWORD *len)
 797 {
 798     DWORD size;
 799     LPSTR oid = NULL;
 800     BYTE *buffer = NULL;
 801     CTL_INFO *inner = NULL;
 802
 803     if (!CryptMsgGetParam(hmsg, CMSG_INNER_CONTENT_TYPE_PARAM, 0, NULL, &size)) return NULL;
 804     if (!(oid = HeapAlloc(GetProcessHeap(), 0, size)))
 805     {
 806         SetLastError(ERROR_OUTOFMEMORY);
 807         return NULL;
 808     }
 809     if (!CryptMsgGetParam(hmsg, CMSG_INNER_CONTENT_TYPE_PARAM, 0, oid, &size)) goto out;
 810     if (!CryptMsgGetParam(hmsg, CMSG_CONTENT_PARAM, 0, NULL, &size)) goto out;
 811     if (!(buffer = HeapAlloc(GetProcessHeap(), 0, size)))
 812     {
 813         SetLastError(ERROR_OUTOFMEMORY);
 814         goto out;
 815     }
 816     if (!CryptMsgGetParam(hmsg, CMSG_CONTENT_PARAM, 0, buffer, &size)) goto out;
 817     if (!CryptDecodeObject(encoding, oid, buffer, size, 0, NULL, &size)) goto out;
 818     if (!(inner = HeapAlloc(GetProcessHeap(), 0, size)))
 819     {
 820         SetLastError(ERROR_OUTOFMEMORY);
 821         goto out;
 822     }
 823     if (!CryptDecodeObject(encoding, oid, buffer, size, 0, inner, &size)) goto out;
 824     *len = size;
 825
 826 out:
 827     HeapFree(GetProcessHeap(), 0, oid);
 828     HeapFree(GetProcessHeap(), 0, buffer);
 829     return inner;
 830 }
 831
 832 /***********************************************************************
 833  *      CryptCATCatalogInfoFromContext  (WINTRUST.@)
 834  */
 835 BOOL WINAPI CryptCATCatalogInfoFromContext(HCATINFO hcatinfo, CATALOG_INFO *info, DWORD flags)
 836 {
 837     struct catinfo *ci = hcatinfo;
 838
 839     TRACE("%p, %p, %x\n", hcatinfo, info, flags);
 840
 841     if (!hcatinfo || hcatinfo == INVALID_HANDLE_VALUE || ci->magic != CATINFO_MAGIC ||
 842         flags || !info || info->cbStruct != sizeof(*info))
 843     {
 844         SetLastError(ERROR_INVALID_PARAMETER);
 845         return FALSE;
 846     }
 847     lstrcpyW(info->wszCatalogFile, ci->file);
 848     return TRUE;
 849 }
 850
 851 /***********************************************************************
 852  *      CryptCATOpen  (WINTRUST.@)
 853  */
 854 HANDLE WINAPI CryptCATOpen(WCHAR *filename, DWORD flags, HCRYPTPROV hProv,
 855                            DWORD dwPublicVersion, DWORD dwEncodingType)
 856 {
 857     HANDLE file, hmsg;
 858     BYTE *buffer = NULL;
 859     DWORD size, open_mode = OPEN_EXISTING;
 860     struct cryptcat *cc;
 861
 862     TRACE("filename %s, flags %#x, provider %#lx, version %#x, type %#x\n",
 863           debugstr_w(filename), flags, hProv, dwPublicVersion, dwEncodingType);
 864
 865     if (!filename)
 866     {
 867         SetLastError(ERROR_INVALID_PARAMETER);
 868         return INVALID_HANDLE_VALUE;
 869     }
 870
 871     if (!dwEncodingType)  dwEncodingType  = X509_ASN_ENCODING | PKCS_7_ASN_ENCODING;
 872
 873     if (flags & CRYPTCAT_OPEN_ALWAYS)
 874         open_mode = OPEN_ALWAYS;
 875     if (flags & CRYPTCAT_OPEN_CREATENEW)
 876         open_mode = CREATE_NEW;
 877
 878     file = CreateFileW(filename, GENERIC_READ, FILE_SHARE_READ, NULL, open_mode, 0, NULL);
 879     if (file == INVALID_HANDLE_VALUE) return INVALID_HANDLE_VALUE;
 880
 881     size = GetFileSize(file, NULL);
 882     if (!(buffer = HeapAlloc(GetProcessHeap(), 0, size)))
 883     {
 884         CloseHandle(file);
 885         SetLastError(ERROR_OUTOFMEMORY);
 886         return INVALID_HANDLE_VALUE;
 887     }
 888     if (!(hmsg = CryptMsgOpenToDecode(dwEncodingType, 0, 0, hProv, NULL, NULL)))
 889     {
 890         CloseHandle(file);
 891         HeapFree(GetProcessHeap(), 0, buffer);
 892         return INVALID_HANDLE_VALUE;
 893     }
 894     if (!ReadFile(file, buffer, size, &size, NULL) || !CryptMsgUpdate(hmsg, buffer, size, TRUE))
 895     {
 896         CloseHandle(file);
 897         HeapFree(GetProcessHeap(), 0, buffer);
 898         CryptMsgClose(hmsg);
 899         return INVALID_HANDLE_VALUE;
 900     }
 901     HeapFree(GetProcessHeap(), 0, buffer);
 902     CloseHandle(file);
 903
 904     size = sizeof(DWORD);
 905     if (!(cc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*cc))))
 906     {
 907         CryptMsgClose(hmsg);
 908         SetLastError(ERROR_OUTOFMEMORY);
 909         return INVALID_HANDLE_VALUE;
 910     }
 911
 912     cc->msg = hmsg;
 913     cc->encoding = dwEncodingType;
 914     if (CryptMsgGetParam(hmsg, CMSG_ATTR_CERT_COUNT_PARAM, 0, &cc->attr_count, &size))
 915     {
 916         DWORD i, sum = 0;
 917         BYTE *p;
 918
 919         for (i = 0; i < cc->attr_count; i++)
 920         {
 921             if (!CryptMsgGetParam(hmsg, CMSG_ATTR_CERT_PARAM, i, NULL, &size))
 922             {
 923                 CryptMsgClose(hmsg);
 924                 HeapFree(GetProcessHeap(), 0, cc);
 925                 return INVALID_HANDLE_VALUE;
 926             }
 927             sum += size;
 928         }
 929         if (!(cc->attr = HeapAlloc(GetProcessHeap(), 0, sizeof(*cc->attr) * cc->attr_count + sum)))
 930         {
 931             CryptMsgClose(hmsg);
 932             HeapFree(GetProcessHeap(), 0, cc);
 933             SetLastError(ERROR_OUTOFMEMORY);
 934             return INVALID_HANDLE_VALUE;
 935         }
 936         p = (BYTE *)(cc->attr + cc->attr_count);
 937         for (i = 0; i < cc->attr_count; i++)
 938         {
 939             if (!CryptMsgGetParam(hmsg, CMSG_ATTR_CERT_PARAM, i, NULL, &size))
 940             {
 941                 CryptMsgClose(hmsg);
 942                 HeapFree(GetProcessHeap(), 0, cc->attr);
 943                 HeapFree(GetProcessHeap(), 0, cc);
 944                 return INVALID_HANDLE_VALUE;
 945             }
 946             if (!CryptMsgGetParam(hmsg, CMSG_ATTR_CERT_PARAM, i, p, &size))
 947             {
 948                 CryptMsgClose(hmsg);
 949                 HeapFree(GetProcessHeap(), 0, cc->attr);
 950                 HeapFree(GetProcessHeap(), 0, cc);
 951                 return INVALID_HANDLE_VALUE;
 952             }
 953             p += size;
 954         }
 955         cc->inner = decode_inner_content(hmsg, dwEncodingType, &cc->inner_len);
 956         if (!cc->inner || !CryptSIPRetrieveSubjectGuid(filename, NULL, &cc->subject))
 957         {
 958             CryptMsgClose(hmsg);
 959             HeapFree(GetProcessHeap(), 0, cc->attr);
 960             HeapFree(GetProcessHeap(), 0, cc->inner);
 961             HeapFree(GetProcessHeap(), 0, cc);
 962             return INVALID_HANDLE_VALUE;
 963         }
 964         cc->magic = CRYPTCAT_MAGIC;
 965         return cc;
 966     }
 967     HeapFree(GetProcessHeap(), 0, cc);
 968     return INVALID_HANDLE_VALUE;
 969 }
 970
 971 /***********************************************************************
 972  *      CryptSIPCreateIndirectData  (WINTRUST.@)
 973  */
 974 BOOL WINAPI CryptSIPCreateIndirectData(SIP_SUBJECTINFO* pSubjectInfo, DWORD* pcbIndirectData,
 975                                        SIP_INDIRECT_DATA* pIndirectData)
 976 {
 977     FIXME("(%p %p %p) stub\n", pSubjectInfo, pcbIndirectData, pIndirectData);
 978
 979     return FALSE;
 980 }
 981
 982
 983 /***********************************************************************
 984  *      CryptCATCDFClose  (WINTRUST.@)
 985  */
 986 BOOL WINAPI CryptCATCDFClose(CRYPTCATCDF *pCDF)
 987 {
 988     FIXME("(%p) stub\n", pCDF);
 989
 990     return FALSE;
 991 }
 992
 993 /***********************************************************************
 994  *      CryptCATCDFEnumCatAttributes  (WINTRUST.@)
 995  */
 996 CRYPTCATATTRIBUTE * WINAPI CryptCATCDFEnumCatAttributes(CRYPTCATCDF *pCDF,
 997                                                         CRYPTCATATTRIBUTE *pPrevAttr,
 998                                                         PFN_CDF_PARSE_ERROR_CALLBACK pfnParseError)
 999 {
1000     FIXME("(%p %p %p) stub\n", pCDF, pPrevAttr, pfnParseError);
1001
1002     return NULL;
1003 }
1004
1005 /***********************************************************************
1006  *      CryptCATCDFEnumMembersByCDFTagEx  (WINTRUST.@)
1007  */
1008 LPWSTR WINAPI CryptCATCDFEnumMembersByCDFTagEx(CRYPTCATCDF *pCDF, LPWSTR pwszPrevCDFTag,
1009                                                PFN_CDF_PARSE_ERROR_CALLBACK pfnParseError,
1010                                                CRYPTCATMEMBER **ppMember, BOOL fContinueOnError,
1011                                                LPVOID pvReserved)
1012 {
1013     FIXME("(%p %s %p %p %d %p) stub\n", pCDF, debugstr_w(pwszPrevCDFTag), pfnParseError,
1014           ppMember, fContinueOnError, pvReserved);
1015
1016     return NULL;
1017 }
1018
1019 /***********************************************************************
1020  *      CryptCATCDFOpen  (WINTRUST.@)
1021  */
1022 CRYPTCATCDF * WINAPI CryptCATCDFOpen(LPWSTR pwszFilePath,
1023                                      PFN_CDF_PARSE_ERROR_CALLBACK pfnParseError)
1024 {
1025     FIXME("(%s %p) stub\n", debugstr_w(pwszFilePath), pfnParseError);
1026
1027     return NULL;
1028 }
1029
1030 static BOOL WINTRUST_GetSignedMsgFromPEFile(SIP_SUBJECTINFO *pSubjectInfo,
1031  DWORD *pdwEncodingType, DWORD dwIndex, DWORD *pcbSignedDataMsg,
1032  BYTE *pbSignedDataMsg)
1033 {
1034     BOOL ret;
1035     WIN_CERTIFICATE *pCert = NULL;
1036     HANDLE file;
1037
1038     TRACE("(%p %p %d %p %p)\n", pSubjectInfo, pdwEncodingType, dwIndex,
1039           pcbSignedDataMsg, pbSignedDataMsg);
1040
1041     if(pSubjectInfo->hFile && pSubjectInfo->hFile!=INVALID_HANDLE_VALUE)
1042         file = pSubjectInfo->hFile;
1043     else
1044     {
1045         file = CreateFileW(pSubjectInfo->pwsFileName, GENERIC_READ,
1046                 FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
1047         if(file == INVALID_HANDLE_VALUE)
1048             return FALSE;
1049     }
1050
1051     if (!pbSignedDataMsg)
1052     {
1053         WIN_CERTIFICATE cert;
1054
1055         /* app hasn't passed buffer, just get the length */
1056         ret = ImageGetCertificateHeader(file, dwIndex, &cert);
1057         if (ret)
1058         {
1059             switch (cert.wCertificateType)
1060             {
1061             case WIN_CERT_TYPE_X509:
1062             case WIN_CERT_TYPE_PKCS_SIGNED_DATA:
1063                 *pcbSignedDataMsg = cert.dwLength;
1064                 break;
1065             default:
1066                 WARN("unknown certificate type %d\n", cert.wCertificateType);
1067                 ret = FALSE;
1068             }
1069         }
1070     }
1071     else
1072     {
1073         DWORD len = 0;
1074
1075         ret = ImageGetCertificateData(file, dwIndex, NULL, &len);
1076         if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
1077             goto error;
1078         pCert = HeapAlloc(GetProcessHeap(), 0, len);
1079         if (!pCert)
1080         {
1081             ret = FALSE;
1082             goto error;
1083         }
1084         ret = ImageGetCertificateData(file, dwIndex, pCert, &len);
1085         if (!ret)
1086             goto error;
1087         pCert->dwLength -= FIELD_OFFSET(WIN_CERTIFICATE, bCertificate);
1088         if (*pcbSignedDataMsg < pCert->dwLength)
1089         {
1090             *pcbSignedDataMsg = pCert->dwLength;
1091             SetLastError(ERROR_INSUFFICIENT_BUFFER);
1092             ret = FALSE;
1093         }
1094         else
1095         {
1096             memcpy(pbSignedDataMsg, pCert->bCertificate, pCert->dwLength);
1097             *pcbSignedDataMsg = pCert->dwLength;
1098             switch (pCert->wCertificateType)
1099             {
1100             case WIN_CERT_TYPE_X509:
1101                 *pdwEncodingType = X509_ASN_ENCODING;
1102                 break;
1103             case WIN_CERT_TYPE_PKCS_SIGNED_DATA:
1104                 *pdwEncodingType = X509_ASN_ENCODING | PKCS_7_ASN_ENCODING;
1105                 break;
1106             default:
1107                 WARN("don't know what to do for encoding type %d\n",
1108                  pCert->wCertificateType);
1109                 *pdwEncodingType = 0;
1110                 ret = FALSE;
1111             }
1112         }
1113     }
1114 error:
1115     if(pSubjectInfo->hFile != file)
1116         CloseHandle(file);
1117     HeapFree(GetProcessHeap(), 0, pCert);
1118     return ret;
1119 }
1120
1121 static BOOL WINTRUST_PutSignedMsgToPEFile(SIP_SUBJECTINFO* pSubjectInfo, DWORD pdwEncodingType,
1122         DWORD* pdwIndex, DWORD cbSignedDataMsg, BYTE* pbSignedDataMsg)
1123 {
1124     WIN_CERTIFICATE *cert;
1125     HANDLE file;
1126     DWORD size;
1127     BOOL ret;
1128
1129     if(pSubjectInfo->hFile && pSubjectInfo->hFile!=INVALID_HANDLE_VALUE)
1130         file = pSubjectInfo->hFile;
1131     else
1132     {
1133         file = CreateFileW(pSubjectInfo->pwsFileName, GENERIC_READ|GENERIC_WRITE,
1134                 FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
1135         if(file == INVALID_HANDLE_VALUE)
1136             return FALSE;
1137     }
1138
1139     /* int aligned WIN_CERTIFICATE structure with cbSignedDataMsg+1 bytes of data */
1140     size = FIELD_OFFSET(WIN_CERTIFICATE, bCertificate[cbSignedDataMsg+4]) & (~3);
1141     cert = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
1142     if(!cert)
1143         return FALSE;
1144
1145     cert->dwLength = size;
1146     cert->wRevision = WIN_CERT_REVISION_2_0;
1147     cert->wCertificateType = WIN_CERT_TYPE_PKCS_SIGNED_DATA;
1148     memcpy(cert->bCertificate, pbSignedDataMsg, cbSignedDataMsg);
1149     ret = ImageAddCertificate(file, cert, pdwIndex);
1150
1151     HeapFree(GetProcessHeap(), 0, cert);
1152     if(file != pSubjectInfo->hFile)
1153         CloseHandle(file);
1154     return ret;
1155 }
1156
1157 /* structure offsets */
1158 #define cfhead_Signature         (0x00)
1159 #define cfhead_CabinetSize       (0x08)
1160 #define cfhead_MinorVersion      (0x18)
1161 #define cfhead_MajorVersion      (0x19)
1162 #define cfhead_Flags             (0x1E)
1163 #define cfhead_SIZEOF            (0x24)
1164 #define cfheadext_HeaderReserved (0x00)
1165 #define cfheadext_SIZEOF         (0x04)
1166 #define cfsigninfo_CertOffset    (0x04)
1167 #define cfsigninfo_CertSize      (0x08)
1168 #define cfsigninfo_SIZEOF        (0x0C)
1169
1170 /* flags */
1171 #define cfheadRESERVE_PRESENT          (0x0004)
1172
1173 /* endian-neutral reading of little-endian data */
1174 #define EndGetI32(a)  ((((a)[3])<<24)|(((a)[2])<<16)|(((a)[1])<<8)|((a)[0]))
1175 #define EndGetI16(a)  ((((a)[1])<<8)|((a)[0]))
1176
1177 /* For documentation purposes only:  this is the structure in the reserved
1178  * area of a signed cabinet file.  The cert offset indicates where in the
1179  * cabinet file the signature resides, and the count indicates its size.
1180  */
1181 typedef struct _CAB_SIGNINFO
1182 {
1183     WORD unk0; /* always 0? */
1184     WORD unk1; /* always 0x0010? */
1185     DWORD dwCertOffset;
1186     DWORD cbCertBlock;
1187 } CAB_SIGNINFO, *PCAB_SIGNINFO;
1188
1189 static BOOL WINTRUST_GetSignedMsgFromCabFile(SIP_SUBJECTINFO *pSubjectInfo,
1190  DWORD *pdwEncodingType, DWORD dwIndex, DWORD *pcbSignedDataMsg,
1191  BYTE *pbSignedDataMsg)
1192 {
1193     int header_resv;
1194     LONG base_offset, cabsize;
1195     USHORT flags;
1196     BYTE buf[64];
1197     DWORD cert_offset, cert_size, dwRead;
1198
1199     TRACE("(%p %p %d %p %p)\n", pSubjectInfo, pdwEncodingType, dwIndex,
1200           pcbSignedDataMsg, pbSignedDataMsg);
1201
1202     /* get basic offset & size info */
1203     base_offset = SetFilePointer(pSubjectInfo->hFile, 0L, NULL, SEEK_CUR);
1204
1205     if (SetFilePointer(pSubjectInfo->hFile, 0, NULL, SEEK_END) == INVALID_SET_FILE_POINTER)
1206     {
1207         TRACE("seek error\n");
1208         return FALSE;
1209     }
1210
1211     cabsize = SetFilePointer(pSubjectInfo->hFile, 0L, NULL, SEEK_CUR);
1212     if ((cabsize == -1) || (base_offset == -1) ||
1213      (SetFilePointer(pSubjectInfo->hFile, 0, NULL, SEEK_SET) == INVALID_SET_FILE_POINTER))
1214     {
1215         TRACE("seek error\n");
1216         return FALSE;
1217     }
1218
1219     /* read in the CFHEADER */
1220     if (!ReadFile(pSubjectInfo->hFile, buf, cfhead_SIZEOF, &dwRead, NULL) ||
1221      dwRead != cfhead_SIZEOF)
1222     {
1223         TRACE("reading header failed\n");
1224         return FALSE;
1225     }
1226
1227     /* check basic MSCF signature */
1228     if (EndGetI32(buf+cfhead_Signature) != 0x4643534d)
1229     {
1230         WARN("cabinet signature not present\n");
1231         return FALSE;
1232     }
1233
1234     /* Ignore the number of folders and files and the set and cabinet IDs */
1235
1236     /* check the header revision */
1237     if ((buf[cfhead_MajorVersion] > 1) ||
1238         (buf[cfhead_MajorVersion] == 1 && buf[cfhead_MinorVersion] > 3))
1239     {
1240         WARN("cabinet format version > 1.3\n");
1241         return FALSE;
1242     }
1243
1244     /* pull the flags out */
1245     flags = EndGetI16(buf+cfhead_Flags);
1246
1247     if (!(flags & cfheadRESERVE_PRESENT))
1248     {
1249         TRACE("no header present, not signed\n");
1250         return FALSE;
1251     }
1252
1253     if (!ReadFile(pSubjectInfo->hFile, buf, cfheadext_SIZEOF, &dwRead, NULL) ||
1254      dwRead != cfheadext_SIZEOF)
1255     {
1256         ERR("bunk reserve-sizes?\n");
1257         return FALSE;
1258     }
1259
1260     header_resv = EndGetI16(buf+cfheadext_HeaderReserved);
1261     if (!header_resv)
1262     {
1263         TRACE("no header_resv, not signed\n");
1264         return FALSE;
1265     }
1266     else if (header_resv < cfsigninfo_SIZEOF)
1267     {
1268         TRACE("header_resv too small, not signed\n");
1269         return FALSE;
1270     }
1271
1272     if (header_resv > 60000)
1273     {
1274         WARN("WARNING; header reserved space > 60000\n");
1275     }
1276
1277     if (!ReadFile(pSubjectInfo->hFile, buf, cfsigninfo_SIZEOF, &dwRead, NULL) ||
1278      dwRead != cfsigninfo_SIZEOF)
1279     {
1280         ERR("couldn't read reserve\n");
1281         return FALSE;
1282     }
1283
1284     cert_offset = EndGetI32(buf+cfsigninfo_CertOffset);
1285     TRACE("cert_offset: %d\n", cert_offset);
1286     cert_size = EndGetI32(buf+cfsigninfo_CertSize);
1287     TRACE("cert_size: %d\n", cert_size);
1288
1289     /* The redundant checks are to avoid wraparound */
1290     if (cert_offset > cabsize || cert_size > cabsize ||
1291      cert_offset + cert_size > cabsize)
1292     {
1293         WARN("offset beyond file, not attempting to read\n");
1294         return FALSE;
1295     }
1296
1297     SetFilePointer(pSubjectInfo->hFile, base_offset, NULL, SEEK_SET);
1298     if (!pbSignedDataMsg)
1299     {
1300         *pcbSignedDataMsg = cert_size;
1301         return TRUE;
1302     }
1303     if (*pcbSignedDataMsg < cert_size)
1304     {
1305         *pcbSignedDataMsg = cert_size;
1306         SetLastError(ERROR_INSUFFICIENT_BUFFER);
1307         return FALSE;
1308     }
1309     if (SetFilePointer(pSubjectInfo->hFile, cert_offset, NULL, SEEK_SET) == INVALID_SET_FILE_POINTER)
1310     {
1311         ERR("couldn't seek to cert location\n");
1312         return FALSE;
1313     }
1314     if (!ReadFile(pSubjectInfo->hFile, pbSignedDataMsg, cert_size, &dwRead,
1315      NULL) || dwRead != cert_size)
1316     {
1317         ERR("couldn't read cert\n");
1318         SetFilePointer(pSubjectInfo->hFile, base_offset, NULL, SEEK_SET);
1319         return FALSE;
1320     }
1321     /* The encoding of the files I've seen appears to be in ASN.1
1322      * format, and there isn't a field indicating the type, so assume it
1323      * always is.
1324      */
1325     *pdwEncodingType = X509_ASN_ENCODING | PKCS_7_ASN_ENCODING;
1326     /* Restore base offset */
1327     SetFilePointer(pSubjectInfo->hFile, base_offset, NULL, SEEK_SET);
1328     return TRUE;
1329 }
1330
1331 static BOOL WINTRUST_GetSignedMsgFromCatFile(SIP_SUBJECTINFO *pSubjectInfo,
1332  DWORD *pdwEncodingType, DWORD dwIndex, DWORD *pcbSignedDataMsg,
1333  BYTE *pbSignedDataMsg)
1334 {
1335     BOOL ret;
1336
1337     TRACE("(%p %p %d %p %p)\n", pSubjectInfo, pdwEncodingType, dwIndex,
1338           pcbSignedDataMsg, pbSignedDataMsg);
1339
1340     if (!pbSignedDataMsg)
1341     {
1342         *pcbSignedDataMsg = GetFileSize(pSubjectInfo->hFile, NULL);
1343          ret = TRUE;
1344     }
1345     else
1346     {
1347         DWORD len = GetFileSize(pSubjectInfo->hFile, NULL);
1348
1349         if (*pcbSignedDataMsg < len)
1350         {
1351             *pcbSignedDataMsg = len;
1352             SetLastError(ERROR_INSUFFICIENT_BUFFER);
1353             ret = FALSE;
1354         }
1355         else
1356         {
1357             ret = ReadFile(pSubjectInfo->hFile, pbSignedDataMsg, len,
1358              pcbSignedDataMsg, NULL);
1359             if (ret)
1360                 *pdwEncodingType = X509_ASN_ENCODING | PKCS_7_ASN_ENCODING;
1361         }
1362     }
1363     return ret;
1364 }
1365
1366 /* GUIDs used by CryptSIPGetSignedDataMsg and CryptSIPPutSignedDataMsg */
1367 static const GUID unknown = { 0xC689AAB8, 0x8E78, 0x11D0, { 0x8C,0x47,
1368     0x00,0xC0,0x4F,0xC2,0x95,0xEE } };
1369 static const GUID cabGUID = { 0xC689AABA, 0x8E78, 0x11D0, { 0x8C,0x47,
1370     0x00,0xC0,0x4F,0xC2,0x95,0xEE } };
1371 static const GUID catGUID = { 0xDE351A43, 0x8E59, 0x11D0, { 0x8C,0x47,
1372      0x00,0xC0,0x4F,0xC2,0x95,0xEE }};
1373
1374 /***********************************************************************
1375  *      CryptSIPGetSignedDataMsg  (WINTRUST.@)
1376  */
1377 BOOL WINAPI CryptSIPGetSignedDataMsg(SIP_SUBJECTINFO* pSubjectInfo, DWORD* pdwEncodingType,
1378                                        DWORD dwIndex, DWORD* pcbSignedDataMsg, BYTE* pbSignedDataMsg)
1379 {
1380     BOOL ret;
1381
1382     TRACE("(%p %p %d %p %p)\n", pSubjectInfo, pdwEncodingType, dwIndex,
1383           pcbSignedDataMsg, pbSignedDataMsg);
1384
1385     if(!pSubjectInfo)
1386     {
1387         SetLastError(ERROR_INVALID_PARAMETER);
1388         return FALSE;
1389     }
1390
1391     if (!memcmp(pSubjectInfo->pgSubjectType, &unknown, sizeof(unknown)))
1392         ret = WINTRUST_GetSignedMsgFromPEFile(pSubjectInfo, pdwEncodingType,
1393          dwIndex, pcbSignedDataMsg, pbSignedDataMsg);
1394     else if (!memcmp(pSubjectInfo->pgSubjectType, &cabGUID, sizeof(cabGUID)))
1395         ret = WINTRUST_GetSignedMsgFromCabFile(pSubjectInfo, pdwEncodingType,
1396          dwIndex, pcbSignedDataMsg, pbSignedDataMsg);
1397     else if (!memcmp(pSubjectInfo->pgSubjectType, &catGUID, sizeof(catGUID)))
1398         ret = WINTRUST_GetSignedMsgFromCatFile(pSubjectInfo, pdwEncodingType,
1399          dwIndex, pcbSignedDataMsg, pbSignedDataMsg);
1400     else
1401     {
1402         FIXME("unimplemented for subject type %s\n",
1403          debugstr_guid(pSubjectInfo->pgSubjectType));
1404         ret = FALSE;
1405     }
1406
1407     TRACE("returning %d\n", ret);
1408     return ret;
1409 }
1410
1411 /***********************************************************************
1412  *      CryptSIPPutSignedDataMsg  (WINTRUST.@)
1413  */
1414 BOOL WINAPI CryptSIPPutSignedDataMsg(SIP_SUBJECTINFO* pSubjectInfo, DWORD pdwEncodingType,
1415         DWORD* pdwIndex, DWORD cbSignedDataMsg, BYTE* pbSignedDataMsg)
1416 {
1417     TRACE("(%p %d %p %d %p)\n", pSubjectInfo, pdwEncodingType, pdwIndex,
1418           cbSignedDataMsg, pbSignedDataMsg);
1419
1420     if(!pSubjectInfo) {
1421         SetLastError(ERROR_INVALID_PARAMETER);
1422         return FALSE;
1423     }
1424
1425     if(!memcmp(pSubjectInfo->pgSubjectType, &unknown, sizeof(unknown)))
1426         return WINTRUST_PutSignedMsgToPEFile(pSubjectInfo, pdwEncodingType,
1427                 pdwIndex, cbSignedDataMsg, pbSignedDataMsg);
1428     else
1429         FIXME("unimplemented for subject type %s\n",
1430                 debugstr_guid(pSubjectInfo->pgSubjectType));
1431
1432     return FALSE;
1433 }
1434
1435 /***********************************************************************
1436  *      CryptSIPRemoveSignedDataMsg  (WINTRUST.@)
1437  */
1438 BOOL WINAPI CryptSIPRemoveSignedDataMsg(SIP_SUBJECTINFO* pSubjectInfo,
1439                                        DWORD dwIndex)
1440 {
1441     FIXME("(%p %d) stub\n", pSubjectInfo, dwIndex);
1442
1443     return FALSE;
1444 }
1445
1446 /***********************************************************************
1447  *      CryptSIPVerifyIndirectData  (WINTRUST.@)
1448  */
1449 BOOL WINAPI CryptSIPVerifyIndirectData(SIP_SUBJECTINFO* pSubjectInfo,
1450                                        SIP_INDIRECT_DATA* pIndirectData)
1451 {
1452     FIXME("(%p %p) stub\n", pSubjectInfo, pIndirectData);
1453
1454     return FALSE;
1455 }