linux-imx

// SPDX-License-Identifier: GPL-2.0-or-later

/*

 * The AEGIS-256 Authenticated-Encryption Algorithm

 *

 * Copyright (c) 2017-2018 Ondrej Mosnacek <omosnacek@gmail.com>

 * Copyright (C) 2017-2018 Red Hat, Inc. All rights reserved.

 */

​

#include <crypto/algapi.h>

#include <crypto/internal/aead.h>

#include <crypto/internal/skcipher.h>

#include <crypto/scatterwalk.h>

#include <linux/err.h>

#include <linux/init.h>

#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/scatterlist.h>

​

#include "aegis.h"

​

#define AEGIS256_NONCE_SIZE 32

#define AEGIS256_STATE_BLOCKS 6

#define AEGIS256_KEY_SIZE 32

#define AEGIS256_MIN_AUTH_SIZE 8

#define AEGIS256_MAX_AUTH_SIZE 16

​

struct aegis_state {

    union aegis_block blocks[AEGIS256_STATE_BLOCKS];

};

​

struct aegis_ctx {

    union aegis_block key[AEGIS256_KEY_SIZE / AEGIS_BLOCK_SIZE];

};

​

struct aegis256_ops {

    int (*skcipher_walk_init)(struct skcipher_walk *walk,

                  struct aead_request *req, bool atomic);

​

    void (*crypt_chunk)(struct aegis_state *state, u8 *dst,

                const u8 *src, unsigned int size);

};

​

static void crypto_aegis256_update(struct aegis_state *state)

{

    union aegis_block tmp;

    unsigned int i;

​

    tmp = state->blocks[AEGIS256_STATE_BLOCKS - 1];

    for (i = AEGIS256_STATE_BLOCKS - 1; i > 0; i--)

        crypto_aegis_aesenc(&state->blocks[i], &state->blocks[i - 1],

                    &state->blocks[i]);

    crypto_aegis_aesenc(&state->blocks[0], &tmp, &state->blocks[0]);

}

​

static void crypto_aegis256_update_a(struct aegis_state *state,

                     const union aegis_block *msg)

{

    crypto_aegis256_update(state);

    crypto_aegis_block_xor(&state->blocks[0], msg);

}

​

static void crypto_aegis256_update_u(struct aegis_state *state, const void *msg)

{

    crypto_aegis256_update(state);

    crypto_xor(state->blocks[0].bytes, msg, AEGIS_BLOCK_SIZE);

}

​

static void crypto_aegis256_init(struct aegis_state *state,

                 const union aegis_block *key,

                 const u8 *iv)

{

    union aegis_block key_iv[2];

    unsigned int i;

​

    key_iv[0] = key[0];

    key_iv[1] = key[1];

    crypto_xor(key_iv[0].bytes, iv + 0 * AEGIS_BLOCK_SIZE,

            AEGIS_BLOCK_SIZE);

    crypto_xor(key_iv[1].bytes, iv + 1 * AEGIS_BLOCK_SIZE,

            AEGIS_BLOCK_SIZE);

​

    state->blocks[0] = key_iv[0];

    state->blocks[1] = key_iv[1];

    state->blocks[2] = crypto_aegis_const[1];

    state->blocks[3] = crypto_aegis_const[0];

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

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

​

    crypto_aegis_block_xor(&state->blocks[4], &crypto_aegis_const[0]);

    crypto_aegis_block_xor(&state->blocks[5], &crypto_aegis_const[1]);

​

    for (i = 0; i < 4; i++) {