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 BOOL WINAPI CertAddEncodedCTLToStore(HCERTSTORE hCertStore,
  33  DWORD dwMsgAndCertEncodingType, const BYTE *pbCtlEncoded, DWORD cbCtlEncoded,
  34  DWORD dwAddDisposition, PCCTL_CONTEXT *ppCtlContext)
  35 {
  36     PCCTL_CONTEXT ctl = CertCreateCTLContext(dwMsgAndCertEncodingType,
  37      pbCtlEncoded, cbCtlEncoded);
  38     BOOL ret;
  39
  40     TRACE("(%p, %08x, %p, %d, %08x, %p)\n", hCertStore,
  41      dwMsgAndCertEncodingType, pbCtlEncoded, cbCtlEncoded, dwAddDisposition,
  42      ppCtlContext);
  43
  44     if (ctl)
  45     {
  46         ret = CertAddCTLContextToStore(hCertStore, ctl, dwAddDisposition,
  47          ppCtlContext);
  48         CertFreeCTLContext(ctl);
  49     }
  50     else
  51         ret = FALSE;
  52     return ret;
  53 }
  54
  55 PCCTL_CONTEXT WINAPI CertEnumCTLsInStore(HCERTSTORE hCertStore,
  56  PCCTL_CONTEXT pPrev)
  57 {
  58     WINECRYPT_CERTSTORE *hcs = (WINECRYPT_CERTSTORE *)hCertStore;
  59     PCCTL_CONTEXT ret;
  60
  61     TRACE("(%p, %p)\n", hCertStore, pPrev);
  62     if (!hCertStore)
  63         ret = NULL;
  64     else if (hcs->dwMagic != WINE_CRYPTCERTSTORE_MAGIC)
  65         ret = NULL;
  66     else
  67         ret = (PCCTL_CONTEXT)hcs->ctls.enumContext(hcs, (void *)pPrev);
  68     return ret;
  69 }
  70
  71 BOOL WINAPI CertDeleteCTLFromStore(PCCTL_CONTEXT pCtlContext)
  72 {
  73     BOOL ret;
  74
  75     TRACE("(%p)\n", pCtlContext);
  76
  77     if (!pCtlContext)
  78         ret = TRUE;
  79     else if (!pCtlContext->hCertStore)
  80     {
  81         ret = TRUE;
  82         CertFreeCTLContext(pCtlContext);
  83     }
  84     else
  85     {
  86         PWINECRYPT_CERTSTORE hcs =
  87          (PWINECRYPT_CERTSTORE)pCtlContext->hCertStore;
  88
  89         if (hcs->dwMagic != WINE_CRYPTCERTSTORE_MAGIC)
  90             ret = FALSE;
  91         else
  92             ret = hcs->ctls.deleteContext(hcs, (void *)pCtlContext);
  93         CertFreeCTLContext(pCtlContext);
  94     }
  95     return ret;
  96 }
  97
  98 PCCTL_CONTEXT WINAPI CertCreateCTLContext(DWORD dwMsgAndCertEncodingType,
  99  const BYTE *pbCtlEncoded, DWORD cbCtlEncoded)
 100 {
 101     PCTL_CONTEXT ctl = NULL;
 102     HCRYPTMSG msg;
 103     BOOL ret;
 104     BYTE *content = NULL;
 105     DWORD contentSize = 0, size;
 106     PCTL_INFO ctlInfo = NULL;
 107
 108     TRACE("(%08x, %p, %d)\n", dwMsgAndCertEncodingType, pbCtlEncoded,
 109      cbCtlEncoded);
 110
 111     if (GET_CERT_ENCODING_TYPE(dwMsgAndCertEncodingType) != X509_ASN_ENCODING)
 112     {
 113         SetLastError(E_INVALIDARG);
 114         return NULL;
 115     }
 116     if (!pbCtlEncoded || !cbCtlEncoded)
 117     {
 118         SetLastError(ERROR_INVALID_DATA);
 119         return NULL;
 120     }
 121     msg = CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING | X509_ASN_ENCODING, 0, 0,
 122      0, NULL, NULL);
 123     if (!msg)
 124         return NULL;
 125     ret = CryptMsgUpdate(msg, pbCtlEncoded, cbCtlEncoded, TRUE);
 126     if (!ret)
 127     {
 128         SetLastError(ERROR_INVALID_DATA);
 129         goto end;
 130     }
 131     /* Check that it's really a CTL */
 132     ret = CryptMsgGetParam(msg, CMSG_INNER_CONTENT_TYPE_PARAM, 0, NULL, &size);
 133     if (ret)
 134     {
 135         char *innerContent = CryptMemAlloc(size);
 136
 137         if (innerContent)
 138         {
 139             ret = CryptMsgGetParam(msg, CMSG_INNER_CONTENT_TYPE_PARAM, 0,
 140              innerContent, &size);
 141             if (ret)
 142             {
 143                 if (strcmp(innerContent, szOID_CTL))
 144                 {
 145                     SetLastError(ERROR_INVALID_DATA);
 146                     ret = FALSE;
 147                 }
 148             }
 149             CryptMemFree(innerContent);
 150         }
 151         else
 152         {
 153             SetLastError(ERROR_OUTOFMEMORY);
 154             ret = FALSE;
 155         }
 156     }
 157     if (!ret)
 158         goto end;
 159     ret = CryptMsgGetParam(msg, CMSG_CONTENT_PARAM, 0, NULL, &contentSize);
 160     if (!ret)
 161         goto end;
 162     content = CryptMemAlloc(contentSize);
 163     if (content)
 164     {
 165         ret = CryptMsgGetParam(msg, CMSG_CONTENT_PARAM, 0, content,
 166          &contentSize);
 167         if (ret)
 168         {
 169             ret = CryptDecodeObjectEx(dwMsgAndCertEncodingType, PKCS_CTL,
 170              content, contentSize, CRYPT_DECODE_ALLOC_FLAG, NULL,
 171              (BYTE *)&ctlInfo, &size);
 172             if (ret)
 173             {
 174                 ctl = (PCTL_CONTEXT)Context_CreateDataContext(
 175                  sizeof(CTL_CONTEXT));
 176                 if (ctl)
 177                 {
 178                     BYTE *data = CryptMemAlloc(cbCtlEncoded);
 179
 180                     if (data)
 181                     {
 182                         memcpy(data, pbCtlEncoded, cbCtlEncoded);
 183                         ctl->dwMsgAndCertEncodingType =
 184                          X509_ASN_ENCODING | PKCS_7_ASN_ENCODING;
 185                         ctl->pbCtlEncoded             = data;
 186                         ctl->cbCtlEncoded             = cbCtlEncoded;
 187                         ctl->pCtlInfo                 = ctlInfo;
 188                         ctl->hCertStore               = NULL;
 189                         ctl->hCryptMsg                = msg;
 190                         ctl->pbCtlContext             = content;
 191                         ctl->cbCtlContext             = contentSize;
 192                     }
 193                     else
 194                     {
 195                         SetLastError(ERROR_OUTOFMEMORY);
 196                         ret = FALSE;
 197                     }
 198                 }
 199                 else
 200                 {
 201                     SetLastError(ERROR_OUTOFMEMORY);
 202                     ret = FALSE;
 203                 }
 204             }
 205         }
 206     }
 207     else
 208     {
 209         SetLastError(ERROR_OUTOFMEMORY);
 210         ret = FALSE;
 211     }
 212
 213 end:
 214     if (!ret)
 215     {
 216         CryptMemFree(ctl);
 217         ctl = NULL;
 218         LocalFree(ctlInfo);
 219         CryptMemFree(content);
 220         CryptMsgClose(msg);
 221     }
 222     return (PCCTL_CONTEXT)ctl;
 223 }
 224
 225 PCCTL_CONTEXT WINAPI CertDuplicateCTLContext(PCCTL_CONTEXT pCtlContext)
 226 {
 227     TRACE("(%p)\n", pCtlContext);
 228     Context_AddRef((void *)pCtlContext, sizeof(CTL_CONTEXT));
 229     return pCtlContext;
 230 }
 231
 232 static void CTLDataContext_Free(void *context)
 233 {
 234     PCTL_CONTEXT ctlContext = (PCTL_CONTEXT)context;
 235
 236     CryptMsgClose(ctlContext->hCryptMsg);
 237     CryptMemFree(ctlContext->pbCtlEncoded);
 238     CryptMemFree(ctlContext->pbCtlContext);
 239     LocalFree(ctlContext->pCtlInfo);
 240 }
 241
 242 BOOL WINAPI CertFreeCTLContext(PCCTL_CONTEXT pCTLContext)
 243 {
 244     TRACE("(%p)\n", pCTLContext);
 245
 246     if (pCTLContext)
 247         Context_Release((void *)pCTLContext, sizeof(CTL_CONTEXT),
 248          CTLDataContext_Free);
 249     return TRUE;
 250 }
 251
 252 DWORD WINAPI CertEnumCTLContextProperties(PCCTL_CONTEXT pCTLContext,
 253  DWORD dwPropId)
 254 {
 255     PCONTEXT_PROPERTY_LIST properties = Context_GetProperties(
 256      (void *)pCTLContext, sizeof(CTL_CONTEXT));
 257     DWORD ret;
 258
 259     TRACE("(%p, %d)\n", pCTLContext, dwPropId);
 260
 261     if (properties)
 262         ret = ContextPropertyList_EnumPropIDs(properties, dwPropId);
 263     else
 264         ret = 0;
 265     return ret;
 266 }
 267
 268 static BOOL CTLContext_SetProperty(PCCTL_CONTEXT context, DWORD dwPropId,
 269                                    DWORD dwFlags, const void *pvData);
 270
 271 static BOOL CTLContext_GetHashProp(PCCTL_CONTEXT context, DWORD dwPropId,
 272  ALG_ID algID, const BYTE *toHash, DWORD toHashLen, void *pvData,
 273  DWORD *pcbData)
 274 {
 275     BOOL ret = CryptHashCertificate(0, algID, 0, toHash, toHashLen, pvData,
 276      pcbData);
 277     if (ret)
 278     {
 279         CRYPT_DATA_BLOB blob = { *pcbData, pvData };
 280
 281         ret = CTLContext_SetProperty(context, dwPropId, 0, &blob);
 282     }
 283     return ret;
 284 }
 285
 286 static BOOL CTLContext_GetProperty(PCCTL_CONTEXT context, DWORD dwPropId,
 287                                    void *pvData, DWORD *pcbData)
 288 {
 289     PCONTEXT_PROPERTY_LIST properties =
 290      Context_GetProperties(context, sizeof(CTL_CONTEXT));
 291     BOOL ret;
 292     CRYPT_DATA_BLOB blob;
 293
 294     TRACE("(%p, %d, %p, %p)\n", context, dwPropId, pvData, pcbData);
 295
 296     if (properties)
 297         ret = ContextPropertyList_FindProperty(properties, dwPropId, &blob);
 298     else
 299         ret = FALSE;
 300     if (ret)
 301     {
 302         if (!pvData)
 303             *pcbData = blob.cbData;
 304         else if (*pcbData < blob.cbData)
 305         {
 306             SetLastError(ERROR_MORE_DATA);
 307             *pcbData = blob.cbData;
 308             ret = FALSE;
 309         }
 310         else
 311         {
 312             memcpy(pvData, blob.pbData, blob.cbData);
 313             *pcbData = blob.cbData;
 314         }
 315     }
 316     else
 317     {
 318         /* Implicit properties */
 319         switch (dwPropId)
 320         {
 321         case CERT_SHA1_HASH_PROP_ID:
 322             ret = CTLContext_GetHashProp(context, dwPropId, CALG_SHA1,
 323              context->pbCtlEncoded, context->cbCtlEncoded, pvData, pcbData);
 324             break;
 325         case CERT_MD5_HASH_PROP_ID:
 326             ret = CTLContext_GetHashProp(context, dwPropId, CALG_MD5,
 327              context->pbCtlEncoded, context->cbCtlEncoded, pvData, pcbData);
 328             break;
 329         default:
 330             SetLastError(CRYPT_E_NOT_FOUND);
 331         }
 332     }
 333     TRACE("returning %d\n", ret);
 334     return ret;
 335 }
 336
 337 BOOL WINAPI CertGetCTLContextProperty(PCCTL_CONTEXT pCTLContext,
 338  DWORD dwPropId, void *pvData, DWORD *pcbData)
 339 {
 340     BOOL ret;
 341
 342     TRACE("(%p, %d, %p, %p)\n", pCTLContext, dwPropId, pvData, pcbData);
 343
 344     switch (dwPropId)
 345     {
 346     case 0:
 347     case CERT_CERT_PROP_ID:
 348     case CERT_CRL_PROP_ID:
 349     case CERT_CTL_PROP_ID:
 350         SetLastError(E_INVALIDARG);
 351         ret = FALSE;
 352         break;
 353     case CERT_ACCESS_STATE_PROP_ID:
 354         if (!pvData)
 355         {
 356             *pcbData = sizeof(DWORD);
 357             ret = TRUE;
 358         }
 359         else if (*pcbData < sizeof(DWORD))
 360         {
 361             SetLastError(ERROR_MORE_DATA);
 362             *pcbData = sizeof(DWORD);
 363             ret = FALSE;
 364         }
 365         else
 366         {
 367             if (pCTLContext->hCertStore)
 368                 ret = CertGetStoreProperty(pCTLContext->hCertStore, dwPropId,
 369                  pvData, pcbData);
 370             else
 371                 *(DWORD *)pvData = 0;
 372             ret = TRUE;
 373         }
 374         break;
 375     default:
 376         ret = CTLContext_GetProperty(pCTLContext, dwPropId, pvData,
 377          pcbData);
 378     }
 379     return ret;
 380 }
 381
 382 static BOOL CTLContext_SetProperty(PCCTL_CONTEXT context, DWORD dwPropId,
 383  DWORD dwFlags, const void *pvData)
 384 {
 385     PCONTEXT_PROPERTY_LIST properties =
 386      Context_GetProperties(context, sizeof(CTL_CONTEXT));
 387     BOOL ret;
 388
 389     TRACE("(%p, %d, %08x, %p)\n", context, dwPropId, dwFlags, pvData);
 390
 391     if (!properties)
 392         ret = FALSE;
 393     else if (!pvData)
 394     {
 395         ContextPropertyList_RemoveProperty(properties, dwPropId);
 396         ret = TRUE;
 397     }
 398     else
 399     {
 400         switch (dwPropId)
 401         {
 402         case CERT_AUTO_ENROLL_PROP_ID:
 403         case CERT_CTL_USAGE_PROP_ID: /* same as CERT_ENHKEY_USAGE_PROP_ID */
 404         case CERT_DESCRIPTION_PROP_ID:
 405         case CERT_FRIENDLY_NAME_PROP_ID:
 406         case CERT_HASH_PROP_ID:
 407         case CERT_KEY_IDENTIFIER_PROP_ID:
 408         case CERT_MD5_HASH_PROP_ID:
 409         case CERT_NEXT_UPDATE_LOCATION_PROP_ID:
 410         case CERT_PUBKEY_ALG_PARA_PROP_ID:
 411         case CERT_PVK_FILE_PROP_ID:
 412         case CERT_SIGNATURE_HASH_PROP_ID:
 413         case CERT_ISSUER_PUBLIC_KEY_MD5_HASH_PROP_ID:
 414         case CERT_SUBJECT_NAME_MD5_HASH_PROP_ID:
 415         case CERT_SUBJECT_PUBLIC_KEY_MD5_HASH_PROP_ID:
 416         case CERT_ENROLLMENT_PROP_ID:
 417         case CERT_CROSS_CERT_DIST_POINTS_PROP_ID:
 418         case CERT_RENEWAL_PROP_ID:
 419         {
 420             PCRYPT_DATA_BLOB blob = (PCRYPT_DATA_BLOB)pvData;
 421
 422             ret = ContextPropertyList_SetProperty(properties, dwPropId,
 423              blob->pbData, blob->cbData);
 424             break;
 425         }
 426         case CERT_DATE_STAMP_PROP_ID:
 427             ret = ContextPropertyList_SetProperty(properties, dwPropId,
 428              (const BYTE *)pvData, sizeof(FILETIME));
 429             break;
 430         default:
 431             FIXME("%d: stub\n", dwPropId);
 432             ret = FALSE;
 433         }
 434     }
 435     TRACE("returning %d\n", ret);
 436     return ret;
 437 }
 438
 439 BOOL WINAPI CertSetCTLContextProperty(PCCTL_CONTEXT pCTLContext,
 440  DWORD dwPropId, DWORD dwFlags, const void *pvData)
 441 {
 442     BOOL ret;
 443
 444     TRACE("(%p, %d, %08x, %p)\n", pCTLContext, dwPropId, dwFlags, pvData);
 445
 446     /* Handle special cases for "read-only"/invalid prop IDs.  Windows just
 447      * crashes on most of these, I'll be safer.
 448      */
 449     switch (dwPropId)
 450     {
 451     case 0:
 452     case CERT_ACCESS_STATE_PROP_ID:
 453     case CERT_CERT_PROP_ID:
 454     case CERT_CRL_PROP_ID:
 455     case CERT_CTL_PROP_ID:
 456         SetLastError(E_INVALIDARG);
 457         return FALSE;
 458     }
 459     ret = CTLContext_SetProperty(pCTLContext, dwPropId, dwFlags, pvData);
 460     TRACE("returning %d\n", ret);
 461     return ret;
 462 }