linux/crypto/shash.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Synchronous Cryptographic Hash operations.
 *
 * Copyright (c) 2008 Herbert Xu <[email protected]>
 */

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

#include "hash.h"

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

static void shash_set_needkey(struct crypto_shash *tfm, struct shash_alg *alg)
{ … }

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

int crypto_shash_update(struct shash_desc *desc, const u8 *data,
			unsigned int len)
{ … }
EXPORT_SYMBOL_GPL(…);

int crypto_shash_final(struct shash_desc *desc, u8 *out)
{ … }
EXPORT_SYMBOL_GPL(…);

static int shash_default_finup(struct shash_desc *desc, const u8 *data,
			       unsigned int len, u8 *out)
{ … }

int crypto_shash_finup(struct shash_desc *desc, const u8 *data,
		       unsigned int len, u8 *out)
{ … }
EXPORT_SYMBOL_GPL(…);

static int shash_default_digest(struct shash_desc *desc, const u8 *data,
				unsigned int len, u8 *out)
{ … }

int crypto_shash_digest(struct shash_desc *desc, const u8 *data,
			unsigned int len, u8 *out)
{ … }
EXPORT_SYMBOL_GPL(…);

int crypto_shash_tfm_digest(struct crypto_shash *tfm, const u8 *data,
			    unsigned int len, u8 *out)
{ … }
EXPORT_SYMBOL_GPL(…);

int crypto_shash_export(struct shash_desc *desc, void *out)
{ … }
EXPORT_SYMBOL_GPL(…);

int crypto_shash_import(struct shash_desc *desc, const void *in)
{ … }
EXPORT_SYMBOL_GPL(…);

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

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

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

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

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

const struct crypto_type crypto_shash_type = …;

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

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

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

struct crypto_shash *crypto_clone_shash(struct crypto_shash *hash)
{ … }
EXPORT_SYMBOL_GPL(…);

int hash_prepare_alg(struct hash_alg_common *alg)
{ … }

static int shash_prepare_alg(struct shash_alg *alg)
{ … }

int crypto_register_shash(struct shash_alg *alg)
{ … }
EXPORT_SYMBOL_GPL(…);

void crypto_unregister_shash(struct shash_alg *alg)
{ … }
EXPORT_SYMBOL_GPL(…);

int crypto_register_shashes(struct shash_alg *algs, int count)
{ … }
EXPORT_SYMBOL_GPL(…);

void crypto_unregister_shashes(struct shash_alg *algs, int count)
{ … }
EXPORT_SYMBOL_GPL(…);

int shash_register_instance(struct crypto_template *tmpl,
			    struct shash_instance *inst)
{ … }
EXPORT_SYMBOL_GPL(…);

void shash_free_singlespawn_instance(struct shash_instance *inst)
{ … }
EXPORT_SYMBOL_GPL(…);

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