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