LXR linux/arch/x86/crypto/serpent_avx

   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 * Glue Code for AVX assembler versions of Serpent Cipher
   4 *
   5 * Copyright (C) 2012 Johannes Goetzfried
   6 *     <Johannes.Goetzfried@informatik.stud.uni-erlangen.de>
   7 *
   8 * Copyright © 2011-2013 Jussi Kivilinna <jussi.kivilinna@iki.fi>
   9 */
  10
  11#include <linux/module.h>
  12#include <linux/types.h>
  13#include <linux/crypto.h>
  14#include <linux/err.h>
  15#include <crypto/algapi.h>
  16#include <crypto/internal/simd.h>
  17#include <crypto/serpent.h>
  18
  19#include "serpent-avx.h"
  20#include "ecb_cbc_helpers.h"
  21
  22/* 8-way parallel cipher functions */
  23asmlinkage void serpent_ecb_enc_8way_avx(const void *ctx, u8 *dst,
  24                                         const u8 *src);
  25EXPORT_SYMBOL_GPL(serpent_ecb_enc_8way_avx);
  26
  27asmlinkage void serpent_ecb_dec_8way_avx(const void *ctx, u8 *dst,
  28                                         const u8 *src);
  29EXPORT_SYMBOL_GPL(serpent_ecb_dec_8way_avx);
  30
  31asmlinkage void serpent_cbc_dec_8way_avx(const void *ctx, u8 *dst,
  32                                         const u8 *src);
  33EXPORT_SYMBOL_GPL(serpent_cbc_dec_8way_avx);
  34
  35static int serpent_setkey_skcipher(struct crypto_skcipher *tfm,
  36                                   const u8 *key, unsigned int keylen)
  37{
  38        return __serpent_setkey(crypto_skcipher_ctx(tfm), key, keylen);
  39}
  40
  41static int ecb_encrypt(struct skcipher_request *req)
  42{
  43        ECB_WALK_START(req, SERPENT_BLOCK_SIZE, SERPENT_PARALLEL_BLOCKS);
  44        ECB_BLOCK(SERPENT_PARALLEL_BLOCKS, serpent_ecb_enc_8way_avx);
  45        ECB_BLOCK(1, __serpent_encrypt);
  46        ECB_WALK_END();
  47}
  48
  49static int ecb_decrypt(struct skcipher_request *req)
  50{
  51        ECB_WALK_START(req, SERPENT_BLOCK_SIZE, SERPENT_PARALLEL_BLOCKS);
  52        ECB_BLOCK(SERPENT_PARALLEL_BLOCKS, serpent_ecb_dec_8way_avx);
  53        ECB_BLOCK(1, __serpent_decrypt);
  54        ECB_WALK_END();
  55}
  56
  57static int cbc_encrypt(struct skcipher_request *req)
  58{
  59        CBC_WALK_START(req, SERPENT_BLOCK_SIZE, -1);
  60        CBC_ENC_BLOCK(__serpent_encrypt);
  61        CBC_WALK_END();
  62}
  63
  64static int cbc_decrypt(struct skcipher_request *req)
  65{
  66        CBC_WALK_START(req, SERPENT_BLOCK_SIZE, SERPENT_PARALLEL_BLOCKS);
  67        CBC_DEC_BLOCK(SERPENT_PARALLEL_BLOCKS, serpent_cbc_dec_8way_avx);
  68        CBC_DEC_BLOCK(1, __serpent_decrypt);
  69        CBC_WALK_END();
  70}
  71
  72static struct skcipher_alg serpent_algs[] = {
  73        {
  74                .base.cra_name          = "__ecb(serpent)",
  75                .base.cra_driver_name   = "__ecb-serpent-avx",
  76                .base.cra_priority      = 500,
  77                .base.cra_flags         = CRYPTO_ALG_INTERNAL,
  78                .base.cra_blocksize     = SERPENT_BLOCK_SIZE,
  79                .base.cra_ctxsize       = sizeof(struct serpent_ctx),
  80                .base.cra_module        = THIS_MODULE,
  81                .min_keysize            = SERPENT_MIN_KEY_SIZE,
  82                .max_keysize            = SERPENT_MAX_KEY_SIZE,
  83                .setkey                 = serpent_setkey_skcipher,
  84                .encrypt                = ecb_encrypt,
  85                .decrypt                = ecb_decrypt,
  86        }, {
  87                .base.cra_name          = "__cbc(serpent)",
  88                .base.cra_driver_name   = "__cbc-serpent-avx",
  89                .base.cra_priority      = 500,
  90                .base.cra_flags         = CRYPTO_ALG_INTERNAL,
  91                .base.cra_blocksize     = SERPENT_BLOCK_SIZE,
  92                .base.cra_ctxsize       = sizeof(struct serpent_ctx),
  93                .base.cra_module        = THIS_MODULE,
  94                .min_keysize            = SERPENT_MIN_KEY_SIZE,
  95                .max_keysize            = SERPENT_MAX_KEY_SIZE,
  96                .ivsize                 = SERPENT_BLOCK_SIZE,
  97                .setkey                 = serpent_setkey_skcipher,
  98                .encrypt                = cbc_encrypt,
  99                .decrypt                = cbc_decrypt,
 100        },
 101};
 102
 103static struct simd_skcipher_alg *serpent_simd_algs[ARRAY_SIZE(serpent_algs)];
 104
 105static int __init serpent_init(void)
 106{
 107        const char *feature_name;
 108
 109        if (!cpu_has_xfeatures(XFEATURE_MASK_SSE | XFEATURE_MASK_YMM,
 110                                &feature_name)) {
 111                pr_info("CPU feature '%s' is not supported.\n", feature_name);
 112                return -ENODEV;
 113        }
 114
 115        return simd_register_skciphers_compat(serpent_algs,
 116                                              ARRAY_SIZE(serpent_algs),
 117                                              serpent_simd_algs);
 118}
 119
 120static void __exit serpent_exit(void)
 121{
 122        simd_unregister_skciphers(serpent_algs, ARRAY_SIZE(serpent_algs),
 123                                  serpent_simd_algs);
 124}
 125
 126module_init(serpent_init);
 127module_exit(serpent_exit);
 128
 129MODULE_DESCRIPTION("Serpent Cipher Algorithm, AVX optimized");
 130MODULE_LICENSE("GPL");
 131MODULE_ALIAS_CRYPTO("serpent");
 132