Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
crypto: rmd160 - Use API partial block handling
Use the Crypto API partial block handling.
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
+35
-51
+35
-51
crypto/rmd160.c
+35
-51
crypto/rmd160.c
···
9
9
* Copyright (c) 2008 Adrian-Ken Rueegsegger <ken@codelabs.ch>
10
10
*/
11
11
#include <crypto/internal/hash.h>
12
-
#include <linux/init.h>
12
+
#include <linux/kernel.h>
13
13
#include <linux/module.h>
14
-
#include <linux/mm.h>
15
-
#include <linux/types.h>
16
-
#include <asm/byteorder.h>
17
-
14
+
#include <linux/string.h>
18
15
#include "ripemd.h"
19
16
20
17
struct rmd160_ctx {
21
18
u64 byte_count;
22
19
u32 state[5];
23
-
__le32 buffer[16];
24
20
};
25
21
26
22
#define K1 RMD_K1
···
261
265
rctx->state[3] = RMD_H3;
262
266
rctx->state[4] = RMD_H4;
263
267
264
-
memset(rctx->buffer, 0, sizeof(rctx->buffer));
265
-
266
268
return 0;
267
269
}
268
270
269
271
static int rmd160_update(struct shash_desc *desc, const u8 *data,
270
272
unsigned int len)
271
273
{
274
+
int remain = len - round_down(len, RMD160_BLOCK_SIZE);
272
275
struct rmd160_ctx *rctx = shash_desc_ctx(desc);
273
-
const u32 avail = sizeof(rctx->buffer) - (rctx->byte_count & 0x3f);
276
+
__le32 buffer[RMD160_BLOCK_SIZE / 4];
274
277
275
-
rctx->byte_count += len;
278
+
rctx->byte_count += len - remain;
276
279
277
-
/* Enough space in buffer? If so copy and we're done */
278
-
if (avail > len) {
279
-
memcpy((char *)rctx->buffer + (sizeof(rctx->buffer) - avail),
280
-
data, len);
281
-
goto out;
282
-
}
280
+
do {
281
+
memcpy(buffer, data, sizeof(buffer));
282
+
rmd160_transform(rctx->state, buffer);
283
+
data += sizeof(buffer);
284
+
len -= sizeof(buffer);
285
+
} while (len >= sizeof(buffer));
283
286
284
-
memcpy((char *)rctx->buffer + (sizeof(rctx->buffer) - avail),
285
-
data, avail);
286
-
287
-
rmd160_transform(rctx->state, rctx->buffer);
288
-
data += avail;
289
-
len -= avail;
290
-
291
-
while (len >= sizeof(rctx->buffer)) {
292
-
memcpy(rctx->buffer, data, sizeof(rctx->buffer));
293
-
rmd160_transform(rctx->state, rctx->buffer);
294
-
data += sizeof(rctx->buffer);
295
-
len -= sizeof(rctx->buffer);
296
-
}
297
-
298
-
memcpy(rctx->buffer, data, len);
299
-
300
-
out:
301
-
return 0;
287
+
memzero_explicit(buffer, sizeof(buffer));
288
+
return remain;
302
289
}
303
290
304
291
/* Add padding and return the message digest. */
305
-
static int rmd160_final(struct shash_desc *desc, u8 *out)
292
+
static int rmd160_finup(struct shash_desc *desc, const u8 *src,
293
+
unsigned int len, u8 *out)
306
294
{
295
+
unsigned int bit_offset = RMD160_BLOCK_SIZE / 8 - 1;
307
296
struct rmd160_ctx *rctx = shash_desc_ctx(desc);
308
-
u32 i, index, padlen;
309
-
__le64 bits;
297
+
union {
298
+
__le64 l64[RMD160_BLOCK_SIZE / 4];
299
+
__le32 l32[RMD160_BLOCK_SIZE / 2];
300
+
u8 u8[RMD160_BLOCK_SIZE * 2];
301
+
} block = {};
310
302
__le32 *dst = (__le32 *)out;
311
-
static const u8 padding[64] = { 0x80, };
303
+
u32 i;
312
304
313
-
bits = cpu_to_le64(rctx->byte_count << 3);
305
+
rctx->byte_count += len;
306
+
if (len >= bit_offset * 8)
307
+
bit_offset += RMD160_BLOCK_SIZE / 8;
308
+
memcpy(&block, src, len);
309
+
block.u8[len] = 0x80;
310
+
block.l64[bit_offset] = cpu_to_le64(rctx->byte_count << 3);
314
311
315
-
/* Pad out to 56 mod 64 */
316
-
index = rctx->byte_count & 0x3f;
317
-
padlen = (index < 56) ? (56 - index) : ((64+56) - index);
318
-
rmd160_update(desc, padding, padlen);
319
-
320
-
/* Append length */
321
-
rmd160_update(desc, (const u8 *)&bits, sizeof(bits));
312
+
rmd160_transform(rctx->state, block.l32);
313
+
if (bit_offset > RMD160_BLOCK_SIZE / 8)
314
+
rmd160_transform(rctx->state,
315
+
block.l32 + RMD160_BLOCK_SIZE / 4);
316
+
memzero_explicit(&block, sizeof(block));
322
317
323
318
/* Store state in digest */
324
319
for (i = 0; i < 5; i++)
325
320
dst[i] = cpu_to_le32p(&rctx->state[i]);
326
-
327
-
/* Wipe context */
328
-
memset(rctx, 0, sizeof(*rctx));
329
-
330
321
return 0;
331
322
}
332
323
···
321
338
.digestsize = RMD160_DIGEST_SIZE,
322
339
.init = rmd160_init,
323
340
.update = rmd160_update,
324
-
.final = rmd160_final,
341
+
.finup = rmd160_finup,
325
342
.descsize = sizeof(struct rmd160_ctx),
326
343
.base = {
327
344
.cra_name = "rmd160",
328
345
.cra_driver_name = "rmd160-generic",
346
+
.cra_flags = CRYPTO_AHASH_ALG_BLOCK_ONLY,
329
347
.cra_blocksize = RMD160_BLOCK_SIZE,
330
348
.cra_module = THIS_MODULE,
331
349
}