crypto.h

Go to the documentation of this file.

/*
 * Copyright (c) 2016 Intel Corporation.
 *
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_CRYPTO_CRYPTO_H_
#define ZEPHYR_INCLUDE_CRYPTO_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"



#define CAP_OPAQUE_KEY_HNDL             BIT(0)

#define CAP_RAW_KEY                     BIT(1)

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



typedef int (*crypto_api_query_hw_caps)(const struct device *dev);

typedef int (*crypto_api_cipher_begin_session)(const struct device *dev, struct cipher_ctx *ctx,
                                               enum cipher_algo algo, enum cipher_mode mode,
                                               enum cipher_op op_type);

typedef int (*crypto_api_cipher_free_session)(const struct device *dev, struct cipher_ctx *ctx);

typedef int (*crypto_api_cipher_async_callback_set)(const struct device *dev,
                                                    cipher_completion_cb cb);

typedef int (*crypto_api_hash_begin_session)(const struct device *dev, struct hash_ctx *ctx,
                                             enum hash_algo algo);

typedef int (*crypto_api_hash_free_session)(const struct device *dev, struct hash_ctx *ctx);

typedef int (*crypto_api_hash_async_callback_set)(const struct device *dev, hash_completion_cb cb);

__subsystem struct crypto_driver_api {
        crypto_api_query_hw_caps query_hw_caps;

        crypto_api_cipher_begin_session cipher_begin_session;

        crypto_api_cipher_free_session cipher_free_session;

        crypto_api_cipher_async_callback_set cipher_async_callback_set;

        crypto_api_hash_begin_session hash_begin_session;

        crypto_api_hash_free_session hash_free_session;

        crypto_api_hash_async_callback_set hash_async_callback_set;
};

 
/* 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)
{
        const struct crypto_driver_api *api = DEVICE_API_GET(crypto, dev);
        int tmp;
 
        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)
{
        const struct crypto_driver_api *api = DEVICE_API_GET(crypto, dev);
        uint32_t flags;
 
        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)
{
        return DEVICE_API_GET(crypto, dev)->cipher_free_session(dev, ctx);
}

static inline int cipher_callback_set(const struct device *dev,
                                      cipher_completion_cb cb)
{
        const struct crypto_driver_api *api = DEVICE_API_GET(crypto, dev);
 
        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_cfb_op(struct cipher_ctx *ctx,
                                struct cipher_pkt *pkt, uint8_t *iv)
{
        __ASSERT(ctx->ops.cipher_mode == CRYPTO_CIPHER_MODE_CFB, "CFB mode "
                 "session invoking a different mode handler");
 
        pkt->ctx = ctx;
        return ctx->ops.cfb_crypt_hndlr(ctx, pkt, iv);
}

static inline int cipher_ofb_op(struct cipher_ctx *ctx,
                                struct cipher_pkt *pkt, uint8_t *iv)
{
        __ASSERT(ctx->ops.cipher_mode == CRYPTO_CIPHER_MODE_OFB, "OFB mode "
                 "session invoking a different mode handler");
 
        pkt->ctx = ctx;
        return ctx->ops.ofb_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)
{
        const struct crypto_driver_api *api = DEVICE_API_GET(crypto, dev);
        uint32_t flags;
 
        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)
{
        return DEVICE_API_GET(crypto, dev)->hash_free_session(dev, ctx);
}

static inline int hash_callback_set(const struct device *dev,
                                    hash_completion_cb cb)
{
        const struct crypto_driver_api *api = DEVICE_API_GET(crypto, dev);
 
        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_CRYPTO_H_ */