sha1.c

  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 * Crypto API support for SHA-1 and HMAC-SHA1
  4 *
  5 * Copyright (c) Alan Smithee.
  6 * Copyright (c) Andrew McDonald <andrew@mcdonald.org.uk>
  7 * Copyright (c) Jean-Francois Dive <jef@linuxbe.org>
  8 * Copyright 2025 Google LLC
  9 */
 10#include <crypto/internal/hash.h>
 11#include <crypto/sha1.h>
 12#include <linux/kernel.h>
 13#include <linux/module.h>
 14
 15/*
 16 * Export and import functions.  crypto_shash wants a particular format that
 17 * matches that used by some legacy drivers.  It currently is the same as the
 18 * library SHA context, except the value in bytecount must be block-aligned and
 19 * the remainder must be stored in an extra u8 appended to the struct.
 20 */
 21
 22#define SHA1_SHASH_STATE_SIZE (sizeof(struct sha1_ctx) + 1)
 23static_assert(sizeof(struct sha1_ctx) == sizeof(struct sha1_state));
 24static_assert(offsetof(struct sha1_ctx, state) == offsetof(struct sha1_state, state));
 25static_assert(offsetof(struct sha1_ctx, bytecount) == offsetof(struct sha1_state, count));
 26static_assert(offsetof(struct sha1_ctx, buf) == offsetof(struct sha1_state, buffer));
 27
 28static int __crypto_sha1_export(const struct sha1_ctx *ctx0, void *out)
 29{
 30	struct sha1_ctx ctx = *ctx0;
 31	unsigned int partial;
 32	u8 *p = out;
 33
 34	partial = ctx.bytecount % SHA1_BLOCK_SIZE;
 35	ctx.bytecount -= partial;
 36	memcpy(p, &ctx, sizeof(ctx));
 37	p += sizeof(ctx);
 38	*p = partial;
 39	return 0;
 40}
 41
 42static int __crypto_sha1_import(struct sha1_ctx *ctx, const void *in)
 43{
 44	const u8 *p = in;
 45
 46	memcpy(ctx, p, sizeof(*ctx));
 47	p += sizeof(*ctx);
 48	ctx->bytecount += *p;
 49	return 0;
 50}
 51
 52static int __crypto_sha1_export_core(const struct sha1_ctx *ctx, void *out)
 53{
 54	memcpy(out, ctx, offsetof(struct sha1_ctx, buf));
 55	return 0;
 56}
 57
 58static int __crypto_sha1_import_core(struct sha1_ctx *ctx, const void *in)
 59{
 60	memcpy(ctx, in, offsetof(struct sha1_ctx, buf));
 61	return 0;
 62}
 63
 64const u8 sha1_zero_message_hash[SHA1_DIGEST_SIZE] = {
 65	0xda, 0x39, 0xa3, 0xee, 0x5e, 0x6b, 0x4b, 0x0d,
 66	0x32, 0x55, 0xbf, 0xef, 0x95, 0x60, 0x18, 0x90,
 67	0xaf, 0xd8, 0x07, 0x09
 68};
 69EXPORT_SYMBOL_GPL(sha1_zero_message_hash);
 70
 71#define SHA1_CTX(desc) ((struct sha1_ctx *)shash_desc_ctx(desc))
 72
 73static int crypto_sha1_init(struct shash_desc *desc)
 74{
 75	sha1_init(SHA1_CTX(desc));
 76	return 0;
 77}
 78
 79static int crypto_sha1_update(struct shash_desc *desc,
 80			      const u8 *data, unsigned int len)
 81{
 82	sha1_update(SHA1_CTX(desc), data, len);
 83	return 0;
 84}
 85
 86static int crypto_sha1_final(struct shash_desc *desc, u8 *out)
 87{
 88	sha1_final(SHA1_CTX(desc), out);
 89	return 0;
 90}
 91
 92static int crypto_sha1_digest(struct shash_desc *desc,
 93			      const u8 *data, unsigned int len, u8 *out)
 94{
 95	sha1(data, len, out);
 96	return 0;
 97}
 98
 99static int crypto_sha1_export(struct shash_desc *desc, void *out)
100{
101	return __crypto_sha1_export(SHA1_CTX(desc), out);
102}
103
104static int crypto_sha1_import(struct shash_desc *desc, const void *in)
105{
106	return __crypto_sha1_import(SHA1_CTX(desc), in);
107}
108
109static int crypto_sha1_export_core(struct shash_desc *desc, void *out)
110{
111	return __crypto_sha1_export_core(SHA1_CTX(desc), out);
112}
113
114static int crypto_sha1_import_core(struct shash_desc *desc, const void *in)
115{
116	return __crypto_sha1_import_core(SHA1_CTX(desc), in);
117}
118
119#define HMAC_SHA1_KEY(tfm) ((struct hmac_sha1_key *)crypto_shash_ctx(tfm))
120#define HMAC_SHA1_CTX(desc) ((struct hmac_sha1_ctx *)shash_desc_ctx(desc))
121
122static int crypto_hmac_sha1_setkey(struct crypto_shash *tfm,
123				   const u8 *raw_key, unsigned int keylen)
124{
125	hmac_sha1_preparekey(HMAC_SHA1_KEY(tfm), raw_key, keylen);
126	return 0;
127}
128
129static int crypto_hmac_sha1_init(struct shash_desc *desc)
130{
131	hmac_sha1_init(HMAC_SHA1_CTX(desc), HMAC_SHA1_KEY(desc->tfm));
132	return 0;
133}
134
135static int crypto_hmac_sha1_update(struct shash_desc *desc,
136				   const u8 *data, unsigned int len)
137{
138	hmac_sha1_update(HMAC_SHA1_CTX(desc), data, len);
139	return 0;
140}
141
142static int crypto_hmac_sha1_final(struct shash_desc *desc, u8 *out)
143{
144	hmac_sha1_final(HMAC_SHA1_CTX(desc), out);
145	return 0;
146}
147
148static int crypto_hmac_sha1_digest(struct shash_desc *desc,
149				   const u8 *data, unsigned int len, u8 *out)
150{
151	hmac_sha1(HMAC_SHA1_KEY(desc->tfm), data, len, out);
152	return 0;
153}
154
155static int crypto_hmac_sha1_export(struct shash_desc *desc, void *out)
156{
157	return __crypto_sha1_export(&HMAC_SHA1_CTX(desc)->sha_ctx, out);
158}
159
160static int crypto_hmac_sha1_import(struct shash_desc *desc, const void *in)
161{
162	struct hmac_sha1_ctx *ctx = HMAC_SHA1_CTX(desc);
163
164	ctx->ostate = HMAC_SHA1_KEY(desc->tfm)->ostate;
165	return __crypto_sha1_import(&ctx->sha_ctx, in);
166}
167
168static int crypto_hmac_sha1_export_core(struct shash_desc *desc, void *out)
169{
170	return __crypto_sha1_export_core(&HMAC_SHA1_CTX(desc)->sha_ctx, out);
171}
172
173static int crypto_hmac_sha1_import_core(struct shash_desc *desc, const void *in)
174{
175	struct hmac_sha1_ctx *ctx = HMAC_SHA1_CTX(desc);
176
177	ctx->ostate = HMAC_SHA1_KEY(desc->tfm)->ostate;
178	return __crypto_sha1_import_core(&ctx->sha_ctx, in);
179}
180
181static struct shash_alg algs[] = {
182	{
183		.base.cra_name		= "sha1",
184		.base.cra_driver_name	= "sha1-lib",
185		.base.cra_priority	= 300,
186		.base.cra_blocksize	= SHA1_BLOCK_SIZE,
187		.base.cra_module	= THIS_MODULE,
188		.digestsize		= SHA1_DIGEST_SIZE,
189		.init			= crypto_sha1_init,
190		.update			= crypto_sha1_update,
191		.final			= crypto_sha1_final,
192		.digest			= crypto_sha1_digest,
193		.export			= crypto_sha1_export,
194		.import			= crypto_sha1_import,
195		.export_core		= crypto_sha1_export_core,
196		.import_core		= crypto_sha1_import_core,
197		.descsize		= sizeof(struct sha1_ctx),
198		.statesize		= SHA1_SHASH_STATE_SIZE,
199	},
200	{
201		.base.cra_name		= "hmac(sha1)",
202		.base.cra_driver_name	= "hmac-sha1-lib",
203		.base.cra_priority	= 300,
204		.base.cra_blocksize	= SHA1_BLOCK_SIZE,
205		.base.cra_ctxsize	= sizeof(struct hmac_sha1_key),
206		.base.cra_module	= THIS_MODULE,
207		.digestsize		= SHA1_DIGEST_SIZE,
208		.setkey			= crypto_hmac_sha1_setkey,
209		.init			= crypto_hmac_sha1_init,
210		.update			= crypto_hmac_sha1_update,
211		.final			= crypto_hmac_sha1_final,
212		.digest			= crypto_hmac_sha1_digest,
213		.export			= crypto_hmac_sha1_export,
214		.import			= crypto_hmac_sha1_import,
215		.export_core		= crypto_hmac_sha1_export_core,
216		.import_core		= crypto_hmac_sha1_import_core,
217		.descsize		= sizeof(struct hmac_sha1_ctx),
218		.statesize		= SHA1_SHASH_STATE_SIZE,
219	},
220};
221
222static int __init crypto_sha1_mod_init(void)
223{
224	return crypto_register_shashes(algs, ARRAY_SIZE(algs));
225}
226module_init(crypto_sha1_mod_init);
227
228static void __exit crypto_sha1_mod_exit(void)
229{
230	crypto_unregister_shashes(algs, ARRAY_SIZE(algs));
231}
232module_exit(crypto_sha1_mod_exit);
233
234MODULE_LICENSE("GPL");
235MODULE_DESCRIPTION("Crypto API support for SHA-1 and HMAC-SHA1");
236
237MODULE_ALIAS_CRYPTO("sha1");
238MODULE_ALIAS_CRYPTO("sha1-lib");
239MODULE_ALIAS_CRYPTO("hmac(sha1)");
240MODULE_ALIAS_CRYPTO("hmac-sha1-lib");