linux-imx

/*

 * ChaCha and XChaCha stream ciphers, including ChaCha20 (RFC7539)

 *

 * Copyright (C) 2015 Martin Willi

 * Copyright (C) 2018 Google LLC

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 */

​

#include <asm/unaligned.h>

#include <crypto/algapi.h>

#include <crypto/chacha.h>

#include <crypto/internal/skcipher.h>

#include <linux/module.h>

​

static void chacha_docrypt(u32 *state, u8 *dst, const u8 *src,

               unsigned int bytes, int nrounds)

{

    /* aligned to potentially speed up crypto_xor() */

    u8 stream[CHACHA_BLOCK_SIZE] __aligned(sizeof(long));

​

    if (dst != src)

        memcpy(dst, src, bytes);

​

    while (bytes >= CHACHA_BLOCK_SIZE) {

        chacha_block(state, stream, nrounds);

        crypto_xor(dst, stream, CHACHA_BLOCK_SIZE);

        bytes -= CHACHA_BLOCK_SIZE;

        dst += CHACHA_BLOCK_SIZE;

    }

    if (bytes) {

        chacha_block(state, stream, nrounds);

        crypto_xor(dst, stream, bytes);

    }

}

​

static int chacha_stream_xor(struct skcipher_request *req,

                 struct chacha_ctx *ctx, u8 *iv)

{

    struct skcipher_walk walk;

    u32 state[16];

    int err;

​

    err = skcipher_walk_virt(&walk, req, false);

​

    crypto_chacha_init(state, ctx, iv);

​

    while (walk.nbytes > 0) {

        unsigned int nbytes = walk.nbytes;

​

        if (nbytes < walk.total)

            nbytes = round_down(nbytes, walk.stride);

​

        chacha_docrypt(state, walk.dst.virt.addr, walk.src.virt.addr,

                   nbytes, ctx->nrounds);

        err = skcipher_walk_done(&walk, walk.nbytes - nbytes);

    }

​

    return err;

}

​

void crypto_chacha_init(u32 *state, struct chacha_ctx *ctx, u8 *iv)

{

    state[0]  = 0x61707865; /* "expa" */

    state[1]  = 0x3320646e; /* "nd 3" */

    state[2]  = 0x79622d32; /* "2-by" */

    state[3]  = 0x6b206574; /* "te k" */

    state[4]  = ctx->key[0];

    state[5]  = ctx->key[1];

    state[6]  = ctx->key[2];

    state[7]  = ctx->key[3];

    state[8]  = ctx->key[4];

    state[9]  = ctx->key[5];

    state[10] = ctx->key[6];

    state[11] = ctx->key[7];

    state[12] = get_unaligned_le32(iv +  0);

    state[13] = get_unaligned_le32(iv +  4);

    state[14] = get_unaligned_le32(iv +  8);

    state[15] = get_unaligned_le32(iv + 12);

}

EXPORT_SYMBOL_GPL(crypto_chacha_init);

​

static int chacha_setkey(struct crypto_skcipher *tfm, const u8 *key,

             unsigned int keysize, int nrounds)

{

    struct chacha_ctx *ctx = crypto_skcipher_ctx(tfm);

    int i;

​

    if (keysize != CHACHA_KEY_SIZE)