Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
torvalds
GitHub Repository: torvalds/linux
 Path: blob/master/arch/x86/crypto/ecb_cbc_helpers.h
26442 views
1
/* SPDX-License-Identifier: GPL-2.0 */

2


3
#ifndef _CRYPTO_ECB_CBC_HELPER_H

4
#define _CRYPTO_ECB_CBC_HELPER_H

5


6
#include <crypto/internal/skcipher.h>

7
#include <asm/fpu/api.h>

8


9
/*

10
 * Mode helpers to instantiate parameterized skcipher ECB/CBC modes without

11
 * having to rely on indirect calls and retpolines.

12
 */

13


14
#define ECB_WALK_START(req, bsize, fpu_blocks) do {			\

15
	void *ctx = crypto_skcipher_ctx(crypto_skcipher_reqtfm(req));	\

16
	const int __fpu_blocks = (fpu_blocks);				\

17
	const int __bsize = (bsize);					\

18
	struct skcipher_walk walk;					\

19
	int err = skcipher_walk_virt(&walk, (req), false);		\

20
	while (walk.nbytes > 0) {					\

21
		unsigned int nbytes = walk.nbytes;			\

22
		bool do_fpu = __fpu_blocks != -1 &&			\

23
			      nbytes >= __fpu_blocks * __bsize;		\

24
		const u8 *src = walk.src.virt.addr;			\

25
		u8 *dst = walk.dst.virt.addr;				\

26
		u8 __maybe_unused buf[(bsize)];				\

27
		if (do_fpu) kernel_fpu_begin()

28


29
#define CBC_WALK_START(req, bsize, fpu_blocks)				\

30
	ECB_WALK_START(req, bsize, fpu_blocks)

31


32
#define ECB_WALK_ADVANCE(blocks) do {					\

33
	dst += (blocks) * __bsize;					\

34
	src += (blocks) * __bsize;					\

35
	nbytes -= (blocks) * __bsize;					\

36
} while (0)

37


38
#define ECB_BLOCK(blocks, func) do {					\

39
	const int __blocks = (blocks);					\

40
	if (do_fpu && __blocks < __fpu_blocks) {			\

41
		kernel_fpu_end();					\

42
		do_fpu = false;						\

43
	}								\

44
	while (nbytes >= __blocks * __bsize) {				\

45
		(func)(ctx, dst, src);					\

46
		ECB_WALK_ADVANCE(blocks);				\

47
	}								\

48
} while (0)

49


50
#define CBC_ENC_BLOCK(func) do {					\

51
	const u8 *__iv = walk.iv;					\

52
	while (nbytes >= __bsize) {					\

53
		crypto_xor_cpy(dst, src, __iv, __bsize);		\

54
		(func)(ctx, dst, dst);					\

55
		__iv = dst;						\

56
		ECB_WALK_ADVANCE(1);					\

57
	}								\

58
	memcpy(walk.iv, __iv, __bsize);					\

59
} while (0)

60


61
#define CBC_DEC_BLOCK(blocks, func) do {				\

62
	const int __blocks = (blocks);					\

63
	if (do_fpu && __blocks <  __fpu_blocks) {			\

64
		kernel_fpu_end();					\

65
		do_fpu = false;						\

66
	}								\

67
	while (nbytes >= __blocks * __bsize) {				\

68
		const u8 *__iv = src + ((blocks) - 1) * __bsize;	\

69
		if (dst == src)						\

70
			__iv = memcpy(buf, __iv, __bsize);		\

71
		(func)(ctx, dst, src);					\

72
		crypto_xor(dst, walk.iv, __bsize);			\

73
		memcpy(walk.iv, __iv, __bsize);				\

74
		ECB_WALK_ADVANCE(blocks);				\

75
	}								\

76
} while (0)

77


78
#define ECB_WALK_END()							\

79
		if (do_fpu) kernel_fpu_end();				\

80
		err = skcipher_walk_done(&walk, nbytes);		\

81
	}								\

82
	return err;							\

83
} while (0)

84


85
#define CBC_WALK_END() ECB_WALK_END()

86


87
#endif

88


89