yubihsm.h

Go to the documentation of this file.

/*
 * Copyright 2015-2018 Yubico AB
 *
 * 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.
 */

#ifndef YUBIHSM_H
#define YUBIHSM_H

#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>

#define YH_CONTEXT_LEN 16
#define YH_HOST_CHAL_LEN 8
#define YH_MSG_BUF_SIZE 2048
#define YH_KEY_LEN 16
#define YH_VID 0x1050
#define YH_PID 0x0030
#define YH_CMD_RESP_FLAG 0x80
#define YH_MAX_ITEMS_COUNT 256
#define YH_MAX_SESSIONS 16
#define YH_DEFAULT_ENC_KEY                                                     \
  "\x09\x0b\x47\xdb\xed\x59\x56\x54\x90\x1d\xee\x1c\xc6\x55\xe4\x20"
#define YH_DEFAULT_MAC_KEY                                                     \
  "\x59\x2f\xd4\x83\xf7\x59\xe2\x99\x09\xa0\x4c\x45\x05\xd2\xce\x0a"
#define YH_DEFAULT_PASSWORD "password"
#define YH_DEFAULT_SALT "Yubico"
#define YH_DEFAULT_ITERS 10000
#define YH_CAPABILITIES_LEN 8
#define YH_MAX_LOG_ENTRIES 64
#define YH_OBJ_LABEL_LEN 40
#define YH_MAX_DOMAINS 16
#define YH_LOG_DIGEST_SIZE 16
#define YH_USB_URL_SCHEME "yhusb://"

// Debug levels
#define YH_VERB_QUIET 0x00
#define YH_VERB_INTERMEDIATE 0x01
#define YH_VERB_CRYPTO 0x02
#define YH_VERB_RAW 0x04
#define YH_VERB_INFO 0x08
#define YH_VERB_ERR 0x10
#define YH_VERB_ALL 0xff

#define YH_CCM_WRAP_OVERHEAD (1 + 13 + 16)

#ifdef __cplusplus
extern "C" {
#endif

typedef struct yh_connector yh_connector;

typedef struct yh_session yh_session;

typedef struct {
  uint8_t capabilities[YH_CAPABILITIES_LEN];
} yh_capabilities;

typedef enum {
  YHR_SUCCESS = 0,
  YHR_MEMORY_ERROR = -1,
  YHR_INIT_ERROR = -2,
  YHR_CONNECTION_ERROR = -3,
  YHR_CONNECTOR_NOT_FOUND = -4,
  YHR_INVALID_PARAMETERS = -5,
  YHR_WRONG_LENGTH = -6,
  YHR_BUFFER_TOO_SMALL = -7,
  YHR_CRYPTOGRAM_MISMATCH = -8,
  YHR_SESSION_AUTHENTICATION_FAILED = -9,
  YHR_MAC_MISMATCH = -10,
  YHR_DEVICE_OK = -11,
  YHR_DEVICE_INVALID_COMMAND = -12,
  YHR_DEVICE_INVALID_DATA = -13,
  YHR_DEVICE_INVALID_SESSION = -14,
  YHR_DEVICE_AUTHENTICATION_FAILED = -15,
  YHR_DEVICE_SESSIONS_FULL = -16,
  YHR_DEVICE_SESSION_FAILED = -17,
  YHR_DEVICE_STORAGE_FAILED = -18,
  YHR_DEVICE_WRONG_LENGTH = -19,
  YHR_DEVICE_INSUFFICIENT_PERMISSIONS = -20,
  YHR_DEVICE_LOG_FULL = -21,
  YHR_DEVICE_OBJECT_NOT_FOUND = -22,
  YHR_DEVICE_INVALID_ID = -23,
  YHR_DEVICE_INVALID_OTP = -24,
  YHR_DEVICE_DEMO_MODE = -25,
  YHR_DEVICE_COMMAND_UNEXECUTED = -26,
  YHR_GENERIC_ERROR = -27,
  YHR_DEVICE_OBJECT_EXISTS = -28,
  YHR_CONNECTOR_ERROR = -29,
  YHR_DEVICE_SSH_CA_CONSTRAINT_VIOLATION = -30,
} yh_rc;

#define ADD_COMMAND(c, v) c = v, c##_R = v | YH_CMD_RESP_FLAG

typedef enum {
  ADD_COMMAND(YHC_ECHO, 0x01),
  ADD_COMMAND(YHC_CREATE_SESSION, 0x03),
  ADD_COMMAND(YHC_AUTHENTICATE_SESSION, 0x04),
  ADD_COMMAND(YHC_SESSION_MESSAGE, 0x05),
  ADD_COMMAND(YHC_GET_DEVICE_INFO, 0x06),
  ADD_COMMAND(YHC_RESET_DEVICE, 0x08),
  ADD_COMMAND(YHC_CLOSE_SESSION, 0x40),
  ADD_COMMAND(YHC_GET_STORAGE_INFO, 0x041),
  ADD_COMMAND(YHC_PUT_OPAQUE, 0x42),
  ADD_COMMAND(YHC_GET_OPAQUE, 0x43),
  ADD_COMMAND(YHC_PUT_AUTHENTICATION_KEY, 0x44),
  ADD_COMMAND(YHC_PUT_ASYMMETRIC_KEY, 0x45),
  ADD_COMMAND(YHC_GENERATE_ASYMMETRIC_KEY, 0x46),
  ADD_COMMAND(YHC_SIGN_PKCS1, 0x47),
  ADD_COMMAND(YHC_LIST_OBJECTS, 0x48),
  ADD_COMMAND(YHC_DECRYPT_PKCS1, 0x49),
  ADD_COMMAND(YHC_EXPORT_WRAPPED, 0x4a),
  ADD_COMMAND(YHC_IMPORT_WRAPPED, 0x4b),
  ADD_COMMAND(YHC_PUT_WRAP_KEY, 0x4c),
  ADD_COMMAND(YHC_GET_LOG_ENTRIES, 0x4d),
  ADD_COMMAND(YHC_GET_OBJECT_INFO, 0x4e),
  ADD_COMMAND(YHC_SET_OPTION, 0x4f),
  ADD_COMMAND(YHC_GET_OPTION, 0x50),
  ADD_COMMAND(YHC_GET_PSEUDO_RANDOM, 0x51),
  ADD_COMMAND(YHC_PUT_HMAC_KEY, 0x52),
  ADD_COMMAND(YHC_SIGN_HMAC, 0x53),
  ADD_COMMAND(YHC_GET_PUBLIC_KEY, 0x54),
  ADD_COMMAND(YHC_SIGN_PSS, 0x55),
  ADD_COMMAND(YHC_SIGN_ECDSA, 0x56),
  ADD_COMMAND(YHC_DERIVE_ECDH, 0x57),
  ADD_COMMAND(YHC_DELETE_OBJECT, 0x58),
  ADD_COMMAND(YHC_DECRYPT_OAEP, 0x59),
  ADD_COMMAND(YHC_GENERATE_HMAC_KEY, 0x5a),
  ADD_COMMAND(YHC_GENERATE_WRAP_KEY, 0x5b),
  ADD_COMMAND(YHC_VERIFY_HMAC, 0x5c),
  ADD_COMMAND(YHC_SIGN_SSH_CERTIFICATE, 0x5d),
  ADD_COMMAND(YHC_PUT_TEMPLATE, 0x5e),
  ADD_COMMAND(YHC_GET_TEMPLATE, 0x5f),
  ADD_COMMAND(YHC_DECRYPT_OTP, 0x60),
  ADD_COMMAND(YHC_CREATE_OTP_AEAD, 0x61),
  ADD_COMMAND(YHC_RANDOMIZE_OTP_AEAD, 0x62),
  ADD_COMMAND(YHC_REWRAP_OTP_AEAD, 0x63),
  ADD_COMMAND(YHC_SIGN_ATTESTATION_CERTIFICATE, 0x64),
  ADD_COMMAND(YHC_PUT_OTP_AEAD_KEY, 0x65),
  ADD_COMMAND(YHC_GENERATE_OTP_AEAD_KEY, 0x66),
  ADD_COMMAND(YHC_SET_LOG_INDEX, 0x67),
  ADD_COMMAND(YHC_WRAP_DATA, 0x68),
  ADD_COMMAND(YHC_UNWRAP_DATA, 0x69),
  ADD_COMMAND(YHC_SIGN_EDDSA, 0x6a),
  ADD_COMMAND(YHC_BLINK_DEVICE, 0x6b),
  ADD_COMMAND(YHC_CHANGE_AUTHENTICATION_KEY, 0x6c),
  YHC_ERROR = 0x7f,
} yh_cmd;

#undef ADD_COMMAND

typedef enum {
  YH_OPAQUE = 0x01,
  YH_AUTHENTICATION_KEY = 0x02,
  YH_ASYMMETRIC_KEY = 0x03,
  YH_WRAP_KEY = 0x04,
  YH_HMAC_KEY = 0x05,
  YH_TEMPLATE = 0x06,
  YH_OTP_AEAD_KEY = 0x07,
  YH_PUBLIC_KEY = 0x83,
} yh_object_type;

#define YH_MAX_ALGORITHM_COUNT 0xff

typedef enum {
  YH_ALGO_RSA_PKCS1_SHA1 = 1,
  YH_ALGO_RSA_PKCS1_SHA256 = 2,
  YH_ALGO_RSA_PKCS1_SHA384 = 3,
  YH_ALGO_RSA_PKCS1_SHA512 = 4,
  YH_ALGO_RSA_PSS_SHA1 = 5,
  YH_ALGO_RSA_PSS_SHA256 = 6,
  YH_ALGO_RSA_PSS_SHA384 = 7,
  YH_ALGO_RSA_PSS_SHA512 = 8,
  YH_ALGO_RSA_2048 = 9,
  YH_ALGO_RSA_3072 = 10,
  YH_ALGO_RSA_4096 = 11,
  YH_ALGO_EC_P256 = 12,
  YH_ALGO_EC_P384 = 13,
  YH_ALGO_EC_P521 = 14,
  YH_ALGO_EC_K256 = 15,
  YH_ALGO_EC_BP256 = 16,
  YH_ALGO_EC_BP384 = 17,
  YH_ALGO_EC_BP512 = 18,
  YH_ALGO_HMAC_SHA1 = 19,
  YH_ALGO_HMAC_SHA256 = 20,
  YH_ALGO_HMAC_SHA384 = 21,
  YH_ALGO_HMAC_SHA512 = 22,
  YH_ALGO_EC_ECDSA_SHA1 = 23,
  YH_ALGO_EC_ECDH = 24,
  YH_ALGO_RSA_OAEP_SHA1 = 25,
  YH_ALGO_RSA_OAEP_SHA256 = 26,
  YH_ALGO_RSA_OAEP_SHA384 = 27,
  YH_ALGO_RSA_OAEP_SHA512 = 28,
  YH_ALGO_AES128_CCM_WRAP = 29,
  YH_ALGO_OPAQUE_DATA = 30,
  YH_ALGO_OPAQUE_X509_CERTIFICATE = 31,
  YH_ALGO_MGF1_SHA1 = 32,
  YH_ALGO_MGF1_SHA256 = 33,
  YH_ALGO_MGF1_SHA384 = 34,
  YH_ALGO_MGF1_SHA512 = 35,
  YH_ALGO_TEMPLATE_SSH = 36,
  YH_ALGO_AES128_YUBICO_OTP = 37,
  YH_ALGO_AES128_YUBICO_AUTHENTICATION = 38,
  YH_ALGO_AES192_YUBICO_OTP = 39,
  YH_ALGO_AES256_YUBICO_OTP = 40,
  YH_ALGO_AES192_CCM_WRAP = 41,
  YH_ALGO_AES256_CCM_WRAP = 42,
  YH_ALGO_EC_ECDSA_SHA256 = 43,
  YH_ALGO_EC_ECDSA_SHA384 = 44,
  YH_ALGO_EC_ECDSA_SHA512 = 45,
  YH_ALGO_EC_ED25519 = 46,
  YH_ALGO_EC_P224 = 47,
} yh_algorithm;

typedef enum {
  YH_OPTION_FORCE_AUDIT = 1,
  YH_OPTION_COMMAND_AUDIT = 3,
} yh_option;

typedef enum {
  YH_CONNECTOR_HTTPS_CA = 1,
  YH_CONNECTOR_PROXY_SERVER = 2,
} yh_connector_option;

#pragma pack(push, 1)

typedef struct {
  uint16_t number;
  uint8_t command;
  uint16_t length;
  uint16_t session_key;
  uint16_t target_key;
  uint16_t second_key;
  uint8_t result;
  uint32_t systick;
  uint8_t digest[YH_LOG_DIGEST_SIZE];
} yh_log_entry;

typedef struct {
  yh_capabilities capabilities;
  uint16_t id;
  uint16_t len;
  uint16_t domains;
  yh_object_type type;
  yh_algorithm algorithm;
  uint8_t sequence;
  uint8_t origin;
  char label[YH_OBJ_LABEL_LEN + 1];
  yh_capabilities delegated_capabilities;
} yh_object_descriptor;
#pragma pack(pop)

static const struct {
  const char *name;
  int bit;
} yh_capability[] = {
  {"change-authentication-key", 0x2e},
  {"create-otp-aead", 0x1e},
  {"decrypt-oaep", 0x0a},
  {"decrypt-otp", 0x1d},
  {"decrypt-pkcs", 0x09},
  {"delete-asymmetric-key", 0x29},
  {"delete-authentication-key", 0x28},
  {"delete-hmac-key", 0x2b},
  {"delete-opaque", 0x27},
  {"delete-otp-aead-key", 0x2d},
  {"delete-template", 0x2c},
  {"delete-wrap-key", 0x2a},
  {"derive-ecdh", 0x0b},
  {"export-wrapped", 0x0c},
  {"exportable-under-wrap", 0x10},
  {"generate-asymmetric-key", 0x04},
  {"generate-hmac-key", 0x15},
  {"generate-otp-aead-key", 0x24},
  {"generate-wrap-key", 0x0f},
  {"get-log-entries", 0x18},
  {"get-opaque", 0x00},
  {"get-option", 0x12},
  {"get-pseudo-random", 0x13},
  {"get-template", 0x1a},
  {"import-wrapped", 0x0d},
  {"put-asymmetric-key", 0x03},
  {"put-authentication-key", 0x02},
  {"put-mac-key", 0x14},
  {"put-opaque", 0x01},
  {"put-otp-aead-key", 0x23},
  {"put-template", 0x1b},
  {"put-wrap-key", 0x0e},
  {"randomize-otp-aead", 0x1f},
  {"reset-device", 0x1c},
  {"rewrap-from-otp-aead-key", 0x20},
  {"rewrap-to-otp-aead-key", 0x21},
  {"set-option", 0x11},
  {"sign-attestation-certificate", 0x22},
  {"sign-ecdsa", 0x07},
  {"sign-eddsa", 0x08},
  {"sign-hmac", 0x16},
  {"sign-pkcs", 0x05},
  {"sign-pss", 0x06},
  {"sign-ssh-certificate", 0x19},
  {"unwrap-data", 0x26},
  {"verify-hmac", 0x17},
  {"wrap-data", 0x25},
};

static const struct {
  const char *name;
  yh_algorithm algorithm;
} yh_algorithms[] = {
  {"aes128-ccm-wrap", YH_ALGO_AES128_CCM_WRAP},
  {"aes128-yubico-authentication", YH_ALGO_AES128_YUBICO_AUTHENTICATION},
  {"aes128-yubico-otp", YH_ALGO_AES128_YUBICO_OTP},
  {"aes192-ccm-wrap", YH_ALGO_AES192_CCM_WRAP},
  {"aes192-yubico-otp", YH_ALGO_AES192_YUBICO_OTP},
  {"aes256-ccm-wrap", YH_ALGO_AES256_CCM_WRAP},
  {"aes256-yubico-otp", YH_ALGO_AES256_YUBICO_OTP},
  {"ecbp256", YH_ALGO_EC_BP256},
  {"ecbp384", YH_ALGO_EC_BP384},
  {"ecbp512", YH_ALGO_EC_BP512},
  {"ecdh", YH_ALGO_EC_ECDH},
  {"ecdsa-sha1", YH_ALGO_EC_ECDSA_SHA1},
  {"ecdsa-sha256", YH_ALGO_EC_ECDSA_SHA256},
  {"ecdsa-sha384", YH_ALGO_EC_ECDSA_SHA384},
  {"ecdsa-sha512", YH_ALGO_EC_ECDSA_SHA512},
  {"eck256", YH_ALGO_EC_K256},
  {"ecp224", YH_ALGO_EC_P224},
  {"ecp256", YH_ALGO_EC_P256},
  {"ecp384", YH_ALGO_EC_P384},
  {"ecp521", YH_ALGO_EC_P521},
  {"ed25519", YH_ALGO_EC_ED25519},
  {"hmac-sha1", YH_ALGO_HMAC_SHA1},
  {"hmac-sha256", YH_ALGO_HMAC_SHA256},
  {"hmac-sha384", YH_ALGO_HMAC_SHA384},
  {"hmac-sha512", YH_ALGO_HMAC_SHA512},
  {"mgf1-sha1", YH_ALGO_MGF1_SHA1},
  {"mgf1-sha256", YH_ALGO_MGF1_SHA256},
  {"mgf1-sha384", YH_ALGO_MGF1_SHA384},
  {"mgf1-sha512", YH_ALGO_MGF1_SHA512},
  {"opaque-data", YH_ALGO_OPAQUE_DATA},
  {"opaque-x509-certificate", YH_ALGO_OPAQUE_X509_CERTIFICATE},
  {"rsa-oaep-sha1", YH_ALGO_RSA_OAEP_SHA1},
  {"rsa-oaep-sha256", YH_ALGO_RSA_OAEP_SHA256},
  {"rsa-oaep-sha384", YH_ALGO_RSA_OAEP_SHA384},
  {"rsa-oaep-sha512", YH_ALGO_RSA_OAEP_SHA512},
  {"rsa-pkcs1-sha1", YH_ALGO_RSA_PKCS1_SHA1},
  {"rsa-pkcs1-sha256", YH_ALGO_RSA_PKCS1_SHA256},
  {"rsa-pkcs1-sha384", YH_ALGO_RSA_PKCS1_SHA384},
  {"rsa-pkcs1-sha512", YH_ALGO_RSA_PKCS1_SHA512},
  {"rsa-pss-sha1", YH_ALGO_RSA_PSS_SHA1},
  {"rsa-pss-sha256", YH_ALGO_RSA_PSS_SHA256},
  {"rsa-pss-sha384", YH_ALGO_RSA_PSS_SHA384},
  {"rsa-pss-sha512", YH_ALGO_RSA_PSS_SHA512},
  {"rsa2048", YH_ALGO_RSA_2048},
  {"rsa3072", YH_ALGO_RSA_3072},
  {"rsa4096", YH_ALGO_RSA_4096},
  {"template-ssh", YH_ALGO_TEMPLATE_SSH},
};

static const struct {
  const char *name;
  yh_object_type type;
} yh_types[] = {
  {"authentication-key", YH_AUTHENTICATION_KEY},
  {"asymmetric-key", YH_ASYMMETRIC_KEY},
  {"hmac-key", YH_HMAC_KEY},
  {"opaque", YH_OPAQUE},
  {"otp-aead-key", YH_OTP_AEAD_KEY},
  {"template", YH_TEMPLATE},
  {"wrap-key", YH_WRAP_KEY},
};

static const struct {
  const char *name;
  yh_option option;
} yh_options[] = {
  {"command-audit", YH_OPTION_COMMAND_AUDIT},
  {"force-audit", YH_OPTION_FORCE_AUDIT},
};

#define YH_ORIGIN_GENERATED 0x01
#define YH_ORIGIN_IMPORTED 0x02
#define YH_ORIGIN_IMPORTED_WRAPPED 0x10

const char *yh_strerror(yh_rc err);

yh_rc yh_set_verbosity(yh_connector *connector, uint8_t verbosity);

yh_rc yh_get_verbosity(uint8_t *verbosity);

void yh_set_debug_output(yh_connector *connector, FILE *output);

yh_rc yh_init(void);

yh_rc yh_exit(void);

yh_rc yh_init_connector(const char *url, yh_connector **connector);

yh_rc yh_set_connector_option(yh_connector *connector, yh_connector_option opt,
                              const void *val);

yh_rc yh_connect(yh_connector *connector, int timeout);

yh_rc yh_disconnect(yh_connector *connector);

yh_rc yh_send_plain_msg(yh_connector *connector, yh_cmd cmd,
                        const uint8_t *data, size_t data_len,
                        yh_cmd *response_cmd, uint8_t *response,
                        size_t *response_len);

yh_rc yh_send_secure_msg(yh_session *session, yh_cmd cmd, const uint8_t *data,
                         size_t data_len, yh_cmd *response_cmd,
                         uint8_t *response, size_t *response_len);

yh_rc yh_create_session_derived(yh_connector *connector, uint16_t authkey_id,
                                const uint8_t *password, size_t password_len,
                                bool recreate_session, yh_session **session);

yh_rc yh_create_session(yh_connector *connector, uint16_t authkey_id,
                        const uint8_t *key_enc, size_t key_enc_len,
                        const uint8_t *key_mac, size_t key_mac_len,
                        bool recreate_session, yh_session **session);

yh_rc yh_begin_create_session_ext(yh_connector *connector, uint16_t authkey_id,
                                  uint8_t **context, uint8_t *card_cryptogram,
                                  size_t card_cryptogram_len,
                                  yh_session **session);

yh_rc yh_finish_create_session_ext(yh_connector *connector, yh_session *session,
                                   const uint8_t *key_senc, size_t key_senc_len,
                                   const uint8_t *key_smac, size_t key_smac_len,
                                   const uint8_t *key_srmac,
                                   size_t key_srmac_len,
                                   uint8_t *card_cryptogram,
                                   size_t card_cryptogram_len);

yh_rc yh_destroy_session(yh_session **session);

yh_rc yh_authenticate_session(yh_session *session);

// Utility and convenience functions below

yh_rc yh_util_get_device_info(yh_connector *connector, uint8_t *major,
                              uint8_t *minor, uint8_t *patch, uint32_t *serial,
                              uint8_t *log_total, uint8_t *log_used,
                              yh_algorithm *algorithms, size_t *n_algorithms);

yh_rc yh_util_list_objects(yh_session *session, uint16_t id,
                           yh_object_type type, uint16_t domains,
                           const yh_capabilities *capabilities,
                           yh_algorithm algorithm, const char *label,
                           yh_object_descriptor *objects, size_t *n_objects);

yh_rc yh_util_get_object_info(yh_session *session, uint16_t id,
                              yh_object_type type,
                              yh_object_descriptor *object);

yh_rc yh_util_get_public_key(yh_session *session, uint16_t id, uint8_t *data,
                             size_t *data_len, yh_algorithm *algorithm);

yh_rc yh_util_close_session(yh_session *session);

yh_rc yh_util_sign_pkcs1v1_5(yh_session *session, uint16_t key_id, bool hashed,
                             const uint8_t *in, size_t in_len, uint8_t *out,
                             size_t *out_len);

yh_rc yh_util_sign_pss(yh_session *session, uint16_t key_id, const uint8_t *in,
                       size_t in_len, uint8_t *out, size_t *out_len,
                       size_t salt_len, yh_algorithm mgf1Algo);

yh_rc yh_util_sign_ecdsa(yh_session *session, uint16_t key_id,
                         const uint8_t *in, size_t in_len, uint8_t *out,
                         size_t *out_len);

yh_rc yh_util_sign_eddsa(yh_session *session, uint16_t key_id,
                         const uint8_t *in, size_t in_len, uint8_t *out,
                         size_t *out_len);

yh_rc yh_util_sign_hmac(yh_session *session, uint16_t key_id, const uint8_t *in,
                        size_t in_len, uint8_t *out, size_t *out_len);

yh_rc yh_util_get_pseudo_random(yh_session *session, size_t len, uint8_t *out,
                                size_t *out_len);

yh_rc yh_util_import_rsa_key(yh_session *session, uint16_t *key_id,
                             const char *label, uint16_t domains,
                             const yh_capabilities *capabilities,
                             yh_algorithm algorithm, const uint8_t *p,
                             const uint8_t *q);

yh_rc yh_util_import_ec_key(yh_session *session, uint16_t *key_id,
                            const char *label, uint16_t domains,
                            const yh_capabilities *capabilities,
                            yh_algorithm algorithm, const uint8_t *s);

yh_rc yh_util_import_ed_key(yh_session *session, uint16_t *key_id,
                            const char *label, uint16_t domains,
                            const yh_capabilities *capabilities,
                            yh_algorithm algorithm, const uint8_t *k);

yh_rc yh_util_import_hmac_key(yh_session *session, uint16_t *key_id,
                              const char *label, uint16_t domains,
                              const yh_capabilities *capabilities,
                              yh_algorithm algorithm, const uint8_t *key,
                              size_t key_len);

yh_rc yh_util_generate_rsa_key(yh_session *session, uint16_t *key_id,
                               const char *label, uint16_t domains,
                               const yh_capabilities *capabilities,
                               yh_algorithm algorithm);

yh_rc yh_util_generate_ec_key(yh_session *session, uint16_t *key_id,
                              const char *label, uint16_t domains,
                              const yh_capabilities *capabilities,
                              yh_algorithm algorithm);

yh_rc yh_util_generate_ed_key(yh_session *session, uint16_t *key_id,
                              const char *label, uint16_t domains,
                              const yh_capabilities *capabilities,
                              yh_algorithm algorithm);

yh_rc yh_util_verify_hmac(yh_session *session, uint16_t key_id,
                          const uint8_t *signature, size_t signature_len,
                          const uint8_t *data, size_t data_len, bool *verified);

yh_rc yh_util_generate_hmac_key(yh_session *session, uint16_t *key_id,
                                const char *label, uint16_t domains,
                                const yh_capabilities *capabilities,
                                yh_algorithm algorithm);

yh_rc yh_util_decrypt_pkcs1v1_5(yh_session *session, uint16_t key_id,
                                const uint8_t *in, size_t in_len, uint8_t *out,
                                size_t *out_len);

yh_rc yh_util_decrypt_oaep(yh_session *session, uint16_t key_id,
                           const uint8_t *in, size_t in_len, uint8_t *out,
                           size_t *out_len, const uint8_t *label,
                           size_t label_len, yh_algorithm mgf1Algo);

yh_rc yh_util_derive_ecdh(yh_session *session, uint16_t key_id,
                          const uint8_t *in, size_t in_len, uint8_t *out,
                          size_t *out_len);

yh_rc yh_util_delete_object(yh_session *session, uint16_t id,
                            yh_object_type type);

yh_rc yh_util_export_wrapped(yh_session *session, uint16_t wrapping_key_id,
                             yh_object_type target_type, uint16_t target_id,
                             uint8_t *out, size_t *out_len);

yh_rc yh_util_import_wrapped(yh_session *session, uint16_t wrapping_key_id,
                             const uint8_t *in, size_t in_len,
                             yh_object_type *target_type, uint16_t *target_id);

yh_rc yh_util_import_wrap_key(yh_session *session, uint16_t *key_id,
                              const char *label, uint16_t domains,
                              const yh_capabilities *capabilities,
                              yh_algorithm algorithm,
                              const yh_capabilities *delegated_capabilities,
                              const uint8_t *in, size_t in_len);

yh_rc yh_util_generate_wrap_key(yh_session *session, uint16_t *key_id,
                                const char *label, uint16_t domains,
                                const yh_capabilities *capabilities,
                                yh_algorithm algorithm,
                                const yh_capabilities *delegated_capabilities);

yh_rc yh_util_get_log_entries(yh_session *session, uint16_t *unlogged_boot,
                              uint16_t *unlogged_auth, yh_log_entry *out,
                              size_t *n_items);

yh_rc yh_util_set_log_index(yh_session *session, uint16_t index);

yh_rc yh_util_get_opaque(yh_session *session, uint16_t object_id, uint8_t *out,
                         size_t *out_len);

yh_rc yh_util_import_opaque(yh_session *session, uint16_t *object_id,
                            const char *label, uint16_t domains,
                            const yh_capabilities *capabilities,
                            yh_algorithm algorithm, const uint8_t *in,
                            size_t in_len);

yh_rc yh_util_sign_ssh_certificate(yh_session *session, uint16_t key_id,
                                   uint16_t template_id, yh_algorithm sig_algo,
                                   const uint8_t *in, size_t in_len,
                                   uint8_t *out, size_t *out_len);

yh_rc yh_util_import_authentication_key(
  yh_session *session, uint16_t *key_id, const char *label, uint16_t domains,
  const yh_capabilities *capabilities,
  const yh_capabilities *delegated_capabilities, const uint8_t *key_enc,
  size_t key_enc_len, const uint8_t *key_mac, size_t key_mac_len);

yh_rc yh_util_import_authentication_key_derived(
  yh_session *session, uint16_t *key_id, const char *label, uint16_t domains,
  const yh_capabilities *capabilities,
  const yh_capabilities *delegated_capabilities, const uint8_t *password,
  size_t password_len);

yh_rc yh_util_change_authentication_key(yh_session *session, uint16_t *key_id,
                                        const uint8_t *key_enc,
                                        size_t key_enc_len,
                                        const uint8_t *key_mac,
                                        size_t key_mac_len);

yh_rc yh_util_change_authentication_key_derived(yh_session *session,
                                                uint16_t *key_id,
                                                const uint8_t *password,
                                                size_t password_len);

yh_rc yh_util_get_template(yh_session *session, uint16_t object_id,
                           uint8_t *out, size_t *out_len);

yh_rc yh_util_import_template(yh_session *session, uint16_t *object_id,
                              const char *label, uint16_t domains,
                              const yh_capabilities *capabilities,
                              yh_algorithm algorithm, const uint8_t *in,
                              size_t in_len);

yh_rc yh_util_create_otp_aead(yh_session *session, uint16_t key_id,
                              const uint8_t *key, const uint8_t *private_id,
                              uint8_t *out, size_t *out_len);

yh_rc yh_util_randomize_otp_aead(yh_session *session, uint16_t key_id,
                                 uint8_t *out, size_t *out_len);

yh_rc yh_util_decrypt_otp(yh_session *session, uint16_t key_id,
                          const uint8_t *aead, size_t aead_len,
                          const uint8_t *otp, uint16_t *useCtr,
                          uint8_t *sessionCtr, uint8_t *tstph, uint16_t *tstpl);

yh_rc yh_util_import_otp_aead_key(yh_session *session, uint16_t *key_id,
                                  const char *label, uint16_t domains,
                                  const yh_capabilities *capabilities,
                                  uint32_t nonce_id, const uint8_t *in,
                                  size_t in_len);

yh_rc yh_util_generate_otp_aead_key(yh_session *session, uint16_t *key_id,
                                    const char *label, uint16_t domains,
                                    const yh_capabilities *capabilities,
                                    yh_algorithm algorithm, uint32_t nonce_id);

yh_rc yh_util_sign_attestation_certificate(yh_session *session, uint16_t key_id,
                                           uint16_t attest_id, uint8_t *out,
                                           size_t *out_len);

yh_rc yh_util_set_option(yh_session *session, yh_option option, size_t len,
                         uint8_t *val);

yh_rc yh_util_get_option(yh_session *session, yh_option option, uint8_t *out,
                         size_t *out_len);

yh_rc yh_util_get_storage_info(yh_session *session, uint16_t *total_records,
                               uint16_t *free_records, uint16_t *total_pages,
                               uint16_t *free_pages, uint16_t *page_size);

yh_rc yh_util_wrap_data(yh_session *session, uint16_t key_id, const uint8_t *in,
                        size_t in_len, uint8_t *out, size_t *out_len);

yh_rc yh_util_unwrap_data(yh_session *session, uint16_t key_id,
                          const uint8_t *in, size_t in_len, uint8_t *out,
                          size_t *out_len);

yh_rc yh_util_blink_device(yh_session *session, uint8_t seconds);

yh_rc yh_util_reset_device(yh_session *session);

yh_rc yh_get_session_id(yh_session *session, uint8_t *sid);

bool yh_connector_has_device(yh_connector *connector);

yh_rc yh_get_connector_version(yh_connector *connector, uint8_t *major,
                               uint8_t *minor, uint8_t *patch);

yh_rc yh_get_connector_address(yh_connector *connector, char **const address);

yh_rc yh_string_to_capabilities(const char *capability,
                                yh_capabilities *result);

yh_rc yh_capabilities_to_strings(const yh_capabilities *num,
                                 const char *result[], size_t *n_result);

bool yh_check_capability(const yh_capabilities *capabilities,
                         const char *capability);

yh_rc yh_merge_capabilities(const yh_capabilities *a, const yh_capabilities *b,
                            yh_capabilities *result);

yh_rc yh_filter_capabilities(const yh_capabilities *capabilities,
                             const yh_capabilities *filter,
                             yh_capabilities *result);

bool yh_is_rsa(yh_algorithm algorithm);

bool yh_is_ec(yh_algorithm algorithm);

bool yh_is_ed(yh_algorithm algorithm);

bool yh_is_hmac(yh_algorithm algorithm);

yh_rc yh_get_key_bitlength(yh_algorithm algorithm, size_t *result);

yh_rc yh_algo_to_string(yh_algorithm algo, char const **result);

yh_rc yh_string_to_algo(const char *string, yh_algorithm *algo);

yh_rc yh_type_to_string(yh_object_type type, char const **result);

yh_rc yh_string_to_type(const char *string, yh_object_type *type);

yh_rc yh_string_to_option(const char *string, yh_option *option);

bool yh_verify_logs(yh_log_entry *logs, size_t n_items,
                    yh_log_entry *last_previous_log);

yh_rc yh_string_to_domains(const char *domains, uint16_t *result);

yh_rc yh_domains_to_string(uint16_t domains, char *string, size_t max_len);
#ifdef __cplusplus
}
#endif

#endif