/**

 * WinPR: Windows Portable Runtime

 * NCrypt pkcs11 provider

 *

 * Copyright 2021 David Fort <contact@hardening-consulting.com>

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

#include <stdlib.h>

#include <winpr/library.h>

#include <winpr/assert.h>

#include <winpr/spec.h>

#include <winpr/smartcard.h>

#include <winpr/asn1.h>

#include <winpr/crt.h>

#include "../log.h"

#include "ncrypt.h"

/* https://github.com/latchset/pkcs11-headers/blob/main/public-domain/3.1/pkcs11.h */

#include "pkcs11-headers/pkcs11.h"

#define TAG WINPR_TAG("ncryptp11")

#define MAX_SLOTS 64

#define MAX_KEYS 64

#define MAX_KEYS_PER_SLOT 64

/** @brief ncrypt provider handle */

typedef struct

{

  NCryptBaseProvider baseProvider;

  HANDLE library;

  CK_FUNCTION_LIST_PTR p11;

  char* modulePath;

} NCryptP11ProviderHandle;

/** @brief a handle returned by NCryptOpenKey */

typedef struct

{

  NCryptBaseHandle base;

  NCryptP11ProviderHandle* provider;

  CK_SLOT_ID slotId;

  CK_BYTE keyCertId[64];

  CK_ULONG keyCertIdLen;

} NCryptP11KeyHandle;

typedef struct

{

  CK_SLOT_ID slotId;

  CK_SLOT_INFO slotInfo;

  CK_KEY_TYPE keyType;

  CK_CHAR keyLabel[256];

  CK_ULONG idLen;

  CK_BYTE id[64];

} NCryptKeyEnum;

typedef struct

{

  CK_ULONG nslots;

  CK_SLOT_ID slots[MAX_SLOTS];

  CK_ULONG nKeys;

  NCryptKeyEnum keys[MAX_KEYS];

  CK_ULONG keyIndex;

} P11EnumKeysState;

typedef struct

{

  const char* label;

  BYTE tag[3];

} piv_cert_tags_t;

static const piv_cert_tags_t piv_cert_tags[] = {

  { "X.509 Certificate for PIV Authentication", { 0x5F, 0xC1, 0x05 } },

  { "X.509 Certificate for Digital Signature", { 0x5F, 0xC1, 0x0A } },

  { "X.509 Certificate for Key Management", { 0x5F, 0xC1, 0x0B } },

  { "X.509 Certificate for Card Authentication", { 0x5F, 0xC1, 0x01 } },

  { "Certificate for PIV Authentication", { 0x5F, 0xC1, 0x05 } },

  { "Certificate for Digital Signature", { 0x5F, 0xC1, 0x0A } },

  { "Certificate for Key Management", { 0x5F, 0xC1, 0x0B } },

  { "Certificate for Card Authentication", { 0x5F, 0xC1, 0x01 } },

  { "Retired Certificate for Key Management 1", { 0x5F, 0xC1, 0x0D } },

  { "Retired Certificate for Key Management 2", { 0x5F, 0xC1, 0x0E } },

  { "Retired Certificate for Key Management 3", { 0x5F, 0xC1, 0x0F } },

  { "Retired Certificate for Key Management 4", { 0x5F, 0xC1, 0x10 } },

  { "Retired Certificate for Key Management 5", { 0x5F, 0xC1, 0x11 } },

  { "Retired Certificate for Key Management 6", { 0x5F, 0xC1, 0x12 } },

  { "Retired Certificate for Key Management 7", { 0x5F, 0xC1, 0x13 } },

  { "Retired Certificate for Key Management 8", { 0x5F, 0xC1, 0x14 } },

  { "Retired Certificate for Key Management 9", { 0x5F, 0xC1, 0x15 } },

  { "Retired Certificate for Key Management 10", { 0x5F, 0xC1, 0x16 } },

  { "Retired Certificate for Key Management 11", { 0x5F, 0xC1, 0x17 } },

  { "Retired Certificate for Key Management 12", { 0x5F, 0xC1, 0x18 } },

  { "Retired Certificate for Key Management 13", { 0x5F, 0xC1, 0x19 } },

  { "Retired Certificate for Key Management 14", { 0x5F, 0xC1, 0x1A } },

  { "Retired Certificate for Key Management 15", { 0x5F, 0xC1, 0x1B } },

  { "Retired Certificate for Key Management 16", { 0x5F, 0xC1, 0x1C } },

  { "Retired Certificate for Key Management 17", { 0x5F, 0xC1, 0x1D } },

  { "Retired Certificate for Key Management 18", { 0x5F, 0xC1, 0x1E } },

  { "Retired Certificate for Key Management 19", { 0x5F, 0xC1, 0x1F } },

  { "Retired Certificate for Key Management 20", { 0x5F, 0xC1, 0x20 } },

};

static const BYTE APDU_PIV_SELECT_AID[] = { 0x00, 0xA4, 0x04, 0x00, 0x09, 0xA0, 0x00, 0x00,

                                          0x03, 0x08, 0x00, 0x00, 0x10, 0x00, 0x00 };

static const BYTE APDU_PIV_GET_CHUID[] = { 0x00, 0xCB, 0x3F, 0xFF, 0x05, 0x5C,

                                         0x03, 0x5F, 0xC1, 0x02, 0x00 };

static const BYTE APDU_PIV_GET_MSCMAP[] = { 0x00, 0xCB, 0x3F, 0xFF, 0x05, 0x5C,

                                          0x03, 0x5F, 0xFF, 0x10, 0x00 };

/* currently not used

static const BYTE APDU_GET_RESPONSE[] = { 0x00, 0xC0, 0x00, 0x00, 0x00 };

*/

#define PIV_CONTAINER_NAME_LEN 36

#define MAX_CONTAINER_NAME_LEN 39

#define MSCMAP_RECORD_SIZE 107

#define MSCMAP_SLOT_OFFSET 80

/* PIV certificate tag to PIV slot byte mapping */

typedef struct

{

  BYTE tag[3];

  BYTE slot;

} piv_tag_to_slot_t;

static const piv_tag_to_slot_t piv_tag_to_slot[] = {

  { { 0x5F, 0xC1, 0x05 }, 0x9A }, /* PIV Auth */

  { { 0x5F, 0xC1, 0x0A }, 0x9C }, /* Digital Sig */

  { { 0x5F, 0xC1, 0x0B }, 0x9D }, /* Key Mgmt */

  { { 0x5F, 0xC1, 0x01 }, 0x9E }, /* Card Auth */

  { { 0x5F, 0xC1, 0x0D }, 0x82 }, /* Retired KM 1 */

  { { 0x5F, 0xC1, 0x0E }, 0x83 }, /* Retired KM 2 */

  { { 0x5F, 0xC1, 0x0F }, 0x84 }, /* Retired KM 3 */

  { { 0x5F, 0xC1, 0x10 }, 0x85 }, /* Retired KM 4 */

  { { 0x5F, 0xC1, 0x11 }, 0x86 }, /* Retired KM 5 */

  { { 0x5F, 0xC1, 0x12 }, 0x87 }, /* Retired KM 6 */

  { { 0x5F, 0xC1, 0x13 }, 0x88 }, /* Retired KM 7 */

  { { 0x5F, 0xC1, 0x14 }, 0x89 }, /* Retired KM 8 */

  { { 0x5F, 0xC1, 0x15 }, 0x8A }, /* Retired KM 9 */

  { { 0x5F, 0xC1, 0x16 }, 0x8B }, /* Retired KM 10 */

  { { 0x5F, 0xC1, 0x17 }, 0x8C }, /* Retired KM 11 */

  { { 0x5F, 0xC1, 0x18 }, 0x8D }, /* Retired KM 12 */

  { { 0x5F, 0xC1, 0x19 }, 0x8E }, /* Retired KM 13 */

  { { 0x5F, 0xC1, 0x1A }, 0x8F }, /* Retired KM 14 */

  { { 0x5F, 0xC1, 0x1B }, 0x90 }, /* Retired KM 15 */

  { { 0x5F, 0xC1, 0x1C }, 0x91 }, /* Retired KM 16 */

  { { 0x5F, 0xC1, 0x1D }, 0x92 }, /* Retired KM 17 */

  { { 0x5F, 0xC1, 0x1E }, 0x93 }, /* Retired KM 18 */

  { { 0x5F, 0xC1, 0x1F }, 0x94 }, /* Retired KM 19 */

  { { 0x5F, 0xC1, 0x20 }, 0x95 }, /* Retired KM 20 */

};

static CK_OBJECT_CLASS object_class_public_key = CKO_PUBLIC_KEY;

static CK_BBOOL object_verify = CK_TRUE;

static CK_ATTRIBUTE public_key_filter[] = { { CKA_CLASS, &object_class_public_key,

                                            sizeof(object_class_public_key) },

                                          { CKA_VERIFY, &object_verify, sizeof(object_verify) } };

WINPR_ATTR_NODISCARD

static const char* CK_RV_error_string(CK_RV rv);

WINPR_ATTR_NODISCARD

static SECURITY_STATUS NCryptP11StorageProvider_dtor(NCRYPT_HANDLE handle)

{

  NCryptP11ProviderHandle* provider = (NCryptP11ProviderHandle*)handle;

  CK_RV rv = CKR_OK;

  if (provider)

  {

    if (provider->p11 && provider->p11->C_Finalize)

      rv = provider->p11->C_Finalize(nullptr);

    if (rv != CKR_OK)

      WLog_WARN(TAG, "C_Finalize failed with %s [0x%08lx]", CK_RV_error_string(rv), rv);

    free(provider->modulePath);

    if (provider->library)

      FreeLibrary(provider->library);

  }

  return winpr_NCryptDefault_dtor(handle);

}

static void fix_padded_string(char* str, size_t maxlen)

{

  if (maxlen == 0)

    return;

  WINPR_ASSERT(str);

  char* ptr = &str[maxlen - 1];

  while ((ptr > str) && (*ptr == ' '))

  {

    *ptr = '\0';

    ptr--;

  }

}

WINPR_ATTR_NODISCARD

static BOOL attributes_have_unallocated_buffers(CK_ATTRIBUTE_PTR attributes, CK_ULONG count)

{

  for (CK_ULONG i = 0; i < count; i++)

  {

    if (!attributes[i].pValue && (attributes[i].ulValueLen != CK_UNAVAILABLE_INFORMATION))

      return TRUE;

  }

  return FALSE;

}

WINPR_ATTR_NODISCARD

static BOOL attribute_allocate_attribute_array(CK_ATTRIBUTE_PTR attribute)

{

  WINPR_ASSERT(attribute);

  attribute->pValue = calloc(attribute->ulValueLen, sizeof(void*));

  return !!attribute->pValue;

}

WINPR_ATTR_NODISCARD

static BOOL attribute_allocate_ulong_array(CK_ATTRIBUTE_PTR attribute)

{

  attribute->pValue = calloc(attribute->ulValueLen, sizeof(CK_ULONG));

  return !!attribute->pValue;

}

WINPR_ATTR_NODISCARD

static BOOL attribute_allocate_buffer(CK_ATTRIBUTE_PTR attribute)

{

  attribute->pValue = calloc(attribute->ulValueLen, 1);

  return !!attribute->pValue;

}

WINPR_ATTR_NODISCARD

static BOOL attributes_allocate_buffers(CK_ATTRIBUTE_PTR attributes, CK_ULONG count)

{

  BOOL ret = TRUE;

  for (CK_ULONG i = 0; i < count; i++)

  {

    if (attributes[i].pValue || (attributes[i].ulValueLen == CK_UNAVAILABLE_INFORMATION))

      continue;

    switch (attributes[i].type)

    {

      case CKA_WRAP_TEMPLATE:

      case CKA_UNWRAP_TEMPLATE:

        ret &= attribute_allocate_attribute_array(&attributes[i]);

        break;

      case CKA_ALLOWED_MECHANISMS:

        ret &= attribute_allocate_ulong_array(&attributes[i]);

        break;

      default:

        ret &= attribute_allocate_buffer(&attributes[i]);

        break;

    }

  }

  return ret;

}

WINPR_ATTR_NODISCARD

static CK_RV object_load_attributes(NCryptP11ProviderHandle* provider, CK_SESSION_HANDLE session,

                                    CK_OBJECT_HANDLE object, CK_ATTRIBUTE_PTR attributes,

                                    CK_ULONG count)

{

  WINPR_ASSERT(provider);

  WINPR_ASSERT(provider->p11);

  WINPR_ASSERT(provider->p11->C_GetAttributeValue);

  CK_RV rv = provider->p11->C_GetAttributeValue(session, object, attributes, count);

  switch (rv)

  {

    case CKR_OK:

      if (!attributes_have_unallocated_buffers(attributes, count))

        return rv;

      /* fallthrough */

      WINPR_FALLTHROUGH

    case CKR_ATTRIBUTE_SENSITIVE:

    case CKR_ATTRIBUTE_TYPE_INVALID:

    case CKR_BUFFER_TOO_SMALL:

      /* attributes need some buffers for the result value */

      if (!attributes_allocate_buffers(attributes, count))

        return CKR_HOST_MEMORY;

      rv = provider->p11->C_GetAttributeValue(session, object, attributes, count);

      if (rv != CKR_OK)

        WLog_WARN(TAG, "C_GetAttributeValue failed with %s [0x%08lx]",

                  CK_RV_error_string(rv), rv);

      break;

    default:

      WLog_WARN(TAG, "C_GetAttributeValue failed with %s [0x%08lx]", CK_RV_error_string(rv),

                rv);

      return rv;

  }

  switch (rv)

  {

    case CKR_ATTRIBUTE_SENSITIVE:

    case CKR_ATTRIBUTE_TYPE_INVALID:

    case CKR_BUFFER_TOO_SMALL:

      WLog_ERR(TAG,

               "C_GetAttributeValue failed with %s [0x%08lx] even after buffer allocation",

               CK_RV_error_string(rv), rv);

      break;

    default:

      break;

  }

  return rv;

}

WINPR_ATTR_NODISCARD

static const char* CK_RV_error_string(CK_RV rv)

{

  static char generic_buffer[200];

#define ERR_ENTRY(X) \

  case X:          \

    return #X

  switch (rv)

  {

    ERR_ENTRY(CKR_OK);

    ERR_ENTRY(CKR_CANCEL);

    ERR_ENTRY(CKR_HOST_MEMORY);

    ERR_ENTRY(CKR_SLOT_ID_INVALID);

    ERR_ENTRY(CKR_GENERAL_ERROR);

    ERR_ENTRY(CKR_FUNCTION_FAILED);

    ERR_ENTRY(CKR_ARGUMENTS_BAD);

    ERR_ENTRY(CKR_NO_EVENT);

    ERR_ENTRY(CKR_NEED_TO_CREATE_THREADS);

    ERR_ENTRY(CKR_CANT_LOCK);

    ERR_ENTRY(CKR_ATTRIBUTE_READ_ONLY);

    ERR_ENTRY(CKR_ATTRIBUTE_SENSITIVE);

    ERR_ENTRY(CKR_ATTRIBUTE_TYPE_INVALID);

    ERR_ENTRY(CKR_ATTRIBUTE_VALUE_INVALID);

    ERR_ENTRY(CKR_DATA_INVALID);

    ERR_ENTRY(CKR_DATA_LEN_RANGE);

    ERR_ENTRY(CKR_DEVICE_ERROR);

    ERR_ENTRY(CKR_DEVICE_MEMORY);

    ERR_ENTRY(CKR_DEVICE_REMOVED);

    ERR_ENTRY(CKR_ENCRYPTED_DATA_INVALID);

    ERR_ENTRY(CKR_ENCRYPTED_DATA_LEN_RANGE);

    ERR_ENTRY(CKR_FUNCTION_CANCELED);

    ERR_ENTRY(CKR_FUNCTION_NOT_PARALLEL);

    ERR_ENTRY(CKR_FUNCTION_NOT_SUPPORTED);

    ERR_ENTRY(CKR_KEY_HANDLE_INVALID);

    ERR_ENTRY(CKR_KEY_SIZE_RANGE);

    ERR_ENTRY(CKR_KEY_TYPE_INCONSISTENT);

    ERR_ENTRY(CKR_KEY_NOT_NEEDED);

    ERR_ENTRY(CKR_KEY_CHANGED);

    ERR_ENTRY(CKR_KEY_NEEDED);

    ERR_ENTRY(CKR_KEY_INDIGESTIBLE);

    ERR_ENTRY(CKR_KEY_FUNCTION_NOT_PERMITTED);

    ERR_ENTRY(CKR_KEY_NOT_WRAPPABLE);

    ERR_ENTRY(CKR_KEY_UNEXTRACTABLE);

    ERR_ENTRY(CKR_MECHANISM_INVALID);

    ERR_ENTRY(CKR_MECHANISM_PARAM_INVALID);

    ERR_ENTRY(CKR_OBJECT_HANDLE_INVALID);

    ERR_ENTRY(CKR_OPERATION_ACTIVE);

    ERR_ENTRY(CKR_OPERATION_NOT_INITIALIZED);

    ERR_ENTRY(CKR_PIN_INCORRECT);

    ERR_ENTRY(CKR_PIN_INVALID);

    ERR_ENTRY(CKR_PIN_LEN_RANGE);

    ERR_ENTRY(CKR_PIN_EXPIRED);

    ERR_ENTRY(CKR_PIN_LOCKED);

    ERR_ENTRY(CKR_SESSION_CLOSED);

    ERR_ENTRY(CKR_SESSION_COUNT);

    ERR_ENTRY(CKR_SESSION_HANDLE_INVALID);

    ERR_ENTRY(CKR_SESSION_PARALLEL_NOT_SUPPORTED);

    ERR_ENTRY(CKR_SESSION_READ_ONLY);

    ERR_ENTRY(CKR_SESSION_EXISTS);

    ERR_ENTRY(CKR_SESSION_READ_ONLY_EXISTS);

    ERR_ENTRY(CKR_SESSION_READ_WRITE_SO_EXISTS);

    ERR_ENTRY(CKR_SIGNATURE_INVALID);

    ERR_ENTRY(CKR_SIGNATURE_LEN_RANGE);

    ERR_ENTRY(CKR_TEMPLATE_INCOMPLETE);

    ERR_ENTRY(CKR_TEMPLATE_INCONSISTENT);

    ERR_ENTRY(CKR_TOKEN_NOT_PRESENT);

    ERR_ENTRY(CKR_TOKEN_NOT_RECOGNIZED);

    ERR_ENTRY(CKR_TOKEN_WRITE_PROTECTED);

    ERR_ENTRY(CKR_UNWRAPPING_KEY_HANDLE_INVALID);

    ERR_ENTRY(CKR_UNWRAPPING_KEY_SIZE_RANGE);

    ERR_ENTRY(CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT);

    ERR_ENTRY(CKR_USER_ALREADY_LOGGED_IN);

    ERR_ENTRY(CKR_USER_NOT_LOGGED_IN);

    ERR_ENTRY(CKR_USER_PIN_NOT_INITIALIZED);

    ERR_ENTRY(CKR_USER_TYPE_INVALID);

    ERR_ENTRY(CKR_USER_ANOTHER_ALREADY_LOGGED_IN);

    ERR_ENTRY(CKR_USER_TOO_MANY_TYPES);

    ERR_ENTRY(CKR_WRAPPED_KEY_INVALID);

    ERR_ENTRY(CKR_WRAPPED_KEY_LEN_RANGE);

    ERR_ENTRY(CKR_WRAPPING_KEY_HANDLE_INVALID);

    ERR_ENTRY(CKR_WRAPPING_KEY_SIZE_RANGE);

    ERR_ENTRY(CKR_WRAPPING_KEY_TYPE_INCONSISTENT);

    ERR_ENTRY(CKR_RANDOM_SEED_NOT_SUPPORTED);

    ERR_ENTRY(CKR_RANDOM_NO_RNG);

    ERR_ENTRY(CKR_DOMAIN_PARAMS_INVALID);

    ERR_ENTRY(CKR_BUFFER_TOO_SMALL);

    ERR_ENTRY(CKR_SAVED_STATE_INVALID);

    ERR_ENTRY(CKR_INFORMATION_SENSITIVE);

    ERR_ENTRY(CKR_STATE_UNSAVEABLE);

    ERR_ENTRY(CKR_CRYPTOKI_NOT_INITIALIZED);

    ERR_ENTRY(CKR_CRYPTOKI_ALREADY_INITIALIZED);

    ERR_ENTRY(CKR_MUTEX_BAD);

    ERR_ENTRY(CKR_MUTEX_NOT_LOCKED);

    ERR_ENTRY(CKR_FUNCTION_REJECTED);

    default:

      (void)snprintf(generic_buffer, sizeof(generic_buffer), "unknown 0x%lx", rv);

      return generic_buffer;

  }

#undef ERR_ENTRY

}

#define loge(tag, msg, rv, index, slot) \

  log_((tag), (msg), (rv), (index), (slot), __FILE__, __func__, __LINE__)

static void log_(const char* tag, const char* msg, CK_RV rv, CK_ULONG index, CK_SLOT_ID slot,

                 const char* file, const char* fkt, size_t line)

{

  const DWORD log_level = WLOG_ERROR;

  static wLog* log_cached_ptr = nullptr;

  if (!log_cached_ptr)

    log_cached_ptr = WLog_Get(tag);

  if (!WLog_IsLevelActive(log_cached_ptr, log_level))

    return;

  WLog_PrintTextMessage(log_cached_ptr, log_level, line, file, fkt,

                        "%s for slot #%lu(%lu), rv=%s", msg, index, slot, CK_RV_error_string(rv));

}

WINPR_ATTR_NODISCARD

static SECURITY_STATUS collect_keys(NCryptP11ProviderHandle* provider, P11EnumKeysState* state)

{

  CK_OBJECT_HANDLE slotObjects[MAX_KEYS_PER_SLOT] = WINPR_C_ARRAY_INIT;

  WINPR_ASSERT(provider);

  CK_FUNCTION_LIST_PTR p11 = provider->p11;

  WINPR_ASSERT(p11);

  WLog_DBG(TAG, "checking %lx slots for valid keys...", state->nslots);

  state->nKeys = 0;

  for (CK_ULONG i = 0; (i < state->nslots) && (state->nKeys < ARRAYSIZE(state->keys)); i++)

  {

    CK_SESSION_HANDLE session = 0;

    CK_SLOT_INFO slotInfo = WINPR_C_ARRAY_INIT;

    CK_TOKEN_INFO tokenInfo = WINPR_C_ARRAY_INIT;

    WINPR_ASSERT(p11->C_GetSlotInfo);

    CK_RV rv = p11->C_GetSlotInfo(state->slots[i], &slotInfo);

    if (rv != CKR_OK)

    {

      loge(TAG, "unable to retrieve information", rv, i, state->slots[i]);

      continue;

    }

    fix_padded_string((char*)slotInfo.slotDescription, sizeof(slotInfo.slotDescription));

    WLog_DBG(TAG, "collecting keys for slot #%lx(%lu) descr='%s' flags=0x%lx", i,

             state->slots[i], slotInfo.slotDescription, slotInfo.flags);

    /* this is a safety guard as we're supposed to have listed only readers with tokens in them

     */

    if (!(slotInfo.flags & CKF_TOKEN_PRESENT))

    {

      WLog_INFO(TAG, "token not present for slot #%lu(%lu)", i, state->slots[i]);

      continue;

    }

    WINPR_ASSERT(p11->C_GetTokenInfo);

    rv = p11->C_GetTokenInfo(state->slots[i], &tokenInfo);

    if (rv != CKR_OK)

      loge(TAG, "unable to retrieve token info", rv, i, state->slots[i]);

    else

    {

      fix_padded_string((char*)tokenInfo.label, sizeof(tokenInfo.label));

      WLog_DBG(TAG, "token, label='%s' flags=0x%lx", tokenInfo.label, tokenInfo.flags);

    }

    WINPR_ASSERT(p11->C_OpenSession);

    rv = p11->C_OpenSession(state->slots[i], CKF_SERIAL_SESSION, nullptr, nullptr, &session);

    if (rv != CKR_OK)

    {

      WLog_ERR(TAG, "unable to openSession for slot #%lu(%lu), session=%p rv=%s", i,

               state->slots[i], WINPR_CXX_COMPAT_CAST(const void*, session),

               CK_RV_error_string(rv));

      continue;

    }

    WINPR_ASSERT(p11->C_FindObjectsInit);

    rv = p11->C_FindObjectsInit(session, public_key_filter, ARRAYSIZE(public_key_filter));

    if (rv != CKR_OK)

    {

      // TODO: shall it be fatal ?

      loge(TAG, "unable to initiate search", rv, i, state->slots[i]);

      goto cleanup_FindObjectsInit;

    }

    {

      CK_ULONG nslotObjects = 0;

      WINPR_ASSERT(p11->C_FindObjects);

      rv =

          p11->C_FindObjects(session, &slotObjects[0], ARRAYSIZE(slotObjects), &nslotObjects);

      if (rv != CKR_OK)

      {

        loge(TAG, "unable to findObjects", rv, i, state->slots[i]);

        goto cleanup_FindObjects;

      }

      WLog_DBG(TAG, "slot has %lu objects", nslotObjects);

      for (CK_ULONG j = 0; (j < nslotObjects) && (state->nKeys < ARRAYSIZE(state->keys)); j++)

      {

        NCryptKeyEnum* key = &state->keys[state->nKeys];

        CK_OBJECT_CLASS dataClass = CKO_PUBLIC_KEY;

        CK_ATTRIBUTE key_or_certAttrs[] = {

          { CKA_ID, &key->id, sizeof(key->id) },

          { CKA_CLASS, &dataClass, sizeof(dataClass) },

          { CKA_LABEL, &key->keyLabel, sizeof(key->keyLabel) },

          { CKA_KEY_TYPE, &key->keyType, sizeof(key->keyType) }

        };

        rv = object_load_attributes(provider, session, slotObjects[j], key_or_certAttrs,

                                    ARRAYSIZE(key_or_certAttrs));

        if (rv != CKR_OK)

        {

          WLog_ERR(TAG, "error getting attributes, rv=%s", CK_RV_error_string(rv));

          continue;

        }

        key->idLen = key_or_certAttrs[0].ulValueLen;

        if (key->idLen > sizeof(key->id))

        {

          WLog_ERR(TAG, "error getting attributes, idLen %lu > %" PRIuz, key->idLen,

                   sizeof(key->id));

          continue;

        }

        if (key_or_certAttrs[1].ulValueLen > sizeof(dataClass))

        {

          WLog_ERR(TAG, "error getting attributes, sizeof(CK_OBJECT_CLASS) %lu > %" PRIuz,

                   key_or_certAttrs[1].ulValueLen, sizeof(dataClass));

          continue;

        }

        if (key_or_certAttrs[2].ulValueLen > sizeof(key->keyLabel))

        {

          WLog_ERR(TAG, "error getting attributes, sizeof(key->keylabel) %lu > %" PRIuz,

                   key_or_certAttrs[2].ulValueLen, sizeof(key->keyLabel));

          continue;

        }

        if (key_or_certAttrs[3].ulValueLen > sizeof(key->keyType))

        {

          WLog_ERR(TAG, "error getting attributes, sizeof(CK_OBJECT_CLASS) %lu > %" PRIuz,

                   key_or_certAttrs[3].ulValueLen, sizeof(key->keyType));

          continue;

        }

        key->slotId = state->slots[i];

        key->slotInfo = slotInfo;

        state->nKeys++;

      }

    }

  cleanup_FindObjects:

    WINPR_ASSERT(p11->C_FindObjectsFinal);

    rv = p11->C_FindObjectsFinal(session);

    if (rv != CKR_OK)

      loge(TAG, "error during C_FindObjectsFinal", rv, i, state->slots[i]);

  cleanup_FindObjectsInit:

    WINPR_ASSERT(p11->C_CloseSession);

    rv = p11->C_CloseSession(session);

    if (rv != CKR_OK)

      loge(TAG, "error closing session", rv, i, state->slots[i]);

  }

  return ERROR_SUCCESS;

}

WINPR_ATTR_NODISCARD

static BOOL convertKeyType(CK_KEY_TYPE k, LPWSTR dest, DWORD len, DWORD* outlen)

{

  const WCHAR* r = nullptr;

  size_t retLen = 0;

#define ALGO_CASE(V, S)                         \

  case V:                                     \

    r = S;                                  \

    retLen = _wcsnlen((S), ARRAYSIZE((S))); \

    break

  switch (k)

  {

    ALGO_CASE(CKK_RSA, BCRYPT_RSA_ALGORITHM);

    ALGO_CASE(CKK_DSA, BCRYPT_DSA_ALGORITHM);

    ALGO_CASE(CKK_DH, BCRYPT_DH_ALGORITHM);

    ALGO_CASE(CKK_EC, BCRYPT_ECDSA_ALGORITHM);

    ALGO_CASE(CKK_RC2, BCRYPT_RC2_ALGORITHM);

    ALGO_CASE(CKK_RC4, BCRYPT_RC4_ALGORITHM);

    ALGO_CASE(CKK_DES, BCRYPT_DES_ALGORITHM);

    ALGO_CASE(CKK_DES3, BCRYPT_3DES_ALGORITHM);

    case CKK_DES2:

    case CKK_X9_42_DH:

    case CKK_KEA:

    case CKK_GENERIC_SECRET:

    case CKK_CAST:

    case CKK_CAST3:

    case CKK_CAST128:

    case CKK_RC5:

    case CKK_IDEA:

    case CKK_SKIPJACK:

    case CKK_BATON:

    case CKK_JUNIPER:

    case CKK_CDMF:

    case CKK_AES:

    case CKK_BLOWFISH:

    case CKK_TWOFISH:

    default:

      break;

  }

#undef ALGO_CASE

  if (retLen > UINT32_MAX)

    return FALSE;

  if (outlen)

    *outlen = (UINT32)retLen;

  if (!r)

  {

    if (dest && len > 0)

      dest[0] = 0;

    return FALSE;

  }

  if (dest)

  {

    if (retLen + 1 > len)

    {

      WLog_ERR(TAG, "target buffer is too small for algo name");

      return FALSE;

    }

    memcpy(dest, r, sizeof(WCHAR) * retLen);

    dest[retLen] = 0;

  }

  return TRUE;

}

WINPR_ATTR_NODISCARD

static BOOL wprintKeyName(LPWSTR str, size_t strByteLen, CK_SLOT_ID slotId, CK_BYTE* id,

                          CK_ULONG idLen)

{

  if (strByteLen < sizeof(slotId) + 2ull)

    return FALSE;

  if ((strByteLen - (sizeof(slotId) * 2ull) / 2ull) < idLen)

    return FALSE;

  char* asciiName = calloc(strByteLen, 2);

  if (!asciiName)

    return FALSE;

  char* ptr = asciiName;

  *ptr++ = '\\';

  const CK_BYTE* bytePtr = ((const CK_BYTE*)&slotId);

  for (CK_ULONG i = 0; i < sizeof(slotId); i++, bytePtr++, ptr += 2)

    (void)snprintf(ptr, 3, "%.2x", *bytePtr);

  *ptr++ = '\\';

  for (CK_ULONG i = 0; i < idLen; i++, id++, ptr += 2)

    (void)snprintf(ptr, 3, "%.2x", *id);

  const SSIZE_T rc =

      ConvertUtf8NToWChar(asciiName, strByteLen, str, strnlen(asciiName, strByteLen) + 1);

  winpr_zfree(asciiName);

  return rc > 0;

}

WINPR_ATTR_NODISCARD

static size_t parseHex(const char* str, const char* end, CK_BYTE* target)

{

  size_t ret = 0;

  for (; str != end && *str; str++, ret++, target++)

  {

    int v = 0;

    if (*str <= '9' && *str >= '0')

    {

      v = (*str - '0');

    }

    else if (*str <= 'f' && *str >= 'a')

    {

      v = (10 + *str - 'a');

    }

    else if (*str <= 'F' && *str >= 'A')

    {

      v |= (10 + *str - 'A');

    }

    else

    {

      return 0;

    }

    v <<= 4;

    str++;

    if (!*str || str == end)

      return 0;

    if (*str <= '9' && *str >= '0')

    {

      v |= (*str - '0');

    }

    else if (*str <= 'f' && *str >= 'a')

    {

      v |= (10 + *str - 'a');

    }

    else if (*str <= 'F' && *str >= 'A')

    {

      v |= (10 + *str - 'A');

    }

    else

    {

      return 0;

    }

    *target = v & 0xFF;

  }

  return ret;

}

WINPR_ATTR_NODISCARD

static SECURITY_STATUS parseKeyName(LPCWSTR pszKeyName, CK_SLOT_ID* slotId, CK_BYTE* id,

                                    CK_ULONG* idLen)

{

  char asciiKeyName[128] = WINPR_C_ARRAY_INIT;

  char* pos = nullptr;

  if (ConvertWCharToUtf8(pszKeyName, asciiKeyName, ARRAYSIZE(asciiKeyName)) < 0)

    return NTE_BAD_KEY;

  if (*asciiKeyName != '\\')

    return NTE_BAD_KEY;

  pos = strchr(&asciiKeyName[1], '\\');

  if (!pos)

    return NTE_BAD_KEY;

  if ((size_t)(pos - &asciiKeyName[1]) > sizeof(CK_SLOT_ID) * 2ull)

    return NTE_BAD_KEY;

  *slotId = (CK_SLOT_ID)0;

  if (parseHex(&asciiKeyName[1], pos, (CK_BYTE*)slotId) != sizeof(CK_SLOT_ID))

    return NTE_BAD_KEY;

  *idLen = parseHex(pos + 1, nullptr, id);

  if (!*idLen)

    return NTE_BAD_KEY;

  return ERROR_SUCCESS;

}

WINPR_ATTR_NODISCARD

static SECURITY_STATUS NCryptP11EnumKeys(NCRYPT_PROV_HANDLE hProvider, LPCWSTR pszScope,

                                         NCryptKeyName** ppKeyName, PVOID* ppEnumState,

                                         WINPR_ATTR_UNUSED DWORD dwFlags)

{

  NCryptP11ProviderHandle* provider = (NCryptP11ProviderHandle*)hProvider;

  P11EnumKeysState* state = (P11EnumKeysState*)*ppEnumState;

  CK_RV rv = WINPR_C_ARRAY_INIT;

  CK_SLOT_ID currentSlot = WINPR_C_ARRAY_INIT;

  CK_SESSION_HANDLE currentSession = 0;

  char slotFilterBuffer[65] = WINPR_C_ARRAY_INIT;

  char* slotFilter = nullptr;

  size_t slotFilterLen = 0;

  SECURITY_STATUS ret = checkNCryptHandle((NCRYPT_HANDLE)hProvider, WINPR_NCRYPT_PROVIDER);

  if (ret != ERROR_SUCCESS)

    return ret;

  if (pszScope)

  {

    /*

     * check whether pszScope is of the form \\.\<reader name>\ for filtering by

     * card reader

     */

    char asciiScope[128 + 6 + 1] = WINPR_C_ARRAY_INIT;

    size_t asciiScopeLen = 0;

    if (ConvertWCharToUtf8(pszScope, asciiScope, ARRAYSIZE(asciiScope) - 1) < 0)

    {

      WLog_WARN(TAG, "Invalid scope");

      return NTE_INVALID_PARAMETER;

    }

    if (strstr(asciiScope, "\\\\.\\") != asciiScope)

    {

      WLog_WARN(TAG, "Invalid scope '%s'", asciiScope);

      return NTE_INVALID_PARAMETER;

    }

    asciiScopeLen = strnlen(asciiScope, ARRAYSIZE(asciiScope));

    if ((asciiScopeLen < 1) || (asciiScope[asciiScopeLen - 1] != '\\'))

    {

      WLog_WARN(TAG, "Invalid scope '%s'", asciiScope);

      return NTE_INVALID_PARAMETER;

    }

    asciiScope[asciiScopeLen - 1] = 0;

    strncpy(slotFilterBuffer, &asciiScope[4], sizeof(slotFilterBuffer));

    slotFilter = slotFilterBuffer;

    slotFilterLen = asciiScopeLen - 5;

  }

  if (!state)

  {

    state = (P11EnumKeysState*)calloc(1, sizeof(*state));

    if (!state)

      return NTE_NO_MEMORY;

    WINPR_ASSERT(provider->p11->C_GetSlotList);

    rv = provider->p11->C_GetSlotList(CK_TRUE, nullptr, &state->nslots);

    if (rv != CKR_OK)

    {

      free(state);

      /* TODO: perhaps convert rv to NTE_*** errors */

      WLog_WARN(TAG, "C_GetSlotList failed with %s [0x%08lx]", CK_RV_error_string(rv), rv);

      return NTE_FAIL;

    }

    if (state->nslots > MAX_SLOTS)

      state->nslots = MAX_SLOTS;

    rv = provider->p11->C_GetSlotList(CK_TRUE, state->slots, &state->nslots);

    if (rv != CKR_OK)

    {

      free(state);

      /* TODO: perhaps convert rv to NTE_*** errors */

      WLog_WARN(TAG, "C_GetSlotList failed with %s [0x%08lx]", CK_RV_error_string(rv), rv);

      return NTE_FAIL;

    }

    ret = collect_keys(provider, state);

    if (ret != ERROR_SUCCESS)

    {

      free(state);

      return ret;

    }

    *ppEnumState = state;

  }

  for (; state->keyIndex < state->nKeys; state->keyIndex++)