dlls/crypt32/ctl.c

   1 /*
   2  * Copyright 2008 Juan Lang
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  *
  18  */
  19
  20 #include <assert.h>
  21 #include <stdarg.h>
  22
  23 #define NONAMELESSUNION
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "wincrypt.h"
  27 #include "wine/debug.h"
  28 #include "crypt32_private.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(crypt);
  31
  32 static void CTL_free(context_t *context)
  33 {
  34     ctl_t *ctl = (ctl_t*)context;
  35
  36     CryptMsgClose(ctl->ctx.hCryptMsg);
  37     CryptMemFree(ctl->ctx.pbCtlEncoded);
  38     CryptMemFree(ctl->ctx.pbCtlContext);
  39     LocalFree(ctl->ctx.pCtlInfo);
  40 }
  41
  42 static const context_vtbl_t ctl_vtbl = {
  43     CTL_free
  44 };
  45
  46 BOOL WINAPI CertAddCTLContextToStore(HCERTSTORE hCertStore,
  47  PCCTL_CONTEXT pCtlContext, DWORD dwAddDisposition,
  48  PCCTL_CONTEXT* ppStoreContext)
  49 {
  50     WINECRYPT_CERTSTORE *store = hCertStore;
  51     BOOL ret = TRUE;
  52     PCCTL_CONTEXT toAdd = NULL, existing = NULL;
  53
  54     TRACE("(%p, %p, %08x, %p)\n", hCertStore, pCtlContext, dwAddDisposition,
  55      ppStoreContext);
  56
  57     if (dwAddDisposition != CERT_STORE_ADD_ALWAYS)
  58     {
  59         existing = CertFindCTLInStore(hCertStore, 0, 0, CTL_FIND_EXISTING,
  60          pCtlContext, NULL);
  61     }
  62
  63     switch (dwAddDisposition)
  64     {
  65     case CERT_STORE_ADD_ALWAYS:
  66         toAdd = CertDuplicateCTLContext(pCtlContext);
  67         break;
  68     case CERT_STORE_ADD_NEW:
  69         if (existing)
  70         {
  71             TRACE("found matching CTL, not adding\n");
  72             SetLastError(CRYPT_E_EXISTS);
  73             ret = FALSE;
  74         }
  75         else
  76             toAdd = CertDuplicateCTLContext(pCtlContext);
  77         break;
  78     case CERT_STORE_ADD_NEWER:
  79         if (existing)
  80         {
  81             LONG newer = CompareFileTime(&existing->pCtlInfo->ThisUpdate,
  82              &pCtlContext->pCtlInfo->ThisUpdate);
  83
  84             if (newer < 0)
  85                 toAdd = CertDuplicateCTLContext(pCtlContext);
  86             else
  87             {
  88                 TRACE("existing CTL is newer, not adding\n");
  89                 SetLastError(CRYPT_E_EXISTS);
  90                 ret = FALSE;
  91             }
  92         }
  93         else
  94             toAdd = CertDuplicateCTLContext(pCtlContext);
  95         break;
  96     case CERT_STORE_ADD_NEWER_INHERIT_PROPERTIES:
  97         if (existing)
  98         {
  99             LONG newer = CompareFileTime(&existing->pCtlInfo->ThisUpdate,
 100              &pCtlContext->pCtlInfo->ThisUpdate);
 101
 102             if (newer < 0)
 103             {
 104                 toAdd = CertDuplicateCTLContext(pCtlContext);
 105                 Context_CopyProperties(existing, pCtlContext);
 106             }
 107             else
 108             {
 109                 TRACE("existing CTL is newer, not adding\n");
 110                 SetLastError(CRYPT_E_EXISTS);
 111                 ret = FALSE;
 112             }
 113         }
 114         else
 115             toAdd = CertDuplicateCTLContext(pCtlContext);
 116         break;
 117     case CERT_STORE_ADD_REPLACE_EXISTING:
 118         toAdd = CertDuplicateCTLContext(pCtlContext);
 119         break;
 120     case CERT_STORE_ADD_REPLACE_EXISTING_INHERIT_PROPERTIES:
 121         toAdd = CertDuplicateCTLContext(pCtlContext);
 122         if (existing)
 123             Context_CopyProperties(toAdd, existing);
 124         break;
 125     case CERT_STORE_ADD_USE_EXISTING:
 126         if (existing)
 127         {
 128             Context_CopyProperties(existing, pCtlContext);
 129             if (ppStoreContext)
 130                 *ppStoreContext = CertDuplicateCTLContext(existing);
 131         }
 132         else
 133             toAdd = CertDuplicateCTLContext(pCtlContext);
 134         break;
 135     default:
 136         FIXME("Unimplemented add disposition %d\n", dwAddDisposition);
 137         ret = FALSE;
 138     }
 139
 140     if (toAdd)
 141     {
 142         if (store)
 143             ret = store->vtbl->ctls.addContext(store, (void *)toAdd,
 144              (void *)existing, (const void **)ppStoreContext);
 145         else if (ppStoreContext)
 146             *ppStoreContext = CertDuplicateCTLContext(toAdd);
 147         CertFreeCTLContext(toAdd);
 148     }
 149     CertFreeCTLContext(existing);
 150
 151     TRACE("returning %d\n", ret);
 152     return ret;
 153 }
 154
 155 BOOL WINAPI CertAddEncodedCTLToStore(HCERTSTORE hCertStore,
 156  DWORD dwMsgAndCertEncodingType, const BYTE *pbCtlEncoded, DWORD cbCtlEncoded,
 157  DWORD dwAddDisposition, PCCTL_CONTEXT *ppCtlContext)
 158 {
 159     PCCTL_CONTEXT ctl = CertCreateCTLContext(dwMsgAndCertEncodingType,
 160      pbCtlEncoded, cbCtlEncoded);
 161     BOOL ret;
 162
 163     TRACE("(%p, %08x, %p, %d, %08x, %p)\n", hCertStore,
 164      dwMsgAndCertEncodingType, pbCtlEncoded, cbCtlEncoded, dwAddDisposition,
 165      ppCtlContext);
 166
 167     if (ctl)
 168     {
 169         ret = CertAddCTLContextToStore(hCertStore, ctl, dwAddDisposition,
 170          ppCtlContext);
 171         CertFreeCTLContext(ctl);
 172     }
 173     else
 174         ret = FALSE;
 175     return ret;
 176 }
 177
 178 PCCTL_CONTEXT WINAPI CertEnumCTLsInStore(HCERTSTORE hCertStore,
 179  PCCTL_CONTEXT pPrev)
 180 {
 181     WINECRYPT_CERTSTORE *hcs = hCertStore;
 182     PCCTL_CONTEXT ret;
 183
 184     TRACE("(%p, %p)\n", hCertStore, pPrev);
 185     if (!hCertStore)
 186         ret = NULL;
 187     else if (hcs->dwMagic != WINE_CRYPTCERTSTORE_MAGIC)
 188         ret = NULL;
 189     else
 190         ret = (PCCTL_CONTEXT)hcs->vtbl->ctls.enumContext(hcs, (void *)pPrev);
 191     return ret;
 192 }
 193
 194 typedef BOOL (*CtlCompareFunc)(PCCTL_CONTEXT pCtlContext, DWORD dwType,
 195  DWORD dwFlags, const void *pvPara);
 196
 197 static BOOL compare_ctl_any(PCCTL_CONTEXT pCtlContext, DWORD dwType,
 198  DWORD dwFlags, const void *pvPara)
 199 {
 200     return TRUE;
 201 }
 202
 203 static BOOL compare_ctl_by_md5_hash(PCCTL_CONTEXT pCtlContext, DWORD dwType,
 204  DWORD dwFlags, const void *pvPara)
 205 {
 206     BOOL ret;
 207     BYTE hash[16];
 208     DWORD size = sizeof(hash);
 209
 210     ret = CertGetCTLContextProperty(pCtlContext, CERT_MD5_HASH_PROP_ID, hash,
 211      &size);
 212     if (ret)
 213     {
 214         const CRYPT_HASH_BLOB *pHash = pvPara;
 215
 216         if (size == pHash->cbData)
 217             ret = !memcmp(pHash->pbData, hash, size);
 218         else
 219             ret = FALSE;
 220     }
 221     return ret;
 222 }
 223
 224 static BOOL compare_ctl_by_sha1_hash(PCCTL_CONTEXT pCtlContext, DWORD dwType,
 225  DWORD dwFlags, const void *pvPara)
 226 {
 227     BOOL ret;
 228     BYTE hash[20];
 229     DWORD size = sizeof(hash);
 230
 231     ret = CertGetCTLContextProperty(pCtlContext, CERT_SHA1_HASH_PROP_ID, hash,
 232      &size);
 233     if (ret)
 234     {
 235         const CRYPT_HASH_BLOB *pHash = pvPara;
 236
 237         if (size == pHash->cbData)
 238             ret = !memcmp(pHash->pbData, hash, size);
 239         else
 240             ret = FALSE;
 241     }
 242     return ret;
 243 }
 244
 245 static BOOL compare_ctl_existing(PCCTL_CONTEXT pCtlContext, DWORD dwType,
 246  DWORD dwFlags, const void *pvPara)
 247 {
 248     BOOL ret;
 249
 250     if (pvPara)
 251     {
 252         PCCTL_CONTEXT ctl = pvPara;
 253
 254         if (pCtlContext->cbCtlContext == ctl->cbCtlContext)
 255         {
 256             if (ctl->cbCtlContext)
 257                 ret = !memcmp(pCtlContext->pbCtlContext, ctl->pbCtlContext,
 258                  ctl->cbCtlContext);
 259             else
 260                 ret = TRUE;
 261         }
 262         else
 263             ret = FALSE;
 264     }
 265     else
 266         ret = FALSE;
 267     return ret;
 268 }
 269
 270 PCCTL_CONTEXT WINAPI CertFindCTLInStore(HCERTSTORE hCertStore,
 271  DWORD dwCertEncodingType, DWORD dwFindFlags, DWORD dwFindType,
 272  const void *pvFindPara, PCCTL_CONTEXT pPrevCtlContext)
 273 {
 274     PCCTL_CONTEXT ret;
 275     CtlCompareFunc compare;
 276
 277     TRACE("(%p, %d, %d, %d, %p, %p)\n", hCertStore, dwCertEncodingType,
 278          dwFindFlags, dwFindType, pvFindPara, pPrevCtlContext);
 279
 280     switch (dwFindType)
 281     {
 282     case CTL_FIND_ANY:
 283         compare = compare_ctl_any;
 284         break;
 285     case CTL_FIND_SHA1_HASH:
 286         compare = compare_ctl_by_sha1_hash;
 287         break;
 288     case CTL_FIND_MD5_HASH:
 289         compare = compare_ctl_by_md5_hash;
 290         break;
 291     case CTL_FIND_EXISTING:
 292         compare = compare_ctl_existing;
 293         break;
 294     default:
 295         FIXME("find type %08x unimplemented\n", dwFindType);
 296         compare = NULL;
 297     }
 298
 299     if (compare)
 300     {
 301         BOOL matches = FALSE;
 302
 303         ret = pPrevCtlContext;
 304         do {
 305             ret = CertEnumCTLsInStore(hCertStore, ret);
 306             if (ret)
 307                 matches = compare(ret, dwFindType, dwFindFlags, pvFindPara);
 308         } while (ret != NULL && !matches);
 309         if (!ret)
 310             SetLastError(CRYPT_E_NOT_FOUND);
 311     }
 312     else
 313     {
 314         SetLastError(CRYPT_E_NOT_FOUND);
 315         ret = NULL;
 316     }
 317     return ret;
 318 }
 319
 320 BOOL WINAPI CertDeleteCTLFromStore(PCCTL_CONTEXT pCtlContext)
 321 {
 322     BOOL ret;
 323
 324     TRACE("(%p)\n", pCtlContext);
 325
 326     if (!pCtlContext)
 327         ret = TRUE;
 328     else if (!pCtlContext->hCertStore)
 329         ret = CertFreeCTLContext(pCtlContext);
 330     else
 331     {
 332         WINECRYPT_CERTSTORE *hcs = pCtlContext->hCertStore;
 333         ctl_t *ctl = ctl_from_ptr(pCtlContext);
 334
 335         if (hcs->dwMagic != WINE_CRYPTCERTSTORE_MAGIC)
 336             ret = FALSE;
 337         else
 338             ret = hcs->vtbl->ctls.delete(hcs, &ctl->base);
 339         if (ret)
 340             ret = CertFreeCTLContext(pCtlContext);
 341     }
 342     return ret;
 343 }
 344
 345 PCCTL_CONTEXT WINAPI CertCreateCTLContext(DWORD dwMsgAndCertEncodingType,
 346  const BYTE *pbCtlEncoded, DWORD cbCtlEncoded)
 347 {
 348     PCTL_CONTEXT ctl = NULL;
 349     HCRYPTMSG msg;
 350     BOOL ret;
 351     BYTE *content = NULL;
 352     DWORD contentSize = 0, size;
 353     PCTL_INFO ctlInfo = NULL;
 354
 355     TRACE("(%08x, %p, %d)\n", dwMsgAndCertEncodingType, pbCtlEncoded,
 356      cbCtlEncoded);
 357
 358     if (GET_CERT_ENCODING_TYPE(dwMsgAndCertEncodingType) != X509_ASN_ENCODING)
 359     {
 360         SetLastError(E_INVALIDARG);
 361         return NULL;
 362     }
 363     if (!pbCtlEncoded || !cbCtlEncoded)
 364     {
 365         SetLastError(ERROR_INVALID_DATA);
 366         return NULL;
 367     }
 368     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING | X509_ASN_ENCODING, 0, 0,
 369      0, NULL, NULL);
 370     if (!msg)
 371         return NULL;
 372     ret = CryptMsgUpdate(msg, pbCtlEncoded, cbCtlEncoded, TRUE);
 373     if (!ret)
 374     {
 375         SetLastError(ERROR_INVALID_DATA);
 376         goto end;
 377     }
 378     /* Check that it's really a CTL */
 379     ret = CryptMsgGetParam(msg, CMSG_INNER_CONTENT_TYPE_PARAM, 0, NULL, &size);
 380     if (ret)
 381     {
 382         char *innerContent = CryptMemAlloc(size);
 383
 384         if (innerContent)
 385         {
 386             ret = CryptMsgGetParam(msg, CMSG_INNER_CONTENT_TYPE_PARAM, 0,
 387              innerContent, &size);
 388             if (ret)
 389             {
 390                 if (strcmp(innerContent, szOID_CTL))
 391                 {
 392                     SetLastError(ERROR_INVALID_DATA);
 393                     ret = FALSE;
 394                 }
 395             }
 396             CryptMemFree(innerContent);
 397         }
 398         else
 399         {
 400             SetLastError(ERROR_OUTOFMEMORY);
 401             ret = FALSE;
 402         }
 403     }
 404     if (!ret)
 405         goto end;
 406     ret = CryptMsgGetParam(msg, CMSG_CONTENT_PARAM, 0, NULL, &contentSize);
 407     if (!ret)
 408         goto end;
 409     content = CryptMemAlloc(contentSize);
 410     if (content)
 411     {
 412         ret = CryptMsgGetParam(msg, CMSG_CONTENT_PARAM, 0, content,
 413          &contentSize);
 414         if (ret)
 415         {
 416             ret = CryptDecodeObjectEx(dwMsgAndCertEncodingType, PKCS_CTL,
 417              content, contentSize, CRYPT_DECODE_ALLOC_FLAG, NULL,
 418              &ctlInfo, &size);
 419             if (ret)
 420             {
 421                 ctl = Context_CreateDataContext(sizeof(CTL_CONTEXT), &ctl_vtbl);
 422                 if (ctl)
 423                 {
 424                     BYTE *data = CryptMemAlloc(cbCtlEncoded);
 425
 426                     if (data)
 427                     {
 428                         memcpy(data, pbCtlEncoded, cbCtlEncoded);
 429                         ctl->dwMsgAndCertEncodingType =
 430                          X509_ASN_ENCODING | PKCS_7_ASN_ENCODING;
 431                         ctl->pbCtlEncoded             = data;
 432                         ctl->cbCtlEncoded             = cbCtlEncoded;
 433                         ctl->pCtlInfo                 = ctlInfo;
 434                         ctl->hCertStore               = NULL;
 435                         ctl->hCryptMsg                = msg;
 436                         ctl->pbCtlContext             = content;
 437                         ctl->cbCtlContext             = contentSize;
 438                     }
 439                     else
 440                     {
 441                         SetLastError(ERROR_OUTOFMEMORY);
 442                         ret = FALSE;
 443                     }
 444                 }
 445                 else
 446                 {
 447                     SetLastError(ERROR_OUTOFMEMORY);
 448                     ret = FALSE;
 449                 }
 450             }
 451         }
 452     }
 453     else
 454     {
 455         SetLastError(ERROR_OUTOFMEMORY);
 456         ret = FALSE;
 457     }
 458
 459 end:
 460     if (!ret)
 461     {
 462         CertFreeCTLContext(ctl);
 463         ctl = NULL;
 464         LocalFree(ctlInfo);
 465         CryptMemFree(content);
 466         CryptMsgClose(msg);
 467     }
 468     return ctl;
 469 }
 470
 471 PCCTL_CONTEXT WINAPI CertDuplicateCTLContext(PCCTL_CONTEXT pCtlContext)
 472 {
 473     TRACE("(%p)\n", pCtlContext);
 474     if (pCtlContext)
 475         Context_AddRef(&ctl_from_ptr(pCtlContext)->base);
 476     return pCtlContext;
 477 }
 478
 479 BOOL WINAPI CertFreeCTLContext(PCCTL_CONTEXT pCTLContext)
 480 {
 481     BOOL ret = TRUE;
 482
 483     TRACE("(%p)\n", pCTLContext);
 484
 485     if (pCTLContext)
 486         ret = Context_Release(&ctl_from_ptr(pCTLContext)->base);
 487     return ret;
 488 }
 489
 490 DWORD WINAPI CertEnumCTLContextProperties(PCCTL_CONTEXT pCTLContext,
 491  DWORD dwPropId)
 492 {
 493     CONTEXT_PROPERTY_LIST *properties = Context_GetProperties(pCTLContext);
 494     DWORD ret;
 495
 496     TRACE("(%p, %d)\n", pCTLContext, dwPropId);
 497
 498     if (properties)
 499         ret = ContextPropertyList_EnumPropIDs(properties, dwPropId);
 500     else
 501         ret = 0;
 502     return ret;
 503 }
 504
 505 static BOOL CTLContext_SetProperty(PCCTL_CONTEXT context, DWORD dwPropId,
 506                                    DWORD dwFlags, const void *pvData);
 507
 508 static BOOL CTLContext_GetHashProp(PCCTL_CONTEXT context, DWORD dwPropId,
 509  ALG_ID algID, const BYTE *toHash, DWORD toHashLen, void *pvData,
 510  DWORD *pcbData)
 511 {
 512     BOOL ret = CryptHashCertificate(0, algID, 0, toHash, toHashLen, pvData,
 513      pcbData);
 514     if (ret && pvData)
 515     {
 516         CRYPT_DATA_BLOB blob = { *pcbData, pvData };
 517
 518         ret = CTLContext_SetProperty(context, dwPropId, 0, &blob);
 519     }
 520     return ret;
 521 }
 522
 523 static BOOL CTLContext_GetProperty(PCCTL_CONTEXT context, DWORD dwPropId,
 524                                    void *pvData, DWORD *pcbData)
 525 {
 526     CONTEXT_PROPERTY_LIST *properties = Context_GetProperties(context);
 527     BOOL ret;
 528     CRYPT_DATA_BLOB blob;
 529
 530     TRACE("(%p, %d, %p, %p)\n", context, dwPropId, pvData, pcbData);
 531
 532     if (properties)
 533         ret = ContextPropertyList_FindProperty(properties, dwPropId, &blob);
 534     else
 535         ret = FALSE;
 536     if (ret)
 537     {
 538         if (!pvData)
 539             *pcbData = blob.cbData;
 540         else if (*pcbData < blob.cbData)
 541         {
 542             SetLastError(ERROR_MORE_DATA);
 543             *pcbData = blob.cbData;
 544             ret = FALSE;
 545         }
 546         else
 547         {
 548             memcpy(pvData, blob.pbData, blob.cbData);
 549             *pcbData = blob.cbData;
 550         }
 551     }
 552     else
 553     {
 554         /* Implicit properties */
 555         switch (dwPropId)
 556         {
 557         case CERT_SHA1_HASH_PROP_ID:
 558             ret = CTLContext_GetHashProp(context, dwPropId, CALG_SHA1,
 559              context->pbCtlEncoded, context->cbCtlEncoded, pvData, pcbData);
 560             break;
 561         case CERT_MD5_HASH_PROP_ID:
 562             ret = CTLContext_GetHashProp(context, dwPropId, CALG_MD5,
 563              context->pbCtlEncoded, context->cbCtlEncoded, pvData, pcbData);
 564             break;
 565         default:
 566             SetLastError(CRYPT_E_NOT_FOUND);
 567         }
 568     }
 569     TRACE("returning %d\n", ret);
 570     return ret;
 571 }
 572
 573 BOOL WINAPI CertGetCTLContextProperty(PCCTL_CONTEXT pCTLContext,
 574  DWORD dwPropId, void *pvData, DWORD *pcbData)
 575 {
 576     BOOL ret;
 577
 578     TRACE("(%p, %d, %p, %p)\n", pCTLContext, dwPropId, pvData, pcbData);
 579
 580     switch (dwPropId)
 581     {
 582     case 0:
 583     case CERT_CERT_PROP_ID:
 584     case CERT_CRL_PROP_ID:
 585     case CERT_CTL_PROP_ID:
 586         SetLastError(E_INVALIDARG);
 587         ret = FALSE;
 588         break;
 589     case CERT_ACCESS_STATE_PROP_ID:
 590         if (!pvData)
 591         {
 592             *pcbData = sizeof(DWORD);
 593             ret = TRUE;
 594         }
 595         else if (*pcbData < sizeof(DWORD))
 596         {
 597             SetLastError(ERROR_MORE_DATA);
 598             *pcbData = sizeof(DWORD);
 599             ret = FALSE;
 600         }
 601         else
 602         {
 603             if (pCTLContext->hCertStore)
 604                 ret = CertGetStoreProperty(pCTLContext->hCertStore, dwPropId,
 605                  pvData, pcbData);
 606             else
 607             {
 608                 *(DWORD *)pvData = 0;
 609                 ret = TRUE;
 610             }
 611         }
 612         break;
 613     default:
 614         ret = CTLContext_GetProperty(pCTLContext, dwPropId, pvData,
 615          pcbData);
 616     }
 617     return ret;
 618 }
 619
 620 static BOOL CTLContext_SetProperty(PCCTL_CONTEXT context, DWORD dwPropId,
 621  DWORD dwFlags, const void *pvData)
 622 {
 623     CONTEXT_PROPERTY_LIST *properties = Context_GetProperties(context);
 624     BOOL ret;
 625
 626     TRACE("(%p, %d, %08x, %p)\n", context, dwPropId, dwFlags, pvData);
 627
 628     if (!properties)
 629         ret = FALSE;
 630     else if (!pvData)
 631     {
 632         ContextPropertyList_RemoveProperty(properties, dwPropId);
 633         ret = TRUE;
 634     }
 635     else
 636     {
 637         switch (dwPropId)
 638         {
 639         case CERT_AUTO_ENROLL_PROP_ID:
 640         case CERT_CTL_USAGE_PROP_ID: /* same as CERT_ENHKEY_USAGE_PROP_ID */
 641         case CERT_DESCRIPTION_PROP_ID:
 642         case CERT_FRIENDLY_NAME_PROP_ID:
 643         case CERT_HASH_PROP_ID:
 644         case CERT_KEY_IDENTIFIER_PROP_ID:
 645         case CERT_MD5_HASH_PROP_ID:
 646         case CERT_NEXT_UPDATE_LOCATION_PROP_ID:
 647         case CERT_PUBKEY_ALG_PARA_PROP_ID:
 648         case CERT_PVK_FILE_PROP_ID:
 649         case CERT_SIGNATURE_HASH_PROP_ID:
 650         case CERT_ISSUER_PUBLIC_KEY_MD5_HASH_PROP_ID:
 651         case CERT_SUBJECT_NAME_MD5_HASH_PROP_ID:
 652         case CERT_SUBJECT_PUBLIC_KEY_MD5_HASH_PROP_ID:
 653         case CERT_ENROLLMENT_PROP_ID:
 654         case CERT_CROSS_CERT_DIST_POINTS_PROP_ID:
 655         case CERT_RENEWAL_PROP_ID:
 656         {
 657             PCRYPT_DATA_BLOB blob = (PCRYPT_DATA_BLOB)pvData;
 658
 659             ret = ContextPropertyList_SetProperty(properties, dwPropId,
 660              blob->pbData, blob->cbData);
 661             break;
 662         }
 663         case CERT_DATE_STAMP_PROP_ID:
 664             ret = ContextPropertyList_SetProperty(properties, dwPropId,
 665              pvData, sizeof(FILETIME));
 666             break;
 667         default:
 668             FIXME("%d: stub\n", dwPropId);
 669             ret = FALSE;
 670         }
 671     }
 672     TRACE("returning %d\n", ret);
 673     return ret;
 674 }
 675
 676 BOOL WINAPI CertSetCTLContextProperty(PCCTL_CONTEXT pCTLContext,
 677  DWORD dwPropId, DWORD dwFlags, const void *pvData)
 678 {
 679     BOOL ret;
 680
 681     TRACE("(%p, %d, %08x, %p)\n", pCTLContext, dwPropId, dwFlags, pvData);
 682
 683     /* Handle special cases for "read-only"/invalid prop IDs.  Windows just
 684      * crashes on most of these, I'll be safer.
 685      */
 686     switch (dwPropId)
 687     {
 688     case 0:
 689     case CERT_ACCESS_STATE_PROP_ID:
 690     case CERT_CERT_PROP_ID:
 691     case CERT_CRL_PROP_ID:
 692     case CERT_CTL_PROP_ID:
 693         SetLastError(E_INVALIDARG);
 694         return FALSE;
 695     }
 696     ret = CTLContext_SetProperty(pCTLContext, dwPropId, dwFlags, pvData);
 697     TRACE("returning %d\n", ret);
 698     return ret;
 699 }