cipher.h

Go to the documentation of this file.

/*
 * Copyright (c) 2016 Intel Corporation.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_CRYPTO_CIPHER_H_
#define ZEPHYR_INCLUDE_CRYPTO_CIPHER_H_
 
#include <device.h>
#include <errno.h>
#include <sys/util.h>
#include <sys/__assert.h>
#include "cipher_structs.h"
 
/* The API a crypto driver should implement */
__subsystem struct crypto_driver_api {
        int (*query_hw_caps)(const struct device *dev);
 
        /* Setup a crypto session */
        int (*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 (*free_session)(const struct device *dev, struct cipher_ctx *ctx);
 
        /* Register async crypto op completion callback with the driver */
        int (*crypto_async_callback_set)(const struct device *dev,
                                         crypto_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 cipher_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->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->free_session(dev, ctx);
}
 
static inline int cipher_callback_set(const struct device *dev,
                                      crypto_completion_cb cb)
{
        struct crypto_driver_api *api;
 
        api = (struct crypto_driver_api *) dev->api;
 
        if (api->crypto_async_callback_set) {
                return api->crypto_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);
}
 
#endif /* ZEPHYR_INCLUDE_CRYPTO_CIPHER_H_ */