crypto.h

Go to the documentation of this file.

/*
 * Copyright (c) 2016 Intel Corporation.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_CRYPTO_H_
#define ZEPHYR_INCLUDE_CRYPTO_H_
 
#include <zephyr/device.h>
#include <errno.h>
#include <zephyr/sys/util.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/crypto/hash.h>
#include "cipher.h"
 
/* ctx.flags values. Not all drivers support all flags.
 * A user app can query the supported hw / driver
 * capabilities via provided API (crypto_query_hwcaps()), and choose a
 * supported config during the session setup.
 */
#define CAP_OPAQUE_KEY_HNDL BIT(0)
#define CAP_RAW_KEY BIT(1)
 
/* TBD to define */
#define CAP_KEY_LOADING_API BIT(2)
 
#define CAP_INPLACE_OPS BIT(3)
#define CAP_SEPARATE_IO_BUFS BIT(4)
 
#define CAP_SYNC_OPS BIT(5)
#define CAP_ASYNC_OPS BIT(6)
 
#define CAP_AUTONONCE BIT(7)
 
#define CAP_NO_IV_PREFIX BIT(8)
 
/* More flags to be added as necessary */
 
__subsystem struct crypto_driver_api {
 int (*query_hw_caps)(const struct device *dev);
 
 /* Setup a crypto session */
 int (*cipher_begin_session)(const struct device *dev, struct cipher_ctx *ctx,
 enum cipher_algo algo, enum cipher_mode mode,
 enum cipher_op op_type);
 
 /* Tear down an established session */
 int (*cipher_free_session)(const struct device *dev, struct cipher_ctx *ctx);
 
 /* Register async crypto op completion callback with the driver */
 int (*cipher_async_callback_set)(const struct device *dev,
 cipher_completion_cb cb);
 
 /* Setup a hash session */
 int (*hash_begin_session)(const struct device *dev, struct hash_ctx *ctx,
 enum hash_algo algo);
 /* Tear down an established hash session */
 int (*hash_free_session)(const struct device *dev, struct hash_ctx *ctx);
 /* Register async hash op completion callback with the driver */
 int (*hash_async_callback_set)(const struct device *dev,
 hash_completion_cb cb);
};
 
/* Following are the public API a user app may call.
 * The first two relate to crypto "session" setup / teardown. Further we
 * have four cipher mode specific (CTR, CCM, CBC ...) calls to perform the
 * actual crypto operation in the context of a session. Also we have an
 * API to provide the callback for async operations.
 */
 
static inline int crypto_query_hwcaps(const struct device *dev)
{
 struct crypto_driver_api *api;
 int tmp;
 
 api = (struct crypto_driver_api *) dev->api;
 
 tmp = api->query_hw_caps(dev);
 
 __ASSERT((tmp & (CAP_OPAQUE_KEY_HNDL | CAP_RAW_KEY)) != 0,
 "Driver should support at least one key type: RAW/Opaque");
 
 __ASSERT((tmp & (CAP_INPLACE_OPS | CAP_SEPARATE_IO_BUFS)) != 0,
 "Driver should support at least one IO buf type: Inplace/separate");
 
 __ASSERT((tmp & (CAP_SYNC_OPS | CAP_ASYNC_OPS)) != 0,
 "Driver should support at least one op-type: sync/async");
 return tmp;
 
}
 
static inline int cipher_begin_session(const struct device *dev,
 struct cipher_ctx *ctx,
 enum cipher_algo algo,
 enum cipher_mode mode,
 enum cipher_op optype)
{
 struct crypto_driver_api *api;
 uint32_t flags;
 
 api = (struct crypto_driver_api *) dev->api;
 ctx->device = dev;
 ctx->ops.cipher_mode = mode;
 
 flags = (ctx->flags & (CAP_OPAQUE_KEY_HNDL | CAP_RAW_KEY));
 __ASSERT(flags != 0U, "Keytype missing: RAW Key or OPAQUE handle");
 __ASSERT(flags != (CAP_OPAQUE_KEY_HNDL | CAP_RAW_KEY),
 "conflicting options for keytype");
 
 flags = (ctx->flags & (CAP_INPLACE_OPS | CAP_SEPARATE_IO_BUFS));
 __ASSERT(flags != 0U, "IO buffer type missing");
 __ASSERT(flags != (CAP_INPLACE_OPS | CAP_SEPARATE_IO_BUFS),
 "conflicting options for IO buffer type");
 
 flags = (ctx->flags & (CAP_SYNC_OPS | CAP_ASYNC_OPS));
 __ASSERT(flags != 0U, "sync/async type missing");
 __ASSERT(flags != (CAP_SYNC_OPS | CAP_ASYNC_OPS),
 "conflicting options for sync/async");
 
 return api->cipher_begin_session(dev, ctx, algo, mode, optype);
}
 
static inline int cipher_free_session(const struct device *dev,
 struct cipher_ctx *ctx)
{
 struct crypto_driver_api *api;
 
 api = (struct crypto_driver_api *) dev->api;
 
 return api->cipher_free_session(dev, ctx);
}
 
static inline int cipher_callback_set(const struct device *dev,
 cipher_completion_cb cb)
{
 struct crypto_driver_api *api;
 
 api = (struct crypto_driver_api *) dev->api;
 
 if (api->cipher_async_callback_set) {
 return api->cipher_async_callback_set(dev, cb);
 }
 
 return -ENOTSUP;
 
}
 
static inline int cipher_block_op(struct cipher_ctx *ctx,
 struct cipher_pkt *pkt)
{
 __ASSERT(ctx->ops.cipher_mode == CRYPTO_CIPHER_MODE_ECB, "ECB mode "
 "session invoking a different mode handler");
 
 pkt->ctx = ctx;
 return ctx->ops.block_crypt_hndlr(ctx, pkt);
}
 
static inline int cipher_cbc_op(struct cipher_ctx *ctx,
 struct cipher_pkt *pkt, uint8_t *iv)
{
 __ASSERT(ctx->ops.cipher_mode == CRYPTO_CIPHER_MODE_CBC, "CBC mode "
 "session invoking a different mode handler");
 
 pkt->ctx = ctx;
 return ctx->ops.cbc_crypt_hndlr(ctx, pkt, iv);
}
 
static inline int cipher_ctr_op(struct cipher_ctx *ctx,
 struct cipher_pkt *pkt, uint8_t *iv)
{
 __ASSERT(ctx->ops.cipher_mode == CRYPTO_CIPHER_MODE_CTR, "CTR mode "
 "session invoking a different mode handler");
 
 pkt->ctx = ctx;
 return ctx->ops.ctr_crypt_hndlr(ctx, pkt, iv);
}
 
static inline int cipher_ccm_op(struct cipher_ctx *ctx,
 struct cipher_aead_pkt *pkt, uint8_t *nonce)
{
 __ASSERT(ctx->ops.cipher_mode == CRYPTO_CIPHER_MODE_CCM, "CCM mode "
 "session invoking a different mode handler");
 
 pkt->pkt->ctx = ctx;
 return ctx->ops.ccm_crypt_hndlr(ctx, pkt, nonce);
}
 
static inline int cipher_gcm_op(struct cipher_ctx *ctx,
 struct cipher_aead_pkt *pkt, uint8_t *nonce)
{
 __ASSERT(ctx->ops.cipher_mode == CRYPTO_CIPHER_MODE_GCM, "GCM mode "
 "session invoking a different mode handler");
 
 pkt->pkt->ctx = ctx;
 return ctx->ops.gcm_crypt_hndlr(ctx, pkt, nonce);
}
 
 
static inline int hash_begin_session(const struct device *dev,
 struct hash_ctx *ctx,
 enum hash_algo algo)
{
 uint32_t flags;
 struct crypto_driver_api *api;
 
 api = (struct crypto_driver_api *) dev->api;
 ctx->device = dev;
 
 flags = (ctx->flags & (CAP_INPLACE_OPS | CAP_SEPARATE_IO_BUFS));
 __ASSERT(flags != 0U, "IO buffer type missing");
 __ASSERT(flags != (CAP_INPLACE_OPS | CAP_SEPARATE_IO_BUFS),
 "conflicting options for IO buffer type");
 
 flags = (ctx->flags & (CAP_SYNC_OPS | CAP_ASYNC_OPS));
 __ASSERT(flags != 0U, "sync/async type missing");
 __ASSERT(flags != (CAP_SYNC_OPS | CAP_ASYNC_OPS),
 "conflicting options for sync/async");
 
 
 return api->hash_begin_session(dev, ctx, algo);
}
 
static inline int hash_free_session(const struct device *dev,
 struct hash_ctx *ctx)
{
 struct crypto_driver_api *api;
 
 api = (struct crypto_driver_api *) dev->api;
 
 return api->hash_free_session(dev, ctx);
}
 
static inline int hash_callback_set(const struct device *dev,
 hash_completion_cb cb)
{
 struct crypto_driver_api *api;
 
 api = (struct crypto_driver_api *) dev->api;
 
 if (api->hash_async_callback_set) {
 return api->hash_async_callback_set(dev, cb);
 }
 
 return -ENOTSUP;
 
}
 
static inline int hash_compute(struct hash_ctx *ctx, struct hash_pkt *pkt)
{
 pkt->ctx = ctx;
 
 return ctx->hash_hndlr(ctx, pkt, true);
}
 
static inline int hash_update(struct hash_ctx *ctx, struct hash_pkt *pkt)
{
 pkt->ctx = ctx;
 
 return ctx->hash_hndlr(ctx, pkt, false);
}
 
#endif /* ZEPHYR_INCLUDE_CRYPTO_H_ */