dlls/ncrypt/main.c

   1 /*
   2  * New cryptographic library (ncrypt.dll)
   3  *
   4  * Copyright 2016 Alex Henrie
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdarg.h>
  22 #include <stdlib.h>
  23
  24 #include "ntstatus.h"
  25 #define WIN32_NO_STATUS
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "ncrypt.h"
  29 #include "bcrypt.h"
  30 #include "ncrypt_internal.h"
  31 #include "wine/debug.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(ncrypt);
  34
  35 static SECURITY_STATUS map_ntstatus(NTSTATUS status)
  36 {
  37     switch (status)
  38     {
  39     case STATUS_INVALID_HANDLE:    return NTE_INVALID_HANDLE;
  40     case STATUS_INVALID_SIGNATURE: return NTE_BAD_SIGNATURE;
  41     case STATUS_SUCCESS:           return ERROR_SUCCESS;
  42     case STATUS_INVALID_PARAMETER: return NTE_INVALID_PARAMETER;
  43     case STATUS_NO_MEMORY:         return NTE_NO_MEMORY;
  44     case STATUS_NOT_SUPPORTED:     return NTE_NOT_SUPPORTED;
  45     case NTE_BAD_DATA:             return NTE_BAD_DATA;
  46     case STATUS_BUFFER_TOO_SMALL:  return NTE_BUFFER_TOO_SMALL;
  47     default:
  48         FIXME("unhandled status %#lx\n", status);
  49         return NTE_INTERNAL_ERROR;
  50     }
  51 }
  52
  53 static struct object *allocate_object(enum object_type type)
  54 {
  55     struct object *ret;
  56     if (!(ret = calloc(1, sizeof(*ret)))) return NULL;
  57     ret->type = type;
  58     return ret;
  59 }
  60
  61 static struct object_property *get_object_property(struct object *object, const WCHAR *name)
  62 {
  63     unsigned int i;
  64     for (i = 0; i < object->num_properties; i++)
  65     {
  66         struct object_property *property = &object->properties[i];
  67         if (!lstrcmpW(property->key, name)) return property;
  68     }
  69     return NULL;
  70 }
  71
  72 struct object_property *add_object_property(struct object *object, const WCHAR *name)
  73 {
  74     struct object_property *property;
  75
  76     if (!object->num_properties)
  77     {
  78         if (!(object->properties = malloc(sizeof(*property))))
  79         {
  80             ERR("Error allocating memory.\n");
  81             return NULL;
  82         }
  83         property = &object->properties[object->num_properties++];
  84     }
  85     else
  86     {
  87         struct object_property *tmp;
  88         if (!(tmp = realloc(object->properties, sizeof(*property) * (object->num_properties + 1))))
  89         {
  90             ERR("Error allocating memory.\n");
  91             return NULL;
  92         }
  93         object->properties = tmp;
  94         property = &object->properties[object->num_properties++];
  95     }
  96
  97     memset(property, 0, sizeof(*property));
  98     if (!(property->key = wcsdup(name)))
  99     {
 100         ERR("Error allocating memory.\n");
 101         return NULL;
 102     }
 103
 104     return property;
 105 }
 106
 107 static SECURITY_STATUS set_object_property(struct object *object, const WCHAR *name, BYTE *value, DWORD value_size)
 108 {
 109     struct object_property *property = get_object_property(object, name);
 110     void *tmp;
 111
 112     if (!property && !(property = add_object_property(object, name))) return NTE_NO_MEMORY;
 113
 114     property->value_size = value_size;
 115     if (!(tmp = realloc(property->value, value_size)))
 116     {
 117         ERR("Error allocating memory.\n");
 118         free(property->key);
 119         property->key = NULL;
 120         return NTE_NO_MEMORY;
 121     }
 122
 123     property->value = tmp;
 124     memcpy(property->value, value, value_size);
 125
 126     return ERROR_SUCCESS;
 127 }
 128
 129 static struct object *create_key_object(enum algid algid, NCRYPT_PROV_HANDLE provider)
 130 {
 131     NCRYPT_SUPPORTED_LENGTHS supported_lengths = {512, 16384, 8, 1024};
 132     struct object *object;
 133     DWORD dw_value;
 134
 135     switch (algid)
 136     {
 137     case RSA:
 138         if (!(object = allocate_object(KEY))) return NULL;
 139
 140         object->key.algid = RSA;
 141         set_object_property(object, NCRYPT_ALGORITHM_PROPERTY, (BYTE *)BCRYPT_RSA_ALGORITHM,
 142                             sizeof(BCRYPT_RSA_ALGORITHM));
 143         set_object_property(object, NCRYPT_ALGORITHM_GROUP_PROPERTY, (BYTE *)BCRYPT_RSA_ALGORITHM,
 144                             sizeof(BCRYPT_RSA_ALGORITHM));
 145         set_object_property(object, NCRYPT_LENGTHS_PROPERTY, (BYTE *)&supported_lengths,
 146                             sizeof(supported_lengths));
 147         dw_value = 128;
 148         set_object_property(object, NCRYPT_BLOCK_LENGTH_PROPERTY, (BYTE *)&dw_value, sizeof(dw_value));
 149         dw_value = 128;
 150         set_object_property(object, BCRYPT_SIGNATURE_LENGTH, (BYTE *)&dw_value, sizeof(dw_value));
 151         break;
 152
 153     default:
 154         ERR("Invalid algid %#x\n", algid);
 155         return NULL;
 156     }
 157
 158     dw_value = 0;
 159     set_object_property(object, NCRYPT_EXPORT_POLICY_PROPERTY, (BYTE *)&dw_value, sizeof(dw_value));
 160     dw_value = NCRYPT_ALLOW_ALL_USAGES;
 161     set_object_property(object, NCRYPT_KEY_USAGE_PROPERTY, (BYTE *)&dw_value, sizeof(dw_value));
 162     dw_value = 0;
 163     set_object_property(object, NCRYPT_KEY_TYPE_PROPERTY, (BYTE *)&dw_value, sizeof(dw_value));
 164     set_object_property(object, NCRYPT_PROVIDER_HANDLE_PROPERTY, (BYTE *)&provider, sizeof(provider));
 165     return object;
 166 }
 167
 168 SECURITY_STATUS WINAPI NCryptCreatePersistedKey(NCRYPT_PROV_HANDLE provider, NCRYPT_KEY_HANDLE *key,
 169                                                 const WCHAR *algid, const WCHAR *name, DWORD keyspec, DWORD flags)
 170 {
 171     struct object *object;
 172
 173     TRACE("(%#Ix, %p, %s, %s, %#lx, %#lx)\n", provider, key, wine_dbgstr_w(algid),
 174           wine_dbgstr_w(name), keyspec, flags);
 175
 176     if (!provider) return NTE_INVALID_HANDLE;
 177     if (!algid) return HRESULT_FROM_WIN32(RPC_X_NULL_REF_POINTER);
 178     if (name) FIXME("Persistent keys are not supported\n");
 179
 180     if (!lstrcmpiW(algid, BCRYPT_RSA_ALGORITHM))
 181     {
 182         NTSTATUS status;
 183         DWORD default_bitlen = 1024;
 184
 185         if (!(object = create_key_object(RSA, provider)))
 186         {
 187             ERR("Error allocating memory\n");
 188             return NTE_NO_MEMORY;
 189         }
 190
 191         status = BCryptGenerateKeyPair(BCRYPT_RSA_ALG_HANDLE, &object->key.bcrypt_key, default_bitlen, 0);
 192         if (status != STATUS_SUCCESS)
 193         {
 194             ERR("Error generating key pair %#lx\n", status);
 195             free(object);
 196             return map_ntstatus(status);
 197         }
 198
 199         set_object_property(object, NCRYPT_LENGTH_PROPERTY, (BYTE *)&default_bitlen, sizeof(default_bitlen));
 200         set_object_property(object, BCRYPT_PUBLIC_KEY_LENGTH, (BYTE *)&default_bitlen, sizeof(default_bitlen));
 201     }
 202     else
 203     {
 204         FIXME("Algorithm not handled %s\n", wine_dbgstr_w(algid));
 205         return NTE_NOT_SUPPORTED;
 206     }
 207
 208     *key = (NCRYPT_KEY_HANDLE)object;
 209     return ERROR_SUCCESS;
 210 }
 211
 212 SECURITY_STATUS WINAPI NCryptDecrypt(NCRYPT_KEY_HANDLE key, BYTE *input, DWORD insize, void *padding,
 213                                      BYTE *output, DWORD outsize, DWORD *result, DWORD flags)
 214 {
 215     FIXME("(%#Ix, %p, %lu, %p, %p, %lu, %p, %#lx): stub\n", key, input, insize, padding,
 216           output, outsize, result, flags);
 217     return NTE_NOT_SUPPORTED;
 218 }
 219
 220 SECURITY_STATUS WINAPI NCryptDeleteKey(NCRYPT_KEY_HANDLE key, DWORD flags)
 221 {
 222     FIXME("(%#Ix, %#lx): stub\n", key, flags);
 223     return NTE_NOT_SUPPORTED;
 224 }
 225
 226 SECURITY_STATUS WINAPI NCryptEncrypt(NCRYPT_KEY_HANDLE key, BYTE *input, DWORD insize, void *padding,
 227                                      BYTE *output, DWORD outsize, DWORD *result, DWORD flags)
 228 {
 229     struct object *key_object = (struct object *)key;
 230
 231     TRACE("(%#Ix, %p, %lu, %p, %p, %lu, %p, %#lx)\n", key, input, insize, padding,
 232           output, outsize, result, flags);
 233
 234     if (flags & ~(NCRYPT_NO_PADDING_FLAG | NCRYPT_PAD_OAEP_FLAG
 235                 | NCRYPT_PAD_PKCS1_FLAG | NCRYPT_SILENT_FLAG))
 236     {
 237         FIXME("Flags %lx not supported\n", flags);
 238         return NTE_BAD_FLAGS;
 239     }
 240
 241     if (flags & NCRYPT_NO_PADDING_FLAG || flags & NCRYPT_PAD_OAEP_FLAG)
 242     {
 243         FIXME("No padding and oaep padding not supported\n");
 244         return NTE_NOT_SUPPORTED;
 245     }
 246
 247     if (key_object->type != KEY) return NTE_INVALID_HANDLE;
 248
 249     return map_ntstatus(BCryptEncrypt(key_object->key.bcrypt_key, input, insize, padding,
 250                                       NULL, 0, output, outsize, result, flags));
 251 }
 252
 253 SECURITY_STATUS WINAPI NCryptEnumAlgorithms(NCRYPT_PROV_HANDLE provider, DWORD alg_ops,
 254                                             DWORD *alg_count, NCryptAlgorithmName **alg_list, DWORD flags)
 255 {
 256     FIXME("(%#Ix, %#lx, %p, %p, %#lx): stub\n", provider, alg_ops, alg_count, alg_list, flags);
 257     return NTE_NOT_SUPPORTED;
 258 }
 259
 260 SECURITY_STATUS WINAPI NCryptEnumKeys(NCRYPT_PROV_HANDLE provider, const WCHAR *scope,
 261                                       NCryptKeyName **key_name, PVOID *enum_state, DWORD flags)
 262 {
 263     FIXME("(%#Ix, %p, %p, %p, %#lx): stub\n", provider, scope, key_name, enum_state, flags);
 264     return NTE_NOT_SUPPORTED;
 265 }
 266
 267 SECURITY_STATUS WINAPI NCryptFinalizeKey(NCRYPT_KEY_HANDLE handle, DWORD flags)
 268 {
 269     struct object *object = (struct object *)handle;
 270     DWORD key_length;
 271     struct object_property *prop;
 272     NTSTATUS status;
 273
 274     TRACE("(%#Ix, %#lx)\n", handle, flags);
 275
 276     if (!object || object->type != KEY) return NTE_INVALID_HANDLE;
 277
 278     if (!(prop = get_object_property(object, NCRYPT_LENGTH_PROPERTY))) return NTE_INVALID_HANDLE;
 279     key_length = *(DWORD *)prop->value;
 280     status = BCryptSetProperty(object->key.bcrypt_key, BCRYPT_KEY_LENGTH, (UCHAR *)&key_length, sizeof(key_length), 0);
 281     if (status != STATUS_SUCCESS)
 282     {
 283         ERR("Error setting key length property\n");
 284         return map_ntstatus(status);
 285     }
 286
 287     status = BCryptFinalizeKeyPair(object->key.bcrypt_key, 0);
 288     if (status != STATUS_SUCCESS)
 289     {
 290         ERR("Error finalizing key pair\n");
 291         return map_ntstatus(status);
 292     }
 293
 294     return ERROR_SUCCESS;
 295 }
 296
 297 SECURITY_STATUS WINAPI NCryptFreeBuffer(PVOID buf)
 298 {
 299     FIXME("(%p): stub\n", buf);
 300     return NTE_NOT_SUPPORTED;
 301 }
 302
 303 static SECURITY_STATUS free_key_object(struct key *key)
 304 {
 305     return map_ntstatus( BCryptDestroyKey(key->bcrypt_key) );
 306 }
 307
 308 SECURITY_STATUS WINAPI NCryptFreeObject(NCRYPT_HANDLE handle)
 309 {
 310     struct object *object = (struct object *)handle;
 311     SECURITY_STATUS ret = STATUS_SUCCESS;
 312     unsigned int i;
 313
 314     TRACE("(%#Ix)\n", handle);
 315
 316     if (!object)
 317     {
 318         WARN("invalid handle %#Ix\n", handle);
 319         return NTE_INVALID_HANDLE;
 320     }
 321
 322     switch (object->type)
 323     {
 324     case KEY:
 325     {
 326         if ((ret = free_key_object(&object->key))) return ret;
 327         break;
 328     }
 329     case STORAGE_PROVIDER:
 330         break;
 331
 332     default:
 333         WARN("invalid handle %#Ix\n", handle);
 334         return NTE_INVALID_HANDLE;
 335     }
 336
 337     for (i = 0; i < object->num_properties; i++)
 338     {
 339         free(object->properties[i].key);
 340         free(object->properties[i].value);
 341     }
 342     free(object->properties);
 343     free(object);
 344     return ret;
 345 }
 346
 347 SECURITY_STATUS WINAPI NCryptGetProperty(NCRYPT_HANDLE handle, const WCHAR *name, BYTE *output,
 348                                          DWORD outsize, DWORD *result, DWORD flags)
 349 {
 350     struct object *object = (struct object *)handle;
 351     const struct object_property *property;
 352
 353     TRACE("(%#Ix, %s, %p, %lu, %p, %#lx)\n", handle, wine_dbgstr_w(name), output, outsize, result, flags);
 354     if (flags) FIXME("flags %#lx not supported\n", flags);
 355
 356     if (!object) return NTE_INVALID_HANDLE;
 357     if (!(property = get_object_property(object, name))) return NTE_INVALID_PARAMETER;
 358
 359     *result = property->value_size;
 360     if (!output) return ERROR_SUCCESS;
 361     if (outsize < property->value_size) return NTE_BUFFER_TOO_SMALL;
 362
 363     memcpy(output, property->value, property->value_size);
 364     return ERROR_SUCCESS;
 365 }
 366
 367 SECURITY_STATUS WINAPI NCryptImportKey(NCRYPT_PROV_HANDLE provider, NCRYPT_KEY_HANDLE decrypt_key,
 368                                        const WCHAR *type, NCryptBufferDesc *params, NCRYPT_KEY_HANDLE *handle,
 369                                        BYTE *data, DWORD datasize, DWORD flags)
 370 {
 371     BCRYPT_KEY_BLOB *header = (BCRYPT_KEY_BLOB *)data;
 372     struct object *object;
 373
 374     TRACE("(%#Ix, %#Ix, %s, %p, %p, %p, %lu, %#lx)\n", provider, decrypt_key, wine_dbgstr_w(type),
 375           params, handle, data, datasize, flags);
 376
 377     if (decrypt_key)
 378     {
 379         FIXME("Key blob decryption not implemented\n");
 380         return NTE_NOT_SUPPORTED;
 381     }
 382     if (params)
 383     {
 384         FIXME("Parameter information not implemented\n");
 385         return NTE_NOT_SUPPORTED;
 386     }
 387     if (flags == NCRYPT_SILENT_FLAG)
 388     {
 389         FIXME("Silent flag not implemented\n");
 390     }
 391     else if (flags)
 392     {
 393         WARN("Invalid flags %#lx\n", flags);
 394         return NTE_BAD_FLAGS;
 395     }
 396
 397     switch(header->Magic)
 398     {
 399     case BCRYPT_RSAFULLPRIVATE_MAGIC:
 400     case BCRYPT_RSAPRIVATE_MAGIC:
 401     case BCRYPT_RSAPUBLIC_MAGIC:
 402     {
 403         NTSTATUS status;
 404         BCRYPT_RSAKEY_BLOB *rsablob = (BCRYPT_RSAKEY_BLOB *)data;
 405
 406         if (!(object = create_key_object(RSA, provider)))
 407         {
 408             ERR("Error allocating memory\n");
 409             return NTE_NO_MEMORY;
 410         }
 411
 412         status = BCryptImportKeyPair(BCRYPT_RSA_ALG_HANDLE, NULL, type, &object->key.bcrypt_key, data, datasize, 0);
 413         if (status != STATUS_SUCCESS)
 414         {
 415             WARN("Error importing key pair %#lx\n", status);
 416             free(object);
 417             return map_ntstatus(status);
 418         }
 419
 420         set_object_property(object, NCRYPT_LENGTH_PROPERTY, (BYTE *)&rsablob->BitLength, sizeof(rsablob->BitLength));
 421         set_object_property(object, BCRYPT_PUBLIC_KEY_LENGTH, (BYTE *)&rsablob->BitLength, sizeof(rsablob->BitLength));
 422         break;
 423     }
 424     default:
 425         FIXME("Unhandled key magic %#lx\n", header->Magic);
 426         return NTE_INVALID_PARAMETER;
 427     }
 428
 429     *handle = (NCRYPT_KEY_HANDLE)object;
 430     return ERROR_SUCCESS;
 431 }
 432
 433 SECURITY_STATUS WINAPI NCryptExportKey(NCRYPT_KEY_HANDLE key, NCRYPT_KEY_HANDLE encrypt_key, const WCHAR *type,
 434                                        NCryptBufferDesc *params, BYTE *output, DWORD output_len, DWORD *ret_len,
 435                                        DWORD flags)
 436 {
 437     struct object *object = (struct object *)key;
 438
 439     TRACE("(%#Ix, %#Ix, %s, %p, %p, %lu, %p, %#lx)\n", key, encrypt_key, wine_dbgstr_w(type), params, output,
 440           output_len, ret_len, flags);
 441
 442     if (encrypt_key)
 443     {
 444         FIXME("Key blob encryption not implemented\n");
 445         return NTE_NOT_SUPPORTED;
 446     }
 447     if (params)
 448     {
 449         FIXME("Parameter information not implemented\n");
 450         return NTE_NOT_SUPPORTED;
 451     }
 452     if (flags == NCRYPT_SILENT_FLAG)
 453     {
 454         FIXME("Silent flag not implemented\n");
 455     }
 456
 457     return map_ntstatus(BCryptExportKey(object->key.bcrypt_key, NULL, type, output, output_len, ret_len, 0));
 458 }
 459
 460 SECURITY_STATUS WINAPI NCryptIsAlgSupported(NCRYPT_PROV_HANDLE provider, const WCHAR *algid, DWORD flags)
 461 {
 462     static const ULONG supported = BCRYPT_CIPHER_OPERATION |\
 463                                    BCRYPT_ASYMMETRIC_ENCRYPTION_OPERATION |\
 464                                    BCRYPT_SIGNATURE_OPERATION |\
 465                                    BCRYPT_SECRET_AGREEMENT_OPERATION;
 466     BCRYPT_ALGORITHM_IDENTIFIER *list;
 467     ULONG i, count;
 468     NTSTATUS status;
 469
 470     TRACE("(%#Ix, %s, %#lx)\n", provider, wine_dbgstr_w(algid), flags);
 471
 472     if (!provider) return NTE_INVALID_HANDLE;
 473     if (!algid) return HRESULT_FROM_WIN32(RPC_X_NULL_REF_POINTER);
 474     if (flags == NCRYPT_SILENT_FLAG)
 475     {
 476         FIXME("Silent flag not implemented\n");
 477     }
 478     else if (flags)
 479     {
 480         WARN("Invalid flags %#lx\n", flags);
 481         return NTE_BAD_FLAGS;
 482     }
 483     if (!lstrcmpiW(BCRYPT_RSA_SIGN_ALGORITHM, algid)) return NTE_NOT_SUPPORTED;
 484
 485     status = BCryptEnumAlgorithms(supported, &count, &list, 0);
 486     if (status != STATUS_SUCCESS)
 487     {
 488         ERR("Error retrieving algorithm list %#lx\n", status);
 489         return map_ntstatus(status);
 490     }
 491
 492     status = STATUS_NOT_SUPPORTED;
 493     for (i = 0; i < count; i++)
 494     {
 495         if (!lstrcmpiW(list[i].pszName, algid))
 496         {
 497             status = STATUS_SUCCESS;
 498             break;
 499         }
 500     }
 501
 502     BCryptFreeBuffer(list);
 503     return map_ntstatus(status);
 504 }
 505
 506 BOOL WINAPI NCryptIsKeyHandle(NCRYPT_KEY_HANDLE hKey)
 507 {
 508     FIXME("(%#Ix): stub\n", hKey);
 509     return FALSE;
 510 }
 511
 512 SECURITY_STATUS WINAPI NCryptOpenKey(NCRYPT_PROV_HANDLE provider, NCRYPT_KEY_HANDLE *key,
 513                                      const WCHAR *name, DWORD keyspec, DWORD flags)
 514 {
 515     FIXME("(%#Ix, %p, %s, %#lx, %#lx): stub\n", provider, key, wine_dbgstr_w(name), keyspec, flags);
 516     return NTE_NOT_SUPPORTED;
 517 }
 518
 519 SECURITY_STATUS WINAPI NCryptOpenStorageProvider(NCRYPT_PROV_HANDLE *provider, const WCHAR *name, DWORD flags)
 520 {
 521     struct object *object;
 522
 523     FIXME("(%p, %s, %#lx): stub\n", provider, wine_dbgstr_w(name), flags);
 524
 525     if (!(object = allocate_object(STORAGE_PROVIDER)))
 526     {
 527         ERR("Error allocating memory.\n");
 528         return NTE_NO_MEMORY;
 529     }
 530     *provider = (NCRYPT_PROV_HANDLE)object;
 531     return ERROR_SUCCESS;
 532 }
 533
 534 SECURITY_STATUS WINAPI NCryptSetProperty(NCRYPT_HANDLE handle, const WCHAR *name, BYTE *input, DWORD insize, DWORD flags)
 535 {
 536     struct object *object = (struct object *)handle;
 537
 538     TRACE("(%#Ix, %s, %p, %lu, %#lx)\n", handle, wine_dbgstr_w(name), input, insize, flags);
 539     if (flags) FIXME("flags %#lx not supported\n", flags);
 540
 541     if (!object) return NTE_INVALID_HANDLE;
 542     return set_object_property(object, name, input, insize);
 543 }
 544
 545 SECURITY_STATUS WINAPI NCryptSignHash(NCRYPT_KEY_HANDLE handle, void *padding, BYTE *value, DWORD value_len,
 546                                       BYTE *sig, DWORD sig_len, DWORD *ret_len, DWORD flags)
 547 {
 548     struct object *object = (struct object *)handle;
 549
 550     TRACE("(%#Ix, %p, %p, %lu, %p, %lu, %#lx)\n", handle, padding, value, value_len, sig, sig_len, flags);
 551     if (flags & NCRYPT_SILENT_FLAG) FIXME("Silent flag not implemented\n");
 552
 553     if (!object || object->type != KEY) return NTE_INVALID_HANDLE;
 554
 555     return map_ntstatus(BCryptSignHash(object->key.bcrypt_key, padding, value, value_len, sig, sig_len,
 556                                        ret_len, flags & ~NCRYPT_SILENT_FLAG));
 557 }
 558
 559 SECURITY_STATUS WINAPI NCryptVerifySignature(NCRYPT_KEY_HANDLE handle, void *padding, BYTE *hash, DWORD hash_size,
 560                                              BYTE *signature, DWORD signature_size, DWORD flags)
 561 {
 562     struct object *key_object = (struct object *)handle;
 563
 564     TRACE("(%#Ix, %p, %p, %lu, %p, %lu, %#lx)\n", handle, padding, hash, hash_size, signature,
 565           signature_size, flags);
 566
 567     if (!hash_size || !signature_size) return NTE_INVALID_PARAMETER;
 568     if (!hash || !signature) return HRESULT_FROM_WIN32(RPC_X_NULL_REF_POINTER);
 569     if (!handle || key_object->type != KEY) return NTE_INVALID_HANDLE;
 570
 571     if (key_object->key.algid < RSA)
 572     {
 573         FIXME("Symmetric keys not supported.\n");
 574         return NTE_NOT_SUPPORTED;
 575     }
 576
 577     return map_ntstatus(BCryptVerifySignature(key_object->key.bcrypt_key, padding, hash, hash_size, signature,
 578                                               signature_size, flags));
 579 }