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;
        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_ */