dlls/bcrypt/bcrypt_main.c

   1 /*
   2  * Copyright 2009 Henri Verbeet for CodeWeavers
   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 "config.h"
  21 #include "wine/port.h"
  22
  23 #include <stdarg.h>
  24 #ifdef HAVE_COMMONCRYPTO_COMMONDIGEST_H
  25 #include <CommonCrypto/CommonDigest.h>
  26 #include <CommonCrypto/CommonHMAC.h>
  27 #elif defined(SONAME_LIBGNUTLS)
  28 #include <gnutls/gnutls.h>
  29 #include <gnutls/crypto.h>
  30 #endif
  31
  32 #include "ntstatus.h"
  33 #define WIN32_NO_STATUS
  34 #include "windef.h"
  35 #include "winbase.h"
  36 #include "ntsecapi.h"
  37 #include "bcrypt.h"
  38
  39 #include "wine/debug.h"
  40 #include "wine/library.h"
  41 #include "wine/unicode.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(bcrypt);
  44
  45 static HINSTANCE instance;
  46
  47 #if defined(HAVE_GNUTLS_HASH) && !defined(HAVE_COMMONCRYPTO_COMMONDIGEST_H)
  48 WINE_DECLARE_DEBUG_CHANNEL(winediag);
  49
  50 static void *libgnutls_handle;
  51 #define MAKE_FUNCPTR(f) static typeof(f) * p##f
  52 MAKE_FUNCPTR(gnutls_global_deinit);
  53 MAKE_FUNCPTR(gnutls_global_init);
  54 MAKE_FUNCPTR(gnutls_global_set_log_function);
  55 MAKE_FUNCPTR(gnutls_global_set_log_level);
  56 MAKE_FUNCPTR(gnutls_hash);
  57 MAKE_FUNCPTR(gnutls_hash_deinit);
  58 MAKE_FUNCPTR(gnutls_hash_init);
  59 MAKE_FUNCPTR(gnutls_hmac);
  60 MAKE_FUNCPTR(gnutls_hmac_deinit);
  61 MAKE_FUNCPTR(gnutls_hmac_init);
  62 MAKE_FUNCPTR(gnutls_perror);
  63 #undef MAKE_FUNCPTR
  64
  65 static void gnutls_log( int level, const char *msg )
  66 {
  67     TRACE( "<%d> %s", level, msg );
  68 }
  69
  70 static BOOL gnutls_initialize(void)
  71 {
  72     int ret;
  73
  74     if (!(libgnutls_handle = wine_dlopen( SONAME_LIBGNUTLS, RTLD_NOW, NULL, 0 )))
  75     {
  76         ERR_(winediag)( "failed to load libgnutls, no support for crypto hashes\n" );
  77         return FALSE;
  78     }
  79
  80 #define LOAD_FUNCPTR(f) \
  81     if (!(p##f = wine_dlsym( libgnutls_handle, #f, NULL, 0 ))) \
  82     { \
  83         ERR( "failed to load %s\n", #f ); \
  84         goto fail; \
  85     }
  86
  87     LOAD_FUNCPTR(gnutls_global_deinit)
  88     LOAD_FUNCPTR(gnutls_global_init)
  89     LOAD_FUNCPTR(gnutls_global_set_log_function)
  90     LOAD_FUNCPTR(gnutls_global_set_log_level)
  91     LOAD_FUNCPTR(gnutls_hash);
  92     LOAD_FUNCPTR(gnutls_hash_deinit);
  93     LOAD_FUNCPTR(gnutls_hash_init);
  94     LOAD_FUNCPTR(gnutls_hmac);
  95     LOAD_FUNCPTR(gnutls_hmac_deinit);
  96     LOAD_FUNCPTR(gnutls_hmac_init);
  97     LOAD_FUNCPTR(gnutls_perror)
  98 #undef LOAD_FUNCPTR
  99
 100     if ((ret = pgnutls_global_init()) != GNUTLS_E_SUCCESS)
 101     {
 102         pgnutls_perror( ret );
 103         goto fail;
 104     }
 105
 106     if (TRACE_ON( bcrypt ))
 107     {
 108         pgnutls_global_set_log_level( 4 );
 109         pgnutls_global_set_log_function( gnutls_log );
 110     }
 111
 112     return TRUE;
 113
 114 fail:
 115     wine_dlclose( libgnutls_handle, NULL, 0 );
 116     libgnutls_handle = NULL;
 117     return FALSE;
 118 }
 119
 120 static void gnutls_uninitialize(void)
 121 {
 122     pgnutls_global_deinit();
 123     wine_dlclose( libgnutls_handle, NULL, 0 );
 124     libgnutls_handle = NULL;
 125 }
 126 #endif /* HAVE_GNUTLS_HASH && !HAVE_COMMONCRYPTO_COMMONDIGEST_H */
 127
 128 NTSTATUS WINAPI BCryptEnumAlgorithms(ULONG dwAlgOperations, ULONG *pAlgCount,
 129                                      BCRYPT_ALGORITHM_IDENTIFIER **ppAlgList, ULONG dwFlags)
 130 {
 131     FIXME("%08x, %p, %p, %08x - stub\n", dwAlgOperations, pAlgCount, ppAlgList, dwFlags);
 132
 133     *ppAlgList=NULL;
 134     *pAlgCount=0;
 135
 136     return STATUS_NOT_IMPLEMENTED;
 137 }
 138
 139 #define MAGIC_ALG  (('A' << 24) | ('L' << 16) | ('G' << 8) | '0')
 140 #define MAGIC_HASH (('H' << 24) | ('A' << 16) | ('S' << 8) | 'H')
 141 struct object
 142 {
 143     ULONG magic;
 144 };
 145
 146 enum alg_id
 147 {
 148     ALG_ID_MD5,
 149     ALG_ID_RNG,
 150     ALG_ID_SHA1,
 151     ALG_ID_SHA256,
 152     ALG_ID_SHA384,
 153     ALG_ID_SHA512
 154 };
 155
 156 static const struct {
 157     ULONG hash_length;
 158     const WCHAR *alg_name;
 159 } alg_props[] = {
 160     /* ALG_ID_MD5    */ { 16, BCRYPT_MD5_ALGORITHM },
 161     /* ALG_ID_RNG    */ {  0, BCRYPT_RNG_ALGORITHM },
 162     /* ALG_ID_SHA1   */ { 20, BCRYPT_SHA1_ALGORITHM },
 163     /* ALG_ID_SHA256 */ { 32, BCRYPT_SHA256_ALGORITHM },
 164     /* ALG_ID_SHA384 */ { 48, BCRYPT_SHA384_ALGORITHM },
 165     /* ALG_ID_SHA512 */ { 64, BCRYPT_SHA512_ALGORITHM }
 166 };
 167
 168 struct algorithm
 169 {
 170     struct object hdr;
 171     enum alg_id   id;
 172     BOOL hmac;
 173 };
 174
 175 NTSTATUS WINAPI BCryptGenRandom(BCRYPT_ALG_HANDLE handle, UCHAR *buffer, ULONG count, ULONG flags)
 176 {
 177     const DWORD supported_flags = BCRYPT_USE_SYSTEM_PREFERRED_RNG;
 178     struct algorithm *algorithm = handle;
 179
 180     TRACE("%p, %p, %u, %08x - semi-stub\n", handle, buffer, count, flags);
 181
 182     if (!algorithm)
 183     {
 184         /* It's valid to call without an algorithm if BCRYPT_USE_SYSTEM_PREFERRED_RNG
 185          * is set. In this case the preferred system RNG is used.
 186          */
 187         if (!(flags & BCRYPT_USE_SYSTEM_PREFERRED_RNG))
 188             return STATUS_INVALID_HANDLE;
 189     }
 190     else if (algorithm->hdr.magic != MAGIC_ALG || algorithm->id != ALG_ID_RNG)
 191         return STATUS_INVALID_HANDLE;
 192
 193     if (!buffer)
 194         return STATUS_INVALID_PARAMETER;
 195
 196     if (flags & ~supported_flags)
 197         FIXME("unsupported flags %08x\n", flags & ~supported_flags);
 198
 199     if (algorithm)
 200         FIXME("ignoring selected algorithm\n");
 201
 202     /* When zero bytes are requested the function returns success too. */
 203     if (!count)
 204         return STATUS_SUCCESS;
 205
 206     if (algorithm || (flags & BCRYPT_USE_SYSTEM_PREFERRED_RNG))
 207     {
 208         if (RtlGenRandom(buffer, count))
 209             return STATUS_SUCCESS;
 210     }
 211
 212     FIXME("called with unsupported parameters, returning error\n");
 213     return STATUS_NOT_IMPLEMENTED;
 214 }
 215
 216 NTSTATUS WINAPI BCryptOpenAlgorithmProvider( BCRYPT_ALG_HANDLE *handle, LPCWSTR id, LPCWSTR implementation, DWORD flags )
 217 {
 218     struct algorithm *alg;
 219     enum alg_id alg_id;
 220
 221     const DWORD supported_flags = BCRYPT_ALG_HANDLE_HMAC_FLAG;
 222
 223     TRACE( "%p, %s, %s, %08x\n", handle, wine_dbgstr_w(id), wine_dbgstr_w(implementation), flags );
 224
 225     if (!handle || !id) return STATUS_INVALID_PARAMETER;
 226     if (flags & ~supported_flags)
 227     {
 228         FIXME( "unsupported flags %08x\n", flags & ~supported_flags);
 229         return STATUS_NOT_IMPLEMENTED;
 230     }
 231
 232     if (!strcmpW( id, BCRYPT_SHA1_ALGORITHM )) alg_id = ALG_ID_SHA1;
 233     else if (!strcmpW( id, BCRYPT_MD5_ALGORITHM )) alg_id = ALG_ID_MD5;
 234     else if (!strcmpW( id, BCRYPT_RNG_ALGORITHM )) alg_id = ALG_ID_RNG;
 235     else if (!strcmpW( id, BCRYPT_SHA256_ALGORITHM )) alg_id = ALG_ID_SHA256;
 236     else if (!strcmpW( id, BCRYPT_SHA384_ALGORITHM )) alg_id = ALG_ID_SHA384;
 237     else if (!strcmpW( id, BCRYPT_SHA512_ALGORITHM )) alg_id = ALG_ID_SHA512;
 238     else
 239     {
 240         FIXME( "algorithm %s not supported\n", debugstr_w(id) );
 241         return STATUS_NOT_IMPLEMENTED;
 242     }
 243     if (implementation && strcmpW( implementation, MS_PRIMITIVE_PROVIDER ))
 244     {
 245         FIXME( "implementation %s not supported\n", debugstr_w(implementation) );
 246         return STATUS_NOT_IMPLEMENTED;
 247     }
 248
 249     if (!(alg = HeapAlloc( GetProcessHeap(), 0, sizeof(*alg) ))) return STATUS_NO_MEMORY;
 250     alg->hdr.magic = MAGIC_ALG;
 251     alg->id        = alg_id;
 252     alg->hmac      = flags & BCRYPT_ALG_HANDLE_HMAC_FLAG;
 253
 254     *handle = alg;
 255     return STATUS_SUCCESS;
 256 }
 257
 258 NTSTATUS WINAPI BCryptCloseAlgorithmProvider( BCRYPT_ALG_HANDLE handle, DWORD flags )
 259 {
 260     struct algorithm *alg = handle;
 261
 262     TRACE( "%p, %08x\n", handle, flags );
 263
 264     if (!alg || alg->hdr.magic != MAGIC_ALG) return STATUS_INVALID_HANDLE;
 265     HeapFree( GetProcessHeap(), 0, alg );
 266     return STATUS_SUCCESS;
 267 }
 268
 269 NTSTATUS WINAPI BCryptGetFipsAlgorithmMode(BOOLEAN *enabled)
 270 {
 271     FIXME("%p - semi-stub\n", enabled);
 272
 273     if (!enabled)
 274         return STATUS_INVALID_PARAMETER;
 275
 276     *enabled = FALSE;
 277     return STATUS_SUCCESS;
 278 }
 279
 280 #ifdef HAVE_COMMONCRYPTO_COMMONDIGEST_H
 281 struct hash
 282 {
 283     struct object hdr;
 284     enum alg_id   alg_id;
 285     BOOL hmac;
 286     union
 287     {
 288         CC_MD5_CTX    md5_ctx;
 289         CC_SHA1_CTX   sha1_ctx;
 290         CC_SHA256_CTX sha256_ctx;
 291         CC_SHA512_CTX sha512_ctx;
 292         CCHmacContext hmac_ctx;
 293     } u;
 294 };
 295
 296 static NTSTATUS hash_init( struct hash *hash )
 297 {
 298     switch (hash->alg_id)
 299     {
 300     case ALG_ID_MD5:
 301         CC_MD5_Init( &hash->u.md5_ctx );
 302         break;
 303
 304     case ALG_ID_SHA1:
 305         CC_SHA1_Init( &hash->u.sha1_ctx );
 306         break;
 307
 308     case ALG_ID_SHA256:
 309         CC_SHA256_Init( &hash->u.sha256_ctx );
 310         break;
 311
 312     case ALG_ID_SHA384:
 313         CC_SHA384_Init( &hash->u.sha512_ctx );
 314         break;
 315
 316     case ALG_ID_SHA512:
 317         CC_SHA512_Init( &hash->u.sha512_ctx );
 318         break;
 319
 320     default:
 321         ERR( "unhandled id %u\n", hash->alg_id );
 322         return STATUS_NOT_IMPLEMENTED;
 323     }
 324     return STATUS_SUCCESS;
 325 }
 326
 327 static NTSTATUS hmac_init( struct hash *hash, UCHAR *key, ULONG key_size )
 328 {
 329     CCHmacAlgorithm cc_algorithm;
 330     switch (hash->alg_id)
 331     {
 332     case ALG_ID_MD5:
 333         cc_algorithm = kCCHmacAlgMD5;
 334         break;
 335
 336     case ALG_ID_SHA1:
 337         cc_algorithm = kCCHmacAlgSHA1;
 338         break;
 339
 340     case ALG_ID_SHA256:
 341         cc_algorithm = kCCHmacAlgSHA256;
 342         break;
 343
 344     case ALG_ID_SHA384:
 345         cc_algorithm = kCCHmacAlgSHA384;
 346         break;
 347
 348     case ALG_ID_SHA512:
 349         cc_algorithm = kCCHmacAlgSHA512;
 350         break;
 351
 352     default:
 353         ERR( "unhandled id %u\n", hash->alg_id );
 354         return STATUS_NOT_IMPLEMENTED;
 355     }
 356
 357     CCHmacInit( &hash->u.hmac_ctx, cc_algorithm, key, key_size );
 358     return STATUS_SUCCESS;
 359 }
 360
 361
 362 static NTSTATUS hash_update( struct hash *hash, UCHAR *input, ULONG size )
 363 {
 364     switch (hash->alg_id)
 365     {
 366     case ALG_ID_MD5:
 367         CC_MD5_Update( &hash->u.md5_ctx, input, size );
 368         break;
 369
 370     case ALG_ID_SHA1:
 371         CC_SHA1_Update( &hash->u.sha1_ctx, input, size );
 372         break;
 373
 374     case ALG_ID_SHA256:
 375         CC_SHA256_Update( &hash->u.sha256_ctx, input, size );
 376         break;
 377
 378     case ALG_ID_SHA384:
 379         CC_SHA384_Update( &hash->u.sha512_ctx, input, size );
 380         break;
 381
 382     case ALG_ID_SHA512:
 383         CC_SHA512_Update( &hash->u.sha512_ctx, input, size );
 384         break;
 385
 386     default:
 387         ERR( "unhandled id %u\n", hash->alg_id );
 388         return STATUS_NOT_IMPLEMENTED;
 389     }
 390     return STATUS_SUCCESS;
 391 }
 392
 393 static NTSTATUS hmac_update( struct hash *hash, UCHAR *input, ULONG size )
 394 {
 395     CCHmacUpdate( &hash->u.hmac_ctx, input, size );
 396     return STATUS_SUCCESS;
 397 }
 398
 399 static NTSTATUS hash_finish( struct hash *hash, UCHAR *output, ULONG size )
 400 {
 401     switch (hash->alg_id)
 402     {
 403     case ALG_ID_MD5:
 404         CC_MD5_Final( output, &hash->u.md5_ctx );
 405         break;
 406
 407     case ALG_ID_SHA1:
 408         CC_SHA1_Final( output, &hash->u.sha1_ctx );
 409         break;
 410
 411     case ALG_ID_SHA256:
 412         CC_SHA256_Final( output, &hash->u.sha256_ctx );
 413         break;
 414
 415     case ALG_ID_SHA384:
 416         CC_SHA384_Final( output, &hash->u.sha512_ctx );
 417         break;
 418
 419     case ALG_ID_SHA512:
 420         CC_SHA512_Final( output, &hash->u.sha512_ctx );
 421         break;
 422
 423     default:
 424         ERR( "unhandled id %u\n", hash->alg_id );
 425         break;
 426     }
 427     return STATUS_SUCCESS;
 428 }
 429
 430 static NTSTATUS hmac_finish( struct hash *hash, UCHAR *output, ULONG size )
 431 {
 432     CCHmacFinal( &hash->u.hmac_ctx, output );
 433
 434     return STATUS_SUCCESS;
 435 }
 436 #elif defined(HAVE_GNUTLS_HASH)
 437 struct hash
 438 {
 439     struct object    hdr;
 440     enum alg_id      alg_id;
 441     BOOL hmac;
 442     union
 443     {
 444         gnutls_hash_hd_t hash_handle;
 445         gnutls_hmac_hd_t hmac_handle;
 446     } u;
 447 };
 448
 449 static NTSTATUS hash_init( struct hash *hash )
 450 {
 451     gnutls_digest_algorithm_t alg;
 452
 453     if (!libgnutls_handle) return STATUS_INTERNAL_ERROR;
 454
 455     switch (hash->alg_id)
 456     {
 457     case ALG_ID_MD5:
 458         alg = GNUTLS_DIG_MD5;
 459         break;
 460     case ALG_ID_SHA1:
 461         alg = GNUTLS_DIG_SHA1;
 462         break;
 463
 464     case ALG_ID_SHA256:
 465         alg = GNUTLS_DIG_SHA256;
 466         break;
 467
 468     case ALG_ID_SHA384:
 469         alg = GNUTLS_DIG_SHA384;
 470         break;
 471
 472     case ALG_ID_SHA512:
 473         alg = GNUTLS_DIG_SHA512;
 474         break;
 475
 476     default:
 477         ERR( "unhandled id %u\n", hash->alg_id );
 478         return STATUS_NOT_IMPLEMENTED;
 479     }
 480
 481     if (pgnutls_hash_init( &hash->u.hash_handle, alg )) return STATUS_INTERNAL_ERROR;
 482     return STATUS_SUCCESS;
 483 }
 484
 485 static NTSTATUS hmac_init( struct hash *hash, UCHAR *key, ULONG key_size )
 486 {
 487     gnutls_mac_algorithm_t alg;
 488
 489     if (!libgnutls_handle) return STATUS_INTERNAL_ERROR;
 490
 491     switch (hash->alg_id)
 492     {
 493     case ALG_ID_MD5:
 494         alg = GNUTLS_MAC_MD5;
 495         break;
 496     case ALG_ID_SHA1:
 497         alg = GNUTLS_MAC_SHA1;
 498         break;
 499
 500     case ALG_ID_SHA256:
 501         alg = GNUTLS_MAC_SHA256;
 502         break;
 503
 504     case ALG_ID_SHA384:
 505         alg = GNUTLS_MAC_SHA384;
 506         break;
 507
 508     case ALG_ID_SHA512:
 509         alg = GNUTLS_MAC_SHA512;
 510         break;
 511
 512     default:
 513         ERR( "unhandled id %u\n", hash->alg_id );
 514         return STATUS_NOT_IMPLEMENTED;
 515     }
 516
 517     if (pgnutls_hmac_init( &hash->u.hmac_handle, alg, key, key_size )) return STATUS_INTERNAL_ERROR;
 518     return STATUS_SUCCESS;
 519 }
 520
 521 static NTSTATUS hash_update( struct hash *hash, UCHAR *input, ULONG size )
 522 {
 523     if (pgnutls_hash( hash->u.hash_handle, input, size )) return STATUS_INTERNAL_ERROR;
 524     return STATUS_SUCCESS;
 525 }
 526
 527 static NTSTATUS hmac_update( struct hash *hash, UCHAR *input, ULONG size )
 528 {
 529     if (pgnutls_hmac( hash->u.hmac_handle, input, size )) return STATUS_INTERNAL_ERROR;
 530     return STATUS_SUCCESS;
 531 }
 532
 533 static NTSTATUS hash_finish( struct hash *hash, UCHAR *output, ULONG size )
 534 {
 535     pgnutls_hash_deinit( hash->u.hash_handle, output );
 536     return STATUS_SUCCESS;
 537 }
 538
 539 static NTSTATUS hmac_finish( struct hash *hash, UCHAR *output, ULONG size )
 540 {
 541     pgnutls_hmac_deinit( hash->u.hmac_handle, output );
 542     return STATUS_SUCCESS;
 543 }
 544 #else
 545 struct hash
 546 {
 547     struct object hdr;
 548     BOOL hmac;
 549     enum alg_id   alg_id;
 550 };
 551
 552 static NTSTATUS hash_init( struct hash *hash )
 553 {
 554     ERR( "support for hashes not available at build time\n" );
 555     return STATUS_NOT_IMPLEMENTED;
 556 }
 557
 558 static NTSTATUS hmac_init( struct hash *hash, UCHAR *key, ULONG key_size )
 559 {
 560     ERR( "support for hashes not available at build time\n" );
 561     return STATUS_NOT_IMPLEMENTED;
 562 }
 563
 564 static NTSTATUS hash_update( struct hash *hash, UCHAR *input, ULONG size )
 565 {
 566     ERR( "support for hashes not available at build time\n" );
 567     return STATUS_NOT_IMPLEMENTED;
 568 }
 569
 570 static NTSTATUS hmac_update( struct hash *hash, UCHAR *input, ULONG size )
 571 {
 572     ERR( "support for hashes not available at build time\n" );
 573     return STATUS_NOT_IMPLEMENTED;
 574 }
 575
 576 static NTSTATUS hash_finish( struct hash *hash, UCHAR *output, ULONG size )
 577 {
 578     ERR( "support for hashes not available at build time\n" );
 579     return STATUS_NOT_IMPLEMENTED;
 580 }
 581
 582 static NTSTATUS hmac_finish( struct hash *hash, UCHAR *output, ULONG size )
 583 {
 584     ERR( "support for hashes not available at build time\n" );
 585     return STATUS_NOT_IMPLEMENTED;
 586 }
 587 #endif
 588
 589 #define OBJECT_LENGTH_MD5       274
 590 #define OBJECT_LENGTH_SHA1      278
 591 #define OBJECT_LENGTH_SHA256    286
 592 #define OBJECT_LENGTH_SHA384    382
 593 #define OBJECT_LENGTH_SHA512    382
 594
 595 static NTSTATUS generic_alg_property( enum alg_id id, const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size )
 596 {
 597     if (!strcmpW( prop, BCRYPT_HASH_LENGTH ))
 598     {
 599         *ret_size = sizeof(ULONG);
 600         if (size < sizeof(ULONG))
 601             return STATUS_BUFFER_TOO_SMALL;
 602         if(buf)
 603             *(ULONG*)buf = alg_props[id].hash_length;
 604         return STATUS_SUCCESS;
 605     }
 606
 607     if (!strcmpW( prop, BCRYPT_ALGORITHM_NAME ))
 608     {
 609         *ret_size = (strlenW(alg_props[id].alg_name)+1)*sizeof(WCHAR);
 610         if (size < *ret_size)
 611             return STATUS_BUFFER_TOO_SMALL;
 612         if(buf)
 613             memcpy(buf, alg_props[id].alg_name, *ret_size);
 614         return STATUS_SUCCESS;
 615     }
 616
 617     return STATUS_NOT_IMPLEMENTED;
 618 }
 619
 620 static NTSTATUS get_alg_property( enum alg_id id, const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size )
 621 {
 622     NTSTATUS status;
 623     ULONG value;
 624
 625     status = generic_alg_property( id, prop, buf, size, ret_size );
 626     if (status != STATUS_NOT_IMPLEMENTED)
 627         return status;
 628
 629     switch (id)
 630     {
 631     case ALG_ID_MD5:
 632         if (!strcmpW( prop, BCRYPT_OBJECT_LENGTH ))
 633         {
 634             value = OBJECT_LENGTH_MD5;
 635             break;
 636         }
 637         FIXME( "unsupported md5 algorithm property %s\n", debugstr_w(prop) );
 638         return STATUS_NOT_IMPLEMENTED;
 639
 640     case ALG_ID_RNG:
 641         if (!strcmpW( prop, BCRYPT_OBJECT_LENGTH )) return STATUS_NOT_SUPPORTED;
 642         FIXME( "unsupported rng algorithm property %s\n", debugstr_w(prop) );
 643         return STATUS_NOT_IMPLEMENTED;
 644
 645     case ALG_ID_SHA1:
 646         if (!strcmpW( prop, BCRYPT_OBJECT_LENGTH ))
 647         {
 648             value = OBJECT_LENGTH_SHA1;
 649             break;
 650         }
 651         FIXME( "unsupported sha1 algorithm property %s\n", debugstr_w(prop) );
 652         return STATUS_NOT_IMPLEMENTED;
 653
 654     case ALG_ID_SHA256:
 655         if (!strcmpW( prop, BCRYPT_OBJECT_LENGTH ))
 656         {
 657             value = OBJECT_LENGTH_SHA256;
 658             break;
 659         }
 660         FIXME( "unsupported sha256 algorithm property %s\n", debugstr_w(prop) );
 661         return STATUS_NOT_IMPLEMENTED;
 662
 663     case ALG_ID_SHA384:
 664         if (!strcmpW( prop, BCRYPT_OBJECT_LENGTH ))
 665         {
 666             value = OBJECT_LENGTH_SHA384;
 667             break;
 668         }
 669         FIXME( "unsupported sha384 algorithm property %s\n", debugstr_w(prop) );
 670         return STATUS_NOT_IMPLEMENTED;
 671
 672     case ALG_ID_SHA512:
 673         if (!strcmpW( prop, BCRYPT_OBJECT_LENGTH ))
 674         {
 675             value = OBJECT_LENGTH_SHA512;
 676             break;
 677         }
 678         FIXME( "unsupported sha512 algorithm property %s\n", debugstr_w(prop) );
 679         return STATUS_NOT_IMPLEMENTED;
 680
 681     default:
 682         FIXME( "unsupported algorithm %u\n", id );
 683         return STATUS_NOT_IMPLEMENTED;
 684     }
 685
 686     if (size < sizeof(ULONG))
 687     {
 688         *ret_size = sizeof(ULONG);
 689         return STATUS_BUFFER_TOO_SMALL;
 690     }
 691     if (buf) *(ULONG *)buf = value;
 692     *ret_size = sizeof(ULONG);
 693
 694     return STATUS_SUCCESS;
 695 }
 696
 697 static NTSTATUS get_hash_property( enum alg_id id, const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size )
 698 {
 699     NTSTATUS status;
 700
 701     status = generic_alg_property( id, prop, buf, size, ret_size );
 702     if (status == STATUS_NOT_IMPLEMENTED)
 703         FIXME( "unsupported property %s\n", debugstr_w(prop) );
 704     return status;
 705 }
 706
 707 NTSTATUS WINAPI BCryptGetProperty( BCRYPT_HANDLE handle, LPCWSTR prop, UCHAR *buffer, ULONG count, ULONG *res, ULONG flags )
 708 {
 709     struct object *object = handle;
 710
 711     TRACE( "%p, %s, %p, %u, %p, %08x\n", handle, wine_dbgstr_w(prop), buffer, count, res, flags );
 712
 713     if (!object) return STATUS_INVALID_HANDLE;
 714     if (!prop || !res) return STATUS_INVALID_PARAMETER;
 715
 716     switch (object->magic)
 717     {
 718     case MAGIC_ALG:
 719     {
 720         const struct algorithm *alg = (const struct algorithm *)object;
 721         return get_alg_property( alg->id, prop, buffer, count, res );
 722     }
 723     case MAGIC_HASH:
 724     {
 725         const struct hash *hash = (const struct hash *)object;
 726         return get_hash_property( hash->alg_id, prop, buffer, count, res );
 727     }
 728     default:
 729         WARN( "unknown magic %08x\n", object->magic );
 730         return STATUS_INVALID_HANDLE;
 731     }
 732 }
 733
 734 NTSTATUS WINAPI BCryptCreateHash( BCRYPT_ALG_HANDLE algorithm, BCRYPT_HASH_HANDLE *handle, UCHAR *object, ULONG objectlen,
 735                                   UCHAR *secret, ULONG secretlen, ULONG flags )
 736 {
 737     struct algorithm *alg = algorithm;
 738     struct hash *hash;
 739     NTSTATUS status;
 740
 741     TRACE( "%p, %p, %p, %u, %p, %u, %08x - stub\n", algorithm, handle, object, objectlen,
 742            secret, secretlen, flags );
 743     if (flags)
 744     {
 745         FIXME( "unimplemented flags %08x\n", flags );
 746         return STATUS_NOT_IMPLEMENTED;
 747     }
 748
 749     if (!alg || alg->hdr.magic != MAGIC_ALG) return STATUS_INVALID_HANDLE;
 750     if (object) FIXME( "ignoring object buffer\n" );
 751
 752     if (!(hash = HeapAlloc( GetProcessHeap(), 0, sizeof(*hash) ))) return STATUS_NO_MEMORY;
 753     hash->hdr.magic = MAGIC_HASH;
 754     hash->alg_id    = alg->id;
 755     hash->hmac      = alg->hmac;
 756
 757     if (hash->hmac)
 758     {
 759         status = hmac_init( hash, secret, secretlen );
 760     }
 761     else
 762     {
 763         status = hash_init( hash );
 764     }
 765
 766     if (status != STATUS_SUCCESS)
 767     {
 768         HeapFree( GetProcessHeap(), 0, hash );
 769         return status;
 770     }
 771
 772     *handle = hash;
 773     return STATUS_SUCCESS;
 774 }
 775
 776 NTSTATUS WINAPI BCryptDestroyHash( BCRYPT_HASH_HANDLE handle )
 777 {
 778     struct hash *hash = handle;
 779
 780     TRACE( "%p\n", handle );
 781
 782     if (!hash || hash->hdr.magic != MAGIC_HASH) return STATUS_INVALID_HANDLE;
 783     HeapFree( GetProcessHeap(), 0, hash );
 784     return STATUS_SUCCESS;
 785 }
 786
 787 NTSTATUS WINAPI BCryptHashData( BCRYPT_HASH_HANDLE handle, UCHAR *input, ULONG size, ULONG flags )
 788 {
 789     struct hash *hash = handle;
 790
 791     TRACE( "%p, %p, %u, %08x\n", handle, input, size, flags );
 792
 793     if (!hash || hash->hdr.magic != MAGIC_HASH) return STATUS_INVALID_HANDLE;
 794     if (!input) return STATUS_SUCCESS;
 795
 796     if (hash->hmac)
 797     {
 798         return hmac_update( hash, input, size );
 799     }
 800     else
 801     {
 802         return hash_update( hash, input, size );
 803     }
 804 }
 805
 806 NTSTATUS WINAPI BCryptFinishHash( BCRYPT_HASH_HANDLE handle, UCHAR *output, ULONG size, ULONG flags )
 807 {
 808     struct hash *hash = handle;
 809
 810     TRACE( "%p, %p, %u, %08x\n", handle, output, size, flags );
 811
 812     if (!hash || hash->hdr.magic != MAGIC_HASH) return STATUS_INVALID_HANDLE;
 813     if (!output) return STATUS_INVALID_PARAMETER;
 814
 815     if (hash->hmac)
 816     {
 817         return hmac_finish( hash, output, size );
 818     }
 819     else
 820     {
 821         return hash_finish( hash, output, size );
 822     }
 823 }
 824
 825 NTSTATUS WINAPI BCryptHash( BCRYPT_ALG_HANDLE algorithm, UCHAR *secret, ULONG secretlen,
 826                             UCHAR *input, ULONG inputlen, UCHAR *output, ULONG outputlen )
 827 {
 828     NTSTATUS status;
 829     BCRYPT_HASH_HANDLE handle;
 830
 831     TRACE( "%p, %p, %u, %p, %u, %p, %u\n", algorithm, secret, secretlen,
 832            input, inputlen, output, outputlen );
 833
 834     status = BCryptCreateHash( algorithm, &handle, NULL, 0, secret, secretlen, 0);
 835     if (status != STATUS_SUCCESS)
 836     {
 837         return status;
 838     }
 839
 840     status = BCryptHashData( handle, input, inputlen, 0 );
 841     if (status != STATUS_SUCCESS)
 842     {
 843         BCryptDestroyHash( handle );
 844         return status;
 845     }
 846
 847     status = BCryptFinishHash( handle, output, outputlen, 0 );
 848     if (status != STATUS_SUCCESS)
 849     {
 850         BCryptDestroyHash( handle );
 851         return status;
 852     }
 853
 854     return BCryptDestroyHash( handle );
 855 }
 856
 857 BOOL WINAPI DllMain( HINSTANCE hinst, DWORD reason, LPVOID reserved )
 858 {
 859     switch (reason)
 860     {
 861     case DLL_PROCESS_ATTACH:
 862         instance = hinst;
 863         DisableThreadLibraryCalls( hinst );
 864 #if defined(HAVE_GNUTLS_HASH) && !defined(HAVE_COMMONCRYPTO_COMMONDIGEST_H)
 865         gnutls_initialize();
 866 #endif
 867         break;
 868
 869     case DLL_PROCESS_DETACH:
 870         if (reserved) break;
 871 #if defined(HAVE_GNUTLS_HASH) && !defined(HAVE_COMMONCRYPTO_COMMONDIGEST_H)
 872         gnutls_uninitialize();
 873 #endif
 874         break;
 875     }
 876     return TRUE;
 877 }