Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
crypto: riscv/sha512 - Use API partial block handling
Use the Crypto API partial block handling.
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
+28
-30
+19
-28
arch/riscv/crypto/sha512-riscv64-glue.c
+19
-28
arch/riscv/crypto/sha512-riscv64-glue.c
···
14
14
#include <crypto/internal/hash.h>
15
15
#include <crypto/internal/simd.h>
16
16
#include <crypto/sha512_base.h>
17
-
#include <linux/linkage.h>
17
+
#include <linux/kernel.h>
18
18
#include <linux/module.h>
19
19
20
20
/*
···
24
24
asmlinkage void sha512_transform_zvknhb_zvkb(
25
25
struct sha512_state *state, const u8 *data, int num_blocks);
26
26
27
-
static int riscv64_sha512_update(struct shash_desc *desc, const u8 *data,
28
-
unsigned int len)
27
+
static void sha512_block(struct sha512_state *state, const u8 *data,
28
+
int num_blocks)
29
29
{
30
30
/*
31
31
* Ensure struct sha512_state begins directly with the SHA-512
···
35
35
36
36
if (crypto_simd_usable()) {
37
37
kernel_vector_begin();
38
-
sha512_base_do_update(desc, data, len,
39
-
sha512_transform_zvknhb_zvkb);
38
+
sha512_transform_zvknhb_zvkb(state, data, num_blocks);
40
39
kernel_vector_end();
41
40
} else {
42
-
crypto_sha512_update(desc, data, len);
41
+
sha512_generic_block_fn(state, data, num_blocks);
43
42
}
44
-
return 0;
43
+
}
44
+
45
+
static int riscv64_sha512_update(struct shash_desc *desc, const u8 *data,
46
+
unsigned int len)
47
+
{
48
+
return sha512_base_do_update_blocks(desc, data, len, sha512_block);
45
49
}
46
50
47
51
static int riscv64_sha512_finup(struct shash_desc *desc, const u8 *data,
48
52
unsigned int len, u8 *out)
49
53
{
50
-
if (crypto_simd_usable()) {
51
-
kernel_vector_begin();
52
-
if (len)
53
-
sha512_base_do_update(desc, data, len,
54
-
sha512_transform_zvknhb_zvkb);
55
-
sha512_base_do_finalize(desc, sha512_transform_zvknhb_zvkb);
56
-
kernel_vector_end();
57
-
58
-
return sha512_base_finish(desc, out);
59
-
}
60
-
61
-
return crypto_sha512_finup(desc, data, len, out);
62
-
}
63
-
64
-
static int riscv64_sha512_final(struct shash_desc *desc, u8 *out)
65
-
{
66
-
return riscv64_sha512_finup(desc, NULL, 0, out);
54
+
sha512_base_do_finup(desc, data, len, sha512_block);
55
+
return sha512_base_finish(desc, out);
67
56
}
68
57
69
58
static int riscv64_sha512_digest(struct shash_desc *desc, const u8 *data,
···
66
77
{
67
78
.init = sha512_base_init,
68
79
.update = riscv64_sha512_update,
69
-
.final = riscv64_sha512_final,
70
80
.finup = riscv64_sha512_finup,
71
81
.digest = riscv64_sha512_digest,
72
-
.descsize = sizeof(struct sha512_state),
82
+
.descsize = SHA512_STATE_SIZE,
73
83
.digestsize = SHA512_DIGEST_SIZE,
74
84
.base = {
75
85
.cra_blocksize = SHA512_BLOCK_SIZE,
76
86
.cra_priority = 300,
87
+
.cra_flags = CRYPTO_AHASH_ALG_BLOCK_ONLY |
88
+
CRYPTO_AHASH_ALG_FINUP_MAX,
77
89
.cra_name = "sha512",
78
90
.cra_driver_name = "sha512-riscv64-zvknhb-zvkb",
79
91
.cra_module = THIS_MODULE,
···
82
92
}, {
83
93
.init = sha384_base_init,
84
94
.update = riscv64_sha512_update,
85
-
.final = riscv64_sha512_final,
86
95
.finup = riscv64_sha512_finup,
87
-
.descsize = sizeof(struct sha512_state),
96
+
.descsize = SHA512_STATE_SIZE,
88
97
.digestsize = SHA384_DIGEST_SIZE,
89
98
.base = {
90
99
.cra_blocksize = SHA384_BLOCK_SIZE,
91
100
.cra_priority = 300,
101
+
.cra_flags = CRYPTO_AHASH_ALG_BLOCK_ONLY |
102
+
CRYPTO_AHASH_ALG_FINUP_MAX,
92
103
.cra_name = "sha384",
93
104
.cra_driver_name = "sha384-riscv64-zvknhb-zvkb",
94
105
.cra_module = THIS_MODULE,
+3
-2
crypto/sha512_generic.c
+3
-2
crypto/sha512_generic.c
···
145
145
state[4] += e; state[5] += f; state[6] += g; state[7] += h;
146
146
}
147
147
148
-
static void sha512_generic_block_fn(struct sha512_state *sst, u8 const *src,
149
-
int blocks)
148
+
void sha512_generic_block_fn(struct sha512_state *sst, u8 const *src,
149
+
int blocks)
150
150
{
151
151
while (blocks--) {
152
152
sha512_transform(sst->state, src);
153
153
src += SHA512_BLOCK_SIZE;
154
154
}
155
155
}
156
+
EXPORT_SYMBOL_GPL(sha512_generic_block_fn);
156
157
157
158
int crypto_sha512_update(struct shash_desc *desc, const u8 *data,
158
159
unsigned int len)
+6
include/crypto/sha512_base.h
+6
include/crypto/sha512_base.h
···
10
10
11
11
#include <crypto/internal/hash.h>
12
12
#include <crypto/sha2.h>
13
+
#include <linux/compiler.h>
14
+
#include <linux/math.h>
13
15
#include <linux/string.h>
16
+
#include <linux/types.h>
14
17
#include <linux/unaligned.h>
15
18
16
19
typedef void (sha512_block_fn)(struct sha512_state *sst, u8 const *src,
···
177
174
put_unaligned_be64(sctx->state[i], digest++);
178
175
return 0;
179
176
}
177
+
178
+
void sha512_generic_block_fn(struct sha512_state *sst, u8 const *src,
179
+
int blocks);
180
180
181
181
#endif /* _CRYPTO_SHA512_BASE_H */