yubihsm.c File Reference

#include <yubihsm.h>
#include "internal.h"
#include <arpa/inet.h>
#include <dlfcn.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <stdio.h>
#include <limits.h>
#include "../common/rand.h"
#include "../common/pkcs5.h"
#include "../common/hash.h"
#include "../aes_cmac/aes_cmac.h"
#include "debug_lib.h"
#include "../common/insecure_memzero.h"

Include dependency graph for yubihsm.c:

Go to the source code of this file.

Macros
#define	STATIC_USB_BACKEND   "usb"
#define	STATIC_HTTP_BACKEND   "http"
#define	LIST_SEPARATORS   ":,;|"
#define	LIST_ID   1
#define	LIST_TYPE   2
#define	LIST_DOMAINS   3
#define	LIST_CAPABILITIES   4
#define	LIST_ALGORITHM   5
#define	LIST_LABEL   6
#define	STATUS_ENDPOINT   "/connector/status"
#define	API_ENDPOINT   "/connector/api"
#define	USB_LIB   "libyubihsm_usb.so." SOVERSION
#define	HTTP_LIB   "libyubihsm_http.so." SOVERSION
#define	htonll(x)

Functions
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, 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, 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)
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_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_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_get_session_id (yh_session *session, uint8_t *sid)
yh_rc	yh_authenticate_session (yh_session *session)
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_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_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_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)

Variables
uint8_t _yh_verbosity	YH_INTERNAL = 0

Macro Definition Documentation

API_ENDPOINT

#define API_ENDPOINT   "/connector/api"

Definition at line 3913 of file yubihsm.c.

htonll

#define htonll

(

x

)

Value:

  ((1 == htonl(1))                                                             \
     ? (x)                                                                     \
     : ((uint64_t) htonl((x) &0xFFFFFFFF) << 32) | htonl((x) >> 32))

Definition at line 4110 of file yubihsm.c.

#define htonll(x)                                                              \
  ((1 == htonl(1))                                                             \
     ? (x)                                                                     \
     : ((uint64_t) htonl((x) &0xFFFFFFFF) << 32) | htonl((x) >> 32))

HTTP_LIB

#define HTTP_LIB   "libyubihsm_http.so." SOVERSION

LIST_ALGORITHM

#define LIST_ALGORITHM   5

Definition at line 1027 of file yubihsm.c.

LIST_CAPABILITIES

#define LIST_CAPABILITIES   4

Definition at line 1026 of file yubihsm.c.

LIST_DOMAINS

#define LIST_DOMAINS   3

Definition at line 1025 of file yubihsm.c.

LIST_ID

#define LIST_ID   1

Definition at line 1023 of file yubihsm.c.

LIST_LABEL

#define LIST_LABEL   6

Definition at line 1028 of file yubihsm.c.

LIST_SEPARATORS

#define LIST_SEPARATORS   ":,;|"

Definition at line 55 of file yubihsm.c.

LIST_TYPE

#define LIST_TYPE   2

Definition at line 1024 of file yubihsm.c.

STATIC_HTTP_BACKEND

#define STATIC_HTTP_BACKEND   "http"

Definition at line 44 of file yubihsm.c.

STATIC_USB_BACKEND

#define STATIC_USB_BACKEND   "usb"

Definition at line 43 of file yubihsm.c.

STATUS_ENDPOINT

#define STATUS_ENDPOINT   "/connector/status"

Definition at line 3912 of file yubihsm.c.

USB_LIB

#define USB_LIB   "libyubihsm_usb.so." SOVERSION

Function Documentation

yh_algo_to_string()

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

Convert an algorithm to its string representation.

Parameters

algo	Algorithm to convert. See yh_algorithm
result	The algorithm as a String. "Unknown" if the algorithm is not supported by YubiHSM 2.

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if result is NULL.

See also

Algorithms

Definition at line 4384 of file yubihsm.c.

                                                                {
 
  if (result == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  for (size_t i = 0; i < sizeof(yh_algorithms) / sizeof(yh_algorithms[0]);
       i++) {
    if (algo == yh_algorithms[i].algorithm) {
      *result = yh_algorithms[i].name;
      return YHR_SUCCESS;
    }
  }
 
  *result = "Unknown";
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_authenticate_session()

yh_rc yh_authenticate_session

(

yh_session *

session

)

Authenticate session

Parameters

session

Session to authenticate

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if the session is NULL. YHR_SESSION_AUTHENTICATION_FAILED if the session fails to authenticate. See yh_rc for other possible errors

See also

Session

Definition at line 2927 of file yubihsm.c.

                                                   {
 
  Msg msg;
  Msg response_msg;
  yh_rc yrc;
 
  uint8_t mac_buf[64];
  uint16_t mac_buf_len;
 
  if (session == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  // Send AUTHENTICATE SESSION command
  msg.st.cmd = YHC_AUTHENTICATE_SESSION;
  msg.st.len = 1 + SCP_HOST_CRYPTO_LEN + SCP_MAC_LEN;
 
  msg.st.data[0] = session->s.sid;
 
  // Compute host cryptogram
  yrc = compute_host_cryptogram(session, msg.st.data + 1);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("%s", yh_strerror(yrc));
    return yrc;
  }
 
  DBG_INT(msg.st.data + 1, SCP_HOST_CRYPTO_LEN, "Host cryptogram: ");
 
  mac_buf_len = SCP_PRF_LEN + msg.st.len + 3 - SCP_MAC_LEN;
  memset(mac_buf, 0, SCP_PRF_LEN); // Initial mac chaining value
  msg.st.len = htons(msg.st.len);
  memcpy(mac_buf + SCP_PRF_LEN, msg.raw, mac_buf_len);
  msg.st.len = ntohs(msg.st.len);
 
  compute_full_mac(mac_buf, mac_buf_len, session->s.s_mac, SCP_KEY_LEN,
                   session->s.mac_chaining_value);
  memcpy(msg.st.data + 1 + SCP_HOST_CRYPTO_LEN, session->s.mac_chaining_value,
         SCP_MAC_LEN);
 
  // Reset counter to 1
  memset(session->s.ctr, 0, SCP_PRF_LEN);
  session->s.ctr[SCP_PRF_LEN - 1]++;
 
  yrc = send_msg(session->parent, &msg, &response_msg);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("%s", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_msg.st.cmd != YHC_AUTHENTICATE_SESSION_R) {
    DBG_ERR("%s", yh_strerror(yrc));
    return YHR_SESSION_AUTHENTICATION_FAILED;
  }
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_begin_create_session_ext()

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 )

Begin creating an external session. The session's encryption key and MAC key are not stored in the device.

This function must be followed by yh_finish_create_session_ext() to set the session keys.

Parameters

connector	Connector to the device
authkey_id	Object ID of the Authentication Key used to authenticate the session
context	pointer to where context data is saved
card_cryptogram	Card cryptogram
card_cryptogram_len	Length of card cryptogram
session	created session

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL. YHR_MEMORY_ERROR if failed to allocate memory for the session. See yh_rc for other possible errors

See also

Session

Definition at line 751 of file yubihsm.c.

                                                        {
 
  Msg msg;
  Msg response_msg;
  yh_rc yrc;
  uint8_t *ptr;
  yh_session *new_session;
  uint8_t host_challenge[YH_HOST_CHAL_LEN];
 
  if (connector == NULL || context == NULL || card_cryptogram == NULL ||
      card_cryptogram_len != SCP_CARD_CRYPTO_LEN || session == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  if (!rand_generate(host_challenge, sizeof(host_challenge))) {
    return YHR_GENERIC_ERROR;
  } // TODO(adma): take this as an input so that it can be generated from the
  // YubiKey
 
  /**********/
  // TODO(adma): replace with func
  new_session = calloc(1, sizeof(yh_session));
  if (new_session == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_MEMORY_ERROR));
    return YHR_MEMORY_ERROR;
  }
 
  // Send CREATE SESSION command
  msg.st.cmd = YHC_CREATE_SESSION;
  msg.st.len = SCP_AUTHKEY_ID_LEN + SCP_HOST_CHAL_LEN;
 
  uint16_t authkey_id_n = htons(authkey_id);
  memcpy(msg.st.data, &authkey_id_n, SCP_AUTHKEY_ID_LEN);
  memcpy(msg.st.data + SCP_AUTHKEY_ID_LEN, host_challenge, SCP_HOST_CHAL_LEN);
  memcpy(new_session->context, host_challenge, SCP_HOST_CHAL_LEN);
 
  DBG_INT(host_challenge, SCP_HOST_CHAL_LEN, "Host challenge: ");
 
  yrc = send_msg(connector, &msg, &response_msg);
  if (yrc != YHR_SUCCESS) {
    goto bcse_failure;
  }
 
  // Parse response
  if (response_msg.st.cmd != YHC_CREATE_SESSION_R) {
    yh_rc translated = translate_device_error(response_msg.st.data[0]);
    DBG_ERR("Device error %s (%d)", yh_strerror(translated),
            response_msg.st.data[0]);
    yrc = translated;
    goto bcse_failure;
  }
 
  if (response_msg.st.len != 1 + SCP_CARD_CHAL_LEN + SCP_CARD_CRYPTO_LEN) {
    yrc = YHR_WRONG_LENGTH;
    goto bcse_failure;
  }
 
  ptr = response_msg.st.data;
 
  // Save sid
  new_session->s.sid = (*ptr++);
 
  // Save card challenge
  memcpy(new_session->context + SCP_HOST_CHAL_LEN, ptr, SCP_CARD_CHAL_LEN);
  ptr += SCP_CARD_CHAL_LEN;
 
  memcpy(card_cryptogram, ptr, SCP_CARD_CRYPTO_LEN);
  ptr += SCP_CARD_CRYPTO_LEN;
 
  DBG_INFO("Received Session ID: %d", new_session->s.sid);
 
  DBG_INT(new_session->context + SCP_HOST_CHAL_LEN, SCP_CARD_CHAL_LEN,
          "Card challenge: ");
  DBG_INT(card_cryptogram, SCP_CARD_CRYPTO_LEN, "Card cryptogram: ");
 
  // Save link back to connector
  new_session->parent = connector;
 
  *session = new_session;
  *context = new_session->context;
 
  return YHR_SUCCESS;
 
bcse_failure:
  free(new_session);
  (new_session) = NULL;
 
  DBG_ERR("%s", yh_strerror(yrc));
 
  return yrc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_capabilities_to_strings()

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

Convert an array of yh_capabilities into strings separated by ','

Parameters

num	Array of yh_capabilities
result	Array of the capabilies as strings
n_result	Number of elements in result

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL. YHR_BUFFER_TOO_SMALL if n_result is too small

See also

Capability

Definition at line 4168 of file yubihsm.c.

                                                                         {
 
  if (num == 0 || result == NULL || n_result == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  size_t matching = 0;
 
  for (size_t i = 0; i < sizeof(yh_capability) / sizeof(yh_capability[0]);
       i++) {
    if (((1ULL << (yh_capability[i].bit % 8)) &
         num->capabilities[YH_CAPABILITIES_LEN - 1 -
                           (yh_capability[i].bit / 8)]) != 0) {
      if (++matching > *n_result) {
        memset(result, 0, *n_result);
 
        return YHR_BUFFER_TOO_SMALL;
      }
 
      result[matching - 1] = yh_capability[i].name;
    }
  }
 
  *n_result = matching;
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_check_capability()

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

Check if a capability is set

Parameters

capabilities	Array of yh_capabilities
capability	Capability to check as a string.

Returns

True if the capability is in capabilities. False otherwise

Code sample

char *capabilities_str = "sign-pkcs,decrypt-pkcs,set-option";
yh_capabilities capabilities = {{0}};
yh_string_to_capabilities(capabilities_str, &capabilities);
//yh_check_capability(&capabilities, "something") => false
//yh_check_capability(&capabilities, "sign-pss") => false
//yh_check_capability(&capabilities, "decrypt-pkcs") => true

See also

Capability

Definition at line 4198 of file yubihsm.c.

                                                 {
 
  yh_capabilities check_capabilities = {{0}};
 
  if (yh_string_to_capabilities(capability, &check_capabilities) !=
      YHR_SUCCESS) {
    return false;
  }
 
  for (int i = 0; i < YH_CAPABILITIES_LEN; i++) {
    if (check_capabilities.capabilities[i] != 0 &&
        (check_capabilities.capabilities[i] & capabilities->capabilities[i]) !=
          0) {
      return true;
    }
  }
 
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_connect()

yh_rc yh_connect	(	yh_connector *	connector,
		int	timeout )

Connect to the device through the specified connector

Parameters

connector	Connector to the device
timeout	Connection timeout in seconds

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if the connector does not exist. See yh_rc for other possible errors

Definition at line 4079 of file yubihsm.c.

                                                       {
 
  if (connector == NULL || connector->bf == NULL) {
    DBG_ERR("Invalid parameters: undefined pointer");
    return YHR_INVALID_PARAMETERS;
  }
 
  yh_rc rc;
 
  rc = connector->bf->backend_connect(connector, timeout);
 
  if (rc != YHR_SUCCESS) {
    DBG_ERR("Failed when connecting: %s", yh_strerror(rc));
  }
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_connector_has_device()

bool yh_connector_has_device

(

yh_connector *

connector

)

Check if the connector has a device connected

Parameters

connector

Connector currently in use

Returns

True if the connector is not NULL and there is a device connected to it. False otherwise

Definition at line 906 of file yubihsm.c.

                                                      {
 
  return connector && connector->has_device;
}

Here is the caller graph for this function:

yh_create_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 )

Create a session that uses the specified encryption key and MAC key to derive session-specific keys

Parameters

connector	Connector to the device
authkey_id	Object ID of the Authentication Key used to authenticate the session
key_enc	Encryption key used to derive the session encryption key
key_enc_len	Length of the encryption key.
key_mac	MAC key used to derive the session MAC key
key_mac_len	Length of the MAC key.
recreate_session	If true, the session will be recreated if expired. This caches the password in memory
session	created session

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL or incorrect. See yh_rc for other possible errors

See also

Session, Authentication Key

Definition at line 616 of file yubihsm.c.

                                                             {
 
  Msg msg;
  Msg response_msg;
  yh_rc yrc;
  uint8_t *ptr;
  uint8_t card_cryptogram[SCP_CARD_CRYPTO_LEN];
  yh_session *new_session;
  uint8_t host_challenge[YH_HOST_CHAL_LEN];
 
  if (connector == NULL || key_enc == NULL || key_enc_len != SCP_KEY_LEN ||
      key_mac == NULL || key_mac_len != SCP_KEY_LEN || session == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  if (!rand_generate(host_challenge, sizeof(host_challenge))) {
    return YHR_GENERIC_ERROR;
  }
 
  if (!*session) {
    new_session = calloc(1, sizeof(yh_session));
    if (new_session == NULL) {
      DBG_ERR("%s", yh_strerror(YHR_MEMORY_ERROR));
      return YHR_MEMORY_ERROR;
    }
  } else {
    new_session = *session;
  }
 
  new_session->authkey_id = authkey_id;
 
  if (recreate) {
    new_session->recreate = true;
    memcpy(new_session->key_enc, key_enc, SCP_KEY_LEN);
    memcpy(new_session->key_mac, key_mac, SCP_KEY_LEN);
  }
 
  // Send CREATE SESSION command
  msg.st.cmd = YHC_CREATE_SESSION;
  msg.st.len = SCP_AUTHKEY_ID_LEN + SCP_HOST_CHAL_LEN;
 
  uint16_t authkey_id_n = htons(authkey_id);
  memcpy(msg.st.data, &authkey_id_n, SCP_AUTHKEY_ID_LEN);
  memcpy(msg.st.data + SCP_AUTHKEY_ID_LEN, host_challenge, SCP_HOST_CHAL_LEN);
  memcpy(new_session->context, host_challenge, SCP_HOST_CHAL_LEN);
 
  DBG_INT(host_challenge, SCP_HOST_CHAL_LEN, "Host challenge: ");
 
  yrc = send_msg(connector, &msg, &response_msg);
  if (yrc != YHR_SUCCESS) {
    goto cs_failure;
  }
 
  // Parse response
  if (response_msg.st.cmd != YHC_CREATE_SESSION_R) {
    yh_rc translated = translate_device_error(response_msg.st.data[0]);
    DBG_ERR("Device error %s (%d)", yh_strerror(translated),
            response_msg.st.data[0]);
    yrc = translated;
    goto cs_failure;
  }
 
  if (response_msg.st.len != 1 + SCP_CARD_CHAL_LEN + SCP_CARD_CRYPTO_LEN) {
    yrc = YHR_WRONG_LENGTH;
    goto cs_failure;
  }
 
  ptr = response_msg.st.data;
 
  // Save sid
  new_session->s.sid = (*ptr++);
 
  // Save card challenge
  memcpy(new_session->context + SCP_HOST_CHAL_LEN, ptr, SCP_CARD_CHAL_LEN);
  ptr += SCP_CARD_CHAL_LEN;
 
  memcpy(card_cryptogram, ptr, SCP_CARD_CRYPTO_LEN);
  ptr += SCP_CARD_CRYPTO_LEN;
 
  DBG_INFO("Received Session ID: %d", new_session->s.sid);
 
  DBG_INT(new_session->context + SCP_HOST_CHAL_LEN, SCP_CARD_CHAL_LEN,
          "Card challenge: ");
  DBG_INT(card_cryptogram, SCP_CARD_CRYPTO_LEN, "Card cryptogram: ");
 
  // Derive session keys
  yrc =
    derive_s_enc(&new_session->s, key_enc, key_enc_len, new_session->context);
  if (yrc != YHR_SUCCESS)
    goto cs_failure;
 
  yrc =
    derive_s_mac(&new_session->s, key_mac, key_mac_len, new_session->context);
  if (yrc != YHR_SUCCESS)
    goto cs_failure;
 
  yrc =
    derive_s_rmac(&new_session->s, key_mac, key_enc_len, new_session->context);
  if (yrc != YHR_SUCCESS)
    goto cs_failure;
 
  DBG_INT(new_session->s.s_enc, SCP_KEY_LEN, "S-ENC: ");
  DBG_INT(new_session->s.s_mac, SCP_KEY_LEN, "S-MAC: ");
  DBG_INT(new_session->s.s_rmac, SCP_KEY_LEN, "S-RMAC: ");
  // Verify card cryptogram
  yrc = verify_card_cryptogram(&new_session->s, new_session->context,
                               card_cryptogram);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("%s", yh_strerror(yrc));
    goto cs_failure;
  }
 
  DBG_INFO("Card cryptogram successfully verified");
 
  // Save link back to connector
  new_session->parent = connector;
 
  *session = new_session;
 
  return YHR_SUCCESS;
 
cs_failure:
  insecure_memzero(new_session, sizeof(yh_session));
  free(new_session);
  (new_session) = NULL;
 
  DBG_ERR("%s", yh_strerror(yrc));
 
  return yrc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_create_session_derived()

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 )

Create a session that uses an encryption key and a MAC key derived from a password

Parameters

connector	Connector to the device
authkey_id	Object ID of the Authentication Key used to authenticate the session
password	Password used to derive the session encryption key and MAC key
password_len	Length of the password in bytes
recreate_session	If true, the session will be recreated if expired. This caches the password in memory
session	The created session

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if the connector, the password or the session are NULL. YHR_GENERIC_ERROR if failed to derive the session encryption key and/or the MAC key or if PRNG related errors occur. YHR_MEMORY_ERROR if failed to allocate memory for the session. See yh_rc for other possible errors

See also

Session

Definition at line 593 of file yubihsm.c.

                                                                     {
 
  if (connector == NULL || password == NULL || session == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  uint8_t key_enc[SCP_KEY_LEN];
  uint8_t key_mac[SCP_KEY_LEN];
 
  yh_rc yrc = derive_keys(password, password_len, key_enc, key_mac);
 
  if (yrc == YHR_SUCCESS) {
    yrc = yh_create_session(connector, authkey_id, key_enc, SCP_KEY_LEN,
                            key_mac, SCP_KEY_LEN, recreate, session);
    insecure_memzero(key_enc, sizeof(key_enc));
    insecure_memzero(key_mac, sizeof(key_mac));
  }
  return yrc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_destroy_session()

yh_rc yh_destroy_session

(

yh_session **

session

)

Free data associated with the session

Parameters

session

Pointer to the session to destroy

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if the session is NULL.

See also

Session

Definition at line 890 of file yubihsm.c.

                                               {
 
  if (session == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  } else if (*session == NULL) {
    return YHR_SUCCESS;
  }
 
  insecure_memzero(*session, sizeof(yh_session));
  free(*session);
  *session = NULL;
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_disconnect()

yh_rc yh_disconnect

(

yh_connector *

connector

)

Disconnect from a connector

Parameters

connector

Connector from which to disconnect

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if the connector is NULL

Definition at line 4097 of file yubihsm.c.

                                             {
 
  if (connector == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  destroy_connector(connector);
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_domains_to_string()

yh_rc yh_domains_to_string	(	uint16_t	domains,
		char *	string,
		size_t	max_len )

Convert domains parameter to its String representation

Parameters

domains	Encoded domains
string	Domains as a string
max_len	Maximum length of the string

Returns

YHR_SUCCESS if successful. YHR_BUFFER_TOO_SMALL if max_len is too small

Examples

• 1 => "1"
• 0x8001 => "1:16"
• 0, ""
• 0xffff => "1:2:3:4:5:6:7:8:9:10:11:12:13:14:15:16"

See also

Domains

Definition at line 4587 of file yubihsm.c.

                                                                           {
  char *ptr = string;
  *ptr = '\0';
  for (uint16_t i = 0; i < YH_MAX_DOMAINS; i++) {
    if (domains & (1 << i)) {
      size_t wrote = snprintf(ptr, max_len, "%d:", i + 1);
      if (wrote >= max_len) {
        return YHR_BUFFER_TOO_SMALL;
      }
      ptr += wrote;
      max_len -= wrote;
    }
  }
  if (ptr != string) {
    *(ptr - 1) = '\0';
  }
  return YHR_SUCCESS;
}

Here is the caller graph for this function:

yh_exit()

yh_rc yh_exit

(

void

)

Global library clean up

Returns

YHR_SUCCESS

Definition at line 3910 of file yubihsm.c.

{ return YHR_SUCCESS; }

Here is the caller graph for this function:

yh_filter_capabilities()

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

Filter one set of capabilities with another. The resulting set of capabilities contains only the capabilities that exist in both sets of input capabilities

Parameters

capabilities	Array of yh_capabilities
filter	Array of yh_capabilities
result	Resulting array of yh_capabilities

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL.

See also

Capability

Definition at line 4231 of file yubihsm.c.

                                                      {
  if (capabilities == NULL || filter == NULL || result == NULL) {
    return YHR_INVALID_PARAMETERS;
  }
 
  for (int i = 0; i < YH_CAPABILITIES_LEN; i++) {
    result->capabilities[i] =
      capabilities->capabilities[i] & filter->capabilities[i];
  }
  return YHR_SUCCESS;
}

yh_finish_create_session_ext()

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 )

Finish creating external session. The session's encryption key and MAC key are not stored in the device.

This function must be called after yh_begin_create_session_ext().

Parameters

connector	Connector to the device
session	The session created with yh_begin_create_session_ext()
key_senc	Session encryption key used to encrypt the messages exchanged with the device
key_senc_len	Lenght of the encryption key. Must be YH_KEY_LEN
key_smac	Session MAC key used for creating the authentication tag for each message
key_smac_len	Length of the MAC key. Must be YH_KEY_LEN
key_srmac	Session return MAC key used for creating the authentication tag for each response message
key_srmac_len	Length of the return MAC key. Must be YH_KEY_LEN
card_cryptogram	Card cryptogram
card_cryptogram_len	Length of card cryptogram

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL or any of the key lengths are not YH_KEY_LEN. See yh_rc for other possible errors

See also

Session

Definition at line 847 of file yubihsm.c.

                              { // TODO(adma): remove all these
 
  if (connector == NULL || session == NULL || key_senc == NULL ||
      key_senc_len != YH_KEY_LEN || key_smac == NULL ||
      key_smac_len != YH_KEY_LEN || key_srmac == NULL ||
      key_srmac_len != YH_KEY_LEN || card_cryptogram == NULL ||
      card_cryptogram_len != SCP_CARD_CRYPTO_LEN) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  yh_rc yrc;
 
  memcpy(session->s.s_enc, key_senc, key_senc_len);
  memcpy(session->s.s_mac, key_smac, key_smac_len);
  memcpy(session->s.s_rmac, key_srmac, key_srmac_len);
 
  DBG_INT(session->s.s_enc, SCP_KEY_LEN, "S-ENC: ");
  DBG_INT(session->s.s_mac, SCP_KEY_LEN, "S-MAC: ");
  DBG_INT(session->s.s_rmac, SCP_KEY_LEN, "S-RMAC: ");
 
  // Verify card cryptogram
  yrc = verify_card_cryptogram(&session->s, session->context, card_cryptogram);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("%s", yh_strerror(yrc));
 
    free(session);
    session = NULL;
 
    DBG_ERR("%s", yh_strerror(yrc));
 
    return yrc;
  }
 
  DBG_INFO("Card cryptogram successfully verified");
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_get_connector_address()

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

Get connector address

Parameters

connector	Connector currently in use
address	Pointer to the connector address as string

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL.

Definition at line 926 of file yubihsm.c.

                                                                              {
 
  if (connector == NULL || address == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  *address = (char *) connector->address;
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_get_connector_version()

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

Get the connector version

Parameters

connector	Connector currently in use
major	Connector major version
minor	Connector minor version
patch	Connector patch version

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL.

Definition at line 911 of file yubihsm.c.

                                                               {
 
  if (connector == NULL || major == NULL || minor == NULL || patch == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  *major = connector->version_major;
  *minor = connector->version_minor;
  *patch = connector->version_patch;
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_get_key_bitlength()

yh_rc yh_get_key_bitlength	(	yh_algorithm	algorithm,
		size_t *	result )

Get the expected key length of a key generated by the given algorithm

Parameters

algorithm	Algorithm to check. See yh_algorithm
result	Expected bitlength of a key generated by the algorithm

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if result is NULL or if the algorithm is no supported by YubiHSM 2. For a list of supported algorithms, see yh_algorithm

Definition at line 4309 of file yubihsm.c.

                                                                   {
 
  if (result == NULL) {
    return YHR_INVALID_PARAMETERS;
  }
 
  switch (algorithm) {
    case YH_ALGO_RSA_2048:
      *result = 2048;
      break;
 
    case YH_ALGO_RSA_3072:
      *result = 3072;
      break;
 
    case YH_ALGO_RSA_4096:
      *result = 4096;
      break;
 
    case YH_ALGO_EC_P256:
      *result = 256;
      break;
 
    case YH_ALGO_EC_P384:
      *result = 384;
      break;
 
    case YH_ALGO_EC_P521:
      *result = 521;
      break;
 
    case YH_ALGO_EC_P224:
      *result = 224;
      break;
 
    case YH_ALGO_EC_K256:
      *result = 256;
      break;
 
    case YH_ALGO_EC_BP256:
      *result = 256;
      break;
 
    case YH_ALGO_EC_BP384:
      *result = 394;
      break;
 
    case YH_ALGO_EC_BP512:
      *result = 512;
      break;
 
    case YH_ALGO_HMAC_SHA1:
      *result = 160;
      break;
 
    case YH_ALGO_HMAC_SHA256:
      *result = 256;
      break;
 
    case YH_ALGO_HMAC_SHA384:
      *result = 384;
      break;
 
    case YH_ALGO_HMAC_SHA512:
      *result = 512;
      break;
 
    default:
      *result = 0;
      return YHR_INVALID_PARAMETERS;
  }
 
  return YHR_SUCCESS;
}

Here is the caller graph for this function:

yh_get_session_id()

yh_rc yh_get_session_id	(	yh_session *	session,
		uint8_t *	sid )

Get the session ID

Parameters

session	Authenticated session to use
sid	Session ID

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL.

Definition at line 2915 of file yubihsm.c.

                                                           {
 
  if (session == NULL || sid == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  *sid = session->s.sid;
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_get_verbosity()

yh_rc yh_get_verbosity

(

uint8_t *

verbosity

)

Get verbosity level when executing commands

Parameters

verbosity

The verbosity level

Returns

YHR_SUCCESS if seccessful. YHR_INVALID_PARAMETERS if verbosity is NULL

See also

YH_VERB_QUIET, YH_VERB_INTERMEDIATE, YH_VERB_CRYPTO, YH_VERB_RAW, YH_VERB_INFO, YH_VERB_ERR, YH_VERB_ALL

Definition at line 3837 of file yubihsm.c.

                                           {
 
  if (verbosity == NULL) {
    return YHR_INVALID_PARAMETERS;
  }
 
  *verbosity = _yh_verbosity;
 
  return YHR_SUCCESS;
}

Here is the caller graph for this function:

yh_init()

yh_rc yh_init

(

void

)

Global library initialization

Returns

YHR_SUCCESS

Definition at line 3857 of file yubihsm.c.

                    {
  if (_yh_output == NULL) {
    _yh_output = stderr;
  }
  return YHR_SUCCESS;
}

Here is the caller graph for this function:

yh_init_connector()

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

Instantiate a new connector

Parameters

url	URL associated with this connector
connector	Connector to the device

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if either the URL or the connector are NULL. YHR_GENERIC_ERROR if failed to load the backend. YHR_MEMORY_ERROR if failed to allocate memory for the connector. YHR_CONNECTION_ERROR if failed to create the connector

Definition at line 4024 of file yubihsm.c.

                                                                   {
  if (url == NULL || connector == NULL) {
    DBG_ERR("Invalid parameters: undefined pointer");
    return YHR_INVALID_PARAMETERS;
  }
 
#ifdef STATIC
#define USB_LIB STATIC_USB_BACKEND
#define HTTP_LIB STATIC_HTTP_BACKEND
#elif defined WIN32
#define USB_LIB "libyubihsm_usb.dll"
#define HTTP_LIB "libyubihsm_http.dll"
#elif defined __APPLE__
#define USB_LIB "libyubihsm_usb." SOVERSION ".dylib"
#define HTTP_LIB "libyubihsm_http." SOVERSION ".dylib"
#else
#define USB_LIB "libyubihsm_usb.so." SOVERSION
#define HTTP_LIB "libyubihsm_http.so." SOVERSION
#endif
 
  void *backend = NULL;
  struct backend_functions *bf = NULL;
 
  if (strncmp(url, YH_USB_URL_SCHEME, strlen(YH_USB_URL_SCHEME)) == 0) {
    DBG_INFO("Loading usb backend");
    load_backend(USB_LIB, &backend, &bf);
  } else if (strncmp(url, "http://", strlen("http://")) == 0 ||
             strncmp(url, "https://", strlen("https://")) == 0) {
    DBG_INFO("Loading http backend");
    load_backend(HTTP_LIB, &backend, &bf);
  }
  if (bf == NULL) {
    DBG_ERR("Failed loading the backend");
    return YHR_GENERIC_ERROR;
  }
 
  return create_connector(connector, url, backend, bf);
}

Here is the caller graph for this function:

yh_is_ec()

bool yh_is_ec

(

yh_algorithm

algorithm

)

Check if an algorithm is a supported Elliptic Curve algorithm.

Supported EC algorithms: YH_ALGO_EC_P224, YH_ALGO_EC_P256, YH_ALGO_EC_P384, YH_ALGO_EC_P521, YH_ALGO_EC_K256, YH_ALGO_EC_BP256, YH_ALGO_EC_BP384 and YH_ALGO_EC_BP512

Parameters

algorithm

Algorithm to check. See yh_algorithm

Returns

True if the algorithm is one of the supported EC algorithms. False otherwise

Definition at line 4260 of file yubihsm.c.

                                      {
 
  switch (algorithm) {
    case YH_ALGO_EC_P224:
    case YH_ALGO_EC_P256:
    case YH_ALGO_EC_P384:
    case YH_ALGO_EC_P521:
    case YH_ALGO_EC_K256:
    case YH_ALGO_EC_BP256:
    case YH_ALGO_EC_BP384:
    case YH_ALGO_EC_BP512:
      return true;
 
    default:
      break;
  }
 
  return false;
}

Here is the caller graph for this function:

yh_is_ed()

bool yh_is_ed

(

yh_algorithm

algorithm

)

Check if an algorithm is a supported ED algorithm.

Supported ED algorithms: YH_ALGO_EC_ED25519

Parameters

algorithm

algorithm. See yh_algorithm

Returns

True if the algorithm is YH_ALGO_EC_ED25519. False otherwise

Definition at line 4280 of file yubihsm.c.

                                      {
 
  switch (algorithm) {
    case YH_ALGO_EC_ED25519:
      return true;
 
    default:
      break;
  }
 
  return false;
}

Here is the caller graph for this function:

yh_is_hmac()

bool yh_is_hmac

(

yh_algorithm

algorithm

)

Check if algorithm is a supported HMAC algorithm.

Supported HMAC algorithms: YH_ALGO_HMAC_SHA1, YH_ALGO_HMAC_SHA256, YH_ALGO_HMAC_SHA384 and YH_ALGO_HMAC_SHA512

Parameters

algorithm

Algorithm to check. See yh_algorithm

Returns

True if the algorithm is one of the supported HMAC algorithms. False otherwise

Definition at line 4293 of file yubihsm.c.

                                        {
 
  switch (algorithm) {
    case YH_ALGO_HMAC_SHA1:
    case YH_ALGO_HMAC_SHA256:
    case YH_ALGO_HMAC_SHA384:
    case YH_ALGO_HMAC_SHA512:
      return true;
 
    default:
      break;
  }
 
  return false;
}

Here is the caller graph for this function:

yh_is_rsa()

bool yh_is_rsa

(

yh_algorithm

algorithm

)

Check if an algorithm is a supported RSA algorithm.

Supported RSA algorithms: YH_ALGO_RSA_2048, YH_ALGO_RSA_3072 and YH_ALGO_RSA_4096

Parameters

algorithm

Algorithm to check. See yh_algorithm

Returns

True if the algorithm is one of the supported RSA algorithms . False otherwise

Definition at line 4245 of file yubihsm.c.

                                       {
 
  switch (algorithm) {
    case YH_ALGO_RSA_2048:
    case YH_ALGO_RSA_3072:
    case YH_ALGO_RSA_4096:
      return true;
 
    default:
      break;
  }
 
  return false;
}

Here is the caller graph for this function:

yh_merge_capabilities()

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

Merge two sets of capabilities. The resulting set of capabilities contain all capabilities from both arrays

Parameters

a	Array of yh_capabilities
b	Array of yh_capabilities
result	Resulting array of yh_capabilities

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL.

See also

Capability

Definition at line 4219 of file yubihsm.c.

                                                     {
  if (a == NULL || b == NULL || result == NULL) {
    return YHR_INVALID_PARAMETERS;
  }
 
  for (int i = 0; i < YH_CAPABILITIES_LEN; i++) {
    result->capabilities[i] = a->capabilities[i] | b->capabilities[i];
  }
  return YHR_SUCCESS;
}

yh_send_plain_msg()

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 )

Send a plain (unencrypted) message to the device through a connector

Parameters

connector	Connector to the device
cmd	Command to send. See yh_cmd
data	Data to send
data_len	length of data to send
response_cmd	Response command
response	Response data
response_len	Length of response data

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL. YHR_BUFFER_TOO_SMALL if the actual response was longer than response_len. See yh_rc for other possible errors

Definition at line 126 of file yubihsm.c.

                                              {
 
  Msg msg;
  Msg response_msg;
 
  yh_rc yrc;
 
  if (connector == NULL || (data_len != 0 && data == NULL) ||
      response_cmd == NULL || response == NULL || response_len == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  if (data_len > sizeof(msg.st.data)) {
    DBG_ERR("Tried to transfer oversized data (%zu > %zu)", data_len,
            sizeof(msg.st.data));
    return YHR_INVALID_PARAMETERS;
  }
 
  msg.st.cmd = cmd;
  msg.st.len = data_len;
  if (data_len > 0) {
    memcpy(msg.st.data, data, data_len);
  }
 
  DBG_DUMPINFO(msg.raw, data_len + 3, "Sending cmd %02x (%3zu Bytes): ", cmd,
               data_len + 3);
 
  yrc = send_msg(connector, &msg, &response_msg);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("%s", yh_strerror(yrc));
    return yrc;
  }
 
  if (*response_len < response_msg.st.len) {
    DBG_DUMPERR(response_msg.raw, response_msg.st.len + 3,
                "%s (received %3d Bytes, can fit %3zu Bytes) ",
                yh_strerror(YHR_BUFFER_TOO_SMALL), response_msg.st.len,
                *response_len);
    return YHR_BUFFER_TOO_SMALL;
  }
 
  *response_cmd = response_msg.st.cmd;
 
  memcpy(response, response_msg.st.data, response_msg.st.len);
  *response_len = response_msg.st.len;
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_send_secure_msg()

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 )

Send an encrypted message to the device over a session. The session has to be authenticated

Parameters

session	Session to send the message over
cmd	Command to send
data	Data to send
data_len	Length of data to send
response_cmd	Response command
response	Response data
response_len	Length of response data

Returns

YHR_SUCCESS if successful. See yh_rc for possible errors

Definition at line 416 of file yubihsm.c.

                                                                  {
 
  size_t saved_len = *response_len;
 
  yh_rc yrc = _send_secure_msg(session, cmd, data, data_len, response_cmd,
                               response, response_len);
  if ((yrc == YHR_DEVICE_INVALID_SESSION ||
       yrc == YHR_DEVICE_AUTHENTICATION_FAILED) &&
      session->recreate) {
    DBG_INFO("Recreating session");
    yrc = yh_create_session(session->parent, session->authkey_id,
                            session->key_enc, SCP_KEY_LEN, session->key_mac,
                            SCP_KEY_LEN, true, &session);
    if (yrc != YHR_SUCCESS) {
      return yrc;
    }
    yrc = yh_authenticate_session(session);
    if (yrc != YHR_SUCCESS) {
      return yrc;
    }
    *response_len = saved_len;
    yrc = _send_secure_msg(session, cmd, data, data_len, response_cmd, response,
                           response_len);
  }
  return yrc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_set_connector_option()

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

Set connector options.

Note that backend options are not supported with winhttp or USB connectors

Parameters

connector	Connector to set an option on
opt	Option to set. See yh_connector_option
val	Value of the option. Type of value is specific to the given option

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if the connector or the value are NULL or if the option is unknown. YHR_CONNECTOR_ERROR if failed to set the option

Definition at line 4063 of file yubihsm.c.

                                               {
 
  if (connector == NULL || val == NULL) {
    DBG_ERR("Invalid parameters: undefined pointer");
    return YHR_INVALID_PARAMETERS;
  }
 
  if (connector->bf == NULL) {
    DBG_ERR("No backend loaded");
    return YHR_INVALID_PARAMETERS;
  }
 
  return connector->bf->backend_option(connector->connection, opt, val);
}

Here is the caller graph for this function:

yh_set_debug_output()

void yh_set_debug_output	(	yh_connector *	connector,
		FILE *	output )

Set file for debug output

Parameters

connector	If not NULL, the debug messages will be written to the specified output file
output	The destination of the debug messages

Returns

void

Definition at line 3848 of file yubihsm.c.

                                                                {
  _yh_output = output;
 
  if (connector != NULL && connector->bf != NULL) {
    // TODO(adma): should we error out if NULL?
    connector->bf->backend_set_verbosity(_yh_verbosity, _yh_output);
  }
}

Here is the caller graph for this function:

yh_set_verbosity()

yh_rc yh_set_verbosity	(	yh_connector *	connector,
		uint8_t	verbosity )

Set verbosity level when executing commands. Default verbosity is YH_VERB_QUIET

This function may be called prior to global library initialization to set the debug level

Parameters

connector	If not NULL, the verbosity of the specific connector will be set
verbosity	The desired level of debug output

Returns

YHR_SUCCESS

See also

YH_VERB_QUIET, YH_VERB_INTERMEDIATE, YH_VERB_CRYPTO, YH_VERB_RAW, YH_VERB_INFO, YH_VERB_ERR, YH_VERB_ALL

Definition at line 3825 of file yubihsm.c.

                                                                   {
 
  _yh_verbosity = verbosity;
 
  if (connector != NULL && connector->bf != NULL) {
    // TODO(adma): should we error out if NULL?
    connector->bf->backend_set_verbosity(_yh_verbosity, _yh_output);
  }
 
  return YHR_SUCCESS;
}

Here is the caller graph for this function:

yh_string_to_algo()

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

Convert a string to an algorithm's numeric value

Parameters

string	Algorithm as string. See yh_algorithm
algo	Algorithm numeric value

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL or if the algorithm is not supported by YubiHSM 2.

Code sample

yh_algorithm algorithm;
//yh_string_to_algo(NULL, &algorithm) => YHR_INVALID_PARAMETERS
//yh_string_to_algo("something", NULL) => YHR_INVALID_PARAMETERS
//yh_string_to_algo("something", &algorithm) => YHR_INVALID_PARAMETERS
//yh_string_to_algo("rsa-pkcs1-sha1", &algorithm) =>

YH_ALGO_RSA_PKCS1_SHA1 //yh_string_to_algo("rsa2048", &algorithm) => YH_ALGO_RSA_2048

See also

Algorithms

Definition at line 4403 of file yubihsm.c.

                                                                {
 
  if (string == NULL || algo == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
  if (strcasecmp(string, "any") == 0) {
    *algo = 0;
    return YHR_SUCCESS;
  }
  for (size_t i = 0; i < sizeof(yh_algorithms) / sizeof(yh_algorithms[0]);
       i++) {
    if (strcasecmp(string, yh_algorithms[i].name) == 0) {
      *algo = yh_algorithms[i].algorithm;
      return YHR_SUCCESS;
    }
  }
 
  return YHR_INVALID_PARAMETERS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_string_to_capabilities()

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

Convert capability string to byte array

Parameters

capability	String of capabilities separated by ',', ':' or '|'
result	Array of yh_capabilities

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL. YHR_BUFFER_TOO_SMALL if capability is too big

Examples:

• "get-opaque" => {"\x00\x00\x00\x00\x00\x00\x00\x01"}
• "sign-hmac:verify-hmac|exportable-under-wrap," => {"\x00\x00\x00\x00\x00\xc1\x00\x00"}
• ",,unwrap-data|:wrap-data,,," => {"\x00\x00\x00\x60\x00\x00\x00\x00"}
• "0x7fffffffffffffff" => {"\x7f\xff\xff\xff\xff\xff\xff\xff"}
• "0xffffffffffffffff" => {"\xff\xff\xff\xff\xff\xff\xff\xff"}

See also

Capability

Definition at line 4115 of file yubihsm.c.

                                                         {
 
  char *endptr;
  char *saveptr = NULL;
  char *str = NULL;
  char tmp[2048] = {0};
  uint64_t value;
 
  if (capability == NULL || result == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  errno = 0;
  value = strtoull(capability, &endptr, 0);
 
  if (capability != endptr && errno != ERANGE) {
    uint64_t actual = htonll(value);
    memcpy(result, &actual, 8);
    return YHR_SUCCESS;
  }
 
  if (strcasecmp(capability, "all") == 0) {
    memset(result->capabilities, 0xff, YH_CAPABILITIES_LEN);
    return YHR_SUCCESS;
  } else if (strcasecmp(capability, "none") == 0) {
    memset(result->capabilities, 0x00, YH_CAPABILITIES_LEN);
    return YHR_SUCCESS;
  }
 
  if (strlen(capability) > sizeof(tmp)) {
    return YHR_BUFFER_TOO_SMALL;
  }
  strncpy(tmp, capability, sizeof(tmp) - 1);
 
  while ((str = strtok_r(str ? NULL : tmp, LIST_SEPARATORS, &saveptr))) {
    for (size_t i = 0; i < sizeof(yh_capability) / sizeof(yh_capability[0]);
         i++) {
      if (strcasecmp(str, yh_capability[i].name) == 0) {
        result
          ->capabilities[YH_CAPABILITIES_LEN - 1 - yh_capability[i].bit / 8] |=
          1ULL << (yh_capability[i].bit % 8);
        break;
      } else if (i + 1 == sizeof(yh_capability) / sizeof(yh_capability[0])) {
        return YHR_INVALID_PARAMETERS;
      }
    }
  }
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_string_to_domains()

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

Convert a string to a domain's numeric value.

The domains string can contain one or several domains separated by ',', ':' or '|'. Each domain can be written in decimal or hex format

Parameters

domains	String of domains
result	Resulting parsed domains as an unsigned int

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL, if the domains string is does not contains the expected values

Examples

• "1" => 1
• "1,2:3,4|5,6;7,8,9,10,11,12,13,14,15,16" => 0xffff
• "1,16" => 0x8001
• "16" => 0x8000
• "16,15" => 0xc000
• "1,0xf" => 0x4001
• "0x1,0x2" => 3
• "0x8888" => 0x8888
• "0" => 0
• "all" => 0xffff
• "2" => 2
• "2:4" => 10

See also

Domains

Definition at line 4535 of file yubihsm.c.

                                                                  {
  char *endptr;
  char *saveptr = NULL;
  char *str = NULL;
  char tmp[64] = {0};
  unsigned long value;
 
  if (domains == NULL || result == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
  *result = 0;
 
  if (strcasecmp(domains, "all") == 0) {
    *result = 0xffff;
    goto out;
  } else if (strcmp(domains, "0") == 0) {
    goto out;
  }
 
  errno = 0;
  value = strtoul(domains, &endptr, 0);
 
  if (strncmp(domains, "0x", 2) == 0 && *endptr == '\0' && errno != ERANGE &&
      value != ULONG_MAX) {
    if (value > USHRT_MAX) {
      DBG_ERR("Tried to parse to long number for domains");
      return YHR_INVALID_PARAMETERS;
    }
    *result = value;
  } else {
    if (strlen(domains) > sizeof(tmp)) {
      return YHR_BUFFER_TOO_SMALL;
    }
    strncpy(tmp, domains, sizeof(tmp) - 1);
 
    while ((str = strtok_r(str ? NULL : tmp, LIST_SEPARATORS, &saveptr))) {
      endptr = NULL;
      value = strtoul(str, &endptr, 0);
      if (errno == ERANGE || value > YH_MAX_DOMAINS || value == 0) {
        DBG_ERR("Domains are numbered from 1 to %d", YH_MAX_DOMAINS);
        return YHR_INVALID_PARAMETERS;
      }
      *result |= 1 << (value - 1);
    }
  }
 
out:
  DBG_INFO("Domains parsed as %x", *result);
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_string_to_option()

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

Convert a string to an option's numeric value

Parameters

string	Option as string. See yh_option
option	Option numeric value

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL or if the option was not recognized.

Code sample

yh_option option;
//yh_string_to_option(NULL, &option) => YHR_INVALID_PARAMETERS
//yh_string_to_option("something", NULL) => YHR_INVALID_PARAMETERS
//yh_string_to_option("something", &option) => YHR_INVALID_PARAMETERS
//yh_string_to_option("force-audit", &option) =>

option=YH_OPTION_FORCE_AUDIT

See also

Options

Definition at line 4463 of file yubihsm.c.

                                                                 {
 
  if (string == NULL || option == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  for (size_t i = 0; i < sizeof(yh_options) / sizeof(yh_options[0]); i++) {
    if (strcasecmp(string, yh_options[i].name) == 0) {
      *option = yh_options[i].option;
      return YHR_SUCCESS;
    }
  }
 
  return YHR_INVALID_PARAMETERS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_string_to_type()

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

Convert a string to a type's numeric value

Parameters

string	Type as a String. See yh_object_type
type	Type numeric value

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL or if the type was not recognized.

Code sample

yh_object_type type;
//yh_string_to_type(NULL, &type) => YHR_INVALID_PARAMETERS
//yh_string_to_type("something", NULL) => YHR_INVALID_PARAMETERS
//yh_string_to_type("something", &type) => YHR_INVALID_PARAMETERS
//yh_string_to_type("opaque", &type) => type=YH_OPAQUE
//yh_string_to_type("authentication-key", &type) =>

type=YH_AUTHENTICATION_KEY

See also

Object

Definition at line 4442 of file yubihsm.c.

                                                                  {
 
  if (string == NULL || type == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  if (strcasecmp(string, "any") == 0) {
    *type = 0;
    return YHR_SUCCESS;
  }
  for (size_t i = 0; i < sizeof(yh_types) / sizeof(yh_types[0]); i++) {
    if (strcasecmp(string, yh_types[i].name) == 0) {
      *type = yh_types[i].type;
      return YHR_SUCCESS;
    }
  }
 
  return YHR_INVALID_PARAMETERS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_type_to_string()

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

Convert a yh_object_type to its string representation

Parameters

type	Type to convert. See yh_object_type
result	The type as a String. "Unknown" if the type was not recognized

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if result is NULL.

Code sample

const char *string;
//yh_type_to_string(0, NULL) => YHR_INVALID_PARAMETERS
//yh_type_to_string(99, &string) => string="Unknown"
//yh_type_to_string(YH_OPAQUE, &string) => string="opaque"
//yh_type_to_string(YH_AUTHENTICATION_KEY, &string) =>

string="authentication-key"

See also

Object

Definition at line 4424 of file yubihsm.c.

                                                                  {
 
  if (result == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  for (size_t i = 0; i < sizeof(yh_types) / sizeof(yh_types[0]); i++) {
    if (type == yh_types[i].type) {
      *result = yh_types[i].name;
      return YHR_SUCCESS;
    }
  }
 
  *result = "Unknown";
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_blink_device()

yh_rc yh_util_blink_device	(	yh_session *	session,
		uint8_t	seconds )

Blink the LED of the device to identify it

Parameters

session	Authenticated session to use
seconds	Number of seconds to blink

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if the session is NULL. See yh_rc for other possible errors

Definition at line 3766 of file yubihsm.c.

                                                                 {
 
  if (session == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  yh_rc yrc;
 
  uint8_t response[5];
  size_t response_len = sizeof(response);
  yh_cmd response_cmd;
 
  yrc = yh_send_secure_msg(session, YHC_BLINK_DEVICE, &seconds, sizeof(seconds),
                           &response_cmd, response, &response_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send BLINK DEVICE command: %s", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(response[0]);
    DBG_ERR("Unable to blink the device: %s (%x)", yh_strerror(translated),
            response[0]);
    return translated;
  }
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_change_authentication_key()

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 )

Replace the long lived encryption key and MAC key associated with an YH_AUTHENTICATION_KEY in the device

Parameters

session	Authenticated session to use
key_id	Object ID of the key to replace
key_enc	New long lived encryption key
key_enc_len	Length of the new encryption key. Must be YH_KEY_LEN
key_mac	New long lived MAC key
key_mac_len	Length of the new MAC key. Must be YH_KEY_LEN

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL or if key_enc_len or key_mac_len are not the expected values. See yh_rc for other possible errors

See also

Authentication Key

Definition at line 3094 of file yubihsm.c.

                                                            {
 
  if (session == NULL || key_id == NULL || key_enc == NULL ||
      key_enc_len != YH_KEY_LEN || key_mac == NULL ||
      key_mac_len != YH_KEY_LEN) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
#pragma pack(push, 1)
  union {
    struct {
      uint16_t key_id;
      uint8_t algorithm;
      uint8_t key_enc[YH_KEY_LEN];
      uint8_t key_mac[YH_KEY_LEN];
    };
    uint8_t buf[1];
  } data;
  union {
    struct {
      uint16_t key_id;
    };
    uint8_t buf[1];
  } response;
#pragma pack(pop)
  size_t response_len = sizeof(response);
  yh_cmd response_cmd;
 
  data.key_id = htons(*key_id);
  data.algorithm = YH_ALGO_AES128_YUBICO_AUTHENTICATION;
  memcpy(data.key_enc, key_enc, key_enc_len);
  memcpy(data.key_mac, key_mac, key_mac_len);
 
  yh_rc yrc = yh_send_secure_msg(session, YHC_CHANGE_AUTHENTICATION_KEY,
                                 data.buf, sizeof(data), &response_cmd,
                                 response.buf, &response_len);
  insecure_memzero(data.buf, sizeof(data));
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send CHANGE AUTHENTICATION KEY command: %s\n",
            yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(response.buf[0]);
    DBG_ERR("Unable to change authentication key: %s (%x)\n",
            yh_strerror(translated), response.buf[0]);
    return translated;
  }
 
  *key_id = ntohs(response.key_id);
  DBG_INFO("Changed Authentication key 0x%04x", *key_id);
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_change_authentication_key_derived()

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

Replace the long lived encryption key and MAC key associated with an YH_AUTHENTICATION_KEY in the device with keys derived from a password

Parameters

session	Authenticated session to use
key_id	Object ID of the key to replace
password	Password to derive the new encryption key and MAC key
password_len	Length of password

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL. See yh_rc for other possible errors

See also

Authentication Key

Definition at line 3155 of file yubihsm.c.

                                                                     {
  if (session == NULL || key_id == NULL || password == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  uint8_t key_enc[SCP_KEY_LEN];
  uint8_t key_mac[SCP_KEY_LEN];
 
  yh_rc yrc = derive_keys(password, password_len, key_enc, key_mac);
 
  if (yrc == YHR_SUCCESS) {
    yrc = yh_util_change_authentication_key(session, key_id, key_enc,
                                            sizeof(key_enc), key_mac,
                                            sizeof(key_mac));
    insecure_memzero(key_enc, sizeof(key_enc));
    insecure_memzero(key_mac, sizeof(key_mac));
  }
  return yrc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_close_session()

yh_rc yh_util_close_session

(

yh_session *

session

)

Close a session

Parameters

session

Session to close

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if the session is NULL. See yh_rc for other possible errors

Definition at line 1257 of file yubihsm.c.

                                                 {
 
  if (session == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  yh_rc yrc;
 
  uint8_t response[5];
  size_t response_len = sizeof(response);
  yh_cmd response_cmd;
 
  yrc = yh_send_secure_msg(session, YHC_CLOSE_SESSION, NULL, 0, &response_cmd,
                           response, &response_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send CLOSE SESSION command: %s", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(response[0]);
    DBG_ERR("Unable to close session: %s (%x)", yh_strerror(translated),
            response[0]);
    return translated;
  }
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_create_otp_aead()

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 )

Create a Yubico OTP AEAD using the provided data

Parameters

session	Authenticated session to use
key_id	Object ID of the Otp-aead Key to use
key	OTP key
private_id	OTP private id
out	The created AEAD
out_len	Length of the created AEAD

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL. See yh_rc for other possible errors

Definition at line 3179 of file yubihsm.c.

                                                             {
 
  if (session == NULL || key == NULL || private_id == NULL || out == NULL ||
      out_len == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
#pragma pack(push, 1)
  union {
    struct {
      uint16_t key_id;
      uint8_t key[16];
      uint8_t private_id[6];
    };
    uint8_t buf[1];
  } data;
#pragma pack(pop)
 
  yh_cmd response_cmd;
 
  data.key_id = htons(key_id);
  memcpy(data.key, key, sizeof(data.key));
  memcpy(data.private_id, private_id, sizeof(data.private_id));
 
  yh_rc yrc = yh_send_secure_msg(session, YHC_CREATE_OTP_AEAD, data.buf,
                                 sizeof(data), &response_cmd, out, out_len);
  insecure_memzero(data.buf, sizeof(data));
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send CREATE OTP AEAD command: %s\n", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(out[0]);
    DBG_ERR("Unable to get OTP AEAD: %s (%x)\n", yh_strerror(translated),
            out[0]);
    return translated;
  }
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_decrypt_oaep()

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 )

Decrypt data using RSA-OAEP

Parameters

session	Authenticated session to use
key_id	Object ID of the RSA key to use for decryption
in	Encrypted data
in_len	Length of encrypted data. Must be 256, 384 or 512
out	Decrypted data
out_len	Length of decrypted data
label	OAEP label
label_len	Length of OAEP label. Must be 20, 32, 48 or 64
mgf1Algo	MGF1 algorithm

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS input parameters are NULL. YHR_WRONG_LENGTH if in_len or label_len are not what expected. See yh_rc for other possible errors

Definition at line 2107 of file yubihsm.c.

                                                                    {
 
  if (session == NULL || in == NULL || out == NULL || out_len == NULL ||
      label == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
#pragma pack(push, 1)
  union {
    struct {
      uint16_t key_id;
      uint8_t mgf1Algo;
      uint8_t bytes[YH_MSG_BUF_SIZE];
    };
    uint8_t buf[1];
  } data;
#pragma pack(pop)
 
  yh_cmd response_cmd;
  yh_rc yrc;
  uint16_t len = 0;
 
  data.key_id = htons(key_id);
  len += sizeof(data.key_id);
 
  data.mgf1Algo = mgf1Algo;
  len += sizeof(data.mgf1Algo);
 
  // in_len has to match the rsa key size
  if (in_len != 256 && in_len != 384 && in_len != 512) {
    DBG_ERR("Wrong input length");
    return YHR_WRONG_LENGTH;
  }
 
  // label_len is hashed and specified the mgf hash
  if (label_len != 20 && label_len != 32 && label_len != 48 &&
      label_len != 64) {
    DBG_ERR("Wrong label length");
    return YHR_WRONG_LENGTH;
  }
 
  memcpy(data.bytes, in, in_len);
  len += in_len;
  memcpy(data.bytes + in_len, label, label_len);
  len += label_len;
 
  yrc = yh_send_secure_msg(session, YHC_DECRYPT_OAEP, data.buf, len,
                           &response_cmd, out, out_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send DECRYPT OAEP command: %s", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(out[0]);
    DBG_ERR("Unable to get decrypted data: %s (%x)", yh_strerror(translated),
            out[0]);
    return translated;
  }
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_decrypt_otp()

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 )

Decrypt a Yubico OTP and return counters and time information.

Parameters

session	Authenticated session to use
key_id	Object ID of the key used for decryption
aead	AEAD as created by yh_util_create_otp_aead() or yh_util_randomize_otp_aead()
aead_len	Length of AEAD
otp	OTP
useCtr	OTP use counter
sessionCtr	OTP session counter
tstph	OTP timestamp high
tstpl	OTP timestamp low

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL. See yh_rc for other possible errors

Definition at line 3261 of file yubihsm.c.

                                           {
 
#pragma pack(push, 1)
  union {
    struct {
      uint16_t key_id;
      uint8_t aead[6 + 16 + 6 + 8]; // FIXME: ya.. magic numbers!
      uint8_t otp[16];
    };
    uint8_t buf[1];
  } data;
  union {
    struct {
      uint16_t useCtr;
      uint8_t sessionCtr;
      uint8_t tstph;
      uint16_t tstpl;
    };
    uint8_t buf[1];
  } response;
#pragma pack(pop)
 
  if (session == NULL || aead == NULL || otp == NULL ||
      aead_len != sizeof(data.aead)) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  yh_cmd response_cmd;
  size_t response_len = sizeof(response);
 
  data.key_id = htons(key_id);
  memcpy(data.aead, aead, sizeof(data.aead));
  memcpy(data.otp, otp, sizeof(data.otp));
 
  yh_rc yrc =
    yh_send_secure_msg(session, YHC_DECRYPT_OTP, data.buf, sizeof(data),
                       &response_cmd, response.buf, &response_len);
  insecure_memzero(data.buf, sizeof(data));
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send DECRYPT OTP command: %s\n", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(response.buf[0]);
    DBG_ERR("Unable to decrypt OTP: %s (%x)\n", yh_strerror(translated),
            response.buf[0]);
    return translated;
  }
 
  if (response_len != sizeof(response)) {
    DBG_ERR("Wrong size returned");
    return YHR_WRONG_LENGTH;
  }
 
  if (useCtr) {
    *useCtr = response.useCtr;
  }
  if (sessionCtr) {
    *sessionCtr = response.sessionCtr;
  }
  if (tstph) {
    *tstph = response.tstph;
  }
  if (tstpl) {
    *tstpl = response.tstpl;
  }
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_decrypt_pkcs1v1_5()

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 )

Decrypt data that was encrypted using RSA-PKCS#1v1.5

Parameters

session	Authenticated session to use
key_id	Object ID of the RSA key to use for decryption
in	Encrypted data
in_len	Length of encrypted data
out	Decrypted data
out_len	Length of decrypted data

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS input parameters are NULL or if in_len is bigger than YH_MSG_BUF_SIZE-2. See yh_rc for other possible errors

Definition at line 2059 of file yubihsm.c.

                                                 {
 
  if (session == NULL || in == NULL || out == NULL || out_len == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  if (in_len > YH_MSG_BUF_SIZE - 2) {
    DBG_ERR("Too much data, must be < %d", YH_MSG_BUF_SIZE - 2);
    return YHR_INVALID_PARAMETERS;
  }
 
#pragma pack(push, 1)
  union {
    struct {
      uint16_t key_id;
      uint8_t bytes[YH_MSG_BUF_SIZE];
    };
    uint8_t buf[1];
  } data;
#pragma pack(pop)
 
  yh_cmd response_cmd;
  yh_rc yrc;
 
  data.key_id = htons(key_id);
 
  memcpy(data.bytes, in, in_len);
 
  yrc = yh_send_secure_msg(session, YHC_DECRYPT_PKCS1, data.buf, in_len + 2,
                           &response_cmd, out, out_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send DECRYPT PKCS1 command: %s", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(out[0]);
    DBG_ERR("Unable to get decrypted data: %s (%x)", yh_strerror(translated),
            out[0]);
    return translated;
  }
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_delete_object()

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

Delete an object in the device

Parameters

session	Authenticated session to use
id	Object ID of the object to delete
type	Type of object to delete. See yh_object_type

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if session is NULL. See yh_rc for other possible errors

Definition at line 2222 of file yubihsm.c.

                                                 {
 
  if (session == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
#pragma pack(push, 1)
  union {
    struct {
      uint16_t id;
      uint8_t type;
    };
    uint8_t buf[1];
  } data;
#pragma pack(pop)
 
  yh_rc yrc;
  yh_cmd response_cmd;
  uint8_t response[YH_MSG_BUF_SIZE];
  size_t response_len = sizeof(response);
 
  data.type = type;
  data.id = htons(id);
 
  yrc = yh_send_secure_msg(session, YHC_DELETE_OBJECT, data.buf, sizeof(data),
                           &response_cmd, response, &response_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send DELETE command: %s", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(response[0]);
    DBG_ERR("Unable to delete object: %s (%x)", yh_strerror(translated),
            response[0]);
    return translated;
  }
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_derive_ecdh()

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 )

Derive an ECDH key from a private EC key on the device and a provided public EC key

Parameters

session	Authenticated session to use
key_id	Object ID of the EC private key to use for ECDH derivation
in	Public key of another EC key-pair
in_len	Length of public key
out	Shared secret ECDH key
out_len	Length of the shared ECDH key

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS input parameters are NULL or if in_len is bigger than YH_MSG_BUF_SIZE-2. See yh_rc for other possible errors

Definition at line 2174 of file yubihsm.c.

                                           {
 
  if (session == NULL || in == NULL || out == NULL || out_len == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  if (in_len > YH_MSG_BUF_SIZE - 2) {
    DBG_ERR("Too much data, must be < %d", YH_MSG_BUF_SIZE - 2);
    return YHR_INVALID_PARAMETERS;
  }
 
#pragma pack(push, 1)
  union {
    struct {
      uint16_t key_id;
      uint8_t bytes[YH_MSG_BUF_SIZE];
    };
    uint8_t buf[1];
  } data;
#pragma pack(pop)
 
  yh_cmd response_cmd;
  yh_rc yrc;
 
  data.key_id = htons(key_id);
 
  memcpy(data.bytes, in, in_len);
 
  yrc = yh_send_secure_msg(session, YHC_DERIVE_ECDH, data.buf, in_len + 2,
                           &response_cmd, out, out_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send DERIVE ECDH command: %s", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(out[0]);
    DBG_ERR("Unable to get decrypted data: %s (%x)", yh_strerror(translated),
            out[0]);
    return translated;
  }
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_export_wrapped()

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 )

Export an object under wrap from the device

Parameters

session	Authenticated session to use
wrapping_key_id	Object ID of the Wrap Key to use to wrap the object
target_type	Type of the object to be exported. See yh_object_type
target_id	Object ID of the object to be exported
out	Wrapped data
out_len	Length of wrapped data

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL. See yh_rc for other possible errors

Definition at line 2265 of file yubihsm.c.

                                                            {
 
  if (session == NULL || out == NULL || out_len == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
#pragma pack(push, 1)
  union {
    struct {
      uint16_t key_id;
      uint8_t type;
      uint16_t tgt_id;
    };
    uint8_t buf[1];
  } data;
#pragma pack(pop)
 
  yh_cmd response_cmd;
  yh_rc yrc;
 
  data.key_id = htons(wrapping_key_id);
  data.type = (uint8_t) target_type;
  data.tgt_id = htons(target_id);
 
  yrc = yh_send_secure_msg(session, YHC_EXPORT_WRAPPED, data.buf, sizeof(data),
                           &response_cmd, out, out_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send EXPORT WRAPPED command: %s", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(out[0]);
    DBG_ERR("Unable to get wrapped object: %s (%x)", yh_strerror(translated),
            out[0]);
    return translated;
  }
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_generate_ec_key()

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 )

Generate an Elliptic Curve key in the device

Parameters

session	Authenticated session to use
key_id	Object ID of the key. 0 if the Object ID should be generated by the device
label	Label of the key. Maximum length is YH_OBJ_LABEL_LEN
domains	Domains to which the key belongs. See yh_string_to_domains()
capabilities	Capabilities of the key. See yh_string_to_capabilities()
algorithm	Algorithm to use to generate the EC key. Supported algorithm: YH_ALGO_EC_P224, YH_ALGO_EC_P256, YH_ALGO_EC_K256, YH_ALGO_EC_BP256, YH_ALGO_EC_P384, YH_ALGO_EC_BP384, YH_ALGO_EC_BP512 and YH_ALGO_EC_P521.

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS input parameters are NULL or the algorithm is not one of YH_ALGO_EC_P224, YH_ALGO_EC_P256, YH_ALGO_EC_K256, YH_ALGO_EC_BP256, YH_ALGO_EC_P384, YH_ALGO_EC_BP384, YH_ALGO_EC_BP512 or YH_ALGO_EC_P521. See yh_rc for other possible errors

Definition at line 1913 of file yubihsm.c.

                                                      {
 
  if (!yh_is_ec(algorithm)) {
    DBG_ERR("Invalid algorithm %d", algorithm);
    return YHR_INVALID_PARAMETERS;
  }
 
  return generate_key(session, key_id, label, domains, capabilities, algorithm);
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_generate_ed_key()

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 )

Generate an ED key in the device

Parameters

session	Authenticated session to use
key_id	Object ID of the key. 0 if the Object ID should be generated by the device
label	Label for the key. Maximum length YH_OBJ_LABEL_LEN
domains	Domains to which the key belongs. See yh_string_to_domains()
capabilities	Capabilities of the ED key. See yh_string_to_capabilities()
algorithm	Algorithm to use to generate the ED key. Supported algorithm: YH_ALGO_EC_ED25519

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS input parameters are NULL or the algorithm is not YH_ALGO_EC_ED25519. See yh_rc for other possible errors

Definition at line 1926 of file yubihsm.c.

                                                      {
 
  if (!yh_is_ed(algorithm)) {
    DBG_ERR("Invalid algorithm %d", algorithm);
    return YHR_INVALID_PARAMETERS;
  }
 
  return generate_key(session, key_id, label, domains, capabilities, algorithm);
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_generate_hmac_key()

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 )

Generate an HMAC key in the device

Parameters

session	Authenticated session to use
key_id	Object ID of the key. 0 if the Object ID should be generated by the device
label	Label of the key. Maximum length YH_OBJ_LABEL_LEN
domains	Domains to which the key belongs. See yh_string_to_domains()
capabilities	Capabilities of the key. See yh_string_to_capabilities()
algorithm	Algorithm to use to generate the HMAC key. Supported algorithims: YH_ALGO_HMAC_SHA1, YH_ALGO_HMAC_SHA256, YH_ALGO_HMAC_SHA384 and YH_ALGO_HMAC_SHA512

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS input parameters are NULL. See yh_rc for other possible errors

Definition at line 1992 of file yubihsm.c.

                                                        {
 
  if (session == NULL || label == NULL || strlen(label) > YH_OBJ_LABEL_LEN ||
      key_id == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  yh_rc yrc;
 
#pragma pack(push, 1)
  union {
    struct {
      uint16_t key_id;
      uint8_t label[YH_OBJ_LABEL_LEN];
      uint16_t domains;
      uint8_t capabilities[YH_CAPABILITIES_LEN];
      uint8_t algorithm;
    };
    uint8_t buf[1];
  } data;
  union {
    struct {
      uint16_t key_id;
    };
    uint8_t buf[1];
  } response;
#pragma pack(pop)
 
  size_t response_len = sizeof(response);
  yh_cmd response_cmd;
 
  data.key_id = htons(*key_id);
 
  memcpy(data.label, label, strlen(label));
  memset(data.label + strlen(label), 0, YH_OBJ_LABEL_LEN - strlen(label));
 
  data.domains = htons(domains);
 
  memcpy(data.capabilities, capabilities, YH_CAPABILITIES_LEN);
 
  data.algorithm = algorithm;
 
  yrc =
    yh_send_secure_msg(session, YHC_GENERATE_HMAC_KEY, data.buf, sizeof(data),
                       &response_cmd, response.buf, &response_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send GENERATE HMAC command: %s", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(response.buf[0]);
    DBG_ERR("Unable to generate key: %s (%x)", yh_strerror(translated),
            response.buf[0]);
    return translated;
  }
 
  *key_id = ntohs(response.key_id);
  DBG_INFO("Generated HMAC key 0x%04x", *key_id);
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_generate_otp_aead_key()

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 )

Generate an YH_OTP_AEAD_KEY for Yubico OTP decryption in the device.

Parameters

session	Authenticated session to use
key_id	Object ID of the AEAD Key. 0 if the Object ID should be generated by the device
label	Label of the AEAD Key. Maximum length is YH_OBJ_LABEL_LEN
domains	Domains the AEAD Key will be operating within. See yh_string_to_domains()
capabilities	Capabilities of the AEAD Key. See yh_string_to_capabilities()
algorithm	Algorithm used to generate the AEAD Key. Supported algorithms: YH_ALGO_AES128_YUBICO_OTP, YH_ALGO_AES192_YUBICO_OTP and YH_ALGO_AES256_YUBICO_OTP
nonce_id	Nonce ID

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL. See yh_rc for other possible errors

Definition at line 3422 of file yubihsm.c.

                                                                               {
 
  if (session == NULL || key_id == NULL || label == NULL ||
      strlen(label) > YH_OBJ_LABEL_LEN || capabilities == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  yh_rc yrc;
 
#pragma pack(push, 1)
  union {
    struct {
      uint16_t key_id;
      uint8_t label[YH_OBJ_LABEL_LEN];
      uint16_t domains;
      uint8_t capabilities[YH_CAPABILITIES_LEN];
      uint8_t algorithm;
      uint32_t nonce_id;
    };
    uint8_t buf[1];
  } data;
  uint16_t data_len = sizeof(data);
  union {
    struct {
      uint16_t key_id;
    };
    uint8_t buf[1];
  } response;
#pragma pack(pop)
 
  size_t response_len = sizeof(response);
  yh_cmd response_cmd;
 
  data.key_id = htons(*key_id);
 
  memcpy(data.label, label, strlen(label));
  memset(data.label + strlen(label), 0, YH_OBJ_LABEL_LEN - strlen(label));
 
  data.domains = htons(domains);
 
  memcpy(data.capabilities, capabilities, YH_CAPABILITIES_LEN);
 
  data.algorithm = algorithm;
 
  data.nonce_id = nonce_id;
 
  yrc =
    yh_send_secure_msg(session, YHC_GENERATE_OTP_AEAD_KEY, data.buf, data_len,
                       &response_cmd, response.buf, &response_len);
  insecure_memzero(data.buf, data_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send GENERATE OTP AEAD KEY command: %s",
            yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(response.buf[0]);
    DBG_ERR("Unable to generate key: %s (%x)", yh_strerror(translated),
            response.buf[0]);
    return translated;
  }
 
  *key_id = ntohs(response.key_id);
  DBG_INFO("Generated OTP AEAD key 0x%04x\n", *key_id);
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_generate_rsa_key()

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 )

Generate an RSA key in the device

Parameters

session	Authenticated session to use
key_id	Object ID of the key. 0 if the Object ID should be generated by the device
label	Label of the key. Maximum length is YH_OBJ_LABEL_LEN
domains	Domains to which the key belongs. See yh_string_to_domains()
capabilities	Capabilities of the key. See yh_string_to_capabilities()
algorithm	Algorithm to use to generate the RSA key. Supported algorithms: YH_ALGO_RSA_2048, YH_ALGO_RSA_3072 and YH_ALGO_RSA_4096

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS input parameters are NULL or the algorithm is not one of YH_ALGO_RSA_2048, YH_ALGO_RSA_3072 or YH_ALGO_RSA_4096. See yh_rc for other possible errors

Definition at line 1900 of file yubihsm.c.

                                                       {
 
  if (!yh_is_rsa(algorithm)) {
    DBG_ERR("Invalid algorithm %d", algorithm);
    return YHR_INVALID_PARAMETERS;
  }
 
  return generate_key(session, key_id, label, domains, capabilities, algorithm);
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_generate_wrap_key()

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 )

Generate a Wrap Key that can be used for export, import, wrap data and unwrap data in the device.

Parameters

session	Authenticated session to use
key_id	Object ID of the Wrap Key. 0 if the Object ID should be generated by the device
label	Label of the Wrap Key. Maximum length YH_OBJ_LABEL_LEN
domains	Domains where the Wrap Key will be operating within. See yh_string_to_domains()
capabilities	Capabilities of the Wrap Key. See yh_string_to_capabilities()
algorithm	Algorithm used to generate the Wrap Key
delegated_capabilities	Delegated capabilitites of the Wrap Key. See yh_string_to_capabilities()

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL. See yh_rc for other possible errors

See also

yh_object_type

Definition at line 2458 of file yubihsm.c.

                                                                               {
 
  if (session == NULL || key_id == NULL || label == NULL ||
      strlen(label) > YH_OBJ_LABEL_LEN || capabilities == NULL ||
      delegated_capabilities == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  yh_rc yrc;
 
#pragma pack(push, 1)
  union {
    struct {
      uint16_t key_id;
      uint8_t label[YH_OBJ_LABEL_LEN];
      uint16_t domains;
      uint8_t capabilities[YH_CAPABILITIES_LEN];
      uint8_t algorithm;
      uint8_t delegated_capabilities[YH_CAPABILITIES_LEN];
    };
    uint8_t buf[1];
  } data;
  uint16_t data_len = sizeof(data);
  union {
    struct {
      uint16_t key_id;
    };
    uint8_t buf[1];
  } response;
#pragma pack(pop)
 
  size_t response_len = sizeof(response);
  yh_cmd response_cmd;
 
  data.key_id = htons(*key_id);
 
  memcpy(data.label, label, strlen(label));
  memset(data.label + strlen(label), 0, YH_OBJ_LABEL_LEN - strlen(label));
 
  data.domains = htons(domains);
 
  memcpy(data.capabilities, capabilities, YH_CAPABILITIES_LEN);
 
  data.algorithm = algorithm;
 
  memcpy(data.delegated_capabilities, delegated_capabilities,
         YH_CAPABILITIES_LEN);
 
  yrc = yh_send_secure_msg(session, YHC_GENERATE_WRAP_KEY, data.buf, data_len,
                           &response_cmd, response.buf, &response_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send GENERATE WRAP KEY command: %s", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(response.buf[0]);
    DBG_ERR("Unable to generate key: %s (%x)", yh_strerror(translated),
            response.buf[0]);
    return translated;
  }
 
  *key_id = ntohs(response.key_id);
  DBG_INFO("Generated Wrap key 0x%04x\n", *key_id);
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_get_device_info()

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 )

Get device version, device serial number, supported algorithms and available log entries.

Parameters

connector	Connector to the device
major	Device major version number
minor	Device minor version number
patch	Device build version number
serial	Device serial number
log_total	Total number of log entries
log_used	Number of written log entries
algorithms	List of supported algorithms
n_algorithms	Number of supported algorithms

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if the connector is NULL. YHR_BUFFER_TOO_SMALL if n_algorithms is smaller than the number of actually supported algorithms. See yh_rc for other possible errors.

See also

Algorithms

Definition at line 938 of file yubihsm.c.

                                                                              {
 
  if (connector == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  yh_rc yrc;
 
#pragma pack(push, 1)
  union {
    struct {
      uint8_t major;
      uint8_t minor;
      uint8_t patch;
      uint32_t serial;
      uint8_t log_total;
      uint8_t log_used;
      uint8_t algorithms[YH_MAX_ALGORITHM_COUNT];
    };
    uint8_t buf[1];
  } response;
#pragma pack(pop)
  size_t response_len = sizeof(response);
  yh_cmd response_cmd;
 
  yrc = yh_send_plain_msg(connector, YHC_GET_DEVICE_INFO, NULL, 0,
                          &response_cmd, response.buf, &response_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send GET DEVICE INFO command: %s", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(response.buf[0]);
    DBG_ERR("Unable to get data: %s (%x)", yh_strerror(translated),
            response.buf[0]);
    return translated;
  }
 
  if (major != NULL) {
    *major = response.major;
  }
 
  if (minor != NULL) {
    *minor = response.minor;
  }
 
  if (patch != NULL) {
    *patch = response.patch;
  }
 
  if (serial != NULL) {
    *serial = ntohl(response.serial);
  }
 
  if (log_total != NULL) {
    *log_total = response.log_total;
  }
 
  if (log_used != NULL) {
    *log_used = response.log_used;
  }
 
  if (algorithms != NULL && n_algorithms) {
    size_t items = response_len - sizeof(response.major) -
                   sizeof(response.minor) - sizeof(response.patch) -
                   sizeof(response.serial) - sizeof(response.log_total) -
                   sizeof(response.log_used);
    if (*n_algorithms < items) {
      DBG_ERR("Algorithms buffer too small");
      return YHR_BUFFER_TOO_SMALL;
    }
    for (size_t i = 0; i < items; i++) {
      algorithms[i] = response.algorithms[i];
    }
    *n_algorithms = items;
  }
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_get_log_entries()

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 )

Get audit logs from the device.

When audit enforce is set, if the log buffer is full, no new operations (other than authentication operations) can be performed unless the log entries are read by this command and then the log index is set by calling yh_util_set_log_index().

Parameters

session	Authenticated session to use
unlogged_boot	Number of unlogged boot events. Used if the log buffer is full and audit enforce is set
unlogged_auth	Number of unlogged authentication events. Used if the log buffer is full and audit enforce is set
out	Log entries on the device
n_items	Number of log entries

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL. YHR_BUFFER_TOO_SMALL if n_items is smaller than the actual number of retrieved log entries. See yh_rc for other possible errors

Definition at line 2531 of file yubihsm.c.

                                               {
 
  if (session == NULL || out == NULL || n_items == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  yh_rc yrc;
 
  union {
    struct {
      uint16_t log_overflow_boot;
      uint16_t log_overflow_auth;
      uint8_t items;
      uint8_t data[1];
    };
    uint8_t buf[YH_MSG_BUF_SIZE];
  } response;
  size_t response_len = sizeof(response);
  yh_cmd response_cmd;
 
  yrc = yh_send_secure_msg(session, YHC_GET_LOG_ENTRIES, NULL, 0, &response_cmd,
                           response.buf, &response_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send GET LOGS command: %s", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(response.buf[0]);
    DBG_ERR("Unable to get logs: %s (%x)", yh_strerror(translated),
            response.buf[0]);
    return translated;
  }
 
  if (unlogged_boot) {
    *unlogged_boot = ntohs(response.log_overflow_boot);
  }
 
  if (unlogged_auth) {
    *unlogged_auth = ntohs(response.log_overflow_auth);
  }
 
  if (response.items > YH_MAX_LOG_ENTRIES) {
    DBG_ERR(
      "Response contain more items than the maximum number of log entries");
    return YHR_DEVICE_INVALID_DATA;
  }
 
  if (response.items > *n_items) {
    DBG_ERR("Log buffer too small, needed at lest %d, got %zu", response.items,
            *n_items);
    return YHR_BUFFER_TOO_SMALL;
  }
 
  *n_items = response.items;
 
  yh_log_entry *ptr = (yh_log_entry *) response.data;
  for (uint16_t i = 0; i < *n_items; i++) {
    out[i].number = ntohs(ptr[i].number);
    out[i].command = ptr[i].command;
    out[i].length = ntohs(ptr[i].length);
    out[i].session_key = ntohs(ptr[i].session_key);
    out[i].target_key = ntohs(ptr[i].target_key);
    out[i].second_key = ntohs(ptr[i].second_key);
    out[i].result = ptr[i].result;
    out[i].systick = ntohl(ptr[i].systick);
    memcpy(out[i].digest, ptr[i].digest, YH_LOG_DIGEST_SIZE);
  }
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_get_object_info()

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

Get metadata of the object with the specified Object ID and Type

Parameters

session	Authenticated session to use
id	Object ID of the object to get
type	Object type. See yh_object_type
object	Object information

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if the session is NULL. See yh_rc for other possible errors.

See also

Objects

Definition at line 1128 of file yubihsm.c.

                                                            {
 
  if (session == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  uint8_t data[3];
  uint8_t *dataptr = data;
 
#pragma pack(push, 1)
  union {
    struct {
      uint8_t capabilities[YH_CAPABILITIES_LEN];
      uint16_t id;
      uint16_t len;
      uint16_t domains;
      uint8_t type;
      uint8_t algorithm;
      uint8_t sequence;
      uint8_t origin;
      uint8_t label[YH_OBJ_LABEL_LEN];
      uint8_t delegated_capabilities[YH_CAPABILITIES_LEN];
    };
    uint8_t buf[1];
  } response;
  size_t response_len = sizeof(response);
#pragma pack(pop)
 
  yh_rc yrc;
  yh_cmd response_cmd;
 
  *dataptr++ = id >> 8 & 0xff;
  *dataptr++ = id & 0xff;
 
  *dataptr++ = (uint16_t) type;
 
  yrc = yh_send_secure_msg(session, YHC_GET_OBJECT_INFO, data, sizeof(data),
                           &response_cmd, response.buf, &response_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send GET OBJECT INFO command: %s", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(response.buf[0]);
    DBG_ERR("Unable to get object info: %s (%x)", yh_strerror(translated),
            response.buf[0]);
    return translated;
  }
 
  if (response_len == sizeof(response)) {
    if (object) {
      memcpy(object->capabilities.capabilities, response.capabilities,
             YH_CAPABILITIES_LEN);
 
      object->id = htons(response.id);
 
      object->len = htons(response.len);
 
      object->domains = htons(response.domains);
 
      object->type = response.type;
 
      object->algorithm = response.algorithm;
 
      object->sequence = response.sequence;
 
      object->origin = response.origin;
 
      memcpy(object->label, response.label, YH_OBJ_LABEL_LEN);
      object->label[YH_OBJ_LABEL_LEN] = 0;
 
      memcpy(object->delegated_capabilities.capabilities,
             response.delegated_capabilities, YH_CAPABILITIES_LEN);
    }
  } else {
    DBG_ERR("Wrong response length, expecting %lu or 0, received %lu",
            (unsigned long) sizeof(yh_object_descriptor),
            (unsigned long) response_len);
    return YHR_WRONG_LENGTH;
  }
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_get_opaque()

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

Get an YH_OPAQUE object (like an X.509 certificate) from the device

Parameters

session	Authenticated session to use
object_id	Object ID of the Opaque object
out	the retrieved Opaque object
out_len	Length of the retrieved Opaque object

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL. See yh_rc for other possible errors

Definition at line 2636 of file yubihsm.c.

                                          {
 
  if (session == NULL || out == NULL || out_len == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  uint8_t data[2];
  yh_cmd response_cmd;
  yh_rc yrc;
 
  uint16_t object_id_h = htons(object_id);
  memcpy(data, &object_id_h, sizeof(object_id_h));
  yrc = yh_send_secure_msg(session, YHC_GET_OPAQUE, data, sizeof(data),
                           &response_cmd, out, out_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send GET OPAQUE command: %s", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(out[0]);
    DBG_ERR("Unable to get object: %s (%x)", yh_strerror(translated), out[0]);
    return translated;
  }
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_get_option()

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

Get a device-global option

Parameters

session	Authenticated session to use
option	Option to get. See yh_option
out	Option value
out_len	Length of option value

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL. See yh_rc for other possible errors

Definition at line 3584 of file yubihsm.c.

                                          {
 
  if (session == NULL || out == NULL || out_len == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
  uint8_t buf[1] = {option};
  yh_cmd response_cmd;
 
  yh_rc yrc = yh_send_secure_msg(session, YHC_GET_OPTION, buf, sizeof(buf),
                                 &response_cmd, out, out_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send GET OPTION command: %s\n", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(out[0]);
    DBG_ERR("Unable to get option: %s (%x)\n", yh_strerror(translated), out[0]);
    return translated;
  }
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_get_pseudo_random()

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

Get a fixed number of pseudo-random bytes from the device

Parameters

session	Authenticated session to use
len	Length of pseudo-random data to get
out	Pseudo-random data out
out_len	Length of pseudo-random data

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS input parameters are NULL. See yh_rc for other possible errors

Definition at line 1560 of file yubihsm.c.

                                                 {
  yh_rc yrc;
  yh_cmd response_cmd;
 
  if (session == NULL || out == NULL || out_len == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  union {
    uint16_t len;
    uint8_t buf[2];
  } data;
  data.len = htons(len);
 
  yrc = yh_send_secure_msg(session, YHC_GET_PSEUDO_RANDOM, data.buf,
                           sizeof(data), &response_cmd, out, out_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send GET PSEUDO RANDOM command: %s", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(out[0]);
    DBG_ERR("Unable to get data: %s (%x)", yh_strerror(translated), out[0]);
    return translated;
  }
 
  return yrc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_get_public_key()

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

Get the value of the public key with the specified Object ID

Parameters

session	Authenticated session to use
id	Object ID of the public key
data	Value of the public key
data_len	Length of the public key in bytes
algorithm	Algorithm of the key

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL. YHR_BUFFER_TOO_SMALL if the actual key length was bigger than data_len. See yh_rc for other possible errors

Definition at line 1216 of file yubihsm.c.

                                                                        {
 
  if (session == NULL || data == NULL || data_len == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  uint8_t cmd[2] = {id >> 8, id & 0xff};
  yh_cmd response_cmd;
  uint8_t response[YH_MSG_BUF_SIZE];
  size_t response_len = sizeof(response);
 
  yh_rc yrc = yh_send_secure_msg(session, YHC_GET_PUBLIC_KEY, cmd, sizeof(cmd),
                                 &response_cmd, response, &response_len);
 
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send GET PUBLIC KEY command: %s", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(response[0]);
    DBG_ERR("Unable to get public key: %s (%x)", yh_strerror(translated),
            response[0]);
    return translated;
  }
 
  if (response_len > *data_len) {
    return YHR_BUFFER_TOO_SMALL;
  }
 
  if (algorithm) {
    *algorithm = *response;
  }
  *data_len = response_len - 1;
  memcpy(data, response + 1, *data_len);
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_get_storage_info()

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 )

Report currently free storage. This is reported as free records, free pages and page size.

Parameters

session	Authenticated session to use
total_records	Total number of records
free_records	Number of free records
total_pages	Total number of pages
free_pages	Number of free pages
page_size	Page size in bytes

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if the session is NULL. See yh_rc for other possible errors

Definition at line 3610 of file yubihsm.c.

                                                                          {
 
  if (session == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  yh_cmd response_cmd;
#pragma pack(push, 1)
  union {
    struct {
      uint16_t total_records;
      uint16_t free_records;
      uint16_t total_pages;
      uint16_t free_pages;
      uint16_t page_size;
    };
    uint8_t buf[1];
  } response;
#pragma pack(pop)
  size_t response_len = sizeof(response);
 
  yh_rc yrc = yh_send_secure_msg(session, YHC_GET_STORAGE_INFO, NULL, 0,
                                 &response_cmd, response.buf, &response_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send GET STORAGE INFO command: %s\n", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(response.buf[0]);
    DBG_ERR("Unable to get storage stats: %s (%x)\n", yh_strerror(translated),
            response.buf[0]);
    return translated;
  }
 
  if (total_records) {
    *total_records = ntohs(response.total_records);
  }
  if (free_records) {
    *free_records = ntohs(response.free_records);
  }
  if (total_pages) {
    *total_pages = ntohs(response.total_pages);
  }
  if (free_pages) {
    *free_pages = ntohs(response.free_pages);
  }
  if (page_size) {
    *page_size = ntohs(response.page_size);
  }
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_get_template()

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

Get a YH_TEMPLATE object from the device

Parameters

session	Authenticated session to use
object_id	Object ID of the Template to get
out	The retrieved Template
out_len	Length of the retrieved Template

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL. See yh_rc for other possible errors

Definition at line 2805 of file yubihsm.c.

                                                          {
  if (session == NULL || out == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  uint8_t data[2];
  yh_cmd response_cmd;
  yh_rc yrc;
 
  uint16_t object_id_h = htons(object_id);
  memcpy(data, &object_id_h, sizeof(object_id_h));
  yrc = yh_send_secure_msg(session, YHC_GET_TEMPLATE, data, sizeof(data),
                           &response_cmd, out, out_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send GET TEMPLATE command: %s", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(out[0]);
    DBG_ERR("Unable to get template object: %s (%x)", yh_strerror(translated),
            out[0]);
    return translated;
  }
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_import_authentication_key()

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 )

Import an YH_AUTHENTICATION_KEY into the device

Parameters

session	Authenticated session to use
key_id	Object ID of the imported key. 0 if the Object ID should be generated by the device
label	Label of the key. Maximum length is YH_OBJ_LABEL_LEN
domains	Domains to which the key belongs. See yh_string_to_domains()
capabilities	Capabilities of the key. See yh_string_to_capabilities()
delegated_capabilities	Delegated capabilities of the key. See yh_string_to_capabilities()
key_enc	Long lived encryption key of the Authentication Key to import
key_enc_len	Length of the encryption key. Must be YH_KEY_LEN
key_mac	Long lived MAC key of the Authentication Key to import
key_mac_len	Length of the MAC key. Must be YH_KEY_LEN

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL or if key_enc_len or key_mac_len are not the expected values. See yh_rc for other possible errors

See also

Authentication Key

Definition at line 2985 of file yubihsm.c.

                                                                  {
 
  if (session == NULL || key_id == NULL || label == NULL ||
      strlen(label) > YH_OBJ_LABEL_LEN || capabilities == NULL ||
      delegated_capabilities == NULL || key_enc == NULL ||
      key_enc_len != YH_KEY_LEN || key_mac == NULL ||
      key_mac_len != YH_KEY_LEN) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
#pragma pack(push, 1)
  union {
    struct {
      uint16_t key_id;
      uint8_t label[YH_OBJ_LABEL_LEN];
      uint16_t domains;
      uint8_t capabilities[YH_CAPABILITIES_LEN];
      uint8_t algorithm;
      uint8_t delegated_capabilities[YH_CAPABILITIES_LEN];
      uint8_t key_enc[YH_KEY_LEN];
      uint8_t key_mac[YH_KEY_LEN];
    };
    uint8_t buf[1];
  } data;
  union {
    struct {
      uint16_t key_id;
    };
    uint8_t buf[1];
  } response;
#pragma pack(pop)
  size_t response_len = sizeof(response);
  yh_cmd response_cmd;
 
  memcpy(data.key_enc, key_enc, YH_KEY_LEN);
  memcpy(data.key_mac, key_mac, YH_KEY_LEN);
 
  data.key_id = htons(*key_id);
 
  memcpy(data.label, label, strlen(label));
  memset(data.label + strlen(label), 0, YH_OBJ_LABEL_LEN - strlen(label));
 
  data.domains = htons(domains);
 
  memcpy(data.capabilities, capabilities, YH_CAPABILITIES_LEN);
 
  data.algorithm = YH_ALGO_AES128_YUBICO_AUTHENTICATION;
 
  memcpy(data.delegated_capabilities, delegated_capabilities,
         YH_CAPABILITIES_LEN);
 
  yh_rc yrc = yh_send_secure_msg(session, YHC_PUT_AUTHENTICATION_KEY, data.buf,
                                 sizeof(data), &response_cmd, response.buf,
                                 &response_len);
  insecure_memzero(data.buf, sizeof(data));
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send PUT AUTHENTICATION KEY command: %s\n",
            yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(response.buf[0]);
    DBG_ERR("Unable to store authentication key: %s (%x)\n",
            yh_strerror(translated), response.buf[0]);
    return translated;
  }
 
  *key_id = ntohs(response.key_id);
  DBG_INFO("Stored Authentication key 0x%04x", *key_id);
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_import_authentication_key_derived()

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 )

Import an YH_AUTHENTICATION_KEY with long lived keys derived from a password

Parameters

session	Authenticated session to use
key_id	Object ID of the key. 0 if the Object ID should be generated by the device
label	Label of the key. Maximum length is YH_OBJ_LABEL_LEN
domains	Domains to which the key belongs. See yh_string_to_domains()
capabilities	Capabilities of the key. See yh_string_to_capabilities()
delegated_capabilities	Delegated capabilities of the key. See yh_string_to_capabilities()
password	Password used to derive the long lived encryption key and MAC key of the Athentication Key
password_len	Length of password

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL. See yh_rc for other possible errors

See also

Authentication Key

Definition at line 3064 of file yubihsm.c.

                       {
 
  if (session == NULL || key_id == NULL || label == NULL ||
      strlen(label) > YH_OBJ_LABEL_LEN || capabilities == NULL ||
      delegated_capabilities == NULL || password == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  uint8_t key_enc[SCP_KEY_LEN];
  uint8_t key_mac[SCP_KEY_LEN];
 
  yh_rc yrc = derive_keys(password, password_len, key_enc, key_mac);
 
  if (yrc == YHR_SUCCESS) {
    yrc =
      yh_util_import_authentication_key(session, key_id, label, domains,
                                        capabilities, delegated_capabilities,
                                        key_enc, sizeof(key_enc), key_mac,
                                        sizeof(key_mac));
    insecure_memzero(key_enc, sizeof(key_enc));
    insecure_memzero(key_mac, sizeof(key_mac));
  }
  return yrc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_import_ec_key()

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 )

Import an Elliptic Curve key into the device

Parameters

session	Authenticated session to use
key_id	Object ID of the key. 0 if the Object ID should be generated by the device
label	Label of the key. Maximum length is YH_OBJ_LABEL_LEN
domains	Domains to which the key belongs specified as an unsigned int. See yh_string_to_domains()
capabilities	Capabilities of the key. See yh_string_to_capabilities()
algorithm	Algorithm of the key to import. Must be one of: YH_ALGO_EC_P224, YH_ALGO_EC_P256, YH_ALGO_EC_K256, YH_ALGO_EC_BP256, YH_ALGO_EC_P384, YH_ALGO_EC_BP384, YH_ALGO_EC_BP512 or YH_ALGO_EC_P521
s	the EC key to import

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS input parameters are NULL or the algorithm is not one of YH_ALGO_EC_P224, YH_ALGO_EC_P256, YH_ALGO_EC_K256, YH_ALGO_EC_BP256, YH_ALGO_EC_P384, YH_ALGO_EC_BP384, YH_ALGO_EC_BP512 or YH_ALGO_EC_P521. See yh_rc for other possible errors

Definition at line 1689 of file yubihsm.c.

                                                                      {
 
  if (session == NULL || key_id == NULL || label == NULL ||
      strlen(label) > YH_OBJ_LABEL_LEN || s == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  uint16_t component_len;
  switch (algorithm) {
    case YH_ALGO_EC_P224:
      component_len = 28;
      break;
    case YH_ALGO_EC_P256:
    case YH_ALGO_EC_K256:
    case YH_ALGO_EC_BP256:
      component_len = 32;
      break;
    case YH_ALGO_EC_P384:
    case YH_ALGO_EC_BP384:
      component_len = 48;
      break;
    case YH_ALGO_EC_BP512:
      component_len = 64;
      break;
    case YH_ALGO_EC_P521:
      component_len = 66;
      break;
    default:
      return YHR_INVALID_PARAMETERS;
  }
  return import_asymmetric(session, key_id, label, domains, capabilities,
                           algorithm, s, component_len);
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_import_ed_key()

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 )

Import an ED key into the device

Parameters

session	Authenticated session to use
key_id	Object ID of the key will have. 0 if the Object ID should be generated by the device
label	Label of the key. Maximum length is YH_OBJ_LABEL_LEN
domains	Domains to which the key belongs. See yh_string_to_domains()
capabilities	Capabilities of the key. See yh_string_to_capabilities()
algorithm	Algorithm of the key to import. Must be YH_ALGO_EC_ED25519
k	the ED key to import

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS input parameters are NULL or the algorithm is not YH_ALGO_EC_ED25519. See yh_rc for other possible errors

Definition at line 1727 of file yubihsm.c.

                                                                      {
 
  if (session == NULL || key_id == NULL || label == NULL ||
      strlen(label) > YH_OBJ_LABEL_LEN || k == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  uint16_t component_len;
  switch (algorithm) {
    case YH_ALGO_EC_ED25519:
      component_len = 32;
      break;
    default:
      return YHR_INVALID_PARAMETERS;
  }
  return import_asymmetric(session, key_id, label, domains, capabilities,
                           algorithm, k, component_len);
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_import_hmac_key()

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 )

Import an HMAC key into the device

Parameters

session	Authenticated session to use
key_id	Object ID of the key. 0 if the Object ID should be generated by the device
label	Label of the key. Maxium length is YH_OBJ_LABEL_LEN
domains	Domains to which the key belongs. See yh_string_to_domains()
capabilities	Capabilities of the key. See yh_string_to_capabilities()
algorithm	Algorithm of the key to import. Must be one of: YH_ALGO_HMAC_SHA1, YH_ALGO_HMAC_SHA256, YH_ALGO_HMAC_SHA384 or YH_ALGO_HMAC_SHA512
key	The HMAC key to import
key_len	Length of the HMAC key to import

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS input parameters are NULL. See yh_rc for other possible errors

Definition at line 1750 of file yubihsm.c.

                                              {
 
  if (session == NULL || key_id == NULL || label == NULL ||
      strlen(label) > YH_OBJ_LABEL_LEN || key == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
#pragma pack(push, 1)
  union {
    struct {
      uint16_t key_id;
      uint8_t label[YH_OBJ_LABEL_LEN];
      uint16_t domains;
      uint8_t capabilities[YH_CAPABILITIES_LEN];
      uint8_t algorithm;
      uint8_t key[128];
    };
    uint8_t buf[1];
  } k;
  union {
    struct {
      uint16_t key_id;
    };
    uint8_t buf[1];
  } response;
#pragma pack(pop)
  yh_rc yrc;
  size_t response_len = sizeof(response);
  yh_cmd response_cmd;
  size_t max_len = 64;
  int len = sizeof(k) - sizeof(k.key);
 
  k.key_id = htons(*key_id);
 
  memcpy(k.label, label, strlen(label));
  memset(k.label + strlen(label), 0, YH_OBJ_LABEL_LEN - strlen(label));
 
  k.domains = htons(domains);
 
  k.algorithm = algorithm;
 
  memcpy(k.capabilities, capabilities, YH_CAPABILITIES_LEN);
 
  if (algorithm == YH_ALGO_HMAC_SHA384 || algorithm == YH_ALGO_HMAC_SHA512) {
    max_len = 128;
  }
 
  if (key_len > max_len) {
    DBG_ERR("Too long key supplied, max %lu bytes allowed",
            (unsigned long) max_len);
    return YHR_WRONG_LENGTH;
  }
 
  memcpy(k.key, key, key_len);
  len += key_len;
 
  yrc = yh_send_secure_msg(session, YHC_PUT_HMAC_KEY, k.buf, len, &response_cmd,
                           response.buf, &response_len);
  insecure_memzero(k.buf, len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send PUT HMAC KEY command: %s", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(response.buf[0]);
    DBG_ERR("Unable to put key: %s (%x)", yh_strerror(translated),
            response.buf[0]);
    return translated;
  }
 
  *key_id = ntohs(response.key_id);
  DBG_INFO("Stored HMAC key 0x%04x", *key_id);
 
  return yrc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_import_opaque()

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 )

Import an YH_OPAQUE object into the device

Parameters

session	Authenticated session to use
object_id	Object ID of the Opaque object. 0 if the Object ID should be generated by the device
label	Label of the Opaque object. Maximum length is YH_OBJ_LABEL_LEN
domains	Domains the Opaque object will be operating within. See yh_string_to_domains()
capabilities	Capabilities of the Opaque object. See yh_string_to_capabilities()
algorithm	Algorithm of the Opaque object
in	the Opaque object to import
in_len	Length of the Opaque object to import

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL or in_len is too big. See yh_rc for other possible errors

Definition at line 2666 of file yubihsm.c.

                                           {
 
  if (session == NULL || object_id == NULL || label == NULL ||
      strlen(label) > YH_OBJ_LABEL_LEN || in == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  yh_rc yrc;
 
#pragma pack(push, 1)
  union {
    struct {
      uint16_t object_id;
      uint8_t label[YH_OBJ_LABEL_LEN];
      uint16_t domains;
      uint8_t capabilities[YH_CAPABILITIES_LEN];
      uint8_t algorithm;
      uint8_t bytes[YH_MSG_BUF_SIZE - sizeof(object_id) - sizeof(domains) -
                    YH_CAPABILITIES_LEN - 2];
    };
    uint8_t buf[1];
  } data;
  uint16_t data_len;
  union {
    struct {
      uint16_t object_id;
    };
    uint8_t buf[1];
  } response;
#pragma pack(pop)
  size_t response_len = sizeof(response);
  yh_cmd response_cmd;
 
  data.object_id = htons(*object_id);
 
  memcpy(data.label, label, strlen(label));
  memset(data.label + strlen(label), 0, YH_OBJ_LABEL_LEN - strlen(label));
 
  data.domains = htons(domains);
 
  memcpy(data.capabilities, capabilities, YH_CAPABILITIES_LEN);
 
  data.algorithm = algorithm;
 
  if (in_len > sizeof(data.bytes)) {
    DBG_ERR("Data length must be in [0, %lu]\n",
            (unsigned long) sizeof(data.bytes));
    return YHR_INVALID_PARAMETERS;
  }
 
  data_len = in_len + sizeof(data) - sizeof(data.bytes);
  memcpy(data.bytes, in, in_len);
 
  yrc = yh_send_secure_msg(session, YHC_PUT_OPAQUE, data.buf, data_len,
                           &response_cmd, response.buf, &response_len);
  insecure_memzero(data.buf, data_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send PUT OPAQUE command: %s", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(response.buf[0]);
    DBG_ERR("Unable to store opaque object: %s (%x)", yh_strerror(translated),
            response.buf[0]);
    return translated;
  }
 
  *object_id = ntohs(response.object_id);
  DBG_INFO("Stored Opaque Object 0x%04x", *object_id);
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_import_otp_aead_key()

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 )

Import an YH_OTP_AEAD_KEY used for Yubico OTP Decryption

Parameters

session	Authenticated session to use
key_id	Object ID of the AEAD Key. 0 if the Object ID should be generated by the device
label	Label of the AEAD Key. Maximum length is YH_OBJ_LABEL_LEN
domains	Domains the AEAD Key will be operating within. See yh_string_to_domains()
capabilities	Capabilities of the AEAD Key. See yh_string_to_capabilities()
nonce_id	Nonce ID
in	AEAD Key to import
in_len	Length of AEAD Key to import. Must be 16, 24 or 32

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL or if in_len is not one of 16, 24 or 32. See yh_rc for other possible errors

Definition at line 3337 of file yubihsm.c.

                                                 {
 
  if (session == NULL || key_id == NULL || label == NULL ||
      strlen(label) > YH_OBJ_LABEL_LEN || capabilities == NULL || in == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
#pragma pack(push, 1)
  union {
    struct {
      uint16_t key_id;
      uint8_t label[YH_OBJ_LABEL_LEN];
      uint16_t domains;
      uint8_t capabilities[YH_CAPABILITIES_LEN];
      uint8_t algorithm;
      uint32_t nonce_id;
      uint8_t key[32];
    };
    uint8_t buf[1];
  } data;
  union {
    struct {
      uint16_t key_id;
    };
    uint8_t buf[1];
  } response;
#pragma pack(pop)
 
  uint16_t data_len = sizeof(data);
  size_t response_len = sizeof(response);
  yh_cmd response_cmd;
 
  yh_rc yrc;
 
  if (in_len == 16) {
    data.algorithm = YH_ALGO_AES128_YUBICO_OTP;
    data_len -= 16;
  } else if (in_len == 24) {
    data.algorithm = YH_ALGO_AES192_YUBICO_OTP;
    data_len -= 8;
  } else if (in_len == 32) {
    data.algorithm = YH_ALGO_AES256_YUBICO_OTP;
  } else {
    DBG_ERR("Key length has to be 16, 24 or 32 bytes.");
    return YHR_INVALID_PARAMETERS;
  }
 
  data.key_id = htons(*key_id);
 
  memcpy(data.label, label, strlen(label));
  memset(data.label + strlen(label), 0, YH_OBJ_LABEL_LEN - strlen(label));
 
  data.domains = htons(domains);
 
  memcpy(data.capabilities, capabilities, YH_CAPABILITIES_LEN);
 
  data.nonce_id = nonce_id;
 
  memcpy(data.key, in, in_len);
 
  yrc = yh_send_secure_msg(session, YHC_PUT_OTP_AEAD_KEY, data.buf, data_len,
                           &response_cmd, response.buf, &response_len);
  insecure_memzero(data.buf, data_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send PUT OTP AEAD KEY command: %s", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(response.buf[0]);
    DBG_ERR("Unable to store OTP AEAD key: %s (%x)", yh_strerror(translated),
            response.buf[0]);
    return translated;
  }
 
  *key_id = ntohs(response.key_id);
  DBG_INFO("Imported OTP AEAD key 0x%04x", *key_id);
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_import_rsa_key()

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 )

Import an RSA key into the device

Parameters

session	Authenticated session to use
key_id	Object ID the key. 0 if Object ID should be generated by the device
label	Label of the key. Maximum length is YH_OBJ_LABEL_LEN
domains	Domains to which the key belongs specified as an unsigned int. See yh_string_to_domains()
capabilities	Capabilities of the key. See yh_string_to_capabilities()
algorithm	Algorithm of the key to import. Must be one of: YH_ALGO_RSA_2048, YH_ALGO_RSA_3072 or YH_ALGO_RSA_4096
p	P component of the RSA key to import
q	Q component of the RSA key to import

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS input parameters are NULL or the algorithm is not one of YH_ALGO_RSA_2048, YH_ALGO_RSA_3072 or YH_ALGO_RSA_4096. See yh_rc for other possible errors

Definition at line 1655 of file yubihsm.c.

                                               {
 
  if (session == NULL || key_id == NULL || label == NULL ||
      strlen(label) > YH_OBJ_LABEL_LEN || p == NULL || q == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  uint8_t keybuf[256 * 2];
  uint16_t component_len;
 
  if (algorithm == YH_ALGO_RSA_2048) {
    component_len = 128;
  } else if (algorithm == YH_ALGO_RSA_3072) {
    component_len = 192;
  } else if (algorithm == YH_ALGO_RSA_4096) {
    component_len = 256;
  } else {
    return YHR_INVALID_PARAMETERS;
  }
  memcpy(keybuf, p, component_len);
  memcpy(keybuf + component_len, q, component_len);
 
  yh_rc yrc = import_asymmetric(session, key_id, label, domains, capabilities,
                                algorithm, keybuf, component_len * 2);
  insecure_memzero(keybuf, sizeof(keybuf));
 
  return yrc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_import_template()

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 )

Import a YH_TEMPLATE object into the device

Parameters

session	Authenticated session to use
object_id	Object ID of the Template. 0 if the Object ID should be generated by the device
label	Label of the Template. Maximum length is YH_OBJ_LABEL_LEN
domains	Domains the Template will be operating within. See yh_string_to_domains()
capabilities	Capabilities of the Template. See yh_string_to_capabilities
algorithm	Algorithm of the Template
in	Template to import
in_len	Length of the Template to import

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL or if in_len is too big. See yh_rc for other possible errors

Definition at line 2835 of file yubihsm.c.

                                             {
 
  if (session == NULL || object_id == NULL || label == NULL ||
      strlen(label) > YH_OBJ_LABEL_LEN || in == NULL || in_len == 0) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  yh_rc yrc;
 
#pragma pack(push, 1)
  union {
    struct {
      uint16_t object_id;
      uint8_t label[YH_OBJ_LABEL_LEN];
      uint16_t domains;
      uint8_t capabilities[YH_CAPABILITIES_LEN];
      uint8_t algorithm;
      uint8_t bytes[YH_MSG_BUF_SIZE - sizeof(object_id) - sizeof(domains) -
                    YH_OBJ_LABEL_LEN - YH_CAPABILITIES_LEN - 2];
    };
    uint8_t buf[1];
  } data;
  uint16_t data_len;
  union {
    struct {
      uint16_t object_id;
    };
    uint8_t buf[1];
  } response;
#pragma pack(pop)
 
  size_t response_len = sizeof(response);
  yh_cmd response_cmd;
 
  data.object_id = htons(*object_id);
 
  memcpy(data.label, label, strlen(label));
  memset(data.label + strlen(label), 0, YH_OBJ_LABEL_LEN - strlen(label));
 
  data.domains = htons(domains);
 
  memcpy(data.capabilities, capabilities, YH_CAPABILITIES_LEN);
 
  data.algorithm = algorithm;
 
  if (in_len > sizeof(data.bytes)) {
    DBG_ERR("Data length must be in [0, %lu]\n",
            (unsigned long) sizeof(data.bytes));
    return YHR_INVALID_PARAMETERS;
  }
 
  data_len = in_len + sizeof(data.object_id) + sizeof(data.domains) +
             YH_CAPABILITIES_LEN + YH_OBJ_LABEL_LEN + sizeof(data.algorithm);
  memcpy(data.bytes, in, in_len);
 
  yrc = yh_send_secure_msg(session, YHC_PUT_TEMPLATE, data.buf, data_len,
                           &response_cmd, response.buf, &response_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send PUT TEMPLATE command: %s", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(response.buf[0]);
    DBG_ERR("Unable to store template object: %s (%x)", yh_strerror(translated),
            response.buf[0]);
    return translated;
  }
 
  *object_id = ntohs(response.object_id);
  DBG_INFO("Stored Opaque Object 0x%04x", *object_id);
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_import_wrap_key()

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 )

Import a Wrap Key into the device

Parameters

session	Authenticated session to use
key_id	Object ID the Wrap Key. 0 if the Object ID should be generated by the device
label	Label of the Wrap Key. Maximum length is YH_OBJ_LABEL_LEN
domains	Domains where the Wrap Key will be operating within. See yh_string_to_domains()
capabilities	Capabilities of the Wrap Key. See yh_string_to_capabilities()
algorithm	Algorithm of the Wrap Key. Supported algorithms: YH_ALGO_AES128_CCM_WRAP, YH_ALGO_AES192_CCM_WRAP and YH_ALGO_AES256_CCM_WRAP
delegated_capabilities	Delegated capabilities of the Wrap Key. See yh_string_to_capabilities()
in	the Wrap Key to import
in_len	Length of the Wrap Key to import

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL, in_len is not what expected based on the algorithm and if the algorithms is not one of YH_ALGO_AES128_CCM_WRAP, YH_ALGO_AES192_CCM_WRAP or YH_ALGO_AES256_CCM_WRAP. See yh_rc for other possible errors

Definition at line 2363 of file yubihsm.c.

                                                                {
 
  if (session == NULL || key_id == NULL || label == NULL ||
      strlen(label) > YH_OBJ_LABEL_LEN || capabilities == NULL ||
      delegated_capabilities == NULL || in == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
#pragma pack(push, 1)
  union {
    struct {
      uint16_t key_id;
      uint8_t label[YH_OBJ_LABEL_LEN];
      uint16_t domains;
      uint8_t capabilities[YH_CAPABILITIES_LEN];
      uint8_t algorithm;
      uint8_t delegated_capabilities[YH_CAPABILITIES_LEN];
      uint8_t key[32];
    };
    uint8_t buf[1];
  } data;
  uint16_t data_len = sizeof(data);
  union {
    struct {
      uint16_t key_id;
    };
    uint8_t buf[1];
  } response;
#pragma pack(pop)
 
  size_t response_len = sizeof(response);
  yh_cmd response_cmd;
  uint16_t key_len;
 
  yh_rc yrc;
 
  switch (algorithm) {
    case YH_ALGO_AES128_CCM_WRAP:
      key_len = 16;
      data_len -= 16;
      break;
    case YH_ALGO_AES192_CCM_WRAP:
      key_len = 24;
      data_len -= 8;
      break;
    case YH_ALGO_AES256_CCM_WRAP:
      key_len = 32;
      break;
    default:
      DBG_ERR("Bad algorithm specified: %x", algorithm);
      return YHR_INVALID_PARAMETERS;
  }
 
  if (in_len != key_len) {
    DBG_ERR("Key length not matching, should be %d", key_len);
    return YHR_INVALID_PARAMETERS;
  }
 
  data.key_id = htons(*key_id);
  memcpy(data.label, label, strlen(label));
  memset(data.label + strlen(label), 0, YH_OBJ_LABEL_LEN - strlen(label));
  data.domains = htons(domains);
  memcpy(data.capabilities, capabilities, YH_CAPABILITIES_LEN);
  data.algorithm = algorithm;
  memcpy(data.delegated_capabilities, delegated_capabilities,
         YH_CAPABILITIES_LEN);
  memcpy(data.key, in, key_len);
 
  yrc = yh_send_secure_msg(session, YHC_PUT_WRAP_KEY, data.buf, data_len,
                           &response_cmd, response.buf, &response_len);
  insecure_memzero(data.buf, data_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send PUT WRAP KEY command: %s", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(response.buf[0]);
    DBG_ERR("Unable to store wrapping key: %s (%x)", yh_strerror(translated),
            response.buf[0]);
    return translated;
  }
 
  *key_id = ntohs(response.key_id);
  DBG_INFO("Imported Wrap key 0x%04x", *key_id);
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_import_wrapped()

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 )

Import a wrapped object into the device. The object should have been previously exported by yh_util_export_wrapped()

Parameters

session	Authenticated session to use
wrapping_key_id	Object ID of the Wrap Key to use to unwrap the object
in	Wrapped data
in_len	Length of wrapped data
target_type	Type of the imported object
target_id	Object ID of the imported object

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL. See yh_rc for other possible errors

Definition at line 2309 of file yubihsm.c.

                                                                               {
 
  if (session == NULL || in == NULL || target_type == NULL ||
      target_id == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  if (in_len > YH_MSG_BUF_SIZE - 2) {
    DBG_ERR("Too much data, must be < %d", YH_MSG_BUF_SIZE - 2);
    return YHR_INVALID_PARAMETERS;
  }
 
#pragma pack(push, 1)
  union {
    struct {
      uint16_t key_id;
      uint8_t bytes[YH_MSG_BUF_SIZE - 2];
    };
    uint8_t buf[1];
  } data;
#pragma pack(pop)
  uint16_t data_len = 2 + in_len;
 
  uint8_t response[YH_MSG_BUF_SIZE];
  size_t response_len = sizeof(response);
  yh_cmd response_cmd;
  yh_rc yrc;
 
  data.key_id = htons(wrapping_key_id);
  memcpy(data.bytes, in, in_len);
 
  yrc = yh_send_secure_msg(session, YHC_IMPORT_WRAPPED, data.buf, data_len,
                           &response_cmd, response, &response_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send IMPORT WRAPPED command: %s", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(response[0]);
    DBG_ERR("Unable to get data: %s (%x)", yh_strerror(translated),
            response[0]);
    return translated;
  }
 
  *target_type = response[0];
  *target_id = ntohs(*((uint16_t *) (response + 1)));
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_list_objects()

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 )

List objects accessible from the session

Parameters

session	Authenticated session to use
id	Object ID to filter by (0 to not filter by ID)
type	Object type to filter by (0 to not filter by type). See yh_object_type
domains	Domains to filter by (0 to not filter by domain)
capabilities	Capabilities to filter by (0 to not filter by capabilities). See yh_capabilities
algorithm	Algorithm to filter by (0 to not filter by algorithm)
label	Label to filter by
objects	Array of objects returned
n_objects	Max number of objects (will be set to number found on return)

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL. YHR_BUFFER_TOO_SMALL if n_objects is smaller than the number of objects found. See yh_rc for other possible errors.

See also

Objects, Domains, Capabilities, Algorithms, Labels

Definition at line 1030 of file yubihsm.c.

                                                                             {
 
  if (session == NULL || objects == NULL || n_objects == NULL ||
      (label != NULL && strlen(label) > YH_OBJ_LABEL_LEN)) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  uint8_t data[YH_MSG_BUF_SIZE];
  uint8_t *dataptr = data;
 
  uint8_t response[YH_MSG_BUF_SIZE];
  size_t response_len = sizeof(response);
 
  yh_rc yrc;
  yh_cmd response_cmd;
 
  if (id) {
    *dataptr++ = LIST_ID;
    *dataptr++ = id >> 8 & 0xff;
    *dataptr++ = id & 0xff;
  }
 
  if (type) {
    *dataptr++ = LIST_TYPE;
    *dataptr++ = type;
  }
 
  if (domains) {
    *dataptr++ = LIST_DOMAINS;
    *dataptr++ = domains >> 8 & 0xff;
    *dataptr++ = domains & 0xff;
  }
 
  if (algorithm) {
    *dataptr++ = LIST_ALGORITHM;
    *dataptr++ = algorithm;
  }
 
  if (label && strlen(label)) {
    *dataptr++ = LIST_LABEL;
    memcpy(dataptr, label, strlen(label));
    memset(dataptr + strlen(label), 0, YH_OBJ_LABEL_LEN - strlen(label));
    dataptr += YH_OBJ_LABEL_LEN;
  }
 
  bool send_capabilities = false;
  for (uint16_t i = 0; i < YH_CAPABILITIES_LEN; i++) {
    if (capabilities->capabilities[i]) {
      send_capabilities = true;
      break;
    }
  }
 
  if (send_capabilities == true) {
    *dataptr++ = LIST_CAPABILITIES;
    for (uint16_t i = 0; i < YH_CAPABILITIES_LEN; i++) {
      *dataptr++ = capabilities->capabilities[i];
    }
  }
 
  yrc = yh_send_secure_msg(session, YHC_LIST_OBJECTS, data, dataptr - data,
                           &response_cmd, response, &response_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send LIST OBJECTS command: %s", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(response[0]);
    DBG_ERR("Unable to list objects: %s (%x)", yh_strerror(translated),
            response[0]);
    return translated;
  }
 
  if ((response_len / 4) > *n_objects) {
    DBG_ERR("Objects buffer too small");
    return YHR_BUFFER_TOO_SMALL;
  }
 
  *n_objects = response_len / 4;
  for (uint16_t i = 0; i < response_len; i += 4) {
    // NOTE: clear the fields that we didn't set
    memset(&objects[i / 4], 0, sizeof(yh_object_descriptor));
    objects[i / 4].id = ntohs(*((uint16_t *) (response + i)));
    objects[i / 4].type = response[i + 2];
    objects[i / 4].sequence = response[i + 3];
  }
 
  DBG_INFO("Found %zu objects", *n_objects);
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_randomize_otp_aead()

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

Create OTP AEAD from random data

Parameters

session	Authenticated session to use
key_id	Object ID of the Otp-aead Key to use
out	The created AEAD
out_len	Length of the created AEAD

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL. See yh_rc for other possible errors

Definition at line 3223 of file yubihsm.c.

                                                                {
 
  if (session == NULL || out == NULL || out_len == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
#pragma pack(push, 1)
  union {
    struct {
      uint16_t key_id;
    };
    uint8_t buf[1];
  } data;
#pragma pack(pop)
 
  yh_cmd response_cmd;
 
  data.key_id = htons(key_id);
 
  yh_rc yrc = yh_send_secure_msg(session, YHC_RANDOMIZE_OTP_AEAD, data.buf,
                                 sizeof(data), &response_cmd, out, out_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send RANDOMIZE OTP AEAD command: %s\n",
            yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(out[0]);
    DBG_ERR("Unable to get OTP AEAD: %s (%x)\n", yh_strerror(translated),
            out[0]);
    return translated;
  }
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_reset_device()

yh_rc yh_util_reset_device

(

yh_session *

session

)

Factory reset the device. Resets and reboots the device, deletes all Objects and restores the default YH_AUTHENTICATION_KEY.

Parameters

session

Authenticated session to use

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if the session is NULL. See yh_rc for other possible errors

Definition at line 3796 of file yubihsm.c.

                                                {
 
  if (session == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  yh_rc yrc;
 
  yh_cmd response_cmd;
  uint8_t response[1];
  size_t response_len = sizeof(response);
 
  yrc = yh_send_secure_msg(session, YHC_RESET_DEVICE, NULL, 0, &response_cmd,
                           response, &response_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send RESET DEVICE command: %s\n", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(response[0]);
    DBG_ERR("Unable to reset: %s (%x)\n", yh_strerror(translated), response[0]);
    return translated;
  }
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_set_log_index()

yh_rc yh_util_set_log_index	(	yh_session *	session,
		uint16_t	index )

Set the index of the last extracted log entry.

This function should be called after yh_util_get_log_entries() to inform the device what the last extracted log entry is so new logs can be written. This is used when forced auditing is enabled.

Parameters

session	Authenticated session to use
index	index to set. Should be the same index as the last entry extracted using yh_util_get_log_entries()

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if the session is NULL. See yh_rc for other possible errors

Definition at line 2606 of file yubihsm.c.

                                                                 {
  if (session == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
  uint8_t data[2];
  yh_cmd response_cmd;
  yh_rc yrc;
  uint8_t response[YH_MSG_BUF_SIZE];
  size_t response_len = sizeof(response);
 
  uint16_t index_h = htons(index);
  memcpy(data, &index_h, sizeof(index_h));
  yrc = yh_send_secure_msg(session, YHC_SET_LOG_INDEX, data, sizeof(data),
                           &response_cmd, response, &response_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send SET LOG INDEX command: %s", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(response[0]);
    DBG_ERR("Unable to set log index: %s (%x)", yh_strerror(translated),
            response[0]);
    return translated;
  }
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_set_option()

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

Set a device-global option

Parameters

session	Authenticated session to use
option	Option to set. See yh_option
len	Length of option value
val	Option value

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if session or val are NULL or if len is too long. See yh_rc for other possible errors

Definition at line 3537 of file yubihsm.c.

                                       {
 
  if (session == NULL || val == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  if (len > YH_MSG_BUF_SIZE - 3) {
    DBG_ERR("Too much data, must be < %d", YH_MSG_BUF_SIZE - 3);
    return YHR_INVALID_PARAMETERS;
  }
 
#pragma pack(push, 1)
  union {
    struct {
      uint8_t option;
      uint16_t len;
      uint8_t bytes[1];
    };
    uint8_t buf[YH_MSG_BUF_SIZE];
  } data;
#pragma pack(pop)
  uint8_t out[YH_MSG_BUF_SIZE];
  size_t outlen = sizeof(out);
  yh_cmd response_cmd;
 
  data.option = option;
  data.len = htons(len);
  memcpy(data.bytes, val, len);
 
  yh_rc yrc = yh_send_secure_msg(session, YHC_SET_OPTION, data.buf, len + 3,
                                 &response_cmd, out, &outlen);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send SET OPTION command: %s\n", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(out[0]);
    DBG_ERR("Unable to put option: %s (%x)\n", yh_strerror(translated), out[0]);
    return translated;
  }
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_sign_attestation_certificate()

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 )

Get attestation of an Asymmetric Key in the form of an X.509 certificate

Parameters

session	Authenticated session to use
key_id	Object ID of the Asymmetric Key to attest
attest_id	Object ID for the key used to sign the attestation certificate
out	The attestation certificate
out_len	Length of the attestation certificate

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL. See yh_rc for other possible errors

Definition at line 3495 of file yubihsm.c.

                                                            {
 
  if (session == NULL || out == NULL || out_len == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
#pragma pack(push, 1)
  union {
    struct {
      uint16_t key_id;
      uint16_t attest_id;
    };
    uint8_t buf[1];
  } data;
#pragma pack(pop)
 
  yh_cmd response_cmd;
 
  data.key_id = htons(key_id);
  data.attest_id = htons(attest_id);
 
  yh_rc yrc =
    yh_send_secure_msg(session, YHC_SIGN_ATTESTATION_CERTIFICATE, data.buf,
                       sizeof(data), &response_cmd, out, out_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send SIGN ATTESTATION CERTIFICATE command: %s\n",
            yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(out[0]);
    DBG_ERR("Unable to get attestation: %s (%x)\n", yh_strerror(translated),
            out[0]);
    return translated;
  }
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_sign_ecdsa()

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 )

Sign data using ECDSA

in is a raw hashed message, a truncated hash to the curve length or a padded hash to the curve length

Parameters

session	Authenticated session to use
key_id	Object ID of the signing key
in	Data to sign
in_len	Length of data to sign
out	Signed data
out_len	Length of signed data

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS input parameters are NULL or if in_len is not 20, 28, 34, 48, 64 or 66. See yh_rc for other possible errors

Definition at line 1411 of file yubihsm.c.

                                          {
 
  if (session == NULL || in == NULL || out == NULL || out_len == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  switch (in_len) {
    case 20:
    case 28: // p224..
    case 32:
    case 48:
    case 64:
    case 66: // p521 needs 66 bytes input
      break;
 
    default:
      DBG_ERR("Data length must be 20, 28, 32, 48, 64 or 66");
      return YHR_INVALID_PARAMETERS;
  }
 
  yh_rc yrc;
 
#pragma pack(push, 1)
  union {
    struct {
      uint16_t key_id;
      uint8_t bytes[YH_MSG_BUF_SIZE];
    };
    uint8_t buf[1];
  } data;
#pragma pack(pop)
  uint16_t data_len = in_len;
 
  yh_cmd response_cmd;
 
  data.key_id = htons(key_id);
 
  memcpy(data.bytes, in, in_len);
 
  yrc = yh_send_secure_msg(session, YHC_SIGN_ECDSA, data.buf, data_len + 2,
                           &response_cmd, out, out_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send SIGN ECDSA command: %s", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(out[0]);
    DBG_ERR("Unable to get signature: %s (%x)", yh_strerror(translated),
            out[0]);
    return translated;
  }
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_sign_eddsa()

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 )

Sign data using EdDSA

Parameters

session	Authenticated session to use
key_id	Object ID of the signing key
in	Data to sign
in_len	Length of data to sign
out	Signed data
out_len	Length of signed data

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS input parameters are NULL or if in_len is bigger than YH_MSG_BUF_SIZE-2. See yh_rc for other possible errors

Definition at line 1470 of file yubihsm.c.

                                          {
 
  if (session == NULL || in == NULL || out == NULL || out_len == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  if (in_len > YH_MSG_BUF_SIZE - 2) {
    DBG_ERR("Too much data, must be < %d", YH_MSG_BUF_SIZE - 2);
    return YHR_INVALID_PARAMETERS;
  }
 
  yh_rc yrc;
 
#pragma pack(push, 1)
  union {
    struct {
      uint16_t key_id;
      uint8_t bytes[YH_MSG_BUF_SIZE];
    };
    uint8_t buf[1];
  } data;
#pragma pack(pop)
  uint16_t data_len = in_len;
 
  yh_cmd response_cmd;
 
  data.key_id = htons(key_id);
 
  memcpy(data.bytes, in, in_len);
 
  yrc = yh_send_secure_msg(session, YHC_SIGN_EDDSA, data.buf, data_len + 2,
                           &response_cmd, out, out_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send SIGN EDDSA command: %s", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(out[0]);
    DBG_ERR("Unable to get signature: %s (%x)", yh_strerror(translated),
            out[0]);
    return translated;
  }
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_sign_hmac()

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 )

Sign data using HMAC

Parameters

session	Authenticated session to use
key_id	Object ID of the signing key
in	Data to HMAC
in_len	Length of data to hmac
out	HMAC
out_len	Length of HMAC

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS input parameters are NULL or if in_len is bigger than YH_MSG_BUF_SIZE-2. See yh_rc for other possible errors

Definition at line 1520 of file yubihsm.c.

                                                                      {
 
  if (session == NULL || in == NULL || out == NULL || out_len == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  if (in_len > YH_MSG_BUF_SIZE - 2) {
    DBG_ERR("Too much data, must be < %d", YH_MSG_BUF_SIZE - 2);
    return YHR_INVALID_PARAMETERS;
  }
 
  uint8_t data[YH_MSG_BUF_SIZE];
  uint16_t data_len = 2;
 
  yh_cmd response_cmd;
 
  data[0] = htons(key_id) & 0xff;
  data[1] = htons(key_id) >> 8;
 
  memcpy(data + 2, in, in_len);
  data_len += in_len;
 
  yh_rc yrc = yh_send_secure_msg(session, YHC_SIGN_HMAC, data, data_len,
                                 &response_cmd, out, out_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send SIGN HMAC command: %s", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(out[0]);
    DBG_ERR("Unable to get data: %s (%x)", yh_strerror(translated), out[0]);
    return translated;
  }
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_sign_pkcs1v1_5()

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 )

Sign data using RSA-PKCS#1v1.5

in is either a raw hashed message (sha1, sha256, sha384 or sha512) or that with correct digestinfo pre-pended

Parameters

session	Authenticated session to use
key_id	Object ID of the signing key
hashed	true if data is only hashed
in	data to sign
in_len	length of data to sign
out	signed data
out_len	length of signed data

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS input parameters are NULL or if in_len is not 20, 34, 48 or 64. See yh_rc for other possible errors

Definition at line 1287 of file yubihsm.c.

                                              {
 
  if (session == NULL || in == NULL || out == NULL || out_len == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  if (hashed)
    switch (in_len) {
      case 20:
      case 32:
      case 48:
      case 64:
        break;
 
      default:
        DBG_ERR("Data length must be 20, 32, 48 or 64");
        return YHR_INVALID_PARAMETERS;
    }
 
  yh_rc yrc;
 
#pragma pack(push, 1)
  union {
    struct {
      uint16_t key_id;
      uint8_t bytes[YH_MSG_BUF_SIZE];
    };
    uint8_t buf[1];
  } data;
#pragma pack(pop)
  uint16_t data_len;
 
  yh_cmd response_cmd;
 
  data.key_id = htons(key_id);
 
  memcpy(data.bytes, in, in_len);
  data_len = in_len;
 
  yrc = yh_send_secure_msg(session, YHC_SIGN_PKCS1, data.buf, data_len + 2,
                           &response_cmd, out, out_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send SIGN PKCS1 command: %s", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(out[0]);
    DBG_ERR("Unable to get signature: %s (%x)", yh_strerror(translated),
            out[0]);
    return translated;
  }
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_sign_pss()

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 )

Sign data using RSA-PSS

in is a raw hashed message (sha1, sha256, sha384 or sha512)

Parameters

session	Authenticated session to use
key_id	Object ID of the signing key
in	Data to sign
in_len	Length of data to sign
out	Signed data
out_len	Length of signed data
salt_len	Length of salt
mgf1Algo	Algorithm for mgf1 (mask generation function for PSS)

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS input parameters are NULL or if in_len is not 20, 34, 48 or 64. See yh_rc for other possible errors

See also

PSS specifications

Definition at line 1346 of file yubihsm.c.

                                                               {
 
  if (session == NULL || in == NULL || out == NULL || out_len == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  switch (in_len) {
    case 20:
    case 32:
    case 48:
    case 64:
      break;
 
    default:
      DBG_ERR("Data length must be 20, 32, 48 or 64");
      return YHR_INVALID_PARAMETERS;
  }
 
  yh_rc yrc;
 
#pragma pack(push, 1)
  union {
    struct {
      uint16_t key_id;
      uint8_t mgf1Algo;
      uint16_t salt_len;
      uint8_t bytes[YH_MSG_BUF_SIZE];
    };
    uint8_t buf[1];
  } data;
#pragma pack(pop)
  uint16_t data_len = in_len;
 
  yh_cmd response_cmd;
 
  data.key_id = htons(key_id);
 
  data.mgf1Algo = mgf1Algo;
 
  // NOTE(adma): 'in' is already a hash of the data, which type is inferred from
  // the length
  data.salt_len = htons(salt_len);
 
  memcpy(data.bytes, in, in_len);
 
  yrc = yh_send_secure_msg(session, YHC_SIGN_PSS, data.buf, data_len + 5,
                           &response_cmd, out, out_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send SIGN PSS command: %s", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(out[0]);
    DBG_ERR("Unable to get signature: %s (%x)", yh_strerror(translated),
            out[0]);
    return translated;
  }
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_sign_ssh_certificate()

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 )

Sign an SSH Certificate request. The function produces a signature that can then be used to produce the SSH Certificate

Parameters

session	Authenticated session to use
key_id	Object ID of the key used to sign the request
template_id	Object ID of the template to use as a certificate template
sig_algo	Signature algorithm to use to sign the certificate request
in	Certificate request
in_len	Length of the certificate request
out	Signature
out_len	Length of the signature

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL or in_len is too big. See yh_rc for other possible errors

Definition at line 2745 of file yubihsm.c.

                                                                  {
  if (session == NULL || in == NULL || out == NULL || out_len == NULL ||
      in_len == 0) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  yh_rc yrc;
 
#pragma pack(push, 1)
  union {
    struct {
      uint16_t key_id;
      uint16_t template_id;
      uint8_t algo;
      uint8_t bytes[YH_MSG_BUF_SIZE - sizeof(key_id) - sizeof(template_id) - 2];
    };
    uint8_t buf[1];
  } data;
  uint16_t data_len;
#pragma pack(pop)
 
  yh_cmd response_cmd;
 
  data.key_id = htons(key_id);
 
  data.template_id = htons(template_id);
 
  data.algo = sig_algo;
 
  if (in_len > sizeof(data.bytes)) {
    DBG_ERR("Data length must be in [0, %lu]\n",
            (unsigned long) sizeof(data.bytes));
    return YHR_INVALID_PARAMETERS;
  }
 
  data_len = in_len + 5;
  memcpy(data.bytes, in, in_len);
 
  yrc = yh_send_secure_msg(session, YHC_SIGN_SSH_CERTIFICATE, data.buf,
                           data_len, &response_cmd, out, out_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send SIGN SSH CERTIFICATE command: %s",
            yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(out[0]);
    DBG_ERR("Unable to get certificate: %s (%x)", yh_strerror(translated),
            out[0]);
    return translated;
  }
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_unwrap_data()

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 )

Decrypt (unwrap) data using a YH_WRAP_KEY.

Parameters

session	Authenticated session to use
key_id	Object ID of the Wrap Key to use
in	Wrapped data
in_len	Length of wrapped data
out	Unwrapped data
out_len	Length of unwrapped data

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL or if in_len is too big. See yh_rc for other possible errors

Definition at line 3716 of file yubihsm.c.

                                           {
 
  if (session == NULL || in == NULL || out == NULL || out_len == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  if (in_len > YH_MSG_BUF_SIZE - 2) {
    DBG_ERR("Too much data, must be < %d", YH_MSG_BUF_SIZE - 2);
    return YHR_INVALID_PARAMETERS;
  }
 
  yh_rc yrc;
 
#pragma pack(push, 1)
  union {
    struct {
      uint16_t key_id;
      uint8_t bytes[YH_MSG_BUF_SIZE];
    };
    uint8_t buf[1];
  } data;
#pragma pack(pop)
  uint16_t data_len = in_len + 2;
 
  yh_cmd response_cmd;
 
  data.key_id = htons(key_id);
  memcpy(data.bytes, in, in_len);
 
  yrc = yh_send_secure_msg(session, YHC_UNWRAP_DATA, data.buf, data_len,
                           &response_cmd, out, out_len);
  insecure_memzero(data.buf, data_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send UNWRAP DATA command: %s", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(out[0]);
    DBG_ERR("Unable to get unwrapped data: %s (%x)", yh_strerror(translated),
            out[0]);
    return translated;
  }
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_verify_hmac()

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 )

Verify a generated HMAC

Parameters

session	Authenticated session to use
key_id	Object ID of the HMAC key
signature	HMAC signature (20, 32, 48 or 64 bytes)
signature_len	length of HMAC signature
data	data to verify
data_len	length of data to verify
verified	true if verification succeeded

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS input parameters are NULL or if signature_len + data_len is too long. See yh_rc for other possible errors

Definition at line 1939 of file yubihsm.c.

                                          {
 
  if (session == NULL || signature == NULL || data == NULL ||
      verified == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  if (data_len + signature_len > YH_MSG_BUF_SIZE - 2) {
    DBG_ERR("Too much data, must be < %d", YH_MSG_BUF_SIZE - 2);
    return YHR_INVALID_PARAMETERS;
  }
 
  yh_rc yrc;
 
  uint8_t cmd_data[YH_MSG_BUF_SIZE];
  int cmd_data_len;
 
  uint8_t response[3];
  size_t response_len = sizeof(response);
  yh_cmd response_cmd;
 
  key_id = htons(key_id);
 
  memcpy(cmd_data, (uint8_t *) &key_id, 2);
  cmd_data_len = 2;
  memcpy(cmd_data + cmd_data_len, signature, signature_len);
  cmd_data_len += signature_len;
  memcpy(cmd_data + cmd_data_len, data, data_len);
  cmd_data_len += data_len;
 
  yrc = yh_send_secure_msg(session, YHC_VERIFY_HMAC, cmd_data, cmd_data_len,
                           &response_cmd, response, &response_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send HMAC VERIFY command: %s", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(response[0]);
    DBG_ERR("Unable to verify data: %s (%x)", yh_strerror(translated),
            response[0]);
    return translated;
  }
 
  *verified = response[0];
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_util_wrap_data()

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 )

Encrypt (wrap) data using a YH_WRAP_KEY.

Parameters

session	Authenticated session to use
key_id	Object ID of the Wrap Key to use
in	Data to wrap
in_len	Length of data to wrap
out	Wrapped data
out_len	Length of the wrapped data

Returns

YHR_SUCCESS if successful. YHR_INVALID_PARAMETERS if input parameters are NULL or if in_len is too big. See yh_rc for other possible errors

Definition at line 3667 of file yubihsm.c.

                                                                      {
 
  if (session == NULL || in == NULL || out == NULL || out_len == NULL) {
    DBG_ERR("%s", yh_strerror(YHR_INVALID_PARAMETERS));
    return YHR_INVALID_PARAMETERS;
  }
 
  if (in_len > YH_MSG_BUF_SIZE - 2) {
    DBG_ERR("Too much data, must be < %d", YH_MSG_BUF_SIZE - 2);
    return YHR_INVALID_PARAMETERS;
  }
 
  yh_rc yrc;
 
#pragma pack(push, 1)
  union {
    struct {
      uint16_t key_id;
      uint8_t bytes[YH_MSG_BUF_SIZE];
    };
    uint8_t buf[1];
  } data;
#pragma pack(pop)
  uint16_t data_len = in_len + 2;
 
  yh_cmd response_cmd;
 
  data.key_id = htons(key_id);
  memcpy(data.bytes, in, in_len);
 
  yrc = yh_send_secure_msg(session, YHC_WRAP_DATA, data.buf, data_len,
                           &response_cmd, out, out_len);
  insecure_memzero(data.buf, data_len);
  if (yrc != YHR_SUCCESS) {
    DBG_ERR("Failed to send WRAP DATA command: %s", yh_strerror(yrc));
    return yrc;
  }
 
  if (response_cmd == YHC_ERROR) {
    yh_rc translated = translate_device_error(out[0]);
    DBG_ERR("Unable to get wrapped data: %s (%x)", yh_strerror(translated),
            out[0]);
    return translated;
  }
 
  return YHR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

yh_verify_logs()

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

Verify an array of log entries

Parameters

logs	Array of log entries
n_items	number of log entries
last_previous_log	Optional pointer to the entry before the first entry in logs

Returns

True if verification succeeds. False otherwise

See also

Logs

Definition at line 4480 of file yubihsm.c.

                                                     {
  if (logs == NULL || n_items == 0) {
    return false;
  }
 
  hash_ctx hashctx = NULL;
  uint8_t previous_hash[32];
  size_t previous_hash_len = 32;
  int start;
  bool ret = false;
 
  if (!hash_create(&hashctx, _SHA256)) {
    return false;
  }
 
  if (last_previous_log != NULL) {
    memcpy(previous_hash, last_previous_log->digest, YH_LOG_DIGEST_SIZE);
    start = 0;
  } else {
    memcpy(previous_hash, logs[0].digest, YH_LOG_DIGEST_SIZE);
    start = 1;
  }
 
  for (uint16_t i = start; i < n_items; i++) {
    yh_log_entry inverted;
    inverted.number = htons(logs[i].number);
    inverted.command = logs[i].command;
    inverted.length = htons(logs[i].length);
    inverted.session_key = htons(logs[i].session_key);
    inverted.target_key = htons(logs[i].target_key);
    inverted.second_key = htons(logs[i].second_key);
    inverted.result = logs[i].result;
    inverted.systick = htonl(logs[i].systick);
 
    hash_init(hashctx);
    hash_update(hashctx, (const uint8_t *) &inverted,
                sizeof(yh_log_entry) - YH_LOG_DIGEST_SIZE);
    hash_update(hashctx, previous_hash, YH_LOG_DIGEST_SIZE);
    hash_final(hashctx, previous_hash, &previous_hash_len);
 
    if (memcmp(logs[i].digest, previous_hash, YH_LOG_DIGEST_SIZE) != 0) {
      goto out;
    }
  }
 
  ret = true;
 
out:
  hash_destroy(hashctx);
  hashctx = NULL;
 
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

YH_INTERNAL

FILE* _yh_output YH_INTERNAL = 0

Definition at line 57 of file yubihsm.c.