/* SPDX-License-Identifier: GPL-2.0 *//* * Common values for SHA-2 algorithms */ #ifndef _CRYPTO_SHA2_H#define _CRYPTO_SHA2_H #include <linux/types.h> #define SHA224_DIGEST_SIZE	28#define SHA224_BLOCK_SIZE	64 #define SHA256_DIGEST_SIZE      32#define SHA256_BLOCK_SIZE       64#define SHA256_STATE_WORDS      8 #define SHA384_DIGEST_SIZE      48#define SHA384_BLOCK_SIZE       128 #define SHA512_DIGEST_SIZE      64#define SHA512_BLOCK_SIZE       128#define SHA512_STATE_SIZE       80 #define SHA224_H0	0xc1059ed8UL#define SHA224_H1	0x367cd507UL#define SHA224_H2	0x3070dd17UL#define SHA224_H3	0xf70e5939UL#define SHA224_H4	0xffc00b31UL#define SHA224_H5	0x68581511UL#define SHA224_H6	0x64f98fa7UL#define SHA224_H7	0xbefa4fa4UL #define SHA256_H0	0x6a09e667UL#define SHA256_H1	0xbb67ae85UL#define SHA256_H2	0x3c6ef372UL#define SHA256_H3	0xa54ff53aUL#define SHA256_H4	0x510e527fUL#define SHA256_H5	0x9b05688cUL#define SHA256_H6	0x1f83d9abUL#define SHA256_H7	0x5be0cd19UL #define SHA384_H0	0xcbbb9d5dc1059ed8ULL#define SHA384_H1	0x629a292a367cd507ULL#define SHA384_H2	0x9159015a3070dd17ULL#define SHA384_H3	0x152fecd8f70e5939ULL#define SHA384_H4	0x67332667ffc00b31ULL#define SHA384_H5	0x8eb44a8768581511ULL#define SHA384_H6	0xdb0c2e0d64f98fa7ULL#define SHA384_H7	0x47b5481dbefa4fa4ULL #define SHA512_H0	0x6a09e667f3bcc908ULL#define SHA512_H1	0xbb67ae8584caa73bULL#define SHA512_H2	0x3c6ef372fe94f82bULL#define SHA512_H3	0xa54ff53a5f1d36f1ULL#define SHA512_H4	0x510e527fade682d1ULL#define SHA512_H5	0x9b05688c2b3e6c1fULL#define SHA512_H6	0x1f83d9abfb41bd6bULL#define SHA512_H7	0x5be0cd19137e2179ULL extern const u8 sha224_zero_message_hash[SHA224_DIGEST_SIZE]; extern const u8 sha256_zero_message_hash[SHA256_DIGEST_SIZE]; extern const u8 sha384_zero_message_hash[SHA384_DIGEST_SIZE]; extern const u8 sha512_zero_message_hash[SHA512_DIGEST_SIZE]; struct crypto_sha256_state {	u32 state[SHA256_STATE_WORDS];	u64 count;}; static inline void sha224_block_init(struct crypto_sha256_state *sctx){	sctx->state[0] = SHA224_H0;	sctx->state[1] = SHA224_H1;	sctx->state[2] = SHA224_H2;	sctx->state[3] = SHA224_H3;	sctx->state[4] = SHA224_H4;	sctx->state[5] = SHA224_H5;	sctx->state[6] = SHA224_H6;	sctx->state[7] = SHA224_H7;	sctx->count = 0;} static inline void sha256_block_init(struct crypto_sha256_state *sctx){	sctx->state[0] = SHA256_H0;	sctx->state[1] = SHA256_H1;	sctx->state[2] = SHA256_H2;	sctx->state[3] = SHA256_H3;	sctx->state[4] = SHA256_H4;	sctx->state[5] = SHA256_H5;	sctx->state[6] = SHA256_H6;	sctx->state[7] = SHA256_H7;	sctx->count = 0;} struct sha256_state {	union {		struct crypto_sha256_state ctx;		struct {			u32 state[SHA256_STATE_WORDS];			u64 count;		};	};	u8 buf[SHA256_BLOCK_SIZE];}; struct sha512_state {	u64 state[SHA512_DIGEST_SIZE / 8];	u64 count[2];	u8 buf[SHA512_BLOCK_SIZE];}; /* State for the SHA-256 (and SHA-224) compression function */struct sha256_block_state {	u32 h[SHA256_STATE_WORDS];}; /* * Context structure, shared by SHA-224 and SHA-256.  The sha224_ctx and * sha256_ctx structs wrap this one so that the API has proper typing and * doesn't allow mixing the SHA-224 and SHA-256 functions arbitrarily. */struct __sha256_ctx {	struct sha256_block_state state;	u64 bytecount;	u8 buf[SHA256_BLOCK_SIZE] __aligned(__alignof__(__be64));};void __sha256_update(struct __sha256_ctx *ctx, const u8 *data, size_t len); /* * HMAC key and message context structs, shared by HMAC-SHA224 and HMAC-SHA256. * The hmac_sha224_* and hmac_sha256_* structs wrap this one so that the API has * proper typing and doesn't allow mixing the functions arbitrarily. */struct __hmac_sha256_key {	struct sha256_block_state istate;	struct sha256_block_state ostate;};struct __hmac_sha256_ctx {	struct __sha256_ctx sha_ctx;	struct sha256_block_state ostate;};void __hmac_sha256_init(struct __hmac_sha256_ctx *ctx,			const struct __hmac_sha256_key *key); /** * struct sha224_ctx - Context for hashing a message with SHA-224 * @ctx: private */struct sha224_ctx {	struct __sha256_ctx ctx;}; /** * sha224_init() - Initialize a SHA-224 context for a new message * @ctx: the context to initialize * * If you don't need incremental computation, consider sha224() instead. * * Context: Any context. */void sha224_init(struct sha224_ctx *ctx); /** * sha224_update() - Update a SHA-224 context with message data * @ctx: the context to update; must have been initialized * @data: the message data * @len: the data length in bytes * * This can be called any number of times. * * Context: Any context. */static inline void sha224_update(struct sha224_ctx *ctx,				 const u8 *data, size_t len){	__sha256_update(&ctx->ctx, data, len);} /** * sha224_final() - Finish computing a SHA-224 message digest * @ctx: the context to finalize; must have been initialized * @out: (output) the resulting SHA-224 message digest * * After finishing, this zeroizes @ctx.  So the caller does not need to do it. * * Context: Any context. */void sha224_final(struct sha224_ctx *ctx, u8 out[at_least SHA224_DIGEST_SIZE]); /** * sha224() - Compute SHA-224 message digest in one shot * @data: the message data * @len: the data length in bytes * @out: (output) the resulting SHA-224 message digest * * Context: Any context. */void sha224(const u8 *data, size_t len, u8 out[at_least SHA224_DIGEST_SIZE]); /** * struct hmac_sha224_key - Prepared key for HMAC-SHA224 * @key: private */struct hmac_sha224_key {	struct __hmac_sha256_key key;}; /** * struct hmac_sha224_ctx - Context for computing HMAC-SHA224 of a message * @ctx: private */struct hmac_sha224_ctx {	struct __hmac_sha256_ctx ctx;}; /** * hmac_sha224_preparekey() - Prepare a key for HMAC-SHA224 * @key: (output) the key structure to initialize * @raw_key: the raw HMAC-SHA224 key * @raw_key_len: the key length in bytes.  All key lengths are supported. * * Note: the caller is responsible for zeroizing both the struct hmac_sha224_key * and the raw key once they are no longer needed. * * Context: Any context. */void hmac_sha224_preparekey(struct hmac_sha224_key *key,			    const u8 *raw_key, size_t raw_key_len); /** * hmac_sha224_init() - Initialize an HMAC-SHA224 context for a new message * @ctx: (output) the HMAC context to initialize * @key: the prepared HMAC key * * If you don't need incremental computation, consider hmac_sha224() instead. * * Context: Any context. */static inline void hmac_sha224_init(struct hmac_sha224_ctx *ctx,				    const struct hmac_sha224_key *key){	__hmac_sha256_init(&ctx->ctx, &key->key);} /** * hmac_sha224_init_usingrawkey() - Initialize an HMAC-SHA224 context for a new *				    message, using a raw key * @ctx: (output) the HMAC context to initialize * @raw_key: the raw HMAC-SHA224 key * @raw_key_len: the key length in bytes.  All key lengths are supported. * * If you don't need incremental computation, consider hmac_sha224_usingrawkey() * instead. * * Context: Any context. */void hmac_sha224_init_usingrawkey(struct hmac_sha224_ctx *ctx,				  const u8 *raw_key, size_t raw_key_len); /** * hmac_sha224_update() - Update an HMAC-SHA224 context with message data * @ctx: the HMAC context to update; must have been initialized * @data: the message data * @data_len: the data length in bytes * * This can be called any number of times. * * Context: Any context. */static inline void hmac_sha224_update(struct hmac_sha224_ctx *ctx,				      const u8 *data, size_t data_len){	__sha256_update(&ctx->ctx.sha_ctx, data, data_len);} /** * hmac_sha224_final() - Finish computing an HMAC-SHA224 value * @ctx: the HMAC context to finalize; must have been initialized * @out: (output) the resulting HMAC-SHA224 value * * After finishing, this zeroizes @ctx.  So the caller does not need to do it. * * Context: Any context. */void hmac_sha224_final(struct hmac_sha224_ctx *ctx,		       u8 out[at_least SHA224_DIGEST_SIZE]); /** * hmac_sha224() - Compute HMAC-SHA224 in one shot, using a prepared key * @key: the prepared HMAC key * @data: the message data * @data_len: the data length in bytes * @out: (output) the resulting HMAC-SHA224 value * * If you're using the key only once, consider using hmac_sha224_usingrawkey(). * * Context: Any context. */void hmac_sha224(const struct hmac_sha224_key *key,		 const u8 *data, size_t data_len,		 u8 out[at_least SHA224_DIGEST_SIZE]); /** * hmac_sha224_usingrawkey() - Compute HMAC-SHA224 in one shot, using a raw key * @raw_key: the raw HMAC-SHA224 key * @raw_key_len: the key length in bytes.  All key lengths are supported. * @data: the message data * @data_len: the data length in bytes * @out: (output) the resulting HMAC-SHA224 value * * If you're using the key multiple times, prefer to use * hmac_sha224_preparekey() followed by multiple calls to hmac_sha224() instead. * * Context: Any context. */void hmac_sha224_usingrawkey(const u8 *raw_key, size_t raw_key_len,			     const u8 *data, size_t data_len,			     u8 out[at_least SHA224_DIGEST_SIZE]); /** * struct sha256_ctx - Context for hashing a message with SHA-256 * @ctx: private */struct sha256_ctx {	struct __sha256_ctx ctx;}; /** * sha256_init() - Initialize a SHA-256 context for a new message * @ctx: the context to initialize * * If you don't need incremental computation, consider sha256() instead. * * Context: Any context. */void sha256_init(struct sha256_ctx *ctx); /** * sha256_update() - Update a SHA-256 context with message data * @ctx: the context to update; must have been initialized * @data: the message data * @len: the data length in bytes * * This can be called any number of times. * * Context: Any context. */static inline void sha256_update(struct sha256_ctx *ctx,				 const u8 *data, size_t len){	__sha256_update(&ctx->ctx, data, len);} /** * sha256_final() - Finish computing a SHA-256 message digest * @ctx: the context to finalize; must have been initialized * @out: (output) the resulting SHA-256 message digest * * After finishing, this zeroizes @ctx.  So the caller does not need to do it. * * Context: Any context. */void sha256_final(struct sha256_ctx *ctx, u8 out[at_least SHA256_DIGEST_SIZE]); /** * sha256() - Compute SHA-256 message digest in one shot * @data: the message data * @len: the data length in bytes * @out: (output) the resulting SHA-256 message digest * * Context: Any context. */void sha256(const u8 *data, size_t len, u8 out[at_least SHA256_DIGEST_SIZE]); /** * sha256_finup_2x() - Compute two SHA-256 digests from a common initial *		       context.  On some CPUs, this is faster than sequentially *		       computing each digest. * @ctx: an optional initial context, which may have already processed data.  If *	 NULL, a default initial context is used (equivalent to sha256_init()). * @data1: data for the first message * @data2: data for the second message * @len: the length of each of @data1 and @data2, in bytes * @out1: (output) the first SHA-256 message digest * @out2: (output) the second SHA-256 message digest * * Context: Any context. */void sha256_finup_2x(const struct sha256_ctx *ctx, const u8 *data1,		     const u8 *data2, size_t len,		     u8 out1[at_least SHA256_DIGEST_SIZE],		     u8 out2[at_least SHA256_DIGEST_SIZE]); /** * sha256_finup_2x_is_optimized() - Check if sha256_finup_2x() is using a real *				    interleaved implementation, as opposed to a *				    sequential fallback * @return: true if optimized * * Context: Any context. */bool sha256_finup_2x_is_optimized(void); /** * struct hmac_sha256_key - Prepared key for HMAC-SHA256 * @key: private */struct hmac_sha256_key {	struct __hmac_sha256_key key;}; /** * struct hmac_sha256_ctx - Context for computing HMAC-SHA256 of a message * @ctx: private */struct hmac_sha256_ctx {	struct __hmac_sha256_ctx ctx;}; /** * hmac_sha256_preparekey() - Prepare a key for HMAC-SHA256 * @key: (output) the key structure to initialize * @raw_key: the raw HMAC-SHA256 key * @raw_key_len: the key length in bytes.  All key lengths are supported. * * Note: the caller is responsible for zeroizing both the struct hmac_sha256_key * and the raw key once they are no longer needed. * * Context: Any context. */void hmac_sha256_preparekey(struct hmac_sha256_key *key,			    const u8 *raw_key, size_t raw_key_len); /** * hmac_sha256_init() - Initialize an HMAC-SHA256 context for a new message * @ctx: (output) the HMAC context to initialize * @key: the prepared HMAC key * * If you don't need incremental computation, consider hmac_sha256() instead. * * Context: Any context. */static inline void hmac_sha256_init(struct hmac_sha256_ctx *ctx,				    const struct hmac_sha256_key *key){	__hmac_sha256_init(&ctx->ctx, &key->key);} /** * hmac_sha256_init_usingrawkey() - Initialize an HMAC-SHA256 context for a new *				    message, using a raw key * @ctx: (output) the HMAC context to initialize * @raw_key: the raw HMAC-SHA256 key * @raw_key_len: the key length in bytes.  All key lengths are supported. * * If you don't need incremental computation, consider hmac_sha256_usingrawkey() * instead. * * Context: Any context. */void hmac_sha256_init_usingrawkey(struct hmac_sha256_ctx *ctx,				  const u8 *raw_key, size_t raw_key_len); /** * hmac_sha256_update() - Update an HMAC-SHA256 context with message data * @ctx: the HMAC context to update; must have been initialized * @data: the message data * @data_len: the data length in bytes * * This can be called any number of times. * * Context: Any context. */static inline void hmac_sha256_update(struct hmac_sha256_ctx *ctx,				      const u8 *data, size_t data_len){	__sha256_update(&ctx->ctx.sha_ctx, data, data_len);} /** * hmac_sha256_final() - Finish computing an HMAC-SHA256 value * @ctx: the HMAC context to finalize; must have been initialized * @out: (output) the resulting HMAC-SHA256 value * * After finishing, this zeroizes @ctx.  So the caller does not need to do it. * * Context: Any context. */void hmac_sha256_final(struct hmac_sha256_ctx *ctx,		       u8 out[at_least SHA256_DIGEST_SIZE]); /** * hmac_sha256() - Compute HMAC-SHA256 in one shot, using a prepared key * @key: the prepared HMAC key * @data: the message data

Lines 1–500 of 913. Load more