path: root/ks.h

/*
 * ks.h
 * ----
 * Keystore, generic parts anyway.  This is internal within libhal.
 *
 * Copyright (c) 2015-2017, NORDUnet A/S All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 * - Redistributions of source code must retain the above copyright notice,
 *   this list of conditions and the following disclaimer.
 *
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 *
 * - Neither the name of the NORDUnet nor the names of its contributors may
 *   be used to endorse or promote products derived from this software
 *   without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef _KS_H_
#define _KS_H_

#include "hal.h"
#include "hal_internal.h"

/*
 * Size of a keystore "block".
 *
 * This must be an integer multiple of the flash subsector size, among
 * other reasons because that's the minimum erasable unit.
 */

#ifndef HAL_KS_BLOCK_SIZE
#define HAL_KS_BLOCK_SIZE       (4096 * 2)
#endif

#if HAL_KS_WRAPPED_KEYSIZE + 8 > HAL_KS_BLOCK_SIZE
#warning HAL_KS_WRAPPED_KEYSIZE is too big for to fit in a keystore block
#endif

/*
 * PIN block gets the all-zeros UUID, which will never be returned by
 * the UUID generation code (by definition -- it's not a version 4 UUID).
 */

extern const hal_uuid_t hal_ks_pin_uuid;

/*
 * Known block states.
 *
 * C does not guarantee any particular representation for enums, so
 * including enums directly in the block header isn't safe.  Instead,
 * we use an access method which casts when reading from the header.
 * Writing to the header isn't a problem, because C does guarantee
 * that enum is compatible with *some* integer type, it just doesn't
 * specify which one.
 */

typedef enum {
  HAL_KS_BLOCK_TYPE_ERASED  = 0xFF, /* Pristine erased block (candidate for reuse) */
  HAL_KS_BLOCK_TYPE_ZEROED  = 0x00, /* Zeroed block (recently used) */
  HAL_KS_BLOCK_TYPE_KEY     = 0x55, /* Block contains key material */
  HAL_KS_BLOCK_TYPE_PIN     = 0xAA, /* Block contains PINs */
  HAL_KS_BLOCK_TYPE_UNKNOWN = -1,   /* Internal code for "I have no clue what this is" */
} hal_ks_block_type_t;

/*
 * Block status.
 */

typedef enum {
  HAL_KS_BLOCK_STATUS_LIVE      = 0x66, /* This is a live block */
  HAL_KS_BLOCK_STATUS_TOMBSTONE = 0x44, /* This is a tombstone left behind during an update  */
  HAL_KS_BLOCK_STATUS_UNKNOWN   = -1,   /* Internal code for "I have no clue what this is" */
} hal_ks_block_status_t;

/*
 * Common header for all keystore block types.  A few of these fields
 * are deliberately omitted from the CRC.
 *
 * The legacy_1 and legacy_2 fields were used in the more complex
 * "chunked" layout used in an earlier iteration of this keystore
 * design, which proved more complex than it was worth.  At the
 * moment, the only thing we do with these fields is include them in
 * the CRC and check them for allowed values, to avoid gratuitously
 * breaking backwards compatability with the earlier design.
 */

typedef struct {
  uint8_t               block_type;
  uint8_t               block_status;
  uint8_t               legacy_1;
  uint8_t               legacy_2;
  hal_crc32_t           crc;
} hal_ks_block_header_t;

/*
 * Key block.  Tail end of "der" field (after der_len) used for attributes.
 */

typedef struct {
  hal_ks_block_header_t header;
  hal_uuid_t            name;
  hal_key_type_t        type;
  hal_curve_name_t      curve;
  hal_key_flags_t       flags;
  size_t                der_len;
  unsigned              attributes_len;
  uint8_t               der[];  /* Must be last field -- C99 "flexible array member" */
} hal_ks_key_block_t;

#define SIZEOF_KS_KEY_BLOCK_DER                                 \
  (HAL_KS_BLOCK_SIZE - offsetof(hal_ks_key_block_t, der))

/*
 * PIN block.  Also includes space for backing up the KEK when
 * HAL_MKM_FLASH_BACKUP_KLUDGE is enabled.
 */

typedef struct {
  hal_ks_block_header_t header;
  hal_ks_pin_t          wheel_pin;
  hal_ks_pin_t          so_pin;
  hal_ks_pin_t          user_pin;
#if HAL_MKM_FLASH_BACKUP_KLUDGE
  uint32_t              kek_set;
  uint8_t               kek[KEK_LENGTH];
#endif
} hal_ks_pin_block_t;

#define FLASH_KEK_NOT_SET 0
#define FLASH_KEK_SET   0x33333333

/*
 * One keystore block.
 */

typedef union {
  uint8_t                   bytes[HAL_KS_BLOCK_SIZE];
  hal_ks_block_header_t     header;
  hal_ks_key_block_t   key;
  hal_ks_pin_block_t   pin;
} hal_ks_block_t;

/*
 * In-memory cache.
 */

typedef struct {
  unsigned              blockno;
  unsigned              lru;
  hal_ks_block_t        block;
} hal_ks_cache_block_t;

/*
 * Keystore object.  hal_internal.h typedefs this to hal_ks_t.
 *
 * We expect this to be a static variable, but we expect the arrays in
 * it to be allocated at runtime using hal_allocate_static_memory()
 * because they can get kind of large.
 *
 * Driver-specific stuff is handled by a form of subclassing: the
 * driver embeds the hal_ks_t structure at the head of whatever else
 * it needs, and performs (controlled, type-safe) casts as needed.
 *
 * Core of this is the keystore index.  This is intended to be usable
 * by both memory-based and flash-based keystores.  Some of the
 * features aren't necessary for memory-based keystores, but should be
 * harmless, and let us keep the drivers simple.
 *
 * General approach is multiple arrays, all but one of which are
 * indexed by "block" numbers, where a block number might be a slot in
 * yet another static array, the number of a flash sub-sector, or
 * whatever is the appropriate unit for holding one keystore record.
 *
 * The index array only contains block numbers.  This is a small data
 * structure so that moving data within it is relatively cheap.
 *
 * The index array is divided into two portions: the index proper, and
 * the free queue.  The index proper is ordered according to the names
 * (UUIDs) of the corresponding blocks; the free queue is a FIFO, to
 * support a simplistic form of wear leveling in flash-based keystores.
 *
 * Key names are kept in a separate array, indexed by block number.
 *
 * The all-zeros UUID, which (by definition) cannot be a valid key
 * UUID, is reserved for the (non-key) block used to stash PINs and
 * other small data which aren't really part of the keystore proper
 * but are kept with it because the keystore is the flash we have.
 *
 * Note that this API deliberately says nothing about how the keys
 * themselves are stored, that's up to the keystore driver.
 */

typedef struct hal_ks_driver hal_ks_driver_t;

struct hal_ks {
  const hal_ks_driver_t *driver;/* Must be first */
  unsigned size;                /* Blocks in keystore */
  unsigned used;                /* How many blocks are in use */
  uint16_t *index;              /* Index/freelist array */
  hal_uuid_t *names;            /* Keyname array */
  unsigned cache_lru;           /* Cache LRU counter */
  unsigned cache_size;          /* Size (how many blocks) in cache */
  hal_ks_cache_block_t *cache;  /* Cache */
};

/*
 * Keystore driver.
 */

struct hal_ks_driver {
  hal_error_t (*init)        (hal_ks_t *ks, const int alloc);
  hal_error_t (*read)        (hal_ks_t *ks, const unsigned blockno, hal_ks_block_t *block);
  hal_error_t (*write)       (hal_ks_t *ks, const unsigned blockno, hal_ks_block_t *block);
  hal_error_t (*deprecate)   (hal_ks_t *ks, const unsigned blockno);
  hal_error_t (*zero)        (hal_ks_t *ks, const unsigned blockno);
  hal_error_t (*erase)       (hal_ks_t *ks, const unsigned blockno);
  hal_error_t (*erase_maybe) (hal_ks_t *ks, const unsigned blockno);
  hal_error_t (*set_owner)   (hal_ks_t *ks, const unsigned blockno,
                              const hal_client_handle_t client, const hal_session_handle_t session);
  hal_error_t (*test_owner)  (hal_ks_t *ks, const unsigned blockno,
                              const hal_client_handle_t client, const hal_session_handle_t session);
  hal_error_t (*copy_owner)  (hal_ks_t *ks, const unsigned source, const unsigned target);
  hal_error_t (*logout)      (hal_ks_t *ks, const hal_client_handle_t client);
};

/*
 * Wrappers around keystore driver methods.
 *
 * hal_ks_init() and hal_ks_logout() are missing here because we
 * expose them to the rest of libhal.
 */

static inline hal_error_t hal_ks_block_read(hal_ks_t *ks, const unsigned blockno, hal_ks_block_t *block)
{
  return
    ks == NULL || ks->driver == NULL  ? HAL_ERROR_BAD_ARGUMENTS   :
    ks->driver->read == NULL          ? HAL_ERROR_NOT_IMPLEMENTED :
    ks->driver->read(ks, blockno, block);
}

static inline hal_error_t hal_ks_block_write(hal_ks_t *ks, const unsigned blockno, hal_ks_block_t *block)
{
  return
    ks == NULL || ks->driver == NULL  ? HAL_ERROR_BAD_ARGUMENTS   :
    ks->driver->write == NULL         ? HAL_ERROR_NOT_IMPLEMENTED :
    ks->driver->write(ks, blockno, block);
}

static inline hal_error_t hal_ks_block_deprecate(hal_ks_t *ks, const unsigned blockno)
{
  return
    ks == NULL || ks->driver == NULL  ? HAL_ERROR_BAD_ARGUMENTS   :
    ks->driver->deprecate == NULL     ? HAL_ERROR_NOT_IMPLEMENTED :
    ks->driver->deprecate(ks, blockno);
}

static inline hal_error_t hal_ks_block_zero(hal_ks_t *ks, const unsigned blockno)
{
  return
    ks == NULL || ks->driver == NULL  ? HAL_ERROR_BAD_ARGUMENTS   :
    ks->driver->zero == NULL          ? HAL_ERROR_NOT_IMPLEMENTED :
    ks->driver->zero(ks, blockno);
}

static inline hal_error_t hal_ks_block_erase(hal_ks_t *ks, const unsigned blockno)
{
  return
    ks == NULL || ks->driver == NULL  ? HAL_ERROR_BAD_ARGUMENTS   :
    ks->driver->erase == NULL         ? HAL_ERROR_NOT_IMPLEMENTED :
    ks->driver->erase(ks, blockno);
}

static inline hal_error_t hal_ks_block_erase_maybe(hal_ks_t *ks, const unsigned blockno)
{
  return
    ks == NULL || ks->driver == NULL  ? HAL_ERROR_BAD_ARGUMENTS   :
    ks->driver->erase_maybe == NULL   ? HAL_ERROR_NOT_IMPLEMENTED :
    ks->driver->erase_maybe(ks, blockno);
}

static inline hal_error_t hal_ks_block_set_owner(hal_ks_t *ks,
                                                 const unsigned blockno,
                                                 const hal_client_handle_t  client,
                                                 const hal_session_handle_t session)
{
  return
    ks == NULL || ks->driver == NULL  ? HAL_ERROR_BAD_ARGUMENTS   :
    ks->driver->set_owner == NULL     ? HAL_ERROR_NOT_IMPLEMENTED :
    ks->driver->set_owner(ks, blockno, client, session);
}

static inline hal_error_t hal_ks_block_test_owner(hal_ks_t *ks,
                                                  const unsigned blockno,
                                                  const hal_client_handle_t  client,
                                                  const hal_session_handle_t session)
{
  return
    ks == NULL || ks->driver == NULL  ? HAL_ERROR_BAD_ARGUMENTS   :
    ks->driver->test_owner == NULL    ? HAL_ERROR_NOT_IMPLEMENTED :
    ks->driver->test_owner(ks, blockno, client, session);
}

static inline hal_error_t hal_ks_block_copy_owner(hal_ks_t *ks,
                                                  const unsigned source,
                                                  const unsigned target)
{
  return
    ks == NULL || ks->driver == NULL  ? HAL_ERROR_BAD_ARGUMENTS   :
    ks->driver->copy_owner == NULL    ? HAL_ERROR_NOT_IMPLEMENTED :
    ks->driver->copy_owner(ks, source, target);
}

/*
 * Type safe casts.
 */

static inline hal_ks_block_type_t hal_ks_block_get_type(const hal_ks_block_t * const block)
{
  return block == NULL ? HAL_KS_BLOCK_TYPE_UNKNOWN :
    (hal_ks_block_type_t) block->header.block_type;
}

static inline hal_ks_block_status_t hal_ks_block_get_status(const hal_ks_block_t * const block)
{
  return block == NULL ? HAL_KS_BLOCK_STATUS_UNKNOWN :
    (hal_ks_block_status_t) block->header.block_status;
}

/*
 * Keystore utilities.  Some or all of these may end up static within ks.c.
 */

extern hal_error_t hal_ks_alloc_common(hal_ks_t *ks,
                                       const unsigned ks_blocks,
                                       const unsigned cache_blocks,
                                       void **extra,
                                       const size_t extra_len);

extern hal_error_t hal_ks_init_common(hal_ks_t *ks);

extern hal_crc32_t hal_ks_block_calculate_crc(const hal_ks_block_t * const block);

extern hal_error_t hal_ks_index_heapsort(hal_ks_t *ks);

extern hal_error_t hal_ks_index_find(hal_ks_t *ks,
                                     const hal_uuid_t * const name,
                                     unsigned *blockno,
                                     int *hint);

extern hal_error_t hal_ks_index_add(hal_ks_t *ks,
                                    const hal_uuid_t * const name,
                                    unsigned *blockno,
                                    int *hint);

extern hal_error_t hal_ks_index_delete(hal_ks_t *ks,
                                       const hal_uuid_t * const name,
                                       unsigned *blockno,
                                       int *hint);

extern hal_error_t hal_ks_index_replace(hal_ks_t *ks,
                                        const hal_uuid_t * const name,
                                        unsigned *blockno,
                                        int *hint);

extern hal_error_t hal_ks_index_fsck(hal_ks_t *ks);

extern const size_t hal_ks_attribute_header_size;

extern hal_error_t hal_ks_attribute_scan(const uint8_t * const bytes,
                                         const size_t bytes_len,
                                         hal_pkey_attribute_t *attributes,
                                         const unsigned attributes_len,
                                         size_t *total_len);

extern hal_error_t hal_ks_attribute_delete(uint8_t *bytes,
                                           const size_t bytes_len,
                                           hal_pkey_attribute_t *attributes,
                                           unsigned *attributes_len,
                                           size_t *total_len,
                                           const uint32_t type);

extern hal_error_t hal_ks_attribute_insert(uint8_t *bytes, const size_t bytes_len,
                                           hal_pkey_attribute_t *attributes,
                                           unsigned *attributes_len,
                                           size_t *total_len,
                                           const uint32_t type,
                                           const uint8_t * const value,
                                           const size_t value_len);

extern hal_ks_block_t *hal_ks_cache_pick_lru(hal_ks_t *ks);

extern hal_ks_block_t *hal_ks_cache_find_block(const hal_ks_t * const ks,
                                               const unsigned blockno);

extern void hal_ks_cache_mark_used(hal_ks_t *ks,
                                   const hal_ks_block_t * const block,
                                   const unsigned blockno);

extern void hal_ks_cache_release(hal_ks_t *ks,
                                 const hal_ks_block_t * const block);

extern hal_error_t hal_ks_block_read_cached(hal_ks_t *ks,
                                            const unsigned blockno,
                                            hal_ks_block_t **block);

extern hal_error_t hal_ks_block_update(hal_ks_t *ks,
                                       const unsigned b1,
                                       hal_ks_block_t *block,
                                       const hal_uuid_t * const uuid,
                                       int *hint);

extern hal_error_t hal_ks_available(hal_ks_t *ks, size_t *count);

#endif /* _KS_H_ */

/*
 * Local variables:
 * indent-tabs-mode: nil
 * End:
 */