Merge tag 'clk-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git...

[linux.git] / crypto / adiantum.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Adiantum length-preserving encryption mode
 *
 * Copyright 2018 Google LLC
 */

/*
 * Adiantum is a tweakable, length-preserving encryption mode designed for fast
 * and secure disk encryption, especially on CPUs without dedicated crypto
 * instructions.  Adiantum encrypts each sector using the XChaCha12 stream
 * cipher, two passes of an ε-almost-∆-universal (ε-∆U) hash function based on
 * NH and Poly1305, and an invocation of the AES-256 block cipher on a single
 * 16-byte block.  See the paper for details:
 *
 *      Adiantum: length-preserving encryption for entry-level processors
 *      (https://eprint.iacr.org/2018/720.pdf)
 *
 * For flexibility, this implementation also allows other ciphers:
 *
 *      - Stream cipher: XChaCha12 or XChaCha20
 *      - Block cipher: any with a 128-bit block size and 256-bit key
 *
 * This implementation doesn't currently allow other ε-∆U hash functions, i.e.
 * HPolyC is not supported.  This is because Adiantum is ~20% faster than HPolyC
 * but still provably as secure, and also the ε-∆U hash function of HBSH is
 * formally defined to take two inputs (tweak, message) which makes it difficult
 * to wrap with the crypto_shash API.  Rather, some details need to be handled
 * here.  Nevertheless, if needed in the future, support for other ε-∆U hash
 * functions could be added here.
 */

#include <crypto/b128ops.h>
#include <crypto/chacha.h>
#include <crypto/internal/cipher.h>
#include <crypto/internal/hash.h>
#include <crypto/internal/poly1305.h>
#include <crypto/internal/skcipher.h>
#include <crypto/nhpoly1305.h>
#include <crypto/scatterwalk.h>
#include <linux/module.h>

/*
 * Size of right-hand part of input data, in bytes; also the size of the block
 * cipher's block size and the hash function's output.
 */
#define BLOCKCIPHER_BLOCK_SIZE          16

/* Size of the block cipher key (K_E) in bytes */
#define BLOCKCIPHER_KEY_SIZE            32

/* Size of the hash key (K_H) in bytes */
#define HASH_KEY_SIZE           (POLY1305_BLOCK_SIZE + NHPOLY1305_KEY_SIZE)

/*
 * The specification allows variable-length tweaks, but Linux's crypto API
 * currently only allows algorithms to support a single length.  The "natural"
 * tweak length for Adiantum is 16, since that fits into one Poly1305 block for
 * the best performance.  But longer tweaks are useful for fscrypt, to avoid
 * needing to derive per-file keys.  So instead we use two blocks, or 32 bytes.
 */
#define TWEAK_SIZE              32

struct adiantum_instance_ctx {
        struct crypto_skcipher_spawn streamcipher_spawn;
        struct crypto_cipher_spawn blockcipher_spawn;
        struct crypto_shash_spawn hash_spawn;
};

struct adiantum_tfm_ctx {
        struct crypto_skcipher *streamcipher;
        struct crypto_cipher *blockcipher;
        struct crypto_shash *hash;
        struct poly1305_core_key header_hash_key;
};

struct adiantum_request_ctx {

        /*
         * Buffer for right-hand part of data, i.e.
         *
         *    P_L => P_M => C_M => C_R when encrypting, or
         *    C_R => C_M => P_M => P_L when decrypting.
         *
         * Also used to build the IV for the stream cipher.
         */
        union {
                u8 bytes[XCHACHA_IV_SIZE];
                __le32 words[XCHACHA_IV_SIZE / sizeof(__le32)];
                le128 bignum;   /* interpret as element of Z/(2^{128}Z) */
        } rbuf;

        bool enc; /* true if encrypting, false if decrypting */

        /*
         * The result of the Poly1305 ε-∆U hash function applied to
         * (bulk length, tweak)
         */
        le128 header_hash;

        /* Sub-requests, must be last */
        union {
                struct shash_desc hash_desc;
                struct skcipher_request streamcipher_req;
        } u;
};

/*
 * Given the XChaCha stream key K_S, derive the block cipher key K_E and the
 * hash key K_H as follows:
 *
 *     K_E || K_H || ... = XChaCha(key=K_S, nonce=1||0^191)
 *
 * Note that this denotes using bits from the XChaCha keystream, which here we
 * get indirectly by encrypting a buffer containing all 0's.
 */
static int adiantum_setkey(struct crypto_skcipher *tfm, const u8 *key,
                           unsigned int keylen)
{
        struct adiantum_tfm_ctx *tctx = crypto_skcipher_ctx(tfm);
        struct {
                u8 iv[XCHACHA_IV_SIZE];
                u8 derived_keys[BLOCKCIPHER_KEY_SIZE + HASH_KEY_SIZE];
                struct scatterlist sg;
                struct crypto_wait wait;
                struct skcipher_request req; /* must be last */
        } *data;
        u8 *keyp;
        int err;

        /* Set the stream cipher key (K_S) */
        crypto_skcipher_clear_flags(tctx->streamcipher, CRYPTO_TFM_REQ_MASK);
        crypto_skcipher_set_flags(tctx->streamcipher,
                                  crypto_skcipher_get_flags(tfm) &
                                  CRYPTO_TFM_REQ_MASK);
        err = crypto_skcipher_setkey(tctx->streamcipher, key, keylen);
        if (err)
                return err;

        /* Derive the subkeys */
        data = kzalloc(sizeof(*data) +
                       crypto_skcipher_reqsize(tctx->streamcipher), GFP_KERNEL);
        if (!data)
                return -ENOMEM;
        data->iv[0] = 1;
        sg_init_one(&data->sg, data->derived_keys, sizeof(data->derived_keys));
        crypto_init_wait(&data->wait);
        skcipher_request_set_tfm(&data->req, tctx->streamcipher);
        skcipher_request_set_callback(&data->req, CRYPTO_TFM_REQ_MAY_SLEEP |
                                                  CRYPTO_TFM_REQ_MAY_BACKLOG,
                                      crypto_req_done, &data->wait);
        skcipher_request_set_crypt(&data->req, &data->sg, &data->sg,
                                   sizeof(data->derived_keys), data->iv);
        err = crypto_wait_req(crypto_skcipher_encrypt(&data->req), &data->wait);
        if (err)
                goto out;
        keyp = data->derived_keys;

        /* Set the block cipher key (K_E) */
        crypto_cipher_clear_flags(tctx->blockcipher, CRYPTO_TFM_REQ_MASK);
        crypto_cipher_set_flags(tctx->blockcipher,
                                crypto_skcipher_get_flags(tfm) &
                                CRYPTO_TFM_REQ_MASK);
        err = crypto_cipher_setkey(tctx->blockcipher, keyp,
                                   BLOCKCIPHER_KEY_SIZE);
        if (err)
                goto out;
        keyp += BLOCKCIPHER_KEY_SIZE;

        /* Set the hash key (K_H) */
        poly1305_core_setkey(&tctx->header_hash_key, keyp);
        keyp += POLY1305_BLOCK_SIZE;

        crypto_shash_clear_flags(tctx->hash, CRYPTO_TFM_REQ_MASK);
        crypto_shash_set_flags(tctx->hash, crypto_skcipher_get_flags(tfm) &
                                           CRYPTO_TFM_REQ_MASK);
        err = crypto_shash_setkey(tctx->hash, keyp, NHPOLY1305_KEY_SIZE);
        keyp += NHPOLY1305_KEY_SIZE;
        WARN_ON(keyp != &data->derived_keys[ARRAY_SIZE(data->derived_keys)]);
out:
        kfree_sensitive(data);
        return err;
}

/* Addition in Z/(2^{128}Z) */
static inline void le128_add(le128 *r, const le128 *v1, const le128 *v2)
{
        u64 x = le64_to_cpu(v1->b);
        u64 y = le64_to_cpu(v2->b);

        r->b = cpu_to_le64(x + y);
        r->a = cpu_to_le64(le64_to_cpu(v1->a) + le64_to_cpu(v2->a) +
                           (x + y < x));
}

/* Subtraction in Z/(2^{128}Z) */
static inline void le128_sub(le128 *r, const le128 *v1, const le128 *v2)
{
        u64 x = le64_to_cpu(v1->b);
        u64 y = le64_to_cpu(v2->b);

        r->b = cpu_to_le64(x - y);
        r->a = cpu_to_le64(le64_to_cpu(v1->a) - le64_to_cpu(v2->a) -
                           (x - y > x));
}

/*
 * Apply the Poly1305 ε-∆U hash function to (bulk length, tweak) and save the
 * result to rctx->header_hash.  This is the calculation
 *
 *      H_T ← Poly1305_{K_T}(bin_{128}(|L|) || T)
 *
 * from the procedure in section 6.4 of the Adiantum paper.  The resulting value
 * is reused in both the first and second hash steps.  Specifically, it's added
 * to the result of an independently keyed ε-∆U hash function (for equal length
 * inputs only) taken over the left-hand part (the "bulk") of the message, to
 * give the overall Adiantum hash of the (tweak, left-hand part) pair.
 */
static void adiantum_hash_header(struct skcipher_request *req)
{
        struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
        const struct adiantum_tfm_ctx *tctx = crypto_skcipher_ctx(tfm);
        struct adiantum_request_ctx *rctx = skcipher_request_ctx(req);
        const unsigned int bulk_len = req->cryptlen - BLOCKCIPHER_BLOCK_SIZE;
        struct {
                __le64 message_bits;
                __le64 padding;
        } header = {
                .message_bits = cpu_to_le64((u64)bulk_len * 8)
        };
        struct poly1305_state state;

        poly1305_core_init(&state);

        BUILD_BUG_ON(sizeof(header) % POLY1305_BLOCK_SIZE != 0);
        poly1305_core_blocks(&state, &tctx->header_hash_key,
                             &header, sizeof(header) / POLY1305_BLOCK_SIZE, 1);

        BUILD_BUG_ON(TWEAK_SIZE % POLY1305_BLOCK_SIZE != 0);
        poly1305_core_blocks(&state, &tctx->header_hash_key, req->iv,
                             TWEAK_SIZE / POLY1305_BLOCK_SIZE, 1);

        poly1305_core_emit(&state, NULL, &rctx->header_hash);
}

/* Hash the left-hand part (the "bulk") of the message using NHPoly1305 */
static int adiantum_hash_message(struct skcipher_request *req,
                                 struct scatterlist *sgl, unsigned int nents,
                                 le128 *digest)
{
        struct adiantum_request_ctx *rctx = skcipher_request_ctx(req);
        const unsigned int bulk_len = req->cryptlen - BLOCKCIPHER_BLOCK_SIZE;
        struct shash_desc *hash_desc = &rctx->u.hash_desc;
        struct sg_mapping_iter miter;
        unsigned int i, n;
        int err;

        err = crypto_shash_init(hash_desc);
        if (err)
                return err;

        sg_miter_start(&miter, sgl, nents, SG_MITER_FROM_SG | SG_MITER_ATOMIC);
        for (i = 0; i < bulk_len; i += n) {
                sg_miter_next(&miter);
                n = min_t(unsigned int, miter.length, bulk_len - i);
                err = crypto_shash_update(hash_desc, miter.addr, n);
                if (err)
                        break;
        }
        sg_miter_stop(&miter);
        if (err)
                return err;

        return crypto_shash_final(hash_desc, (u8 *)digest);
}

/* Continue Adiantum encryption/decryption after the stream cipher step */
static int adiantum_finish(struct skcipher_request *req)
{
        struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
        const struct adiantum_tfm_ctx *tctx = crypto_skcipher_ctx(tfm);
        struct adiantum_request_ctx *rctx = skcipher_request_ctx(req);
        const unsigned int bulk_len = req->cryptlen - BLOCKCIPHER_BLOCK_SIZE;
        struct scatterlist *dst = req->dst;
        const unsigned int dst_nents = sg_nents(dst);
        le128 digest;
        int err;

        /* If decrypting, decrypt C_M with the block cipher to get P_M */
        if (!rctx->enc)
                crypto_cipher_decrypt_one(tctx->blockcipher, rctx->rbuf.bytes,
                                          rctx->rbuf.bytes);

        /*
         * Second hash step
         *      enc: C_R = C_M - H_{K_H}(T, C_L)
         *      dec: P_R = P_M - H_{K_H}(T, P_L)
         */
        rctx->u.hash_desc.tfm = tctx->hash;
        le128_sub(&rctx->rbuf.bignum, &rctx->rbuf.bignum, &rctx->header_hash);
        if (dst_nents == 1 && dst->offset + req->cryptlen <= PAGE_SIZE) {
                /* Fast path for single-page destination */
                struct page *page = sg_page(dst);
                void *virt = kmap_local_page(page) + dst->offset;

                err = crypto_shash_digest(&rctx->u.hash_desc, virt, bulk_len,
                                          (u8 *)&digest);
                if (err) {
                        kunmap_local(virt);
                        return err;
                }
                le128_sub(&rctx->rbuf.bignum, &rctx->rbuf.bignum, &digest);
                memcpy(virt + bulk_len, &rctx->rbuf.bignum, sizeof(le128));
                flush_dcache_page(page);
                kunmap_local(virt);
        } else {
                /* Slow path that works for any destination scatterlist */
                err = adiantum_hash_message(req, dst, dst_nents, &digest);
                if (err)
                        return err;
                le128_sub(&rctx->rbuf.bignum, &rctx->rbuf.bignum, &digest);
                scatterwalk_map_and_copy(&rctx->rbuf.bignum, dst,
                                         bulk_len, sizeof(le128), 1);
        }
        return 0;
}

static void adiantum_streamcipher_done(void *data, int err)
{
        struct skcipher_request *req = data;

        if (!err)
                err = adiantum_finish(req);

        skcipher_request_complete(req, err);
}

static int adiantum_crypt(struct skcipher_request *req, bool enc)
{
        struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
        const struct adiantum_tfm_ctx *tctx = crypto_skcipher_ctx(tfm);
        struct adiantum_request_ctx *rctx = skcipher_request_ctx(req);
        const unsigned int bulk_len = req->cryptlen - BLOCKCIPHER_BLOCK_SIZE;
        struct scatterlist *src = req->src;
        const unsigned int src_nents = sg_nents(src);
        unsigned int stream_len;
        le128 digest;
        int err;

        if (req->cryptlen < BLOCKCIPHER_BLOCK_SIZE)
                return -EINVAL;

        rctx->enc = enc;

        /*
         * First hash step
         *      enc: P_M = P_R + H_{K_H}(T, P_L)
         *      dec: C_M = C_R + H_{K_H}(T, C_L)
         */
        adiantum_hash_header(req);
        rctx->u.hash_desc.tfm = tctx->hash;
        if (src_nents == 1 && src->offset + req->cryptlen <= PAGE_SIZE) {
                /* Fast path for single-page source */
                void *virt = kmap_local_page(sg_page(src)) + src->offset;

                err = crypto_shash_digest(&rctx->u.hash_desc, virt, bulk_len,
                                          (u8 *)&digest);
                memcpy(&rctx->rbuf.bignum, virt + bulk_len, sizeof(le128));
                kunmap_local(virt);
        } else {
                /* Slow path that works for any source scatterlist */
                err = adiantum_hash_message(req, src, src_nents, &digest);
                scatterwalk_map_and_copy(&rctx->rbuf.bignum, src,
                                         bulk_len, sizeof(le128), 0);
        }
        if (err)
                return err;
        le128_add(&rctx->rbuf.bignum, &rctx->rbuf.bignum, &rctx->header_hash);
        le128_add(&rctx->rbuf.bignum, &rctx->rbuf.bignum, &digest);

        /* If encrypting, encrypt P_M with the block cipher to get C_M */
        if (enc)
                crypto_cipher_encrypt_one(tctx->blockcipher, rctx->rbuf.bytes,
                                          rctx->rbuf.bytes);

        /* Initialize the rest of the XChaCha IV (first part is C_M) */
        BUILD_BUG_ON(BLOCKCIPHER_BLOCK_SIZE != 16);
        BUILD_BUG_ON(XCHACHA_IV_SIZE != 32);    /* nonce || stream position */
        rctx->rbuf.words[4] = cpu_to_le32(1);
        rctx->rbuf.words[5] = 0;
        rctx->rbuf.words[6] = 0;
        rctx->rbuf.words[7] = 0;

        /*
         * XChaCha needs to be done on all the data except the last 16 bytes;
         * for disk encryption that usually means 4080 or 496 bytes.  But ChaCha
         * implementations tend to be most efficient when passed a whole number
         * of 64-byte ChaCha blocks, or sometimes even a multiple of 256 bytes.
         * And here it doesn't matter whether the last 16 bytes are written to,
         * as the second hash step will overwrite them.  Thus, round the XChaCha
         * length up to the next 64-byte boundary if possible.
         */
        stream_len = bulk_len;
        if (round_up(stream_len, CHACHA_BLOCK_SIZE) <= req->cryptlen)
                stream_len = round_up(stream_len, CHACHA_BLOCK_SIZE);

        skcipher_request_set_tfm(&rctx->u.streamcipher_req, tctx->streamcipher);
        skcipher_request_set_crypt(&rctx->u.streamcipher_req, req->src,
                                   req->dst, stream_len, &rctx->rbuf);
        skcipher_request_set_callback(&rctx->u.streamcipher_req,
                                      req->base.flags,
                                      adiantum_streamcipher_done, req);
        return crypto_skcipher_encrypt(&rctx->u.streamcipher_req) ?:
                adiantum_finish(req);
}

static int adiantum_encrypt(struct skcipher_request *req)
{
        return adiantum_crypt(req, true);
}

static int adiantum_decrypt(struct skcipher_request *req)
{
        return adiantum_crypt(req, false);
}

static int adiantum_init_tfm(struct crypto_skcipher *tfm)
{
        struct skcipher_instance *inst = skcipher_alg_instance(tfm);
        struct adiantum_instance_ctx *ictx = skcipher_instance_ctx(inst);
        struct adiantum_tfm_ctx *tctx = crypto_skcipher_ctx(tfm);
        struct crypto_skcipher *streamcipher;
        struct crypto_cipher *blockcipher;
        struct crypto_shash *hash;
        unsigned int subreq_size;
        int err;

        streamcipher = crypto_spawn_skcipher(&ictx->streamcipher_spawn);
        if (IS_ERR(streamcipher))
                return PTR_ERR(streamcipher);

        blockcipher = crypto_spawn_cipher(&ictx->blockcipher_spawn);
        if (IS_ERR(blockcipher)) {
                err = PTR_ERR(blockcipher);
                goto err_free_streamcipher;
        }

        hash = crypto_spawn_shash(&ictx->hash_spawn);
        if (IS_ERR(hash)) {
                err = PTR_ERR(hash);
                goto err_free_blockcipher;
        }

        tctx->streamcipher = streamcipher;
        tctx->blockcipher = blockcipher;
        tctx->hash = hash;

        BUILD_BUG_ON(offsetofend(struct adiantum_request_ctx, u) !=
                     sizeof(struct adiantum_request_ctx));
        subreq_size = max(sizeof_field(struct adiantum_request_ctx,
                                       u.hash_desc) +
                          crypto_shash_descsize(hash),
                          sizeof_field(struct adiantum_request_ctx,
                                       u.streamcipher_req) +
                          crypto_skcipher_reqsize(streamcipher));

        crypto_skcipher_set_reqsize(tfm,
                                    offsetof(struct adiantum_request_ctx, u) +
                                    subreq_size);
        return 0;

err_free_blockcipher:
        crypto_free_cipher(blockcipher);
err_free_streamcipher:
        crypto_free_skcipher(streamcipher);
        return err;
}

static void adiantum_exit_tfm(struct crypto_skcipher *tfm)
{
        struct adiantum_tfm_ctx *tctx = crypto_skcipher_ctx(tfm);

        crypto_free_skcipher(tctx->streamcipher);
        crypto_free_cipher(tctx->blockcipher);
        crypto_free_shash(tctx->hash);
}

static void adiantum_free_instance(struct skcipher_instance *inst)
{
        struct adiantum_instance_ctx *ictx = skcipher_instance_ctx(inst);

        crypto_drop_skcipher(&ictx->streamcipher_spawn);
        crypto_drop_cipher(&ictx->blockcipher_spawn);
        crypto_drop_shash(&ictx->hash_spawn);
        kfree(inst);
}

/*
 * Check for a supported set of inner algorithms.
 * See the comment at the beginning of this file.
 */
static bool adiantum_supported_algorithms(struct skcipher_alg_common *streamcipher_alg,
                                          struct crypto_alg *blockcipher_alg,
                                          struct shash_alg *hash_alg)
{
        if (strcmp(streamcipher_alg->base.cra_name, "xchacha12") != 0 &&
            strcmp(streamcipher_alg->base.cra_name, "xchacha20") != 0)
                return false;

        if (blockcipher_alg->cra_cipher.cia_min_keysize > BLOCKCIPHER_KEY_SIZE ||
            blockcipher_alg->cra_cipher.cia_max_keysize < BLOCKCIPHER_KEY_SIZE)
                return false;
        if (blockcipher_alg->cra_blocksize != BLOCKCIPHER_BLOCK_SIZE)
                return false;

        if (strcmp(hash_alg->base.cra_name, "nhpoly1305") != 0)
                return false;

        return true;
}

static int adiantum_create(struct crypto_template *tmpl, struct rtattr **tb)
{
        u32 mask;
        const char *nhpoly1305_name;
        struct skcipher_instance *inst;
        struct adiantum_instance_ctx *ictx;
        struct skcipher_alg_common *streamcipher_alg;
        struct crypto_alg *blockcipher_alg;
        struct shash_alg *hash_alg;
        int err;

        err = crypto_check_attr_type(tb, CRYPTO_ALG_TYPE_SKCIPHER, &mask);
        if (err)
                return err;

        inst = kzalloc(sizeof(*inst) + sizeof(*ictx), GFP_KERNEL);
        if (!inst)
                return -ENOMEM;
        ictx = skcipher_instance_ctx(inst);

        /* Stream cipher, e.g. "xchacha12" */
        err = crypto_grab_skcipher(&ictx->streamcipher_spawn,
                                   skcipher_crypto_instance(inst),
                                   crypto_attr_alg_name(tb[1]), 0, mask);
        if (err)
                goto err_free_inst;
        streamcipher_alg = crypto_spawn_skcipher_alg_common(&ictx->streamcipher_spawn);

        /* Block cipher, e.g. "aes" */
        err = crypto_grab_cipher(&ictx->blockcipher_spawn,
                                 skcipher_crypto_instance(inst),
                                 crypto_attr_alg_name(tb[2]), 0, mask);
        if (err)
                goto err_free_inst;
        blockcipher_alg = crypto_spawn_cipher_alg(&ictx->blockcipher_spawn);

        /* NHPoly1305 ε-∆U hash function */
        nhpoly1305_name = crypto_attr_alg_name(tb[3]);
        if (nhpoly1305_name == ERR_PTR(-ENOENT))
                nhpoly1305_name = "nhpoly1305";
        err = crypto_grab_shash(&ictx->hash_spawn,
                                skcipher_crypto_instance(inst),
                                nhpoly1305_name, 0, mask);
        if (err)
                goto err_free_inst;
        hash_alg = crypto_spawn_shash_alg(&ictx->hash_spawn);

        /* Check the set of algorithms */
        if (!adiantum_supported_algorithms(streamcipher_alg, blockcipher_alg,
                                           hash_alg)) {
                pr_warn("Unsupported Adiantum instantiation: (%s,%s,%s)\n",
                        streamcipher_alg->base.cra_name,
                        blockcipher_alg->cra_name, hash_alg->base.cra_name);
                err = -EINVAL;
                goto err_free_inst;
        }

        /* Instance fields */

        err = -ENAMETOOLONG;
        if (snprintf(inst->alg.base.cra_name, CRYPTO_MAX_ALG_NAME,
                     "adiantum(%s,%s)", streamcipher_alg->base.cra_name,
                     blockcipher_alg->cra_name) >= CRYPTO_MAX_ALG_NAME)
                goto err_free_inst;
        if (snprintf(inst->alg.base.cra_driver_name, CRYPTO_MAX_ALG_NAME,
                     "adiantum(%s,%s,%s)",
                     streamcipher_alg->base.cra_driver_name,
                     blockcipher_alg->cra_driver_name,
                     hash_alg->base.cra_driver_name) >= CRYPTO_MAX_ALG_NAME)
                goto err_free_inst;

        inst->alg.base.cra_blocksize = BLOCKCIPHER_BLOCK_SIZE;
        inst->alg.base.cra_ctxsize = sizeof(struct adiantum_tfm_ctx);
        inst->alg.base.cra_alignmask = streamcipher_alg->base.cra_alignmask;
        /*
         * The block cipher is only invoked once per message, so for long
         * messages (e.g. sectors for disk encryption) its performance doesn't
         * matter as much as that of the stream cipher and hash function.  Thus,
         * weigh the block cipher's ->cra_priority less.
         */
        inst->alg.base.cra_priority = (4 * streamcipher_alg->base.cra_priority +
                                       2 * hash_alg->base.cra_priority +
                                       blockcipher_alg->cra_priority) / 7;

        inst->alg.setkey = adiantum_setkey;
        inst->alg.encrypt = adiantum_encrypt;
        inst->alg.decrypt = adiantum_decrypt;
        inst->alg.init = adiantum_init_tfm;
        inst->alg.exit = adiantum_exit_tfm;
        inst->alg.min_keysize = streamcipher_alg->min_keysize;
        inst->alg.max_keysize = streamcipher_alg->max_keysize;
        inst->alg.ivsize = TWEAK_SIZE;

        inst->free = adiantum_free_instance;

        err = skcipher_register_instance(tmpl, inst);
        if (err) {
err_free_inst:
                adiantum_free_instance(inst);
        }
        return err;
}

/* adiantum(streamcipher_name, blockcipher_name [, nhpoly1305_name]) */
static struct crypto_template adiantum_tmpl = {
        .name = "adiantum",
        .create = adiantum_create,
        .module = THIS_MODULE,
};

static int __init adiantum_module_init(void)
{
        return crypto_register_template(&adiantum_tmpl);
}

static void __exit adiantum_module_exit(void)
{
        crypto_unregister_template(&adiantum_tmpl);
}

subsys_initcall(adiantum_module_init);
module_exit(adiantum_module_exit);

MODULE_DESCRIPTION("Adiantum length-preserving encryption mode");
MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("Eric Biggers <ebiggers@google.com>");
MODULE_ALIAS_CRYPTO("adiantum");
MODULE_IMPORT_NS("CRYPTO_INTERNAL");