Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
torvalds
GitHub Repository: torvalds/linux
 Path: blob/master/arch/powerpc/crypto/md5-glue.c
26424 views
1
// SPDX-License-Identifier: GPL-2.0-or-later

2
/*

3
 * Glue code for MD5 implementation for PPC assembler

4
 *

5
 * Based on generic implementation.

6
 *

7
 * Copyright (c) 2015 Markus Stockhausen <[email protected]>

8
 */

9


10
#include <crypto/internal/hash.h>

11
#include <crypto/md5.h>

12
#include <linux/kernel.h>

13
#include <linux/module.h>

14
#include <linux/string.h>

15


16
extern void ppc_md5_transform(u32 *state, const u8 *src, u32 blocks);

17


18
static int ppc_md5_init(struct shash_desc *desc)

19
{

20
	struct md5_state *sctx = shash_desc_ctx(desc);

21


22
	sctx->hash[0] = MD5_H0;

23
	sctx->hash[1] = MD5_H1;

24
	sctx->hash[2] = MD5_H2;

25
	sctx->hash[3] =	MD5_H3;

26
	sctx->byte_count = 0;

27


28
	return 0;

29
}

30


31
static int ppc_md5_update(struct shash_desc *desc, const u8 *data,

32
			unsigned int len)

33
{

34
	struct md5_state *sctx = shash_desc_ctx(desc);

35


36
	sctx->byte_count += round_down(len, MD5_HMAC_BLOCK_SIZE);

37
	ppc_md5_transform(sctx->hash, data, len >> 6);

38
	return len - round_down(len, MD5_HMAC_BLOCK_SIZE);

39
}

40


41
static int ppc_md5_finup(struct shash_desc *desc, const u8 *src,

42
			 unsigned int offset, u8 *out)

43
{

44
	struct md5_state *sctx = shash_desc_ctx(desc);

45
	__le64 block[MD5_BLOCK_WORDS] = {};

46
	u8 *p = memcpy(block, src, offset);

47
	__le32 *dst = (__le32 *)out;

48
	__le64 *pbits;

49


50
	src = p;

51
	p += offset;

52
	*p++ = 0x80;

53
	sctx->byte_count += offset;

54
	pbits = &block[(MD5_BLOCK_WORDS / (offset > 55 ? 1 : 2)) - 1];

55
	*pbits = cpu_to_le64(sctx->byte_count << 3);

56
	ppc_md5_transform(sctx->hash, src, (pbits - block + 1) / 8);

57
	memzero_explicit(block, sizeof(block));

58


59
	dst[0] = cpu_to_le32(sctx->hash[0]);

60
	dst[1] = cpu_to_le32(sctx->hash[1]);

61
	dst[2] = cpu_to_le32(sctx->hash[2]);

62
	dst[3] = cpu_to_le32(sctx->hash[3]);

63
	return 0;

64
}

65


66
static struct shash_alg alg = {

67
	.digestsize	=	MD5_DIGEST_SIZE,

68
	.init		=	ppc_md5_init,

69
	.update		=	ppc_md5_update,

70
	.finup		=	ppc_md5_finup,

71
	.descsize	=	MD5_STATE_SIZE,

72
	.base		=	{

73
		.cra_name	=	"md5",

74
		.cra_driver_name=	"md5-ppc",

75
		.cra_priority	=	200,

76
		.cra_flags	=	CRYPTO_AHASH_ALG_BLOCK_ONLY,

77
		.cra_blocksize	=	MD5_HMAC_BLOCK_SIZE,

78
		.cra_module	=	THIS_MODULE,

79
	}

80
};

81


82
static int __init ppc_md5_mod_init(void)

83
{

84
	return crypto_register_shash(&alg);

85
}

86


87
static void __exit ppc_md5_mod_fini(void)

88
{

89
	crypto_unregister_shash(&alg);

90
}

91


92
module_init(ppc_md5_mod_init);

93
module_exit(ppc_md5_mod_fini);

94


95
MODULE_LICENSE("GPL");

96
MODULE_DESCRIPTION("MD5 Secure Hash Algorithm, PPC assembler");

97


98
MODULE_ALIAS_CRYPTO("md5");

99
MODULE_ALIAS_CRYPTO("md5-ppc");

100


101