]>
Commit | Line | Data |
---|---|---|
1953c22f AK |
1 | /* |
2 | * Cryptographic API. | |
3 | * | |
4 | * MD5 Message Digest Algorithm (RFC1321). | |
5 | * | |
6 | * Adapted for OCTEON by Aaro Koskinen <aaro.koskinen@iki.fi>. | |
7 | * | |
8 | * Based on crypto/md5.c, which is: | |
9 | * | |
10 | * Derived from cryptoapi implementation, originally based on the | |
11 | * public domain implementation written by Colin Plumb in 1993. | |
12 | * | |
13 | * Copyright (c) Cryptoapi developers. | |
14 | * Copyright (c) 2002 James Morris <jmorris@intercode.com.au> | |
15 | * | |
16 | * This program is free software; you can redistribute it and/or modify it | |
17 | * under the terms of the GNU General Public License as published by the Free | |
18 | * Software Foundation; either version 2 of the License, or (at your option) | |
19 | * any later version. | |
20 | */ | |
21 | ||
22 | #include <crypto/md5.h> | |
23 | #include <linux/init.h> | |
24 | #include <linux/types.h> | |
25 | #include <linux/module.h> | |
26 | #include <linux/string.h> | |
27 | #include <asm/byteorder.h> | |
28 | #include <linux/cryptohash.h> | |
29 | #include <asm/octeon/octeon.h> | |
30 | #include <crypto/internal/hash.h> | |
31 | ||
32 | #include "octeon-crypto.h" | |
33 | ||
34 | /* | |
35 | * We pass everything as 64-bit. OCTEON can handle misaligned data. | |
36 | */ | |
37 | ||
38 | static void octeon_md5_store_hash(struct md5_state *ctx) | |
39 | { | |
40 | u64 *hash = (u64 *)ctx->hash; | |
41 | ||
42 | write_octeon_64bit_hash_dword(hash[0], 0); | |
43 | write_octeon_64bit_hash_dword(hash[1], 1); | |
44 | } | |
45 | ||
46 | static void octeon_md5_read_hash(struct md5_state *ctx) | |
47 | { | |
48 | u64 *hash = (u64 *)ctx->hash; | |
49 | ||
50 | hash[0] = read_octeon_64bit_hash_dword(0); | |
51 | hash[1] = read_octeon_64bit_hash_dword(1); | |
52 | } | |
53 | ||
54 | static void octeon_md5_transform(const void *_block) | |
55 | { | |
56 | const u64 *block = _block; | |
57 | ||
58 | write_octeon_64bit_block_dword(block[0], 0); | |
59 | write_octeon_64bit_block_dword(block[1], 1); | |
60 | write_octeon_64bit_block_dword(block[2], 2); | |
61 | write_octeon_64bit_block_dword(block[3], 3); | |
62 | write_octeon_64bit_block_dword(block[4], 4); | |
63 | write_octeon_64bit_block_dword(block[5], 5); | |
64 | write_octeon_64bit_block_dword(block[6], 6); | |
65 | octeon_md5_start(block[7]); | |
66 | } | |
67 | ||
68 | static int octeon_md5_init(struct shash_desc *desc) | |
69 | { | |
70 | struct md5_state *mctx = shash_desc_ctx(desc); | |
71 | ||
1beb6b92 LC |
72 | mctx->hash[0] = cpu_to_le32(MD5_H0); |
73 | mctx->hash[1] = cpu_to_le32(MD5_H1); | |
74 | mctx->hash[2] = cpu_to_le32(MD5_H2); | |
75 | mctx->hash[3] = cpu_to_le32(MD5_H3); | |
1953c22f AK |
76 | mctx->byte_count = 0; |
77 | ||
78 | return 0; | |
79 | } | |
80 | ||
81 | static int octeon_md5_update(struct shash_desc *desc, const u8 *data, | |
82 | unsigned int len) | |
83 | { | |
84 | struct md5_state *mctx = shash_desc_ctx(desc); | |
85 | const u32 avail = sizeof(mctx->block) - (mctx->byte_count & 0x3f); | |
86 | struct octeon_cop2_state state; | |
87 | unsigned long flags; | |
88 | ||
89 | mctx->byte_count += len; | |
90 | ||
91 | if (avail > len) { | |
92 | memcpy((char *)mctx->block + (sizeof(mctx->block) - avail), | |
93 | data, len); | |
94 | return 0; | |
95 | } | |
96 | ||
97 | memcpy((char *)mctx->block + (sizeof(mctx->block) - avail), data, | |
98 | avail); | |
99 | ||
1953c22f AK |
100 | flags = octeon_crypto_enable(&state); |
101 | octeon_md5_store_hash(mctx); | |
102 | ||
103 | octeon_md5_transform(mctx->block); | |
104 | data += avail; | |
105 | len -= avail; | |
106 | ||
107 | while (len >= sizeof(mctx->block)) { | |
108 | octeon_md5_transform(data); | |
109 | data += sizeof(mctx->block); | |
110 | len -= sizeof(mctx->block); | |
111 | } | |
112 | ||
113 | octeon_md5_read_hash(mctx); | |
114 | octeon_crypto_disable(&state, flags); | |
1953c22f AK |
115 | |
116 | memcpy(mctx->block, data, len); | |
117 | ||
118 | return 0; | |
119 | } | |
120 | ||
121 | static int octeon_md5_final(struct shash_desc *desc, u8 *out) | |
122 | { | |
123 | struct md5_state *mctx = shash_desc_ctx(desc); | |
124 | const unsigned int offset = mctx->byte_count & 0x3f; | |
125 | char *p = (char *)mctx->block + offset; | |
126 | int padding = 56 - (offset + 1); | |
127 | struct octeon_cop2_state state; | |
128 | unsigned long flags; | |
129 | ||
130 | *p++ = 0x80; | |
131 | ||
1953c22f AK |
132 | flags = octeon_crypto_enable(&state); |
133 | octeon_md5_store_hash(mctx); | |
134 | ||
135 | if (padding < 0) { | |
136 | memset(p, 0x00, padding + sizeof(u64)); | |
137 | octeon_md5_transform(mctx->block); | |
138 | p = (char *)mctx->block; | |
139 | padding = 56; | |
140 | } | |
141 | ||
142 | memset(p, 0, padding); | |
143 | mctx->block[14] = cpu_to_le32(mctx->byte_count << 3); | |
144 | mctx->block[15] = cpu_to_le32(mctx->byte_count >> 29); | |
145 | octeon_md5_transform(mctx->block); | |
146 | ||
147 | octeon_md5_read_hash(mctx); | |
148 | octeon_crypto_disable(&state, flags); | |
1953c22f AK |
149 | |
150 | memcpy(out, mctx->hash, sizeof(mctx->hash)); | |
151 | memset(mctx, 0, sizeof(*mctx)); | |
152 | ||
153 | return 0; | |
154 | } | |
155 | ||
156 | static int octeon_md5_export(struct shash_desc *desc, void *out) | |
157 | { | |
158 | struct md5_state *ctx = shash_desc_ctx(desc); | |
159 | ||
160 | memcpy(out, ctx, sizeof(*ctx)); | |
161 | return 0; | |
162 | } | |
163 | ||
164 | static int octeon_md5_import(struct shash_desc *desc, const void *in) | |
165 | { | |
166 | struct md5_state *ctx = shash_desc_ctx(desc); | |
167 | ||
168 | memcpy(ctx, in, sizeof(*ctx)); | |
169 | return 0; | |
170 | } | |
171 | ||
172 | static struct shash_alg alg = { | |
173 | .digestsize = MD5_DIGEST_SIZE, | |
174 | .init = octeon_md5_init, | |
175 | .update = octeon_md5_update, | |
176 | .final = octeon_md5_final, | |
177 | .export = octeon_md5_export, | |
178 | .import = octeon_md5_import, | |
179 | .descsize = sizeof(struct md5_state), | |
180 | .statesize = sizeof(struct md5_state), | |
181 | .base = { | |
182 | .cra_name = "md5", | |
183 | .cra_driver_name= "octeon-md5", | |
184 | .cra_priority = OCTEON_CR_OPCODE_PRIORITY, | |
185 | .cra_flags = CRYPTO_ALG_TYPE_SHASH, | |
186 | .cra_blocksize = MD5_HMAC_BLOCK_SIZE, | |
187 | .cra_module = THIS_MODULE, | |
188 | } | |
189 | }; | |
190 | ||
191 | static int __init md5_mod_init(void) | |
192 | { | |
193 | if (!octeon_has_crypto()) | |
194 | return -ENOTSUPP; | |
195 | return crypto_register_shash(&alg); | |
196 | } | |
197 | ||
198 | static void __exit md5_mod_fini(void) | |
199 | { | |
200 | crypto_unregister_shash(&alg); | |
201 | } | |
202 | ||
203 | module_init(md5_mod_init); | |
204 | module_exit(md5_mod_fini); | |
205 | ||
206 | MODULE_LICENSE("GPL"); | |
207 | MODULE_DESCRIPTION("MD5 Message Digest Algorithm (OCTEON)"); | |
208 | MODULE_AUTHOR("Aaro Koskinen <aaro.koskinen@iki.fi>"); |