dlls/crypt32/serialize.c

   1 /*
   2  * Copyright 2004-2006 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18 #include <stdarg.h>
  19 #include "windef.h"
  20 #include "winbase.h"
  21 #include "wincrypt.h"
  22 #include "wine/debug.h"
  23 #include "excpt.h"
  24 #include "wine/exception.h"
  25 #include "crypt32_private.h"
  26
  27 WINE_DEFAULT_DEBUG_CHANNEL(crypt);
  28
  29 /* An extended certificate property in serialized form is prefixed by this
  30  * header.
  31  */
  32 typedef struct _WINE_CERT_PROP_HEADER
  33 {
  34     DWORD propID;
  35     DWORD unknown; /* always 1 */
  36     DWORD cb;
  37 } WINE_CERT_PROP_HEADER, *PWINE_CERT_PROP_HEADER;
  38
  39 BOOL WINAPI CertSerializeCRLStoreElement(PCCRL_CONTEXT pCrlContext,
  40  DWORD dwFlags, BYTE *pbElement, DWORD *pcbElement)
  41 {
  42     FIXME("(%p, %08lx, %p, %p): stub\n", pCrlContext, dwFlags, pbElement,
  43      pcbElement);
  44     return FALSE;
  45 }
  46
  47 BOOL WINAPI CertSerializeCTLStoreElement(PCCTL_CONTEXT pCtlContext,
  48  DWORD dwFlags, BYTE *pbElement, DWORD *pcbElement)
  49 {
  50     FIXME("(%p, %08lx, %p, %p): stub\n", pCtlContext, dwFlags, pbElement,
  51      pcbElement);
  52     return FALSE;
  53 }
  54
  55 BOOL WINAPI CertSerializeCertificateStoreElement(PCCERT_CONTEXT pCertContext,
  56  DWORD dwFlags, BYTE *pbElement, DWORD *pcbElement)
  57 {
  58     BOOL ret;
  59
  60     TRACE("(%p, %08lx, %p, %p)\n", pCertContext, dwFlags, pbElement,
  61      pcbElement);
  62
  63     if (pCertContext)
  64     {
  65         DWORD bytesNeeded = sizeof(WINE_CERT_PROP_HEADER) +
  66          pCertContext->cbCertEncoded;
  67         DWORD prop = 0;
  68
  69         ret = TRUE;
  70         do {
  71             prop = CertEnumCertificateContextProperties(pCertContext, prop);
  72             if (prop)
  73             {
  74                 DWORD propSize = 0;
  75
  76                 ret = CertGetCertificateContextProperty(pCertContext,
  77                  prop, NULL, &propSize);
  78                 if (ret)
  79                     bytesNeeded += sizeof(WINE_CERT_PROP_HEADER) + propSize;
  80             }
  81         } while (ret && prop != 0);
  82
  83         if (!pbElement)
  84         {
  85             *pcbElement = bytesNeeded;
  86             ret = TRUE;
  87         }
  88         else if (*pcbElement < bytesNeeded)
  89         {
  90             *pcbElement = bytesNeeded;
  91             SetLastError(ERROR_MORE_DATA);
  92             ret = FALSE;
  93         }
  94         else
  95         {
  96             PWINE_CERT_PROP_HEADER hdr;
  97             DWORD bufSize = 0;
  98             LPBYTE buf = NULL;
  99
 100             prop = 0;
 101             do {
 102                 prop = CertEnumCertificateContextProperties(pCertContext, prop);
 103                 if (prop)
 104                 {
 105                     DWORD propSize = 0;
 106
 107                     ret = CertGetCertificateContextProperty(pCertContext,
 108                      prop, NULL, &propSize);
 109                     if (ret)
 110                     {
 111                         if (bufSize < propSize)
 112                         {
 113                             if (buf)
 114                                 buf = CryptMemRealloc(buf, propSize);
 115                             else
 116                                 buf = CryptMemAlloc(propSize);
 117                             bufSize = propSize;
 118                         }
 119                         if (buf)
 120                         {
 121                             ret = CertGetCertificateContextProperty(
 122                              pCertContext, prop, buf, &propSize);
 123                             if (ret)
 124                             {
 125                                 hdr = (PWINE_CERT_PROP_HEADER)pbElement;
 126                                 hdr->propID = prop;
 127                                 hdr->unknown = 1;
 128                                 hdr->cb = propSize;
 129                                 pbElement += sizeof(WINE_CERT_PROP_HEADER);
 130                                 if (propSize)
 131                                 {
 132                                     memcpy(pbElement, buf, propSize);
 133                                     pbElement += propSize;
 134                                 }
 135                             }
 136                         }
 137                         else
 138                             ret = FALSE;
 139                     }
 140                 }
 141             } while (ret && prop != 0);
 142             CryptMemFree(buf);
 143
 144             hdr = (PWINE_CERT_PROP_HEADER)pbElement;
 145             hdr->propID = CERT_CERT_PROP_ID;
 146             hdr->unknown = 1;
 147             hdr->cb = pCertContext->cbCertEncoded;
 148             memcpy(pbElement + sizeof(WINE_CERT_PROP_HEADER),
 149              pCertContext->pbCertEncoded, pCertContext->cbCertEncoded);
 150         }
 151     }
 152     else
 153         ret = FALSE;
 154     return ret;
 155 }
 156
 157 /* Looks for the property with ID propID in the buffer buf.  Returns a pointer
 158  * to its header if a valid header is found, NULL if not.  Valid means the
 159  * length of thte property won't overrun buf, and the unknown field is 1.
 160  */
 161 static const WINE_CERT_PROP_HEADER *CRYPT_findPropID(const BYTE *buf,
 162  DWORD size, DWORD propID)
 163 {
 164     const WINE_CERT_PROP_HEADER *ret = NULL;
 165     BOOL done = FALSE;
 166
 167     while (size && !ret && !done)
 168     {
 169         if (size < sizeof(WINE_CERT_PROP_HEADER))
 170         {
 171             SetLastError(CRYPT_E_FILE_ERROR);
 172             done = TRUE;
 173         }
 174         else
 175         {
 176             const WINE_CERT_PROP_HEADER *hdr =
 177              (const WINE_CERT_PROP_HEADER *)buf;
 178
 179             size -= sizeof(WINE_CERT_PROP_HEADER);
 180             buf += sizeof(WINE_CERT_PROP_HEADER);
 181             if (size < hdr->cb)
 182             {
 183                 SetLastError(E_INVALIDARG);
 184                 done = TRUE;
 185             }
 186             else if (!hdr->propID)
 187             {
 188                 /* assume a zero prop ID means the data are uninitialized, so
 189                  * stop looking.
 190                  */
 191                 done = TRUE;
 192             }
 193             else if (hdr->unknown != 1)
 194             {
 195                 SetLastError(ERROR_FILE_NOT_FOUND);
 196                 done = TRUE;
 197             }
 198             else if (hdr->propID == propID)
 199                 ret = hdr;
 200             else
 201             {
 202                 buf += hdr->cb;
 203                 size -= hdr->cb;
 204             }
 205         }
 206     }
 207     return ret;
 208 }
 209
 210 const void *CRYPT_ReadSerializedElement(const BYTE *pbElement, DWORD cbElement,
 211  DWORD dwContextTypeFlags, DWORD *pdwContentType)
 212 {
 213     const void *context;
 214
 215     TRACE("(%p, %ld, %08lx, %p)\n", pbElement, cbElement, dwContextTypeFlags,
 216      pdwContentType);
 217
 218     if (!cbElement)
 219     {
 220         SetLastError(ERROR_END_OF_MEDIA);
 221         return NULL;
 222     }
 223
 224     __TRY
 225     {
 226         const WINE_CONTEXT_INTERFACE *contextInterface = NULL;
 227         const WINE_CERT_PROP_HEADER *hdr = NULL;
 228         DWORD type = 0;
 229         BOOL ret;
 230
 231         ret = TRUE;
 232         context = NULL;
 233         if (dwContextTypeFlags == CERT_STORE_ALL_CONTEXT_FLAG)
 234         {
 235             hdr = CRYPT_findPropID(pbElement, cbElement, CERT_CERT_PROP_ID);
 236             if (hdr)
 237                 type = CERT_STORE_CERTIFICATE_CONTEXT;
 238             else
 239             {
 240                 hdr = CRYPT_findPropID(pbElement, cbElement, CERT_CRL_PROP_ID);
 241                 if (hdr)
 242                     type = CERT_STORE_CRL_CONTEXT;
 243                 else
 244                 {
 245                     hdr = CRYPT_findPropID(pbElement, cbElement,
 246                      CERT_CTL_PROP_ID);
 247                     if (hdr)
 248                         type = CERT_STORE_CTL_CONTEXT;
 249                 }
 250             }
 251         }
 252         else if (dwContextTypeFlags & CERT_STORE_CERTIFICATE_CONTEXT_FLAG)
 253         {
 254             hdr = CRYPT_findPropID(pbElement, cbElement, CERT_CERT_PROP_ID);
 255             type = CERT_STORE_CERTIFICATE_CONTEXT;
 256         }
 257         else if (dwContextTypeFlags & CERT_STORE_CRL_CONTEXT_FLAG)
 258         {
 259             hdr = CRYPT_findPropID(pbElement, cbElement, CERT_CRL_PROP_ID);
 260             type = CERT_STORE_CRL_CONTEXT;
 261         }
 262         else if (dwContextTypeFlags & CERT_STORE_CTL_CONTEXT_FLAG)
 263         {
 264             hdr = CRYPT_findPropID(pbElement, cbElement, CERT_CTL_PROP_ID);
 265             type = CERT_STORE_CTL_CONTEXT;
 266         }
 267
 268         switch (type)
 269         {
 270         case CERT_STORE_CERTIFICATE_CONTEXT:
 271             contextInterface = pCertInterface;
 272             break;
 273         case CERT_STORE_CRL_CONTEXT:
 274             contextInterface = pCRLInterface;
 275             break;
 276         case CERT_STORE_CTL_CONTEXT:
 277             contextInterface = pCTLInterface;
 278             break;
 279         default:
 280             SetLastError(E_INVALIDARG);
 281             ret = FALSE;
 282         }
 283         if (!hdr)
 284             ret = FALSE;
 285
 286         if (ret)
 287             context = contextInterface->create(X509_ASN_ENCODING,
 288              (BYTE *)hdr + sizeof(WINE_CERT_PROP_HEADER), hdr->cb);
 289         if (ret && context)
 290         {
 291             BOOL noMoreProps = FALSE;
 292
 293             while (!noMoreProps && ret)
 294             {
 295                 if (cbElement < sizeof(WINE_CERT_PROP_HEADER))
 296                     ret = FALSE;
 297                 else
 298                 {
 299                     const WINE_CERT_PROP_HEADER *hdr =
 300                      (const WINE_CERT_PROP_HEADER *)pbElement;
 301
 302                     TRACE("prop is %ld\n", hdr->propID);
 303                     cbElement -= sizeof(WINE_CERT_PROP_HEADER);
 304                     pbElement += sizeof(WINE_CERT_PROP_HEADER);
 305                     if (cbElement < hdr->cb)
 306                     {
 307                         SetLastError(E_INVALIDARG);
 308                         ret = FALSE;
 309                     }
 310                     else if (!hdr->propID)
 311                     {
 312                         /* Like in CRYPT_findPropID, stop if the propID is zero
 313                          */
 314                         noMoreProps = TRUE;
 315                     }
 316                     else if (hdr->unknown != 1)
 317                     {
 318                         SetLastError(ERROR_FILE_NOT_FOUND);
 319                         ret = FALSE;
 320                     }
 321                     else if (hdr->propID != CERT_CERT_PROP_ID &&
 322                      hdr->propID != CERT_CRL_PROP_ID && hdr->propID !=
 323                      CERT_CTL_PROP_ID)
 324                     {
 325                         /* Have to create a blob for most types, but not
 326                          * for all.. arghh.
 327                          */
 328                         switch (hdr->propID)
 329                         {
 330                         case CERT_AUTO_ENROLL_PROP_ID:
 331                         case CERT_CTL_USAGE_PROP_ID:
 332                         case CERT_DESCRIPTION_PROP_ID:
 333                         case CERT_FRIENDLY_NAME_PROP_ID:
 334                         case CERT_HASH_PROP_ID:
 335                         case CERT_KEY_IDENTIFIER_PROP_ID:
 336                         case CERT_MD5_HASH_PROP_ID:
 337                         case CERT_NEXT_UPDATE_LOCATION_PROP_ID:
 338                         case CERT_PUBKEY_ALG_PARA_PROP_ID:
 339                         case CERT_PVK_FILE_PROP_ID:
 340                         case CERT_SIGNATURE_HASH_PROP_ID:
 341                         case CERT_ISSUER_PUBLIC_KEY_MD5_HASH_PROP_ID:
 342                         case CERT_SUBJECT_PUBLIC_KEY_MD5_HASH_PROP_ID:
 343                         case CERT_ENROLLMENT_PROP_ID:
 344                         case CERT_CROSS_CERT_DIST_POINTS_PROP_ID:
 345                         case CERT_RENEWAL_PROP_ID:
 346                         {
 347                             CRYPT_DATA_BLOB blob = { hdr->cb,
 348                              (LPBYTE)pbElement };
 349
 350                             ret = contextInterface->setProp(context,
 351                              hdr->propID, 0, &blob);
 352                             break;
 353                         }
 354                         case CERT_DATE_STAMP_PROP_ID:
 355                             ret = contextInterface->setProp(context,
 356                              hdr->propID, 0, pbElement);
 357                             break;
 358                         default:
 359                             FIXME("prop ID %ld: stub\n", hdr->propID);
 360                         }
 361                     }
 362                     pbElement += hdr->cb;
 363                     cbElement -= hdr->cb;
 364                     if (!cbElement)
 365                         noMoreProps = TRUE;
 366                 }
 367             }
 368             if (ret)
 369             {
 370                 if (pdwContentType)
 371                     *pdwContentType = type;
 372             }
 373             else
 374             {
 375                 contextInterface->free(context);
 376                 context = NULL;
 377             }
 378         }
 379     }
 380     __EXCEPT_PAGE_FAULT
 381     {
 382         SetLastError(STATUS_ACCESS_VIOLATION);
 383         context = NULL;
 384     }
 385     __ENDTRY
 386     return context;
 387 }
 388
 389 BOOL WINAPI CertAddSerializedElementToStore(HCERTSTORE hCertStore,
 390  const BYTE *pbElement, DWORD cbElement, DWORD dwAddDisposition, DWORD dwFlags,
 391  DWORD dwContextTypeFlags, DWORD *pdwContentType, const void **ppvContext)
 392 {
 393     const void *context;
 394     DWORD type;
 395     BOOL ret;
 396
 397     TRACE("(%p, %p, %ld, %08lx, %08lx, %08lx, %p, %p)\n", hCertStore,
 398      pbElement, cbElement, dwAddDisposition, dwFlags, dwContextTypeFlags,
 399      pdwContentType, ppvContext);
 400
 401     /* Call the internal function, then delete the hashes.  Tests show this
 402      * function uses real hash values, not whatever's stored in the hash
 403      * property.
 404      */
 405     context = CRYPT_ReadSerializedElement(pbElement, cbElement,
 406      dwContextTypeFlags, &type);
 407     if (context)
 408     {
 409         const WINE_CONTEXT_INTERFACE *contextInterface = NULL;
 410
 411         switch (type)
 412         {
 413         case CERT_STORE_CERTIFICATE_CONTEXT:
 414             contextInterface = pCertInterface;
 415             break;
 416         case CERT_STORE_CRL_CONTEXT:
 417             contextInterface = pCRLInterface;
 418             break;
 419         case CERT_STORE_CTL_CONTEXT:
 420             contextInterface = pCTLInterface;
 421             break;
 422         default:
 423             SetLastError(E_INVALIDARG);
 424         }
 425         if (contextInterface)
 426         {
 427             contextInterface->setProp(context, CERT_HASH_PROP_ID, 0, NULL);
 428             contextInterface->setProp(context, CERT_MD5_HASH_PROP_ID, 0, NULL);
 429             contextInterface->setProp(context, CERT_SIGNATURE_HASH_PROP_ID, 0,
 430              NULL);
 431             if (pdwContentType)
 432                 *pdwContentType = type;
 433             ret = contextInterface->addContextToStore(hCertStore, context,
 434              dwAddDisposition, ppvContext);
 435             contextInterface->free(context);
 436         }
 437         else
 438             ret = FALSE;
 439     }
 440     else
 441         ret = FALSE;
 442     return ret;
 443 }