lib/hcrypto/evp-wincng.c

   1 /*
   2  * Copyright (c) 2015, Secure Endpoints Inc.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * - Redistributions of source code must retain the above copyright
  10  *   notice, this list of conditions and the following disclaimer.
  11  *
  12  * - Redistributions in binary form must reproduce the above copyright
  13  *   notice, this list of conditions and the following disclaimer in
  14  *   the documentation and/or other materials provided with the
  15  *   distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  18  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  19  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  20  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  21  * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  22  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  24  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  26  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  27  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  28  * OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 /* Windows CNG provider */
  32
  33 #include "config.h"
  34
  35 #include <windows.h>
  36 #include <assert.h>
  37
  38 #if NTDDI_VERSION >= NTDDI_VISTA
  39
  40 #include <evp.h>
  41 #include <evp-wincng.h>
  42
  43 #include <bcrypt.h>
  44
  45 /*
  46  * CNG cipher provider
  47  */
  48
  49 struct wincng_key {
  50     BCRYPT_KEY_HANDLE hKey;
  51     UCHAR rgbKeyObject[1];
  52 };
  53
  54 #define WINCNG_KEY_OBJECT_SIZE(ctx) \
  55         ((ctx)->cipher->ctx_size - sizeof(struct wincng_key) + 1)
  56
  57 static int
  58 wincng_do_cipher(EVP_CIPHER_CTX *ctx,
  59                  unsigned char *out,
  60                  const unsigned char *in,
  61                  unsigned int size)
  62 {
  63     struct wincng_key *cng = ctx->cipher_data;
  64     NTSTATUS status;
  65     ULONG cbResult;
  66
  67     assert(EVP_CIPHER_CTX_mode(ctx) == EVP_CIPH_STREAM_CIPHER ||
  68            (size % ctx->cipher->block_size) == 0);
  69
  70     if (ctx->encrypt) {
  71         status = BCryptEncrypt(cng->hKey,
  72                                (PUCHAR)in,
  73                                size,
  74                                NULL, /* pPaddingInfo */
  75                                ctx->cipher->iv_len ? ctx->iv : NULL,
  76                                ctx->cipher->iv_len,
  77                                out,
  78                                size,
  79                                &cbResult,
  80                                0);
  81     } else {
  82         status = BCryptDecrypt(cng->hKey,
  83                                (PUCHAR)in,
  84                                size,
  85                                NULL, /* pPaddingInfo */
  86                                ctx->cipher->iv_len ? ctx->iv : NULL,
  87                                ctx->cipher->iv_len,
  88                                out,
  89                                size,
  90                                &cbResult,
  91                                0);
  92     }
  93
  94     return BCRYPT_SUCCESS(status) && cbResult == size;
  95 }
  96
  97 static int
  98 wincng_cleanup(EVP_CIPHER_CTX *ctx)
  99 {
 100     struct wincng_key *cng = ctx->cipher_data;
 101
 102     if (cng->hKey)
 103         BCryptDestroyKey(cng->hKey);
 104     SecureZeroMemory(cng->rgbKeyObject, WINCNG_KEY_OBJECT_SIZE(ctx));
 105
 106     return 1;
 107 }
 108
 109 static int
 110 wincng_cipher_algorithm_init(EVP_CIPHER *cipher,
 111                              LPWSTR pszAlgId)
 112 {
 113     BCRYPT_ALG_HANDLE hAlgorithm = NULL;
 114     NTSTATUS status;
 115     LPCWSTR pszChainingMode;
 116     ULONG cbKeyObject, cbChainingMode, cbData;
 117
 118     if (cipher->app_data)
 119         return 1;
 120
 121     status = BCryptOpenAlgorithmProvider(&hAlgorithm,
 122                                          pszAlgId,
 123                                          NULL,
 124                                          0);
 125     if (!BCRYPT_SUCCESS(status))
 126         return 0;
 127
 128     status = BCryptGetProperty(hAlgorithm,
 129                                BCRYPT_OBJECT_LENGTH,
 130                                (PUCHAR)&cbKeyObject,
 131                                sizeof(ULONG),
 132                                &cbData,
 133                                0);
 134     if (!BCRYPT_SUCCESS(status)) {
 135         BCryptCloseAlgorithmProvider(hAlgorithm, 0);
 136         return 0;
 137     }
 138
 139     cipher->ctx_size = sizeof(struct wincng_key) + cbKeyObject - 1;
 140
 141     switch (cipher->flags & EVP_CIPH_MODE) {
 142     case EVP_CIPH_CBC_MODE:
 143         pszChainingMode = BCRYPT_CHAIN_MODE_CBC;
 144         cbChainingMode = sizeof(BCRYPT_CHAIN_MODE_CBC);
 145         break;
 146     case EVP_CIPH_CFB8_MODE:
 147         pszChainingMode = BCRYPT_CHAIN_MODE_CFB;
 148         cbChainingMode = sizeof(BCRYPT_CHAIN_MODE_CFB);
 149         break;
 150     default:
 151         pszChainingMode = NULL;
 152         cbChainingMode = 0;
 153         break;
 154     }
 155
 156     if (cbChainingMode) {
 157         status = BCryptSetProperty(hAlgorithm,
 158                                    BCRYPT_CHAINING_MODE,
 159                                    (PUCHAR)pszChainingMode,
 160                                    cbChainingMode,
 161                                    0);
 162         if (!BCRYPT_SUCCESS(status)) {
 163             BCryptCloseAlgorithmProvider(hAlgorithm, 0);
 164             return 0;
 165         }
 166     }
 167
 168     if (wcscmp(pszAlgId, BCRYPT_RC2_ALGORITHM) == 0) {
 169         ULONG cbEffectiveKeyLength = EVP_CIPHER_key_length(cipher) * 8;
 170
 171         status = BCryptSetProperty(hAlgorithm,
 172                                    BCRYPT_EFFECTIVE_KEY_LENGTH,
 173                                    (PUCHAR)&cbEffectiveKeyLength,
 174                                    sizeof(cbEffectiveKeyLength),
 175                                    0);
 176         if (!BCRYPT_SUCCESS(status)) {
 177             BCryptCloseAlgorithmProvider(hAlgorithm, 0);
 178             return 0;
 179         }
 180     }
 181
 182     InterlockedCompareExchangePointerRelease(&cipher->app_data,
 183                                              hAlgorithm, NULL);
 184     return 1;
 185 }
 186
 187 static int
 188 wincng_key_init(EVP_CIPHER_CTX *ctx,
 189                 const unsigned char *key,
 190                 const unsigned char *iv,
 191                 int encp)
 192 {
 193     struct wincng_key *cng = ctx->cipher_data;
 194     NTSTATUS status;
 195
 196     assert(cng != NULL);
 197     assert(ctx->cipher != NULL);
 198
 199     if (ctx->cipher->app_data == NULL)
 200         return 0;
 201
 202     /*
 203      * Note: ctx->key_len not EVP_CIPHER_CTX_key_length() for
 204      * variable length key support.
 205      */
 206     status = BCryptGenerateSymmetricKey(ctx->cipher->app_data,
 207                                         &cng->hKey,
 208                                         cng->rgbKeyObject,
 209                                         WINCNG_KEY_OBJECT_SIZE(ctx),
 210                                         (PUCHAR)key,
 211                                         ctx->key_len,
 212                                         0);
 213
 214     return BCRYPT_SUCCESS(status);
 215 }
 216
 217 #define WINCNG_CIPHER_ALGORITHM(name, alg_id, block_size, key_len,      \
 218                                 iv_len, flags)                          \
 219                                                                         \
 220     static EVP_CIPHER                                                   \
 221     wincng_##name = {                                                   \
 222         0,                                                              \
 223         block_size,                                                     \
 224         key_len,                                                        \
 225         iv_len,                                                         \
 226         flags,                                                          \
 227         wincng_key_init,                                                \
 228         wincng_do_cipher,                                               \
 229         wincng_cleanup,                                                 \
 230         0,                                                              \
 231         NULL,                                                           \
 232         NULL,                                                           \
 233         NULL,                                                           \
 234         NULL                                                            \
 235     };                                                                  \
 236                                                                         \
 237     const EVP_CIPHER *                                                  \
 238     hc_EVP_wincng_##name(void)                                          \
 239     {                                                                   \
 240         wincng_cipher_algorithm_init(&wincng_##name, alg_id);           \
 241         return wincng_##name.app_data ? &wincng_##name : NULL;          \
 242     }
 243
 244 #define WINCNG_CIPHER_ALGORITHM_CLEANUP(name) do {                      \
 245         if (wincng_##name.app_data) {                                   \
 246             BCryptCloseAlgorithmProvider(wincng_##name.app_data, 0);    \
 247             wincng_##name.app_data = NULL;                              \
 248         }                                                               \
 249     } while (0)
 250
 251 #define WINCNG_CIPHER_ALGORITHM_UNAVAILABLE(name)                       \
 252                                                                         \
 253     const EVP_CIPHER *                                                  \
 254     hc_EVP_wincng_##name(void)                                          \
 255     {                                                                   \
 256         return NULL;                                                    \
 257     }
 258
 259 /**
 260  * The tripple DES cipher type (Windows CNG provider)
 261  *
 262  * @return the DES-EDE3-CBC EVP_CIPHER pointer.
 263  *
 264  * @ingroup hcrypto_evp
 265  */
 266
 267 WINCNG_CIPHER_ALGORITHM(des_ede3_cbc,
 268                         BCRYPT_3DES_ALGORITHM,
 269                         8,
 270                         24,
 271                         8,
 272                         EVP_CIPH_CBC_MODE);
 273
 274 /**
 275  * The DES cipher type (Windows CNG provider)
 276  *
 277  * @return the DES-CBC EVP_CIPHER pointer.
 278  *
 279  * @ingroup hcrypto_evp
 280  */
 281
 282 WINCNG_CIPHER_ALGORITHM(des_cbc,
 283                         BCRYPT_DES_ALGORITHM,
 284                         8,
 285                         8,
 286                         8,
 287                         EVP_CIPH_CBC_MODE);
 288
 289 /**
 290  * The AES-128 cipher type (Windows CNG provider)
 291  *
 292  * @return the AES-128-CBC EVP_CIPHER pointer.
 293  *
 294  * @ingroup hcrypto_evp
 295  */
 296
 297 WINCNG_CIPHER_ALGORITHM(aes_128_cbc,
 298                         BCRYPT_AES_ALGORITHM,
 299                         16,
 300                         16,
 301                         16,
 302                         EVP_CIPH_CBC_MODE);
 303
 304 /**
 305  * The AES-192 cipher type (Windows CNG provider)
 306  *
 307  * @return the AES-192-CBC EVP_CIPHER pointer.
 308  *
 309  * @ingroup hcrypto_evp
 310  */
 311
 312 WINCNG_CIPHER_ALGORITHM(aes_192_cbc,
 313                         BCRYPT_AES_ALGORITHM,
 314                         16,
 315                         24,
 316                         16,
 317                         EVP_CIPH_CBC_MODE);
 318
 319 /**
 320  * The AES-256 cipher type (Windows CNG provider)
 321  *
 322  * @return the AES-256-CBC EVP_CIPHER pointer.
 323  *
 324  * @ingroup hcrypto_evp
 325  */
 326
 327 WINCNG_CIPHER_ALGORITHM(aes_256_cbc,
 328                         BCRYPT_AES_ALGORITHM,
 329                         16,
 330                         32,
 331                         16,
 332                         EVP_CIPH_CBC_MODE);
 333
 334 /**
 335  * The AES-128 CFB8 cipher type (Windows CNG provider)
 336  *
 337  * @return the AES-128-CFB8 EVP_CIPHER pointer.
 338  *
 339  * @ingroup hcrypto_evp
 340  */
 341
 342 WINCNG_CIPHER_ALGORITHM(aes_128_cfb8,
 343                         BCRYPT_AES_ALGORITHM,
 344                         16,
 345                         16,
 346                         16,
 347                         EVP_CIPH_CFB8_MODE);
 348
 349 /**
 350  * The AES-192 CFB8 cipher type (Windows CNG provider)
 351  *
 352  * @return the AES-192-CFB8 EVP_CIPHER pointer.
 353  *
 354  * @ingroup hcrypto_evp
 355  */
 356
 357 WINCNG_CIPHER_ALGORITHM(aes_192_cfb8,
 358                         BCRYPT_AES_ALGORITHM,
 359                         16,
 360                         24,
 361                         16,
 362                         EVP_CIPH_CFB8_MODE);
 363
 364 /**
 365  * The AES-256 CFB8 cipher type (Windows CNG provider)
 366  *
 367  * @return the AES-256-CFB8 EVP_CIPHER pointer.
 368  *
 369  * @ingroup hcrypto_evp
 370  */
 371
 372 WINCNG_CIPHER_ALGORITHM(aes_256_cfb8,
 373                         BCRYPT_AES_ALGORITHM,
 374                         16,
 375                         32,
 376                         16,
 377                         EVP_CIPH_CFB8_MODE);
 378
 379 /**
 380  * The RC2 cipher type - Windows CNG
 381  *
 382  * @return the RC2 EVP_CIPHER pointer.
 383  *
 384  * @ingroup hcrypto_evp
 385  */
 386
 387 WINCNG_CIPHER_ALGORITHM(rc2_cbc,
 388                         BCRYPT_RC2_ALGORITHM,
 389                         8,
 390                         16,
 391                         8,
 392                         EVP_CIPH_CBC_MODE);
 393
 394 /**
 395  * The RC2-40 cipher type - Windows CNG
 396  *
 397  * @return the RC2-40 EVP_CIPHER pointer.
 398  *
 399  * @ingroup hcrypto_evp
 400  */
 401
 402 WINCNG_CIPHER_ALGORITHM(rc2_40_cbc,
 403                         BCRYPT_RC2_ALGORITHM,
 404                         8,
 405                         5,
 406                         8,
 407                         EVP_CIPH_CBC_MODE);
 408
 409 /**
 410  * The RC2-64 cipher type - Windows CNG
 411  *
 412  * @return the RC2-64 EVP_CIPHER pointer.
 413  *
 414  * @ingroup hcrypto_evp
 415  */
 416
 417 WINCNG_CIPHER_ALGORITHM(rc2_64_cbc,
 418                         BCRYPT_RC2_ALGORITHM,
 419                         8,
 420                         8,
 421                         8,
 422                         EVP_CIPH_CBC_MODE);
 423
 424 /**
 425  * The Camellia-128 cipher type - CommonCrypto
 426  *
 427  * @return the Camellia-128 EVP_CIPHER pointer.
 428  *
 429  * @ingroup hcrypto_evp
 430  */
 431
 432 WINCNG_CIPHER_ALGORITHM_UNAVAILABLE(camellia_128_cbc);
 433
 434 /**
 435  * The Camellia-198 cipher type - CommonCrypto
 436  *
 437  * @return the Camellia-198 EVP_CIPHER pointer.
 438  *
 439  * @ingroup hcrypto_evp
 440  */
 441
 442 WINCNG_CIPHER_ALGORITHM_UNAVAILABLE(camellia_192_cbc);
 443
 444 /**
 445  * The Camellia-256 cipher type - CommonCrypto
 446  *
 447  * @return the Camellia-256 EVP_CIPHER pointer.
 448  *
 449  * @ingroup hcrypto_evp
 450  */
 451
 452 WINCNG_CIPHER_ALGORITHM_UNAVAILABLE(camellia_256_cbc);
 453
 454 /**
 455  * The RC4 cipher type (Windows CNG provider)
 456  *
 457  * @return the RC4 EVP_CIPHER pointer.
 458  *
 459  * @ingroup hcrypto_evp
 460  */
 461
 462 WINCNG_CIPHER_ALGORITHM(rc4,
 463                         BCRYPT_RC4_ALGORITHM,
 464                         1,
 465                         16,
 466                         0,
 467                         EVP_CIPH_STREAM_CIPHER | EVP_CIPH_VARIABLE_LENGTH);
 468
 469 /**
 470  * The RC4-40 cipher type (Windows CNG provider)
 471  *
 472  * @return the RC4 EVP_CIPHER pointer.
 473  *
 474  * @ingroup hcrypto_evp
 475  */
 476
 477 WINCNG_CIPHER_ALGORITHM(rc4_40,
 478                         BCRYPT_RC4_ALGORITHM,
 479                         1,
 480                         5,
 481                         0,
 482                         EVP_CIPH_STREAM_CIPHER | EVP_CIPH_VARIABLE_LENGTH);
 483
 484 static void
 485 wincng_cipher_algorithm_cleanup(void)
 486 {
 487     WINCNG_CIPHER_ALGORITHM_CLEANUP(des_ede3_cbc);
 488     WINCNG_CIPHER_ALGORITHM_CLEANUP(des_cbc);
 489     WINCNG_CIPHER_ALGORITHM_CLEANUP(aes_128_cbc);
 490     WINCNG_CIPHER_ALGORITHM_CLEANUP(aes_192_cbc);
 491     WINCNG_CIPHER_ALGORITHM_CLEANUP(aes_256_cbc);
 492     WINCNG_CIPHER_ALGORITHM_CLEANUP(aes_128_cfb8);
 493     WINCNG_CIPHER_ALGORITHM_CLEANUP(aes_192_cfb8);
 494     WINCNG_CIPHER_ALGORITHM_CLEANUP(aes_256_cfb8);
 495     WINCNG_CIPHER_ALGORITHM_CLEANUP(rc2_cbc);
 496     WINCNG_CIPHER_ALGORITHM_CLEANUP(rc2_40_cbc);
 497     WINCNG_CIPHER_ALGORITHM_CLEANUP(rc2_64_cbc);
 498     WINCNG_CIPHER_ALGORITHM_CLEANUP(rc4);
 499     WINCNG_CIPHER_ALGORITHM_CLEANUP(rc4_40);
 500 }
 501
 502 /*
 503  * CNG digest provider
 504  */
 505
 506 struct wincng_md_ctx {
 507     BCRYPT_HASH_HANDLE hHash;
 508     ULONG cbHashObject;
 509     UCHAR rgbHashObject[1];
 510 };
 511
 512 static BCRYPT_ALG_HANDLE
 513 wincng_md_algorithm_init(EVP_MD *md,
 514                          LPCWSTR pszAlgId)
 515 {
 516     BCRYPT_ALG_HANDLE hAlgorithm;
 517     NTSTATUS status;
 518     ULONG cbHashObject, cbData;
 519     ULONG cbHash = 0, cbBlock = 0;
 520
 521     status = BCryptOpenAlgorithmProvider(&hAlgorithm,
 522                                          pszAlgId,
 523                                          NULL,
 524                                          0);
 525     if (!BCRYPT_SUCCESS(status))
 526         return NULL;
 527
 528     status = BCryptGetProperty(hAlgorithm,
 529                                BCRYPT_HASH_LENGTH,
 530                                (PUCHAR)&cbHash,
 531                                sizeof(ULONG),
 532                                &cbData,
 533                                0);
 534     if (!BCRYPT_SUCCESS(status)) {
 535         BCryptCloseAlgorithmProvider(hAlgorithm, 0);
 536         return NULL;
 537     }
 538
 539     status = BCryptGetProperty(hAlgorithm,
 540                                BCRYPT_HASH_BLOCK_LENGTH,
 541                                (PUCHAR)&cbBlock,
 542                                sizeof(ULONG),
 543                                &cbData,
 544                                0);
 545     if (!BCRYPT_SUCCESS(status)) {
 546         BCryptCloseAlgorithmProvider(hAlgorithm, 0);
 547         return NULL;
 548     }
 549
 550     status = BCryptGetProperty(hAlgorithm,
 551                                BCRYPT_OBJECT_LENGTH,
 552                                (PUCHAR)&cbHashObject,
 553                                sizeof(ULONG),
 554                                &cbData,
 555                                0);
 556     if (!BCRYPT_SUCCESS(status)) {
 557         BCryptCloseAlgorithmProvider(hAlgorithm, 0);
 558         return NULL;
 559     }
 560
 561     md->hash_size = cbHash;
 562     md->block_size = cbBlock;
 563     md->ctx_size = sizeof(struct wincng_md_ctx) + cbHashObject - 1;
 564
 565     return hAlgorithm;
 566 }
 567
 568 static int
 569 wincng_md_hash_init(BCRYPT_ALG_HANDLE hAlgorithm,
 570                     EVP_MD_CTX *ctx)
 571 {
 572     struct wincng_md_ctx *cng = (struct wincng_md_ctx *)ctx;
 573     NTSTATUS status;
 574     ULONG cbData;
 575
 576     status = BCryptGetProperty(hAlgorithm,
 577                                BCRYPT_OBJECT_LENGTH,
 578                                (PUCHAR)&cng->cbHashObject,
 579                                sizeof(ULONG),
 580                                &cbData,
 581                                0);
 582     if (!BCRYPT_SUCCESS(status))
 583         return 0;
 584
 585     status = BCryptCreateHash(hAlgorithm,
 586                               &cng->hHash,
 587                               cng->rgbHashObject,
 588                               cng->cbHashObject,
 589                               NULL,
 590                               0,
 591                               0);
 592
 593     return BCRYPT_SUCCESS(status);
 594 }
 595
 596 static int
 597 wincng_md_update(EVP_MD_CTX *ctx,
 598                  const void *data,
 599                  size_t length)
 600 {
 601     struct wincng_md_ctx *cng = (struct wincng_md_ctx *)ctx;
 602     NTSTATUS status;
 603
 604     status = BCryptHashData(cng->hHash, (PUCHAR)data, length, 0);
 605
 606     return BCRYPT_SUCCESS(status);
 607 }
 608
 609 static int
 610 wincng_md_final(void *digest,
 611                 EVP_MD_CTX *ctx)
 612 {
 613     struct wincng_md_ctx *cng = (struct wincng_md_ctx *)ctx;
 614     NTSTATUS status;
 615     ULONG cbHash, cbData;
 616
 617     status = BCryptGetProperty(cng->hHash,
 618                                BCRYPT_HASH_LENGTH,
 619                                (PUCHAR)&cbHash,
 620                                sizeof(DWORD),
 621                                &cbData,
 622                                0);
 623     if (!BCRYPT_SUCCESS(status))
 624         return 0;
 625
 626     status = BCryptFinishHash(cng->hHash,
 627                               digest,
 628                               cbHash,
 629                               0);
 630
 631     return BCRYPT_SUCCESS(status);
 632 }
 633
 634 static int
 635 wincng_md_cleanup(EVP_MD_CTX *ctx)
 636 {
 637     struct wincng_md_ctx *cng = (struct wincng_md_ctx *)ctx;
 638
 639     if (cng->hHash)
 640         BCryptDestroyHash(cng->hHash);
 641     SecureZeroMemory(cng->rgbHashObject, cng->cbHashObject);
 642
 643     return 1;
 644 }
 645
 646 #define WINCNG_MD_ALGORITHM(name, alg_id)                               \
 647                                                                         \
 648     static BCRYPT_ALG_HANDLE wincng_hAlgorithm_##name;                  \
 649                                                                         \
 650     static int wincng_##name##_init(EVP_MD_CTX *ctx)                    \
 651     {                                                                   \
 652         return wincng_md_hash_init(wincng_hAlgorithm_##name, ctx);      \
 653     }                                                                   \
 654                                                                         \
 655     const EVP_MD *                                                      \
 656     hc_EVP_wincng_##name(void)                                          \
 657     {                                                                   \
 658         static struct hc_evp_md name = {                                \
 659             0,                                                          \
 660             0,                                                          \
 661             0,                                                          \
 662             wincng_##name##_init,                                       \
 663             wincng_md_update,                                           \
 664             wincng_md_final,                                            \
 665             wincng_md_cleanup                                           \
 666         };                                                              \
 667                                                                         \
 668         if (wincng_hAlgorithm_##name == NULL) {                         \
 669             BCRYPT_ALG_HANDLE hAlgorithm =                              \
 670                 wincng_md_algorithm_init(&name, alg_id);                \
 671             InterlockedCompareExchangePointerRelease(                   \
 672                 &wincng_hAlgorithm_##name, hAlgorithm, NULL);           \
 673         }                                                               \
 674         return wincng_hAlgorithm_##name ? &name : NULL;                 \
 675     }
 676
 677 #define WINCNG_MD_ALGORITHM_CLEANUP(name) do {                          \
 678         if (wincng_hAlgorithm_##name) {                                 \
 679             BCryptCloseAlgorithmProvider(wincng_hAlgorithm_##name, 0);  \
 680             wincng_hAlgorithm_##name = NULL;                            \
 681         }                                                               \
 682     } while (0)
 683
 684 WINCNG_MD_ALGORITHM(md2,    BCRYPT_MD2_ALGORITHM);
 685 WINCNG_MD_ALGORITHM(md4,    BCRYPT_MD4_ALGORITHM);
 686 WINCNG_MD_ALGORITHM(md5,    BCRYPT_MD5_ALGORITHM);
 687 WINCNG_MD_ALGORITHM(sha1,   BCRYPT_SHA1_ALGORITHM);
 688 WINCNG_MD_ALGORITHM(sha256, BCRYPT_SHA256_ALGORITHM);
 689 WINCNG_MD_ALGORITHM(sha384, BCRYPT_SHA384_ALGORITHM);
 690 WINCNG_MD_ALGORITHM(sha512, BCRYPT_SHA512_ALGORITHM);
 691
 692 static void
 693 wincng_md_algorithm_cleanup(void)
 694 {
 695     WINCNG_MD_ALGORITHM_CLEANUP(md2);
 696     WINCNG_MD_ALGORITHM_CLEANUP(md4);
 697     WINCNG_MD_ALGORITHM_CLEANUP(md5);
 698     WINCNG_MD_ALGORITHM_CLEANUP(sha1);
 699     WINCNG_MD_ALGORITHM_CLEANUP(sha256);
 700     WINCNG_MD_ALGORITHM_CLEANUP(sha384);
 701     WINCNG_MD_ALGORITHM_CLEANUP(sha512);
 702 }
 703
 704 void _hc_wincng_cleanup(void)
 705 {
 706     wincng_md_algorithm_cleanup();
 707     wincng_cipher_algorithm_cleanup();
 708 }
 709
 710 #endif /* NTDDI_VERSION >= NTDDI_VISTA */