linux-imx

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

/*

 * The AEGIS-128L 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 AEGIS128L_CHUNK_BLOCKS 2

#define AEGIS128L_CHUNK_SIZE (AEGIS128L_CHUNK_BLOCKS * AEGIS_BLOCK_SIZE)

#define AEGIS128L_NONCE_SIZE 16

#define AEGIS128L_STATE_BLOCKS 8

#define AEGIS128L_KEY_SIZE 16

#define AEGIS128L_MIN_AUTH_SIZE 8

#define AEGIS128L_MAX_AUTH_SIZE 16

​

union aegis_chunk {

    union aegis_block blocks[AEGIS128L_CHUNK_BLOCKS];

    u8 bytes[AEGIS128L_CHUNK_SIZE];

};

​

struct aegis_state {

    union aegis_block blocks[AEGIS128L_STATE_BLOCKS];

};

​

struct aegis_ctx {

    union aegis_block key;

};

​

struct aegis128l_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_aegis128l_update(struct aegis_state *state)

{

    union aegis_block tmp;

    unsigned int i;

​

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

    for (i = AEGIS128L_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_aegis128l_update_a(struct aegis_state *state,

                      const union aegis_chunk *msg)

{

    crypto_aegis128l_update(state);

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

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

}

​

static void crypto_aegis128l_update_u(struct aegis_state *state,

                      const void *msg)

{

    crypto_aegis128l_update(state);

    crypto_xor(state->blocks[0].bytes, msg + 0 * AEGIS_BLOCK_SIZE,

            AEGIS_BLOCK_SIZE);

    crypto_xor(state->blocks[4].bytes, msg + 1 * AEGIS_BLOCK_SIZE,

            AEGIS_BLOCK_SIZE);

}

​

static void crypto_aegis128l_init(struct aegis_state *state,

                  const union aegis_block *key,

                  const u8 *iv)

{

    union aegis_block key_iv;

    union aegis_chunk chunk;

    unsigned int i;

​

    memcpy(chunk.blocks[0].bytes, iv, AEGIS_BLOCK_SIZE);

    chunk.blocks[1] = *key;

​

    key_iv = *key;

    crypto_aegis_block_xor(&key_iv, &chunk.blocks[0]);