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_COMMONCRYPTOR_H
  25 #include <CommonCrypto/CommonCryptor.h>
  26 #elif defined(SONAME_LIBGNUTLS)
  27 #include <gnutls/gnutls.h>
  28 #include <gnutls/crypto.h>
  29 #endif
  30
  31 #include "ntstatus.h"
  32 #define WIN32_NO_STATUS
  33 #include "windef.h"
  34 #include "winbase.h"
  35 #include "ntsecapi.h"
  36 #include "bcrypt.h"
  37
  38 #include "bcrypt_internal.h"
  39
  40 #include "wine/debug.h"
  41 #include "wine/library.h"
  42 #include "wine/unicode.h"
  43
  44 WINE_DEFAULT_DEBUG_CHANNEL(bcrypt);
  45
  46 static HINSTANCE instance;
  47
  48 #if defined(HAVE_GNUTLS_CIPHER_INIT) && !defined(HAVE_COMMONCRYPTO_COMMONCRYPTOR_H)
  49 WINE_DECLARE_DEBUG_CHANNEL(winediag);
  50
  51 static void *libgnutls_handle;
  52 #define MAKE_FUNCPTR(f) static typeof(f) * p##f
  53 MAKE_FUNCPTR(gnutls_cipher_decrypt2);
  54 MAKE_FUNCPTR(gnutls_cipher_deinit);
  55 MAKE_FUNCPTR(gnutls_cipher_encrypt2);
  56 MAKE_FUNCPTR(gnutls_cipher_init);
  57 MAKE_FUNCPTR(gnutls_global_deinit);
  58 MAKE_FUNCPTR(gnutls_global_init);
  59 MAKE_FUNCPTR(gnutls_global_set_log_function);
  60 MAKE_FUNCPTR(gnutls_global_set_log_level);
  61 MAKE_FUNCPTR(gnutls_perror);
  62 #undef MAKE_FUNCPTR
  63
  64 static void gnutls_log( int level, const char *msg )
  65 {
  66     TRACE( "<%d> %s", level, msg );
  67 }
  68
  69 static BOOL gnutls_initialize(void)
  70 {
  71     int ret;
  72
  73     if (!(libgnutls_handle = wine_dlopen( SONAME_LIBGNUTLS, RTLD_NOW, NULL, 0 )))
  74     {
  75         ERR_(winediag)( "failed to load libgnutls, no support for encryption\n" );
  76         return FALSE;
  77     }
  78
  79 #define LOAD_FUNCPTR(f) \
  80     if (!(p##f = wine_dlsym( libgnutls_handle, #f, NULL, 0 ))) \
  81     { \
  82         ERR( "failed to load %s\n", #f ); \
  83         goto fail; \
  84     }
  85
  86     LOAD_FUNCPTR(gnutls_cipher_decrypt2)
  87     LOAD_FUNCPTR(gnutls_cipher_deinit)
  88     LOAD_FUNCPTR(gnutls_cipher_encrypt2)
  89     LOAD_FUNCPTR(gnutls_cipher_init)
  90     LOAD_FUNCPTR(gnutls_global_deinit)
  91     LOAD_FUNCPTR(gnutls_global_init)
  92     LOAD_FUNCPTR(gnutls_global_set_log_function)
  93     LOAD_FUNCPTR(gnutls_global_set_log_level)
  94     LOAD_FUNCPTR(gnutls_perror)
  95 #undef LOAD_FUNCPTR
  96
  97     if ((ret = pgnutls_global_init()) != GNUTLS_E_SUCCESS)
  98     {
  99         pgnutls_perror( ret );
 100         goto fail;
 101     }
 102
 103     if (TRACE_ON( bcrypt ))
 104     {
 105         pgnutls_global_set_log_level( 4 );
 106         pgnutls_global_set_log_function( gnutls_log );
 107     }
 108
 109     return TRUE;
 110
 111 fail:
 112     wine_dlclose( libgnutls_handle, NULL, 0 );
 113     libgnutls_handle = NULL;
 114     return FALSE;
 115 }
 116
 117 static void gnutls_uninitialize(void)
 118 {
 119     pgnutls_global_deinit();
 120     wine_dlclose( libgnutls_handle, NULL, 0 );
 121     libgnutls_handle = NULL;
 122 }
 123 #endif /* HAVE_GNUTLS_CIPHER_INIT && !HAVE_COMMONCRYPTO_COMMONCRYPTOR_H */
 124
 125 NTSTATUS WINAPI BCryptAddContextFunction(ULONG table, LPCWSTR context, ULONG iface, LPCWSTR function, ULONG pos)
 126 {
 127     FIXME("%08x, %s, %08x, %s, %u: stub\n", table, debugstr_w(context), iface, debugstr_w(function), pos);
 128     return STATUS_SUCCESS;
 129 }
 130
 131 NTSTATUS WINAPI BCryptAddContextFunctionProvider(ULONG table, LPCWSTR context, ULONG iface, LPCWSTR function, LPCWSTR provider, ULONG pos)
 132 {
 133     FIXME("%08x, %s, %08x, %s, %s, %u: stub\n", table, debugstr_w(context), iface, debugstr_w(function), debugstr_w(provider), pos);
 134     return STATUS_SUCCESS;
 135 }
 136
 137 NTSTATUS WINAPI BCryptRemoveContextFunction(ULONG table, LPCWSTR context, ULONG iface, LPCWSTR function)
 138 {
 139     FIXME("%08x, %s, %08x, %s: stub\n", table, debugstr_w(context), iface, debugstr_w(function));
 140     return STATUS_NOT_IMPLEMENTED;
 141 }
 142
 143 NTSTATUS WINAPI BCryptRemoveContextFunctionProvider(ULONG table, LPCWSTR context, ULONG iface, LPCWSTR function, LPCWSTR provider)
 144 {
 145     FIXME("%08x, %s, %08x, %s, %s: stub\n", table, debugstr_w(context), iface, debugstr_w(function), debugstr_w(provider));
 146     return STATUS_NOT_IMPLEMENTED;
 147 }
 148
 149 NTSTATUS WINAPI BCryptRegisterProvider(LPCWSTR provider, ULONG flags, PCRYPT_PROVIDER_REG reg)
 150 {
 151     FIXME("%s, %08x, %p: stub\n", debugstr_w(provider), flags, reg);
 152     return STATUS_SUCCESS;
 153 }
 154
 155 NTSTATUS WINAPI BCryptUnregisterProvider(LPCWSTR provider)
 156 {
 157     FIXME("%s: stub\n", debugstr_w(provider));
 158     return STATUS_NOT_IMPLEMENTED;
 159 }
 160
 161 NTSTATUS WINAPI BCryptEnumAlgorithms(ULONG dwAlgOperations, ULONG *pAlgCount,
 162                                      BCRYPT_ALGORITHM_IDENTIFIER **ppAlgList, ULONG dwFlags)
 163 {
 164     FIXME("%08x, %p, %p, %08x - stub\n", dwAlgOperations, pAlgCount, ppAlgList, dwFlags);
 165
 166     *ppAlgList=NULL;
 167     *pAlgCount=0;
 168
 169     return STATUS_NOT_IMPLEMENTED;
 170 }
 171
 172 #define MAGIC_ALG  (('A' << 24) | ('L' << 16) | ('G' << 8) | '0')
 173 #define MAGIC_HASH (('H' << 24) | ('A' << 16) | ('S' << 8) | 'H')
 174 #define MAGIC_KEY  (('K' << 24) | ('E' << 16) | ('Y' << 8) | '0')
 175 struct object
 176 {
 177     ULONG magic;
 178 };
 179
 180 enum alg_id
 181 {
 182     ALG_ID_AES,
 183     ALG_ID_MD2,
 184     ALG_ID_MD4,
 185     ALG_ID_MD5,
 186     ALG_ID_RNG,
 187     ALG_ID_SHA1,
 188     ALG_ID_SHA256,
 189     ALG_ID_SHA384,
 190     ALG_ID_SHA512
 191 };
 192
 193 #define MAX_HASH_OUTPUT_BYTES 64
 194 #define MAX_HASH_BLOCK_BITS 1024
 195
 196 static const struct {
 197     ULONG object_length;
 198     ULONG hash_length;
 199     ULONG block_bits;
 200     const WCHAR *alg_name;
 201 } alg_props[] = {
 202     /* ALG_ID_AES    */ {  654,    0,    0, BCRYPT_AES_ALGORITHM },
 203     /* ALG_ID_MD2    */ {  270,   16,  128, BCRYPT_MD2_ALGORITHM },
 204     /* ALG_ID_MD4    */ {  270,   16,  512, BCRYPT_MD4_ALGORITHM },
 205     /* ALG_ID_MD5    */ {  274,   16,  512, BCRYPT_MD5_ALGORITHM },
 206     /* ALG_ID_RNG    */ {    0,    0,    0, BCRYPT_RNG_ALGORITHM },
 207     /* ALG_ID_SHA1   */ {  278,   20,  512, BCRYPT_SHA1_ALGORITHM },
 208     /* ALG_ID_SHA256 */ {  286,   32,  512, BCRYPT_SHA256_ALGORITHM },
 209     /* ALG_ID_SHA384 */ {  382,   48, 1024, BCRYPT_SHA384_ALGORITHM },
 210     /* ALG_ID_SHA512 */ {  382,   64, 1024, BCRYPT_SHA512_ALGORITHM }
 211 };
 212
 213 struct algorithm
 214 {
 215     struct object hdr;
 216     enum alg_id   id;
 217     BOOL hmac;
 218 };
 219
 220 NTSTATUS WINAPI BCryptGenRandom(BCRYPT_ALG_HANDLE handle, UCHAR *buffer, ULONG count, ULONG flags)
 221 {
 222     const DWORD supported_flags = BCRYPT_USE_SYSTEM_PREFERRED_RNG;
 223     struct algorithm *algorithm = handle;
 224
 225     TRACE("%p, %p, %u, %08x - semi-stub\n", handle, buffer, count, flags);
 226
 227     if (!algorithm)
 228     {
 229         /* It's valid to call without an algorithm if BCRYPT_USE_SYSTEM_PREFERRED_RNG
 230          * is set. In this case the preferred system RNG is used.
 231          */
 232         if (!(flags & BCRYPT_USE_SYSTEM_PREFERRED_RNG))
 233             return STATUS_INVALID_HANDLE;
 234     }
 235     else if (algorithm->hdr.magic != MAGIC_ALG || algorithm->id != ALG_ID_RNG)
 236         return STATUS_INVALID_HANDLE;
 237
 238     if (!buffer)
 239         return STATUS_INVALID_PARAMETER;
 240
 241     if (flags & ~supported_flags)
 242         FIXME("unsupported flags %08x\n", flags & ~supported_flags);
 243
 244     if (algorithm)
 245         FIXME("ignoring selected algorithm\n");
 246
 247     /* When zero bytes are requested the function returns success too. */
 248     if (!count)
 249         return STATUS_SUCCESS;
 250
 251     if (algorithm || (flags & BCRYPT_USE_SYSTEM_PREFERRED_RNG))
 252     {
 253         if (RtlGenRandom(buffer, count))
 254             return STATUS_SUCCESS;
 255     }
 256
 257     FIXME("called with unsupported parameters, returning error\n");
 258     return STATUS_NOT_IMPLEMENTED;
 259 }
 260
 261 NTSTATUS WINAPI BCryptOpenAlgorithmProvider( BCRYPT_ALG_HANDLE *handle, LPCWSTR id, LPCWSTR implementation, DWORD flags )
 262 {
 263     const DWORD supported_flags = BCRYPT_ALG_HANDLE_HMAC_FLAG;
 264     struct algorithm *alg;
 265     enum alg_id alg_id;
 266
 267     TRACE( "%p, %s, %s, %08x\n", handle, wine_dbgstr_w(id), wine_dbgstr_w(implementation), flags );
 268
 269     if (!handle || !id) return STATUS_INVALID_PARAMETER;
 270     if (flags & ~supported_flags)
 271     {
 272         FIXME( "unsupported flags %08x\n", flags & ~supported_flags);
 273         return STATUS_NOT_IMPLEMENTED;
 274     }
 275
 276     if (!strcmpW( id, BCRYPT_AES_ALGORITHM )) alg_id = ALG_ID_AES;
 277     else if (!strcmpW( id, BCRYPT_MD2_ALGORITHM )) alg_id = ALG_ID_MD2;
 278     else if (!strcmpW( id, BCRYPT_MD4_ALGORITHM )) alg_id = ALG_ID_MD4;
 279     else if (!strcmpW( id, BCRYPT_MD5_ALGORITHM )) alg_id = ALG_ID_MD5;
 280     else if (!strcmpW( id, BCRYPT_RNG_ALGORITHM )) alg_id = ALG_ID_RNG;
 281     else if (!strcmpW( id, BCRYPT_SHA1_ALGORITHM )) alg_id = ALG_ID_SHA1;
 282     else if (!strcmpW( id, BCRYPT_SHA256_ALGORITHM )) alg_id = ALG_ID_SHA256;
 283     else if (!strcmpW( id, BCRYPT_SHA384_ALGORITHM )) alg_id = ALG_ID_SHA384;
 284     else if (!strcmpW( id, BCRYPT_SHA512_ALGORITHM )) alg_id = ALG_ID_SHA512;
 285     else
 286     {
 287         FIXME( "algorithm %s not supported\n", debugstr_w(id) );
 288         return STATUS_NOT_IMPLEMENTED;
 289     }
 290     if (implementation && strcmpW( implementation, MS_PRIMITIVE_PROVIDER ))
 291     {
 292         FIXME( "implementation %s not supported\n", debugstr_w(implementation) );
 293         return STATUS_NOT_IMPLEMENTED;
 294     }
 295
 296     if (!(alg = HeapAlloc( GetProcessHeap(), 0, sizeof(*alg) ))) return STATUS_NO_MEMORY;
 297     alg->hdr.magic = MAGIC_ALG;
 298     alg->id        = alg_id;
 299     alg->hmac      = flags & BCRYPT_ALG_HANDLE_HMAC_FLAG;
 300
 301     *handle = alg;
 302     return STATUS_SUCCESS;
 303 }
 304
 305 NTSTATUS WINAPI BCryptCloseAlgorithmProvider( BCRYPT_ALG_HANDLE handle, DWORD flags )
 306 {
 307     struct algorithm *alg = handle;
 308
 309     TRACE( "%p, %08x\n", handle, flags );
 310
 311     if (!alg || alg->hdr.magic != MAGIC_ALG) return STATUS_INVALID_HANDLE;
 312     HeapFree( GetProcessHeap(), 0, alg );
 313     return STATUS_SUCCESS;
 314 }
 315
 316 NTSTATUS WINAPI BCryptGetFipsAlgorithmMode(BOOLEAN *enabled)
 317 {
 318     FIXME("%p - semi-stub\n", enabled);
 319
 320     if (!enabled)
 321         return STATUS_INVALID_PARAMETER;
 322
 323     *enabled = FALSE;
 324     return STATUS_SUCCESS;
 325 }
 326
 327 struct hash_impl
 328 {
 329     union
 330     {
 331         MD2_CTX md2;
 332         MD4_CTX md4;
 333         MD5_CTX md5;
 334         SHA_CTX sha1;
 335         SHA256_CTX sha256;
 336         SHA512_CTX sha512;
 337     } u;
 338 };
 339
 340 static NTSTATUS hash_init( struct hash_impl *hash, enum alg_id alg_id )
 341 {
 342     switch (alg_id)
 343     {
 344     case ALG_ID_MD2:
 345         md2_init( &hash->u.md2 );
 346         break;
 347
 348     case ALG_ID_MD4:
 349         MD4Init( &hash->u.md4 );
 350         break;
 351
 352     case ALG_ID_MD5:
 353         MD5Init( &hash->u.md5 );
 354         break;
 355
 356     case ALG_ID_SHA1:
 357         A_SHAInit( &hash->u.sha1 );
 358         break;
 359
 360     case ALG_ID_SHA256:
 361         sha256_init( &hash->u.sha256 );
 362         break;
 363
 364     case ALG_ID_SHA384:
 365         sha384_init( &hash->u.sha512 );
 366         break;
 367
 368     case ALG_ID_SHA512:
 369         sha512_init( &hash->u.sha512 );
 370         break;
 371
 372     default:
 373         ERR( "unhandled id %u\n", alg_id );
 374         return STATUS_NOT_IMPLEMENTED;
 375     }
 376     return STATUS_SUCCESS;
 377 }
 378
 379 static NTSTATUS hash_update( struct hash_impl *hash, enum alg_id alg_id,
 380                              UCHAR *input, ULONG size )
 381 {
 382     switch (alg_id)
 383     {
 384     case ALG_ID_MD2:
 385         md2_update( &hash->u.md2, input, size );
 386         break;
 387
 388     case ALG_ID_MD4:
 389         MD4Update( &hash->u.md4, input, size );
 390         break;
 391
 392     case ALG_ID_MD5:
 393         MD5Update( &hash->u.md5, input, size );
 394         break;
 395
 396     case ALG_ID_SHA1:
 397         A_SHAUpdate( &hash->u.sha1, input, size );
 398         break;
 399
 400     case ALG_ID_SHA256:
 401         sha256_update( &hash->u.sha256, input, size );
 402         break;
 403
 404     case ALG_ID_SHA384:
 405         sha384_update( &hash->u.sha512, input, size );
 406         break;
 407
 408     case ALG_ID_SHA512:
 409         sha512_update( &hash->u.sha512, input, size );
 410         break;
 411
 412     default:
 413         ERR( "unhandled id %u\n", alg_id );
 414         return STATUS_NOT_IMPLEMENTED;
 415     }
 416     return STATUS_SUCCESS;
 417 }
 418
 419 static NTSTATUS hash_finish( struct hash_impl *hash, enum alg_id alg_id,
 420                              UCHAR *output, ULONG size )
 421 {
 422     switch (alg_id)
 423     {
 424     case ALG_ID_MD2:
 425         md2_finalize( &hash->u.md2, output );
 426         break;
 427
 428     case ALG_ID_MD4:
 429         MD4Final( &hash->u.md4 );
 430         memcpy( output, hash->u.md4.digest, 16 );
 431         break;
 432
 433     case ALG_ID_MD5:
 434         MD5Final( &hash->u.md5 );
 435         memcpy( output, hash->u.md5.digest, 16 );
 436         break;
 437
 438     case ALG_ID_SHA1:
 439         A_SHAFinal( &hash->u.sha1, (ULONG *)output );
 440         break;
 441
 442     case ALG_ID_SHA256:
 443         sha256_finalize( &hash->u.sha256, output );
 444         break;
 445
 446     case ALG_ID_SHA384:
 447         sha384_finalize( &hash->u.sha512, output );
 448         break;
 449
 450     case ALG_ID_SHA512:
 451         sha512_finalize( &hash->u.sha512, output );
 452         break;
 453
 454     default:
 455         ERR( "unhandled id %u\n", alg_id );
 456         return STATUS_NOT_IMPLEMENTED;
 457     }
 458     return STATUS_SUCCESS;
 459 }
 460
 461 struct hash
 462 {
 463     struct object    hdr;
 464     enum alg_id      alg_id;
 465     BOOL             hmac;
 466     struct hash_impl outer;
 467     struct hash_impl inner;
 468 };
 469
 470 #define BLOCK_LENGTH_AES        16
 471
 472 static NTSTATUS generic_alg_property( enum alg_id id, const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size )
 473 {
 474     if (!strcmpW( prop, BCRYPT_OBJECT_LENGTH ))
 475     {
 476         if (!alg_props[id].object_length)
 477             return STATUS_NOT_SUPPORTED;
 478         *ret_size = sizeof(ULONG);
 479         if (size < sizeof(ULONG))
 480             return STATUS_BUFFER_TOO_SMALL;
 481         if (buf)
 482             *(ULONG *)buf = alg_props[id].object_length;
 483         return STATUS_SUCCESS;
 484     }
 485
 486     if (!strcmpW( prop, BCRYPT_HASH_LENGTH ))
 487     {
 488         if (!alg_props[id].hash_length)
 489             return STATUS_NOT_SUPPORTED;
 490         *ret_size = sizeof(ULONG);
 491         if (size < sizeof(ULONG))
 492             return STATUS_BUFFER_TOO_SMALL;
 493         if(buf)
 494             *(ULONG*)buf = alg_props[id].hash_length;
 495         return STATUS_SUCCESS;
 496     }
 497
 498     if (!strcmpW( prop, BCRYPT_ALGORITHM_NAME ))
 499     {
 500         *ret_size = (strlenW(alg_props[id].alg_name)+1)*sizeof(WCHAR);
 501         if (size < *ret_size)
 502             return STATUS_BUFFER_TOO_SMALL;
 503         if(buf)
 504             memcpy(buf, alg_props[id].alg_name, *ret_size);
 505         return STATUS_SUCCESS;
 506     }
 507
 508     return STATUS_NOT_IMPLEMENTED;
 509 }
 510
 511 static NTSTATUS get_alg_property( enum alg_id id, const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size )
 512 {
 513     NTSTATUS status;
 514
 515     status = generic_alg_property( id, prop, buf, size, ret_size );
 516     if (status != STATUS_NOT_IMPLEMENTED)
 517         return status;
 518
 519     switch (id)
 520     {
 521     case ALG_ID_AES:
 522         if (!strcmpW( prop, BCRYPT_BLOCK_LENGTH ))
 523         {
 524             *ret_size = sizeof(ULONG);
 525             if (size < sizeof(ULONG))
 526                 return STATUS_BUFFER_TOO_SMALL;
 527             if (buf)
 528                 *(ULONG *)buf = BLOCK_LENGTH_AES;
 529             return STATUS_SUCCESS;
 530         }
 531         if (!strcmpW( prop, BCRYPT_CHAINING_MODE ))
 532         {
 533             if (size >= sizeof(BCRYPT_CHAIN_MODE_CBC))
 534             {
 535                 memcpy(buf, BCRYPT_CHAIN_MODE_CBC, sizeof(BCRYPT_CHAIN_MODE_CBC));
 536                 *ret_size = sizeof(BCRYPT_CHAIN_MODE_CBC) * sizeof(WCHAR);
 537                 return STATUS_SUCCESS;
 538             }
 539             else
 540             {
 541                 *ret_size = sizeof(BCRYPT_CHAIN_MODE_CBC) * sizeof(WCHAR);
 542                 return STATUS_BUFFER_TOO_SMALL;
 543             }
 544         }
 545         if (!strcmpW( prop, BCRYPT_KEY_LENGTHS ))
 546         {
 547             BCRYPT_KEY_LENGTHS_STRUCT *key_lengths = (void *)buf;
 548             *ret_size = sizeof(*key_lengths);
 549             if (key_lengths && size < *ret_size) return STATUS_BUFFER_TOO_SMALL;
 550             if (key_lengths)
 551             {
 552                 key_lengths->dwMinLength = 128;
 553                 key_lengths->dwMaxLength = 256;
 554                 key_lengths->dwIncrement = 64;
 555             }
 556             return STATUS_SUCCESS;
 557         }
 558         break;
 559
 560     default:
 561         break;
 562     }
 563
 564     FIXME( "unsupported property %s\n", debugstr_w(prop) );
 565     return STATUS_NOT_IMPLEMENTED;
 566 }
 567
 568 static NTSTATUS get_hash_property( enum alg_id id, const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size )
 569 {
 570     NTSTATUS status;
 571
 572     status = generic_alg_property( id, prop, buf, size, ret_size );
 573     if (status == STATUS_NOT_IMPLEMENTED)
 574         FIXME( "unsupported property %s\n", debugstr_w(prop) );
 575     return status;
 576 }
 577
 578 NTSTATUS WINAPI BCryptGetProperty( BCRYPT_HANDLE handle, LPCWSTR prop, UCHAR *buffer, ULONG count, ULONG *res, ULONG flags )
 579 {
 580     struct object *object = handle;
 581
 582     TRACE( "%p, %s, %p, %u, %p, %08x\n", handle, wine_dbgstr_w(prop), buffer, count, res, flags );
 583
 584     if (!object) return STATUS_INVALID_HANDLE;
 585     if (!prop || !res) return STATUS_INVALID_PARAMETER;
 586
 587     switch (object->magic)
 588     {
 589     case MAGIC_ALG:
 590     {
 591         const struct algorithm *alg = (const struct algorithm *)object;
 592         return get_alg_property( alg->id, prop, buffer, count, res );
 593     }
 594     case MAGIC_HASH:
 595     {
 596         const struct hash *hash = (const struct hash *)object;
 597         return get_hash_property( hash->alg_id, prop, buffer, count, res );
 598     }
 599     default:
 600         WARN( "unknown magic %08x\n", object->magic );
 601         return STATUS_INVALID_HANDLE;
 602     }
 603 }
 604
 605 NTSTATUS WINAPI BCryptSetProperty( BCRYPT_HANDLE handle, const WCHAR *prop, UCHAR *value, ULONG size, ULONG flags )
 606 {
 607     FIXME( "%p, %s, %p, %u, %08x\n", handle, debugstr_w(prop), value, size, flags );
 608     return STATUS_NOT_IMPLEMENTED;
 609 }
 610
 611 NTSTATUS WINAPI BCryptCreateHash( BCRYPT_ALG_HANDLE algorithm, BCRYPT_HASH_HANDLE *handle, UCHAR *object, ULONG objectlen,
 612                                   UCHAR *secret, ULONG secretlen, ULONG flags )
 613 {
 614     struct algorithm *alg = algorithm;
 615     UCHAR buffer[MAX_HASH_BLOCK_BITS / 8] = {0};
 616     struct hash *hash;
 617     int block_bytes;
 618     NTSTATUS status;
 619     int i;
 620
 621     TRACE( "%p, %p, %p, %u, %p, %u, %08x - stub\n", algorithm, handle, object, objectlen,
 622            secret, secretlen, flags );
 623     if (flags)
 624     {
 625         FIXME( "unimplemented flags %08x\n", flags );
 626         return STATUS_NOT_IMPLEMENTED;
 627     }
 628
 629     if (!alg || alg->hdr.magic != MAGIC_ALG) return STATUS_INVALID_HANDLE;
 630     if (object) FIXME( "ignoring object buffer\n" );
 631
 632     if (!(hash = HeapAlloc( GetProcessHeap(), 0, sizeof(*hash) ))) return STATUS_NO_MEMORY;
 633     hash->hdr.magic = MAGIC_HASH;
 634     hash->alg_id    = alg->id;
 635     hash->hmac      = alg->hmac;
 636
 637     /* initialize hash */
 638     if ((status = hash_init( &hash->inner, hash->alg_id ))) goto end;
 639     if (!hash->hmac) goto end;
 640
 641     /* initialize hmac */
 642     if ((status = hash_init( &hash->outer, hash->alg_id ))) goto end;
 643     block_bytes = alg_props[hash->alg_id].block_bits / 8;
 644     if (secretlen > block_bytes)
 645     {
 646         struct hash_impl temp;
 647         if ((status = hash_init( &temp, hash->alg_id ))) goto end;
 648         if ((status = hash_update( &temp, hash->alg_id, secret, secretlen ))) goto end;
 649         if ((status = hash_finish( &temp, hash->alg_id, buffer,
 650                                    alg_props[hash->alg_id].hash_length ))) goto end;
 651     }
 652     else
 653     {
 654         memcpy( buffer, secret, secretlen );
 655     }
 656     for (i = 0; i < block_bytes; i++) buffer[i] ^= 0x5c;
 657     if ((status = hash_update( &hash->outer, hash->alg_id, buffer, block_bytes ))) goto end;
 658     for (i = 0; i < block_bytes; i++) buffer[i] ^= (0x5c ^ 0x36);
 659     status = hash_update( &hash->inner, hash->alg_id, buffer, block_bytes );
 660
 661 end:
 662     if (status != STATUS_SUCCESS)
 663     {
 664         HeapFree( GetProcessHeap(), 0, hash );
 665         return status;
 666     }
 667
 668     *handle = hash;
 669     return STATUS_SUCCESS;
 670 }
 671
 672 NTSTATUS WINAPI BCryptDuplicateHash( BCRYPT_HASH_HANDLE handle, BCRYPT_HASH_HANDLE *handle_copy,
 673                                      UCHAR *object, ULONG objectlen, ULONG flags )
 674 {
 675     struct hash *hash_orig = handle;
 676     struct hash *hash_copy;
 677
 678     TRACE( "%p, %p, %p, %u, %u\n", handle, handle_copy, object, objectlen, flags );
 679
 680     if (!hash_orig || hash_orig->hdr.magic != MAGIC_HASH) return STATUS_INVALID_HANDLE;
 681     if (!handle_copy) return STATUS_INVALID_PARAMETER;
 682     if (object) FIXME( "ignoring object buffer\n" );
 683
 684     if (!(hash_copy = HeapAlloc( GetProcessHeap(), 0, sizeof(*hash_copy) )))
 685         return STATUS_NO_MEMORY;
 686
 687     memcpy( hash_copy, hash_orig, sizeof(*hash_orig) );
 688
 689     *handle_copy = hash_copy;
 690     return STATUS_SUCCESS;
 691 }
 692
 693 NTSTATUS WINAPI BCryptDestroyHash( BCRYPT_HASH_HANDLE handle )
 694 {
 695     struct hash *hash = handle;
 696
 697     TRACE( "%p\n", handle );
 698
 699     if (!hash || hash->hdr.magic != MAGIC_HASH) return STATUS_INVALID_HANDLE;
 700     HeapFree( GetProcessHeap(), 0, hash );
 701     return STATUS_SUCCESS;
 702 }
 703
 704 NTSTATUS WINAPI BCryptHashData( BCRYPT_HASH_HANDLE handle, UCHAR *input, ULONG size, ULONG flags )
 705 {
 706     struct hash *hash = handle;
 707
 708     TRACE( "%p, %p, %u, %08x\n", handle, input, size, flags );
 709
 710     if (!hash || hash->hdr.magic != MAGIC_HASH) return STATUS_INVALID_HANDLE;
 711     if (!input) return STATUS_SUCCESS;
 712
 713     return hash_update( &hash->inner, hash->alg_id, input, size );
 714 }
 715
 716 NTSTATUS WINAPI BCryptFinishHash( BCRYPT_HASH_HANDLE handle, UCHAR *output, ULONG size, ULONG flags )
 717 {
 718     UCHAR buffer[MAX_HASH_OUTPUT_BYTES];
 719     struct hash *hash = handle;
 720     NTSTATUS status;
 721     int hash_length;
 722
 723     TRACE( "%p, %p, %u, %08x\n", handle, output, size, flags );
 724
 725     if (!hash || hash->hdr.magic != MAGIC_HASH) return STATUS_INVALID_HANDLE;
 726     if (!output) return STATUS_INVALID_PARAMETER;
 727
 728     if (!hash->hmac)
 729         return hash_finish( &hash->inner, hash->alg_id, output, size );
 730
 731     hash_length = alg_props[hash->alg_id].hash_length;
 732     if ((status = hash_finish( &hash->inner, hash->alg_id, buffer, hash_length ))) return status;
 733     if ((status = hash_update( &hash->outer, hash->alg_id, buffer, hash_length ))) return status;
 734     return hash_finish( &hash->outer, hash->alg_id, output, size );
 735 }
 736
 737 NTSTATUS WINAPI BCryptHash( BCRYPT_ALG_HANDLE algorithm, UCHAR *secret, ULONG secretlen,
 738                             UCHAR *input, ULONG inputlen, UCHAR *output, ULONG outputlen )
 739 {
 740     NTSTATUS status;
 741     BCRYPT_HASH_HANDLE handle;
 742
 743     TRACE( "%p, %p, %u, %p, %u, %p, %u\n", algorithm, secret, secretlen,
 744            input, inputlen, output, outputlen );
 745
 746     status = BCryptCreateHash( algorithm, &handle, NULL, 0, secret, secretlen, 0);
 747     if (status != STATUS_SUCCESS)
 748     {
 749         return status;
 750     }
 751
 752     status = BCryptHashData( handle, input, inputlen, 0 );
 753     if (status != STATUS_SUCCESS)
 754     {
 755         BCryptDestroyHash( handle );
 756         return status;
 757     }
 758
 759     status = BCryptFinishHash( handle, output, outputlen, 0 );
 760     if (status != STATUS_SUCCESS)
 761     {
 762         BCryptDestroyHash( handle );
 763         return status;
 764     }
 765
 766     return BCryptDestroyHash( handle );
 767 }
 768
 769 #if defined(HAVE_GNUTLS_CIPHER_INIT) || defined(HAVE_COMMONCRYPTO_COMMONCRYPTOR_H)
 770 static ULONG get_block_size( enum alg_id alg )
 771 {
 772     ULONG ret = 0, size = sizeof(ret);
 773     get_alg_property( alg, BCRYPT_BLOCK_LENGTH, (UCHAR *)&ret, sizeof(ret), &size );
 774     return ret;
 775 }
 776 #endif
 777
 778 #if defined(HAVE_GNUTLS_CIPHER_INIT) && !defined(HAVE_COMMONCRYPTO_COMMONCRYPTOR_H)
 779 struct key
 780 {
 781     struct object      hdr;
 782     enum alg_id        alg_id;
 783     ULONG              block_size;
 784     gnutls_cipher_hd_t handle;
 785     UCHAR             *secret;
 786     ULONG              secret_len;
 787 };
 788
 789 static NTSTATUS key_init( struct key *key, enum alg_id id, const UCHAR *secret, ULONG secret_len )
 790 {
 791     UCHAR *buffer;
 792
 793     if (!libgnutls_handle) return STATUS_INTERNAL_ERROR;
 794
 795     switch (id)
 796     {
 797     case ALG_ID_AES:
 798         break;
 799
 800     default:
 801         FIXME( "algorithm %u not supported\n", id );
 802         return STATUS_NOT_SUPPORTED;
 803     }
 804
 805     if (!(key->block_size = get_block_size( id ))) return STATUS_INVALID_PARAMETER;
 806     if (!(buffer = HeapAlloc( GetProcessHeap(), 0, secret_len ))) return STATUS_NO_MEMORY;
 807     memcpy( buffer, secret, secret_len );
 808
 809     key->alg_id     = id;
 810     key->handle     = 0;        /* initialized on first use */
 811     key->secret     = buffer;
 812     key->secret_len = secret_len;
 813
 814     return STATUS_SUCCESS;
 815 }
 816
 817 static gnutls_cipher_algorithm_t get_gnutls_cipher( const struct key *key )
 818 {
 819     switch (key->alg_id)
 820     {
 821     case ALG_ID_AES:
 822         FIXME( "handle block size and chaining mode\n" );
 823         return GNUTLS_CIPHER_AES_128_CBC;
 824
 825     default:
 826         FIXME( "algorithm %u not supported\n", key->alg_id );
 827         return GNUTLS_CIPHER_UNKNOWN;
 828     }
 829 }
 830
 831 static NTSTATUS key_set_params( struct key *key, UCHAR *iv, ULONG iv_len )
 832 {
 833     gnutls_cipher_algorithm_t cipher;
 834     gnutls_datum_t secret, vector;
 835     int ret;
 836
 837     if (key->handle)
 838     {
 839         pgnutls_cipher_deinit( key->handle );
 840         key->handle = NULL;
 841     }
 842
 843     if ((cipher = get_gnutls_cipher( key )) == GNUTLS_CIPHER_UNKNOWN)
 844         return STATUS_NOT_SUPPORTED;
 845
 846     secret.data = key->secret;
 847     secret.size = key->secret_len;
 848     if (iv)
 849     {
 850         vector.data = iv;
 851         vector.size = iv_len;
 852     }
 853
 854     if ((ret = pgnutls_cipher_init( &key->handle, cipher, &secret, iv ? &vector : NULL )))
 855     {
 856         pgnutls_perror( ret );
 857         return STATUS_INTERNAL_ERROR;
 858     }
 859
 860     return STATUS_SUCCESS;
 861 }
 862
 863 static NTSTATUS key_encrypt( struct key *key, const UCHAR *input, ULONG input_len, UCHAR *output,
 864                              ULONG output_len )
 865 {
 866     int ret;
 867
 868     if ((ret = pgnutls_cipher_encrypt2( key->handle, input, input_len, output, output_len )))
 869     {
 870         pgnutls_perror( ret );
 871         return STATUS_INTERNAL_ERROR;
 872     }
 873
 874     return STATUS_SUCCESS;
 875 }
 876
 877 static NTSTATUS key_decrypt( struct key *key, const UCHAR *input, ULONG input_len, UCHAR *output,
 878                              ULONG output_len  )
 879 {
 880     int ret;
 881
 882     if ((ret = pgnutls_cipher_decrypt2( key->handle, input, input_len, output, output_len )))
 883     {
 884         pgnutls_perror( ret );
 885         return STATUS_INTERNAL_ERROR;
 886     }
 887
 888     return STATUS_SUCCESS;
 889 }
 890
 891 static NTSTATUS key_destroy( struct key *key )
 892 {
 893     if (key->handle) pgnutls_cipher_deinit( key->handle );
 894     HeapFree( GetProcessHeap(), 0, key->secret );
 895     HeapFree( GetProcessHeap(), 0, key );
 896     return STATUS_SUCCESS;
 897 }
 898 #elif defined(HAVE_COMMONCRYPTO_COMMONCRYPTOR_H)
 899 struct key
 900 {
 901     struct object  hdr;
 902     enum alg_id    alg_id;
 903     ULONG          block_size;
 904     CCCryptorRef   ref_encrypt;
 905     CCCryptorRef   ref_decrypt;
 906     UCHAR         *secret;
 907     ULONG          secret_len;
 908 };
 909
 910 static NTSTATUS key_init( struct key *key, enum alg_id id, const UCHAR *secret, ULONG secret_len )
 911 {
 912     UCHAR *buffer;
 913
 914     switch (id)
 915     {
 916     case ALG_ID_AES:
 917         break;
 918
 919     default:
 920         FIXME( "algorithm %u not supported\n", id );
 921         return STATUS_NOT_SUPPORTED;
 922     }
 923
 924     if (!(key->block_size = get_block_size( id ))) return STATUS_INVALID_PARAMETER;
 925     if (!(buffer = HeapAlloc( GetProcessHeap(), 0, secret_len ))) return STATUS_NO_MEMORY;
 926     memcpy( buffer, secret, secret_len );
 927
 928     key->alg_id      = id;
 929     key->ref_encrypt = NULL;        /* initialized on first use */
 930     key->ref_decrypt = NULL;
 931     key->secret      = buffer;
 932     key->secret_len  = secret_len;
 933
 934     return STATUS_SUCCESS;
 935 }
 936
 937 static NTSTATUS key_set_params( struct key *key, UCHAR *iv, ULONG iv_len )
 938 {
 939     CCCryptorStatus status;
 940
 941     if (key->ref_encrypt)
 942     {
 943         CCCryptorRelease( key->ref_encrypt );
 944         key->ref_encrypt = NULL;
 945     }
 946     if (key->ref_decrypt)
 947     {
 948         CCCryptorRelease( key->ref_decrypt );
 949         key->ref_decrypt = NULL;
 950     }
 951
 952     if ((status = CCCryptorCreateWithMode( kCCEncrypt, kCCModeCBC, kCCAlgorithmAES, ccNoPadding, iv,
 953                                            key->secret, key->secret_len, NULL, 0, 0, 0, &key->ref_encrypt )) != kCCSuccess)
 954     {
 955         WARN( "CCCryptorCreateWithMode failed %d\n", status );
 956         return STATUS_INTERNAL_ERROR;
 957     }
 958     if ((status = CCCryptorCreateWithMode( kCCDecrypt, kCCModeCBC, kCCAlgorithmAES, ccNoPadding, iv,
 959                                            key->secret, key->secret_len, NULL, 0, 0, 0, &key->ref_decrypt )) != kCCSuccess)
 960     {
 961         WARN( "CCCryptorCreateWithMode failed %d\n", status );
 962         CCCryptorRelease( key->ref_encrypt );
 963         key->ref_encrypt = NULL;
 964         return STATUS_INTERNAL_ERROR;
 965     }
 966
 967     return STATUS_SUCCESS;
 968 }
 969
 970 static NTSTATUS key_encrypt( struct key *key, const UCHAR *input, ULONG input_len, UCHAR *output,
 971                              ULONG output_len  )
 972 {
 973     CCCryptorStatus status;
 974
 975     if ((status = CCCryptorUpdate( key->ref_encrypt, input, input_len, output, output_len, NULL  )) != kCCSuccess)
 976     {
 977         WARN( "CCCryptorUpdate failed %d\n", status );
 978         return STATUS_INTERNAL_ERROR;
 979     }
 980
 981     return STATUS_SUCCESS;
 982 }
 983
 984 static NTSTATUS key_decrypt( struct key *key, const UCHAR *input, ULONG input_len, UCHAR *output,
 985                              ULONG output_len )
 986 {
 987     CCCryptorStatus status;
 988
 989     if ((status = CCCryptorUpdate( key->ref_decrypt, input, input_len, output, output_len, NULL  )) != kCCSuccess)
 990     {
 991         WARN( "CCCryptorUpdate failed %d\n", status );
 992         return STATUS_INTERNAL_ERROR;
 993     }
 994
 995     return STATUS_SUCCESS;
 996 }
 997
 998 static NTSTATUS key_destroy( struct key *key )
 999 {
1000     if (key->ref_encrypt) CCCryptorRelease( key->ref_encrypt );
1001     if (key->ref_decrypt) CCCryptorRelease( key->ref_decrypt );
1002     HeapFree( GetProcessHeap(), 0, key->secret );
1003     HeapFree( GetProcessHeap(), 0, key );
1004     return STATUS_SUCCESS;
1005 }
1006 #else
1007 struct key
1008 {
1009     struct object hdr;
1010     ULONG         block_size;
1011 };
1012
1013 static NTSTATUS key_init( struct key *key, enum alg_id id, const UCHAR *secret, ULONG secret_len )
1014 {
1015     ERR( "support for keys not available at build time\n" );
1016     return STATUS_NOT_IMPLEMENTED;
1017 }
1018
1019 static NTSTATUS key_set_params( struct key *key, UCHAR *iv, ULONG iv_len )
1020 {
1021     ERR( "support for keys not available at build time\n" );
1022     return STATUS_NOT_IMPLEMENTED;
1023 }
1024
1025 static NTSTATUS key_encrypt( struct key *key, const UCHAR *input, ULONG input_len, UCHAR *output,
1026                              ULONG output_len  )
1027 {
1028     ERR( "support for keys not available at build time\n" );
1029     return STATUS_NOT_IMPLEMENTED;
1030 }
1031
1032 static NTSTATUS key_decrypt( struct key *key, const UCHAR *input, ULONG input_len, UCHAR *output,
1033                              ULONG output_len )
1034 {
1035     ERR( "support for keys not available at build time\n" );
1036     return STATUS_NOT_IMPLEMENTED;
1037 }
1038
1039 static NTSTATUS key_destroy( struct key *key )
1040 {
1041     ERR( "support for keys not available at build time\n" );
1042     return STATUS_NOT_IMPLEMENTED;
1043 }
1044 #endif
1045
1046 NTSTATUS WINAPI BCryptGenerateSymmetricKey( BCRYPT_ALG_HANDLE algorithm, BCRYPT_KEY_HANDLE *handle,
1047                                             UCHAR *object, ULONG object_len, UCHAR *secret, ULONG secret_len,
1048                                             ULONG flags )
1049 {
1050     struct algorithm *alg = algorithm;
1051     struct key *key;
1052     NTSTATUS status;
1053
1054     TRACE( "%p, %p, %p, %u, %p, %u, %08x\n", algorithm, handle, object, object_len, secret, secret_len, flags );
1055
1056     if (!alg || alg->hdr.magic != MAGIC_ALG) return STATUS_INVALID_HANDLE;
1057     if (object) FIXME( "ignoring object buffer\n" );
1058
1059     if (!(key = HeapAlloc( GetProcessHeap(), 0, sizeof(*key) ))) return STATUS_NO_MEMORY;
1060     key->hdr.magic = MAGIC_KEY;
1061
1062     if ((status = key_init( key, alg->id, secret, secret_len )))
1063     {
1064         HeapFree( GetProcessHeap(), 0, key );
1065         return status;
1066     }
1067
1068     *handle = key;
1069     return STATUS_SUCCESS;
1070 }
1071
1072 NTSTATUS WINAPI BCryptDestroyKey( BCRYPT_KEY_HANDLE handle )
1073 {
1074     struct key *key = handle;
1075
1076     TRACE( "%p\n", handle );
1077
1078     if (!key || key->hdr.magic != MAGIC_KEY) return STATUS_INVALID_HANDLE;
1079     return key_destroy( key );
1080 }
1081
1082 NTSTATUS WINAPI BCryptEncrypt( BCRYPT_KEY_HANDLE handle, UCHAR *input, ULONG input_len,
1083                                void *padding, UCHAR *iv, ULONG iv_len, UCHAR *output,
1084                                ULONG output_len, ULONG *ret_len, ULONG flags )
1085 {
1086     struct key *key = handle;
1087     ULONG bytes_left = input_len;
1088     UCHAR *buf, *src, *dst;
1089     NTSTATUS status;
1090
1091     TRACE( "%p, %p, %u, %p, %p, %u, %p, %u, %p, %08x\n", handle, input, input_len,
1092            padding, iv, iv_len, output, output_len, ret_len, flags );
1093
1094     if (!key || key->hdr.magic != MAGIC_KEY) return STATUS_INVALID_HANDLE;
1095     if (padding)
1096     {
1097         FIXME( "padding info not implemented\n" );
1098         return STATUS_NOT_IMPLEMENTED;
1099     }
1100     if (flags & ~BCRYPT_BLOCK_PADDING)
1101     {
1102         FIXME( "flags %08x not implemented\n", flags );
1103         return STATUS_NOT_IMPLEMENTED;
1104     }
1105
1106     if ((status = key_set_params( key, iv, iv_len ))) return status;
1107
1108     *ret_len = input_len;
1109
1110     if (flags & BCRYPT_BLOCK_PADDING)
1111         *ret_len = (input_len + key->block_size) & ~(key->block_size - 1);
1112     else if (input_len & (key->block_size - 1))
1113         return STATUS_INVALID_BUFFER_SIZE;
1114
1115     if (!output) return STATUS_SUCCESS;
1116     if (output_len < *ret_len) return STATUS_BUFFER_TOO_SMALL;
1117
1118     src = input;
1119     dst = output;
1120     while (bytes_left >= key->block_size)
1121     {
1122         if ((status = key_encrypt( key, src, key->block_size, dst, key->block_size ))) return status;
1123         bytes_left -= key->block_size;
1124         src += key->block_size;
1125         dst += key->block_size;
1126     }
1127
1128     if (flags & BCRYPT_BLOCK_PADDING)
1129     {
1130         if (!(buf = HeapAlloc( GetProcessHeap(), 0, key->block_size ))) return STATUS_NO_MEMORY;
1131         memcpy( buf, src, bytes_left );
1132         memset( buf + bytes_left, key->block_size - bytes_left, key->block_size - bytes_left );
1133         status = key_encrypt( key, buf, key->block_size, dst, key->block_size );
1134         HeapFree( GetProcessHeap(), 0, buf );
1135     }
1136
1137     return status;
1138 }
1139
1140 NTSTATUS WINAPI BCryptDecrypt( BCRYPT_KEY_HANDLE handle, UCHAR *input, ULONG input_len,
1141                                void *padding, UCHAR *iv, ULONG iv_len, UCHAR *output,
1142                                ULONG output_len, ULONG *ret_len, ULONG flags )
1143 {
1144     struct key *key = handle;
1145     ULONG bytes_left = input_len;
1146     UCHAR *buf, *src, *dst;
1147     NTSTATUS status;
1148
1149     TRACE( "%p, %p, %u, %p, %p, %u, %p, %u, %p, %08x\n", handle, input, input_len,
1150            padding, iv, iv_len, output, output_len, ret_len, flags );
1151
1152     if (!key || key->hdr.magic != MAGIC_KEY) return STATUS_INVALID_HANDLE;
1153     if (padding)
1154     {
1155         FIXME( "padding info not implemented\n" );
1156         return STATUS_NOT_IMPLEMENTED;
1157     }
1158     if (flags & ~BCRYPT_BLOCK_PADDING)
1159     {
1160         FIXME( "flags %08x not supported\n", flags );
1161         return STATUS_NOT_IMPLEMENTED;
1162     }
1163
1164     if ((status = key_set_params( key, iv, iv_len ))) return status;
1165
1166     *ret_len = input_len;
1167
1168     if (input_len & (key->block_size - 1)) return STATUS_INVALID_BUFFER_SIZE;
1169     if (!output) return STATUS_SUCCESS;
1170     if (flags & BCRYPT_BLOCK_PADDING)
1171     {
1172         if (output_len + key->block_size < *ret_len) return STATUS_BUFFER_TOO_SMALL;
1173         if (input_len < key->block_size) return STATUS_BUFFER_TOO_SMALL;
1174         bytes_left -= key->block_size;
1175     }
1176     else if (output_len < *ret_len)
1177         return STATUS_BUFFER_TOO_SMALL;
1178
1179     src = input;
1180     dst = output;
1181     while (bytes_left >= key->block_size)
1182     {
1183         if ((status = key_decrypt( key, src, key->block_size, dst, key->block_size ))) return status;
1184         bytes_left -= key->block_size;
1185         src += key->block_size;
1186         dst += key->block_size;
1187     }
1188
1189     if (flags & BCRYPT_BLOCK_PADDING)
1190     {
1191         if (!(buf = HeapAlloc( GetProcessHeap(), 0, key->block_size ))) return STATUS_NO_MEMORY;
1192         status = key_decrypt( key, src, key->block_size, buf, key->block_size );
1193         if (!status && buf[ key->block_size - 1 ] <= key->block_size)
1194         {
1195             *ret_len -= buf[ key->block_size - 1 ];
1196             if (output_len < *ret_len) status = STATUS_BUFFER_TOO_SMALL;
1197             else memcpy( dst, buf, key->block_size - buf[ key->block_size - 1 ] );
1198         }
1199         else
1200             status = STATUS_UNSUCCESSFUL; /* FIXME: invalid padding */
1201         HeapFree( GetProcessHeap(), 0, buf );
1202     }
1203
1204     return status;
1205 }
1206
1207 BOOL WINAPI DllMain( HINSTANCE hinst, DWORD reason, LPVOID reserved )
1208 {
1209     switch (reason)
1210     {
1211     case DLL_PROCESS_ATTACH:
1212         instance = hinst;
1213         DisableThreadLibraryCalls( hinst );
1214 #if defined(HAVE_GNUTLS_CIPHER_INIT) && !defined(HAVE_COMMONCRYPTO_COMMONCRYPTOR_H)
1215         gnutls_initialize();
1216 #endif
1217         break;
1218
1219     case DLL_PROCESS_DETACH:
1220         if (reserved) break;
1221 #if defined(HAVE_GNUTLS_CIPHER_INIT) && !defined(HAVE_COMMONCRYPTO_COMMONCRYPTOR_H)
1222         gnutls_uninitialize();
1223 #endif
1224         break;
1225     }
1226     return TRUE;
1227 }