linux/crypto/ahash.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Asynchronous Cryptographic Hash operations.
 *
 * This is the implementation of the ahash (asynchronous hash) API.  It differs
 * from shash (synchronous hash) in that ahash supports asynchronous operations,
 * and it hashes data from scatterlists instead of virtually addressed buffers.
 *
 * The ahash API provides access to both ahash and shash algorithms.  The shash
 * API only provides access to shash algorithms.
 *
 * Copyright (c) 2008 Loc Ho <[email protected]>
 */

#include <crypto/scatterwalk.h>
#include <linux/cryptouser.h>
#include <linux/err.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/seq_file.h>
#include <linux/string.h>
#include <net/netlink.h>

#include "hash.h"

#define CRYPTO_ALG_TYPE_AHASH_MASK …

/*
 * For an ahash tfm that is using an shash algorithm (instead of an ahash
 * algorithm), this returns the underlying shash tfm.
 */
static inline struct crypto_shash *ahash_to_shash(struct crypto_ahash *tfm)
{ … }

static inline struct shash_desc *prepare_shash_desc(struct ahash_request *req,
						    struct crypto_ahash *tfm)
{ … }

int shash_ahash_update(struct ahash_request *req, struct shash_desc *desc)
{ … }
EXPORT_SYMBOL_GPL(…);

int shash_ahash_finup(struct ahash_request *req, struct shash_desc *desc)
{ … }
EXPORT_SYMBOL_GPL(…);

int shash_ahash_digest(struct ahash_request *req, struct shash_desc *desc)
{ … }
EXPORT_SYMBOL_GPL(…);

static void crypto_exit_ahash_using_shash(struct crypto_tfm *tfm)
{ … }

static int crypto_init_ahash_using_shash(struct crypto_tfm *tfm)
{ … }

static int hash_walk_next(struct crypto_hash_walk *walk)
{ … }

static int hash_walk_new_entry(struct crypto_hash_walk *walk)
{ … }

int crypto_hash_walk_done(struct crypto_hash_walk *walk, int err)
{ … }
EXPORT_SYMBOL_GPL(…);

int crypto_hash_walk_first(struct ahash_request *req,
			   struct crypto_hash_walk *walk)
{ … }
EXPORT_SYMBOL_GPL(…);

static int ahash_nosetkey(struct crypto_ahash *tfm, const u8 *key,
			  unsigned int keylen)
{ … }

static void ahash_set_needkey(struct crypto_ahash *tfm, struct ahash_alg *alg)
{ … }

int crypto_ahash_setkey(struct crypto_ahash *tfm, const u8 *key,
			unsigned int keylen)
{ … }
EXPORT_SYMBOL_GPL(…);

int crypto_ahash_init(struct ahash_request *req)
{ … }
EXPORT_SYMBOL_GPL(…);

static int ahash_save_req(struct ahash_request *req, crypto_completion_t cplt,
			  bool has_state)
{ … }

static void ahash_restore_req(struct ahash_request *req, int err)
{ … }

int crypto_ahash_update(struct ahash_request *req)
{ … }
EXPORT_SYMBOL_GPL(…);

int crypto_ahash_final(struct ahash_request *req)
{ … }
EXPORT_SYMBOL_GPL(…);

int crypto_ahash_finup(struct ahash_request *req)
{ … }
EXPORT_SYMBOL_GPL(…);

int crypto_ahash_digest(struct ahash_request *req)
{ … }
EXPORT_SYMBOL_GPL(…);

static void ahash_def_finup_done2(void *data, int err)
{ … }

static int ahash_def_finup_finish1(struct ahash_request *req, int err)
{ … }

static void ahash_def_finup_done1(void *data, int err)
{ … }

static int ahash_def_finup(struct ahash_request *req)
{ … }

int crypto_ahash_export(struct ahash_request *req, void *out)
{ … }
EXPORT_SYMBOL_GPL(…);

int crypto_ahash_import(struct ahash_request *req, const void *in)
{ … }
EXPORT_SYMBOL_GPL(…);

static void crypto_ahash_exit_tfm(struct crypto_tfm *tfm)
{ … }

static int crypto_ahash_init_tfm(struct crypto_tfm *tfm)
{ … }

static unsigned int crypto_ahash_extsize(struct crypto_alg *alg)
{ … }

static void crypto_ahash_free_instance(struct crypto_instance *inst)
{ … }

static int __maybe_unused crypto_ahash_report(
	struct sk_buff *skb, struct crypto_alg *alg)
{ … }

static void crypto_ahash_show(struct seq_file *m, struct crypto_alg *alg)
	__maybe_unused;
static void crypto_ahash_show(struct seq_file *m, struct crypto_alg *alg)
{ … }

static const struct crypto_type crypto_ahash_type = …;

int crypto_grab_ahash(struct crypto_ahash_spawn *spawn,
		      struct crypto_instance *inst,
		      const char *name, u32 type, u32 mask)
{ … }
EXPORT_SYMBOL_GPL(…);

struct crypto_ahash *crypto_alloc_ahash(const char *alg_name, u32 type,
					u32 mask)
{ … }
EXPORT_SYMBOL_GPL(…);

int crypto_has_ahash(const char *alg_name, u32 type, u32 mask)
{ … }
EXPORT_SYMBOL_GPL(…);

static bool crypto_hash_alg_has_setkey(struct hash_alg_common *halg)
{ … }

struct crypto_ahash *crypto_clone_ahash(struct crypto_ahash *hash)
{ … }
EXPORT_SYMBOL_GPL(…);

static int ahash_prepare_alg(struct ahash_alg *alg)
{ … }

int crypto_register_ahash(struct ahash_alg *alg)
{ … }
EXPORT_SYMBOL_GPL(…);

void crypto_unregister_ahash(struct ahash_alg *alg)
{ … }
EXPORT_SYMBOL_GPL(…);

int crypto_register_ahashes(struct ahash_alg *algs, int count)
{ … }
EXPORT_SYMBOL_GPL(…);

void crypto_unregister_ahashes(struct ahash_alg *algs, int count)
{ … }
EXPORT_SYMBOL_GPL(…);

int ahash_register_instance(struct crypto_template *tmpl,
			    struct ahash_instance *inst)
{ … }
EXPORT_SYMBOL_GPL(…);

MODULE_LICENSE(…) …;
MODULE_DESCRIPTION(…) …;