Quelle  ghash-clmulni-intel_glue.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Accelerated GHASH implementation with Intel PCLMULQDQ-NI
 * instructions. This file contains glue code.
 *
 * Copyright (c) 2009 Intel Corp.
 *   Author: Huang Ying <ying.huang@intel.com>
 */

#include <asm/cpu_device_id.h>
#include <asm/simd.h>
#include <crypto/b128ops.h>
#include <crypto/ghash.h>
#include <crypto/internal/hash.h>
#include <crypto/utils.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/string.h>
#include <linux/unaligned.h>

asmlinkage void clmul_ghash_mul(char *dst, const le128 *shash);

asmlinkage int clmul_ghash_update(char *dst, const char *src,
      unsigned int srclen, const le128 *shash);

struct x86_ghash_ctx {
 le128 shash;
};

static int ghash_init(struct shash_desc *desc)
{
 struct ghash_desc_ctx *dctx = shash_desc_ctx(desc);

 memset(dctx, 0, sizeof(*dctx));

 return 0;
}

static int ghash_setkey(struct crypto_shash *tfm,
   const u8 *key, unsigned int keylen)
{
 struct x86_ghash_ctx *ctx = crypto_shash_ctx(tfm);
 u64 a, b;

 if (keylen != GHASH_BLOCK_SIZE)
  return -EINVAL;

 /*
 * GHASH maps bits to polynomial coefficients backwards, which makes it
 * hard to implement.  But it can be shown that the GHASH multiplication
 *
 * D * K (mod x^128 + x^7 + x^2 + x + 1)
 *
 * (where D is a data block and K is the key) is equivalent to:
 *
 * bitreflect(D) * bitreflect(K) * x^(-127)
 * (mod x^128 + x^127 + x^126 + x^121 + 1)
 *
 * So, the code below precomputes:
 *
 * bitreflect(K) * x^(-127) (mod x^128 + x^127 + x^126 + x^121 + 1)
 *
 * ... but in Montgomery form (so that Montgomery multiplication can be
 * used), i.e. with an extra x^128 factor, which means actually:
 *
 * bitreflect(K) * x (mod x^128 + x^127 + x^126 + x^121 + 1)
 *
 * The within-a-byte part of bitreflect() cancels out GHASH's built-in
 * reflection, and thus bitreflect() is actually a byteswap.
 */
 a = get_unaligned_be64(key);
 b = get_unaligned_be64(key + 8);
 ctx->shash.a = cpu_to_le64((a << 1) | (b >> 63));
 ctx->shash.b = cpu_to_le64((b << 1) | (a >> 63));
 if (a >> 63)
  ctx->shash.a ^= cpu_to_le64((u64)0xc2 << 56);
 return 0;
}

static int ghash_update(struct shash_desc *desc,
    const u8 *src, unsigned int srclen)
{
 struct x86_ghash_ctx *ctx = crypto_shash_ctx(desc->tfm);
 struct ghash_desc_ctx *dctx = shash_desc_ctx(desc);
 u8 *dst = dctx->buffer;
 int remain;

 kernel_fpu_begin();
 remain = clmul_ghash_update(dst, src, srclen, &ctx->shash);
 kernel_fpu_end();
 return remain;
}

static void ghash_flush(struct x86_ghash_ctx *ctx, struct ghash_desc_ctx *dctx,
   const u8 *src, unsigned int len)
{
 u8 *dst = dctx->buffer;

 kernel_fpu_begin();
 if (len) {
  crypto_xor(dst, src, len);
  clmul_ghash_mul(dst, &ctx->shash);
 }
 kernel_fpu_end();
}

static int ghash_finup(struct shash_desc *desc, const u8 *src,
         unsigned int len, u8 *dst)
{
 struct x86_ghash_ctx *ctx = crypto_shash_ctx(desc->tfm);
 struct ghash_desc_ctx *dctx = shash_desc_ctx(desc);
 u8 *buf = dctx->buffer;

 ghash_flush(ctx, dctx, src, len);
 memcpy(dst, buf, GHASH_BLOCK_SIZE);

 return 0;
}

static struct shash_alg ghash_alg = {
 .digestsize = GHASH_DIGEST_SIZE,
 .init  = ghash_init,
 .update  = ghash_update,
 .finup  = ghash_finup,
 .setkey  = ghash_setkey,
 .descsize = sizeof(struct ghash_desc_ctx),
 .base  = {
  .cra_name  = "ghash",
  .cra_driver_name = "ghash-pclmulqdqni",
  .cra_priority  = 400,
  .cra_flags  = CRYPTO_AHASH_ALG_BLOCK_ONLY,
  .cra_blocksize  = GHASH_BLOCK_SIZE,
  .cra_ctxsize  = sizeof(struct x86_ghash_ctx),
  .cra_module  = THIS_MODULE,
 },
};

static const struct x86_cpu_id pcmul_cpu_id[] = {
 X86_MATCH_FEATURE(X86_FEATURE_PCLMULQDQ, NULL), /* Pickle-Mickle-Duck */
 {}
};
MODULE_DEVICE_TABLE(x86cpu, pcmul_cpu_id);

static int __init ghash_pclmulqdqni_mod_init(void)
{
 if (!x86_match_cpu(pcmul_cpu_id))
  return -ENODEV;

 return crypto_register_shash(&ghash_alg);
}

static void __exit ghash_pclmulqdqni_mod_exit(void)
{
 crypto_unregister_shash(&ghash_alg);
}

module_init(ghash_pclmulqdqni_mod_init);
module_exit(ghash_pclmulqdqni_mod_exit);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("GHASH hash function, accelerated by PCLMULQDQ-NI");
MODULE_ALIAS_CRYPTO("ghash");