cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

hash.h (6147B)

      1/* SPDX-License-Identifier: GPL-2.0-or-later */
      2/*
      3 * Hash algorithms.
      4 * 
      5 * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au>
      6 */
      7
      8#ifndef _CRYPTO_INTERNAL_HASH_H
      9#define _CRYPTO_INTERNAL_HASH_H
     10
     11#include <crypto/algapi.h>
     12#include <crypto/hash.h>
     13
     14struct ahash_request;
     15struct scatterlist;
     16
     17struct crypto_hash_walk {
     18	char *data;
     19
     20	unsigned int offset;
     21	unsigned int alignmask;
     22
     23	struct page *pg;
     24	unsigned int entrylen;
     25
     26	unsigned int total;
     27	struct scatterlist *sg;
     28
     29	unsigned int flags;
     30};
     31
     32struct ahash_instance {
     33	void (*free)(struct ahash_instance *inst);
     34	union {
     35		struct {
     36			char head[offsetof(struct ahash_alg, halg.base)];
     37			struct crypto_instance base;
     38		} s;
     39		struct ahash_alg alg;
     40	};
     41};
     42
     43struct shash_instance {
     44	void (*free)(struct shash_instance *inst);
     45	union {
     46		struct {
     47			char head[offsetof(struct shash_alg, base)];
     48			struct crypto_instance base;
     49		} s;
     50		struct shash_alg alg;
     51	};
     52};
     53
     54struct crypto_ahash_spawn {
     55	struct crypto_spawn base;
     56};
     57
     58struct crypto_shash_spawn {
     59	struct crypto_spawn base;
     60};
     61
     62int crypto_hash_walk_done(struct crypto_hash_walk *walk, int err);
     63int crypto_hash_walk_first(struct ahash_request *req,
     64			   struct crypto_hash_walk *walk);
     65
     66static inline int crypto_hash_walk_last(struct crypto_hash_walk *walk)
     67{
     68	return !(walk->entrylen | walk->total);
     69}
     70
     71int crypto_register_ahash(struct ahash_alg *alg);
     72void crypto_unregister_ahash(struct ahash_alg *alg);
     73int crypto_register_ahashes(struct ahash_alg *algs, int count);
     74void crypto_unregister_ahashes(struct ahash_alg *algs, int count);
     75int ahash_register_instance(struct crypto_template *tmpl,
     76			    struct ahash_instance *inst);
     77
     78bool crypto_shash_alg_has_setkey(struct shash_alg *alg);
     79
     80static inline bool crypto_shash_alg_needs_key(struct shash_alg *alg)
     81{
     82	return crypto_shash_alg_has_setkey(alg) &&
     83		!(alg->base.cra_flags & CRYPTO_ALG_OPTIONAL_KEY);
     84}
     85
     86bool crypto_hash_alg_has_setkey(struct hash_alg_common *halg);
     87
     88int crypto_grab_ahash(struct crypto_ahash_spawn *spawn,
     89		      struct crypto_instance *inst,
     90		      const char *name, u32 type, u32 mask);
     91
     92static inline void crypto_drop_ahash(struct crypto_ahash_spawn *spawn)
     93{
     94	crypto_drop_spawn(&spawn->base);
     95}
     96
     97static inline struct hash_alg_common *crypto_spawn_ahash_alg(
     98	struct crypto_ahash_spawn *spawn)
     99{
    100	return __crypto_hash_alg_common(spawn->base.alg);
    101}
    102
    103int crypto_register_shash(struct shash_alg *alg);
    104void crypto_unregister_shash(struct shash_alg *alg);
    105int crypto_register_shashes(struct shash_alg *algs, int count);
    106void crypto_unregister_shashes(struct shash_alg *algs, int count);
    107int shash_register_instance(struct crypto_template *tmpl,
    108			    struct shash_instance *inst);
    109void shash_free_singlespawn_instance(struct shash_instance *inst);
    110
    111int crypto_grab_shash(struct crypto_shash_spawn *spawn,
    112		      struct crypto_instance *inst,
    113		      const char *name, u32 type, u32 mask);
    114
    115static inline void crypto_drop_shash(struct crypto_shash_spawn *spawn)
    116{
    117	crypto_drop_spawn(&spawn->base);
    118}
    119
    120static inline struct shash_alg *crypto_spawn_shash_alg(
    121	struct crypto_shash_spawn *spawn)
    122{
    123	return __crypto_shash_alg(spawn->base.alg);
    124}
    125
    126int shash_ahash_update(struct ahash_request *req, struct shash_desc *desc);
    127int shash_ahash_finup(struct ahash_request *req, struct shash_desc *desc);
    128int shash_ahash_digest(struct ahash_request *req, struct shash_desc *desc);
    129
    130int crypto_init_shash_ops_async(struct crypto_tfm *tfm);
    131
    132static inline void *crypto_ahash_ctx(struct crypto_ahash *tfm)
    133{
    134	return crypto_tfm_ctx(crypto_ahash_tfm(tfm));
    135}
    136
    137static inline struct ahash_alg *__crypto_ahash_alg(struct crypto_alg *alg)
    138{
    139	return container_of(__crypto_hash_alg_common(alg), struct ahash_alg,
    140			    halg);
    141}
    142
    143static inline void crypto_ahash_set_reqsize(struct crypto_ahash *tfm,
    144					    unsigned int reqsize)
    145{
    146	tfm->reqsize = reqsize;
    147}
    148
    149static inline struct crypto_instance *ahash_crypto_instance(
    150	struct ahash_instance *inst)
    151{
    152	return &inst->s.base;
    153}
    154
    155static inline struct ahash_instance *ahash_instance(
    156	struct crypto_instance *inst)
    157{
    158	return container_of(inst, struct ahash_instance, s.base);
    159}
    160
    161static inline struct ahash_instance *ahash_alg_instance(
    162	struct crypto_ahash *ahash)
    163{
    164	return ahash_instance(crypto_tfm_alg_instance(&ahash->base));
    165}
    166
    167static inline void *ahash_instance_ctx(struct ahash_instance *inst)
    168{
    169	return crypto_instance_ctx(ahash_crypto_instance(inst));
    170}
    171
    172static inline void ahash_request_complete(struct ahash_request *req, int err)
    173{
    174	req->base.complete(&req->base, err);
    175}
    176
    177static inline u32 ahash_request_flags(struct ahash_request *req)
    178{
    179	return req->base.flags;
    180}
    181
    182static inline struct crypto_ahash *crypto_spawn_ahash(
    183	struct crypto_ahash_spawn *spawn)
    184{
    185	return crypto_spawn_tfm2(&spawn->base);
    186}
    187
    188static inline int ahash_enqueue_request(struct crypto_queue *queue,
    189					     struct ahash_request *request)
    190{
    191	return crypto_enqueue_request(queue, &request->base);
    192}
    193
    194static inline struct ahash_request *ahash_dequeue_request(
    195	struct crypto_queue *queue)
    196{
    197	return ahash_request_cast(crypto_dequeue_request(queue));
    198}
    199
    200static inline void *crypto_shash_ctx(struct crypto_shash *tfm)
    201{
    202	return crypto_tfm_ctx(&tfm->base);
    203}
    204
    205static inline struct crypto_instance *shash_crypto_instance(
    206	struct shash_instance *inst)
    207{
    208	return &inst->s.base;
    209}
    210
    211static inline struct shash_instance *shash_instance(
    212	struct crypto_instance *inst)
    213{
    214	return container_of(inst, struct shash_instance, s.base);
    215}
    216
    217static inline struct shash_instance *shash_alg_instance(
    218	struct crypto_shash *shash)
    219{
    220	return shash_instance(crypto_tfm_alg_instance(&shash->base));
    221}
    222
    223static inline void *shash_instance_ctx(struct shash_instance *inst)
    224{
    225	return crypto_instance_ctx(shash_crypto_instance(inst));
    226}
    227
    228static inline struct crypto_shash *crypto_spawn_shash(
    229	struct crypto_shash_spawn *spawn)
    230{
    231	return crypto_spawn_tfm2(&spawn->base);
    232}
    233
    234static inline void *crypto_shash_ctx_aligned(struct crypto_shash *tfm)
    235{
    236	return crypto_tfm_ctx_aligned(&tfm->base);
    237}
    238
    239static inline struct crypto_shash *__crypto_shash_cast(struct crypto_tfm *tfm)
    240{
    241	return container_of(tfm, struct crypto_shash, base);
    242}
    243
    244#endif	/* _CRYPTO_INTERNAL_HASH_H */
    245