projects/linux·blob master · refs

229 lines · 6.2 KiB

1/* SPDX-License-Identifier: GPL-2.0 */
2#ifndef _CRYPTO_MD5_H
3#define _CRYPTO_MD5_H
4
5#include <crypto/hash.h>
6#include <linux/types.h>
7#include <linux/string.h>
8
9#define MD5_DIGEST_SIZE 16
10#define MD5_HMAC_BLOCK_SIZE 64
11#define MD5_BLOCK_SIZE 64
12#define MD5_BLOCK_WORDS 16
13#define MD5_HASH_WORDS 4
14#define MD5_STATE_SIZE 24
15
16#define MD5_H0 0x67452301UL
17#define MD5_H1 0xefcdab89UL
18#define MD5_H2 0x98badcfeUL
19#define MD5_H3 0x10325476UL
20
21#define CRYPTO_MD5_STATESIZE \
22 CRYPTO_HASH_STATESIZE(MD5_STATE_SIZE, MD5_HMAC_BLOCK_SIZE)
23
24extern const u8 md5_zero_message_hash[MD5_DIGEST_SIZE];
25
26struct md5_state {
27 u32 hash[MD5_HASH_WORDS];
28 u64 byte_count;
29 u32 block[MD5_BLOCK_WORDS];
30};
31
32/* State for the MD5 compression function */
33struct md5_block_state {
34 u32 h[MD5_HASH_WORDS];
35};
36
37/**
38 * struct md5_ctx - Context for hashing a message with MD5
39 * @state: the compression function state
40 * @bytecount: number of bytes processed so far
41 * @buf: partial block buffer; bytecount % MD5_BLOCK_SIZE bytes are valid
42 */
43struct md5_ctx {
44 struct md5_block_state state;
45 u64 bytecount;
46 u8 buf[MD5_BLOCK_SIZE] __aligned(__alignof__(__le64));
47};
48
49/**
50 * md5_init() - Initialize an MD5 context for a new message
51 * @ctx: the context to initialize
52 *
53 * If you don't need incremental computation, consider md5() instead.
54 *
55 * Context: Any context.
56 */
57void md5_init(struct md5_ctx *ctx);
58
59/**
60 * md5_update() - Update an MD5 context with message data
61 * @ctx: the context to update; must have been initialized
62 * @data: the message data
63 * @len: the data length in bytes
64 *
65 * This can be called any number of times.
66 *
67 * Context: Any context.
68 */
69void md5_update(struct md5_ctx *ctx, const u8 *data, size_t len);
70
71/**
72 * md5_final() - Finish computing an MD5 message digest
73 * @ctx: the context to finalize; must have been initialized
74 * @out: (output) the resulting MD5 message digest
75 *
76 * After finishing, this zeroizes @ctx. So the caller does not need to do it.
77 *
78 * Context: Any context.
79 */
80void md5_final(struct md5_ctx *ctx, u8 out[at_least MD5_DIGEST_SIZE]);
81
82/**
83 * md5() - Compute MD5 message digest in one shot
84 * @data: the message data
85 * @len: the data length in bytes
86 * @out: (output) the resulting MD5 message digest
87 *
88 * Context: Any context.
89 */
90void md5(const u8 *data, size_t len, u8 out[at_least MD5_DIGEST_SIZE]);
91
92/**
93 * struct hmac_md5_key - Prepared key for HMAC-MD5
94 * @istate: private
95 * @ostate: private
96 */
97struct hmac_md5_key {
98 struct md5_block_state istate;
99 struct md5_block_state ostate;
100};
101
102/**
103 * hmac_md5_zeroize_key() - Zeroize an hmac_md5_key structure
104 * @key: The hmac_md5_key to zeroize
105 */
106static inline void hmac_md5_zeroize_key(struct hmac_md5_key *key)
107{
108 memzero_explicit(key, sizeof(*key));
109}
110
111/**
112 * struct hmac_md5_ctx - Context for computing HMAC-MD5 of a message
113 * @hash_ctx: private
114 * @ostate: private
115 */
116struct hmac_md5_ctx {
117 struct md5_ctx hash_ctx;
118 struct md5_block_state ostate;
119};
120
121/**
122 * hmac_md5_zeroize_ctx() - Zeroize an hmac_md5_ctx structure
123 * @ctx: The hmac_md5_ctx context to zeroize
124 */
125static inline void hmac_md5_zeroize_ctx(struct hmac_md5_ctx *ctx)
126{
127 memzero_explicit(ctx, sizeof(*ctx));
128}
129
130/**
131 * hmac_md5_preparekey() - Prepare a key for HMAC-MD5
132 * @key: (output) the key structure to initialize
133 * @raw_key: the raw HMAC-MD5 key
134 * @raw_key_len: the key length in bytes. All key lengths are supported.
135 *
136 * Note: the caller is responsible for zeroizing both the struct hmac_md5_key
137 * and the raw key once they are no longer needed.
138 *
139 * Context: Any context.
140 */
141void hmac_md5_preparekey(struct hmac_md5_key *key,
142 const u8 *raw_key, size_t raw_key_len);
143
144/**
145 * hmac_md5_init() - Initialize an HMAC-MD5 context for a new message
146 * @ctx: (output) the HMAC context to initialize
147 * @key: the prepared HMAC key
148 *
149 * If you don't need incremental computation, consider hmac_md5() instead.
150 *
151 * Context: Any context.
152 */
153void hmac_md5_init(struct hmac_md5_ctx *ctx, const struct hmac_md5_key *key);
154
155/**
156 * hmac_md5_init_usingrawkey() - Initialize an HMAC-MD5 context for a new
157 * message, using a raw key
158 * @ctx: (output) the HMAC context to initialize
159 * @raw_key: the raw HMAC-MD5 key
160 * @raw_key_len: the key length in bytes. All key lengths are supported.
161 *
162 * If you don't need incremental computation, consider hmac_md5_usingrawkey()
163 * instead.
164 *
165 * Context: Any context.
166 */
167void hmac_md5_init_usingrawkey(struct hmac_md5_ctx *ctx,
168 const u8 *raw_key, size_t raw_key_len);
169
170/**
171 * hmac_md5_update() - Update an HMAC-MD5 context with message data
172 * @ctx: the HMAC context to update; must have been initialized
173 * @data: the message data
174 * @data_len: the data length in bytes
175 *
176 * This can be called any number of times.
177 *
178 * Context: Any context.
179 */
180static inline void hmac_md5_update(struct hmac_md5_ctx *ctx,
181 const u8 *data, size_t data_len)
182{
183 md5_update(&ctx->hash_ctx, data, data_len);
184}
185
186/**
187 * hmac_md5_final() - Finish computing an HMAC-MD5 value
188 * @ctx: the HMAC context to finalize; must have been initialized
189 * @out: (output) the resulting HMAC-MD5 value
190 *
191 * After finishing, this zeroizes @ctx. So the caller does not need to do it.
192 *
193 * Context: Any context.
194 */
195void hmac_md5_final(struct hmac_md5_ctx *ctx, u8 out[at_least MD5_DIGEST_SIZE]);
196
197/**
198 * hmac_md5() - Compute HMAC-MD5 in one shot, using a prepared key
199 * @key: the prepared HMAC key
200 * @data: the message data
201 * @data_len: the data length in bytes
202 * @out: (output) the resulting HMAC-MD5 value
203 *
204 * If you're using the key only once, consider using hmac_md5_usingrawkey().
205 *
206 * Context: Any context.
207 */
208void hmac_md5(const struct hmac_md5_key *key,
209 const u8 *data, size_t data_len,
210 u8 out[at_least MD5_DIGEST_SIZE]);
211
212/**
213 * hmac_md5_usingrawkey() - Compute HMAC-MD5 in one shot, using a raw key
214 * @raw_key: the raw HMAC-MD5 key
215 * @raw_key_len: the key length in bytes. All key lengths are supported.
216 * @data: the message data
217 * @data_len: the data length in bytes
218 * @out: (output) the resulting HMAC-MD5 value
219 *
220 * If you're using the key multiple times, prefer to use hmac_md5_preparekey()
221 * followed by multiple calls to hmac_md5() instead.
222 *
223 * Context: Any context.
224 */
225void hmac_md5_usingrawkey(const u8 *raw_key, size_t raw_key_len,
226 const u8 *data, size_t data_len,
227 u8 out[at_least MD5_DIGEST_SIZE]);
228
229#endif /* _CRYPTO_MD5_H */