Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 2952ff1a598ce300c911d00d82872d00ca8b61ca

Authored by Adrian-Ken Rueegsegger
Committed by Herbert Xu
1 parent c928a0cddd

[CRYPTO] rmd256: Fix endian issues 

This patch fixes endian issues making rmd256 work
properly on big-endian machines.

Signed-off-by: Adrian-Ken Rueegsegger <rueegsegger@swiss-it.ch>
Acked-by: Sebastian Siewior <sebastian@breakpoint.cc>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>

Showing 1 changed file with 9 additions and 28 deletions Inline Diff

1 /* 1 /*
2 * Cryptographic API. 2 * Cryptographic API.
3 * 3 *
4 * RIPEMD-256 - RACE Integrity Primitives Evaluation Message Digest. 4 * RIPEMD-256 - RACE Integrity Primitives Evaluation Message Digest.
5 * 5 *
6 * Based on the reference implementation by Antoon Bosselaers, ESAT-COSIC 6 * Based on the reference implementation by Antoon Bosselaers, ESAT-COSIC
7 * 7 *
8 * Copyright (c) 2008 Adrian-Ken Rueegsegger <rueegsegger (at) swiss-it.ch> 8 * Copyright (c) 2008 Adrian-Ken Rueegsegger <rueegsegger (at) swiss-it.ch>
9 * 9 *
10 * This program is free software; you can redistribute it and/or modify it 10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by the Free 11 * under the terms of the GNU General Public License as published by the Free
12 * Software Foundation; either version 2 of the License, or (at your option) 12 * Software Foundation; either version 2 of the License, or (at your option)
13 * any later version. 13 * any later version.
14 * 14 *
15 */ 15 */
16 #include <linux/init.h> 16 #include <linux/init.h>
17 #include <linux/module.h> 17 #include <linux/module.h>
18 #include <linux/mm.h> 18 #include <linux/mm.h>
19 #include <linux/crypto.h> 19 #include <linux/crypto.h>
20 #include <linux/cryptohash.h> 20 #include <linux/cryptohash.h>
21 #include <linux/types.h> 21 #include <linux/types.h>
22 #include <asm/byteorder.h> 22 #include <asm/byteorder.h>
23 23
24 #include "ripemd.h" 24 #include "ripemd.h"
25 25
26 struct rmd256_ctx { 26 struct rmd256_ctx {
27 u64 byte_count; 27 u64 byte_count;
28 u32 state[8]; 28 u32 state[8];
29 u32 buffer[16]; 29 u32 buffer[16];
30 }; 30 };
31 31
32 #define K1 RMD_K1 32 #define K1 RMD_K1
33 #define K2 RMD_K2 33 #define K2 RMD_K2
34 #define K3 RMD_K3 34 #define K3 RMD_K3
35 #define K4 RMD_K4 35 #define K4 RMD_K4
36 #define KK1 RMD_K6 36 #define KK1 RMD_K6
37 #define KK2 RMD_K7 37 #define KK2 RMD_K7
38 #define KK3 RMD_K8 38 #define KK3 RMD_K8
39 #define KK4 RMD_K1 39 #define KK4 RMD_K1
40 40
41 #define F1(x, y, z) (x ^ y ^ z) /* XOR */ 41 #define F1(x, y, z) (x ^ y ^ z) /* XOR */
42 #define F2(x, y, z) (z ^ (x & (y ^ z))) /* x ? y : z */ 42 #define F2(x, y, z) (z ^ (x & (y ^ z))) /* x ? y : z */
43 #define F3(x, y, z) ((x | ~y) ^ z) 43 #define F3(x, y, z) ((x | ~y) ^ z)
44 #define F4(x, y, z) (y ^ (z & (x ^ y))) /* z ? x : y */ 44 #define F4(x, y, z) (y ^ (z & (x ^ y))) /* z ? x : y */
45 45
46 #define ROUND(a, b, c, d, f, k, x, s) { \ 46 #define ROUND(a, b, c, d, f, k, x, s) { \
47 (a) += f((b), (c), (d)) + (x) + (k); \ 47 (a) += f((b), (c), (d)) + le32_to_cpu(x) + (k); \
48 (a) = rol32((a), (s)); \ 48 (a) = rol32((a), (s)); \
49 } 49 }
50 50
51 static void rmd256_transform(u32 *state, u32 const *in) 51 static void rmd256_transform(u32 *state, u32 const *in)
52 { 52 {
53 u32 aa, bb, cc, dd, aaa, bbb, ccc, ddd, tmp; 53 u32 aa, bb, cc, dd, aaa, bbb, ccc, ddd, tmp;
54 54
55 /* Initialize left lane */ 55 /* Initialize left lane */
56 aa = state[0]; 56 aa = state[0];
57 bb = state[1]; 57 bb = state[1];
58 cc = state[2]; 58 cc = state[2];
59 dd = state[3]; 59 dd = state[3];
60 60
61 /* Initialize right lane */ 61 /* Initialize right lane */
62 aaa = state[4]; 62 aaa = state[4];
63 bbb = state[5]; 63 bbb = state[5];
64 ccc = state[6]; 64 ccc = state[6];
65 ddd = state[7]; 65 ddd = state[7];
66 66
67 /* round 1: left lane */ 67 /* round 1: left lane */
68 ROUND(aa, bb, cc, dd, F1, K1, in[0], 11); 68 ROUND(aa, bb, cc, dd, F1, K1, in[0], 11);
69 ROUND(dd, aa, bb, cc, F1, K1, in[1], 14); 69 ROUND(dd, aa, bb, cc, F1, K1, in[1], 14);
70 ROUND(cc, dd, aa, bb, F1, K1, in[2], 15); 70 ROUND(cc, dd, aa, bb, F1, K1, in[2], 15);
71 ROUND(bb, cc, dd, aa, F1, K1, in[3], 12); 71 ROUND(bb, cc, dd, aa, F1, K1, in[3], 12);
72 ROUND(aa, bb, cc, dd, F1, K1, in[4], 5); 72 ROUND(aa, bb, cc, dd, F1, K1, in[4], 5);
73 ROUND(dd, aa, bb, cc, F1, K1, in[5], 8); 73 ROUND(dd, aa, bb, cc, F1, K1, in[5], 8);
74 ROUND(cc, dd, aa, bb, F1, K1, in[6], 7); 74 ROUND(cc, dd, aa, bb, F1, K1, in[6], 7);
75 ROUND(bb, cc, dd, aa, F1, K1, in[7], 9); 75 ROUND(bb, cc, dd, aa, F1, K1, in[7], 9);
76 ROUND(aa, bb, cc, dd, F1, K1, in[8], 11); 76 ROUND(aa, bb, cc, dd, F1, K1, in[8], 11);
77 ROUND(dd, aa, bb, cc, F1, K1, in[9], 13); 77 ROUND(dd, aa, bb, cc, F1, K1, in[9], 13);
78 ROUND(cc, dd, aa, bb, F1, K1, in[10], 14); 78 ROUND(cc, dd, aa, bb, F1, K1, in[10], 14);
79 ROUND(bb, cc, dd, aa, F1, K1, in[11], 15); 79 ROUND(bb, cc, dd, aa, F1, K1, in[11], 15);
80 ROUND(aa, bb, cc, dd, F1, K1, in[12], 6); 80 ROUND(aa, bb, cc, dd, F1, K1, in[12], 6);
81 ROUND(dd, aa, bb, cc, F1, K1, in[13], 7); 81 ROUND(dd, aa, bb, cc, F1, K1, in[13], 7);
82 ROUND(cc, dd, aa, bb, F1, K1, in[14], 9); 82 ROUND(cc, dd, aa, bb, F1, K1, in[14], 9);
83 ROUND(bb, cc, dd, aa, F1, K1, in[15], 8); 83 ROUND(bb, cc, dd, aa, F1, K1, in[15], 8);
84 84
85 /* round 1: right lane */ 85 /* round 1: right lane */
86 ROUND(aaa, bbb, ccc, ddd, F4, KK1, in[5], 8); 86 ROUND(aaa, bbb, ccc, ddd, F4, KK1, in[5], 8);
87 ROUND(ddd, aaa, bbb, ccc, F4, KK1, in[14], 9); 87 ROUND(ddd, aaa, bbb, ccc, F4, KK1, in[14], 9);
88 ROUND(ccc, ddd, aaa, bbb, F4, KK1, in[7], 9); 88 ROUND(ccc, ddd, aaa, bbb, F4, KK1, in[7], 9);
89 ROUND(bbb, ccc, ddd, aaa, F4, KK1, in[0], 11); 89 ROUND(bbb, ccc, ddd, aaa, F4, KK1, in[0], 11);
90 ROUND(aaa, bbb, ccc, ddd, F4, KK1, in[9], 13); 90 ROUND(aaa, bbb, ccc, ddd, F4, KK1, in[9], 13);
91 ROUND(ddd, aaa, bbb, ccc, F4, KK1, in[2], 15); 91 ROUND(ddd, aaa, bbb, ccc, F4, KK1, in[2], 15);
92 ROUND(ccc, ddd, aaa, bbb, F4, KK1, in[11], 15); 92 ROUND(ccc, ddd, aaa, bbb, F4, KK1, in[11], 15);
93 ROUND(bbb, ccc, ddd, aaa, F4, KK1, in[4], 5); 93 ROUND(bbb, ccc, ddd, aaa, F4, KK1, in[4], 5);
94 ROUND(aaa, bbb, ccc, ddd, F4, KK1, in[13], 7); 94 ROUND(aaa, bbb, ccc, ddd, F4, KK1, in[13], 7);
95 ROUND(ddd, aaa, bbb, ccc, F4, KK1, in[6], 7); 95 ROUND(ddd, aaa, bbb, ccc, F4, KK1, in[6], 7);
96 ROUND(ccc, ddd, aaa, bbb, F4, KK1, in[15], 8); 96 ROUND(ccc, ddd, aaa, bbb, F4, KK1, in[15], 8);
97 ROUND(bbb, ccc, ddd, aaa, F4, KK1, in[8], 11); 97 ROUND(bbb, ccc, ddd, aaa, F4, KK1, in[8], 11);
98 ROUND(aaa, bbb, ccc, ddd, F4, KK1, in[1], 14); 98 ROUND(aaa, bbb, ccc, ddd, F4, KK1, in[1], 14);
99 ROUND(ddd, aaa, bbb, ccc, F4, KK1, in[10], 14); 99 ROUND(ddd, aaa, bbb, ccc, F4, KK1, in[10], 14);
100 ROUND(ccc, ddd, aaa, bbb, F4, KK1, in[3], 12); 100 ROUND(ccc, ddd, aaa, bbb, F4, KK1, in[3], 12);
101 ROUND(bbb, ccc, ddd, aaa, F4, KK1, in[12], 6); 101 ROUND(bbb, ccc, ddd, aaa, F4, KK1, in[12], 6);
102 102
103 /* Swap contents of "a" registers */ 103 /* Swap contents of "a" registers */
104 tmp = aa; aa = aaa; aaa = tmp; 104 tmp = aa; aa = aaa; aaa = tmp;
105 105
106 /* round 2: left lane */ 106 /* round 2: left lane */
107 ROUND(aa, bb, cc, dd, F2, K2, in[7], 7); 107 ROUND(aa, bb, cc, dd, F2, K2, in[7], 7);
108 ROUND(dd, aa, bb, cc, F2, K2, in[4], 6); 108 ROUND(dd, aa, bb, cc, F2, K2, in[4], 6);
109 ROUND(cc, dd, aa, bb, F2, K2, in[13], 8); 109 ROUND(cc, dd, aa, bb, F2, K2, in[13], 8);
110 ROUND(bb, cc, dd, aa, F2, K2, in[1], 13); 110 ROUND(bb, cc, dd, aa, F2, K2, in[1], 13);
111 ROUND(aa, bb, cc, dd, F2, K2, in[10], 11); 111 ROUND(aa, bb, cc, dd, F2, K2, in[10], 11);
112 ROUND(dd, aa, bb, cc, F2, K2, in[6], 9); 112 ROUND(dd, aa, bb, cc, F2, K2, in[6], 9);
113 ROUND(cc, dd, aa, bb, F2, K2, in[15], 7); 113 ROUND(cc, dd, aa, bb, F2, K2, in[15], 7);
114 ROUND(bb, cc, dd, aa, F2, K2, in[3], 15); 114 ROUND(bb, cc, dd, aa, F2, K2, in[3], 15);
115 ROUND(aa, bb, cc, dd, F2, K2, in[12], 7); 115 ROUND(aa, bb, cc, dd, F2, K2, in[12], 7);
116 ROUND(dd, aa, bb, cc, F2, K2, in[0], 12); 116 ROUND(dd, aa, bb, cc, F2, K2, in[0], 12);
117 ROUND(cc, dd, aa, bb, F2, K2, in[9], 15); 117 ROUND(cc, dd, aa, bb, F2, K2, in[9], 15);
118 ROUND(bb, cc, dd, aa, F2, K2, in[5], 9); 118 ROUND(bb, cc, dd, aa, F2, K2, in[5], 9);
119 ROUND(aa, bb, cc, dd, F2, K2, in[2], 11); 119 ROUND(aa, bb, cc, dd, F2, K2, in[2], 11);
120 ROUND(dd, aa, bb, cc, F2, K2, in[14], 7); 120 ROUND(dd, aa, bb, cc, F2, K2, in[14], 7);
121 ROUND(cc, dd, aa, bb, F2, K2, in[11], 13); 121 ROUND(cc, dd, aa, bb, F2, K2, in[11], 13);
122 ROUND(bb, cc, dd, aa, F2, K2, in[8], 12); 122 ROUND(bb, cc, dd, aa, F2, K2, in[8], 12);
123 123
124 /* round 2: right lane */ 124 /* round 2: right lane */
125 ROUND(aaa, bbb, ccc, ddd, F3, KK2, in[6], 9); 125 ROUND(aaa, bbb, ccc, ddd, F3, KK2, in[6], 9);
126 ROUND(ddd, aaa, bbb, ccc, F3, KK2, in[11], 13); 126 ROUND(ddd, aaa, bbb, ccc, F3, KK2, in[11], 13);
127 ROUND(ccc, ddd, aaa, bbb, F3, KK2, in[3], 15); 127 ROUND(ccc, ddd, aaa, bbb, F3, KK2, in[3], 15);
128 ROUND(bbb, ccc, ddd, aaa, F3, KK2, in[7], 7); 128 ROUND(bbb, ccc, ddd, aaa, F3, KK2, in[7], 7);
129 ROUND(aaa, bbb, ccc, ddd, F3, KK2, in[0], 12); 129 ROUND(aaa, bbb, ccc, ddd, F3, KK2, in[0], 12);
130 ROUND(ddd, aaa, bbb, ccc, F3, KK2, in[13], 8); 130 ROUND(ddd, aaa, bbb, ccc, F3, KK2, in[13], 8);
131 ROUND(ccc, ddd, aaa, bbb, F3, KK2, in[5], 9); 131 ROUND(ccc, ddd, aaa, bbb, F3, KK2, in[5], 9);
132 ROUND(bbb, ccc, ddd, aaa, F3, KK2, in[10], 11); 132 ROUND(bbb, ccc, ddd, aaa, F3, KK2, in[10], 11);
133 ROUND(aaa, bbb, ccc, ddd, F3, KK2, in[14], 7); 133 ROUND(aaa, bbb, ccc, ddd, F3, KK2, in[14], 7);
134 ROUND(ddd, aaa, bbb, ccc, F3, KK2, in[15], 7); 134 ROUND(ddd, aaa, bbb, ccc, F3, KK2, in[15], 7);
135 ROUND(ccc, ddd, aaa, bbb, F3, KK2, in[8], 12); 135 ROUND(ccc, ddd, aaa, bbb, F3, KK2, in[8], 12);
136 ROUND(bbb, ccc, ddd, aaa, F3, KK2, in[12], 7); 136 ROUND(bbb, ccc, ddd, aaa, F3, KK2, in[12], 7);
137 ROUND(aaa, bbb, ccc, ddd, F3, KK2, in[4], 6); 137 ROUND(aaa, bbb, ccc, ddd, F3, KK2, in[4], 6);
138 ROUND(ddd, aaa, bbb, ccc, F3, KK2, in[9], 15); 138 ROUND(ddd, aaa, bbb, ccc, F3, KK2, in[9], 15);
139 ROUND(ccc, ddd, aaa, bbb, F3, KK2, in[1], 13); 139 ROUND(ccc, ddd, aaa, bbb, F3, KK2, in[1], 13);
140 ROUND(bbb, ccc, ddd, aaa, F3, KK2, in[2], 11); 140 ROUND(bbb, ccc, ddd, aaa, F3, KK2, in[2], 11);
141 141
142 /* Swap contents of "b" registers */ 142 /* Swap contents of "b" registers */
143 tmp = bb; bb = bbb; bbb = tmp; 143 tmp = bb; bb = bbb; bbb = tmp;
144 144
145 /* round 3: left lane */ 145 /* round 3: left lane */
146 ROUND(aa, bb, cc, dd, F3, K3, in[3], 11); 146 ROUND(aa, bb, cc, dd, F3, K3, in[3], 11);
147 ROUND(dd, aa, bb, cc, F3, K3, in[10], 13); 147 ROUND(dd, aa, bb, cc, F3, K3, in[10], 13);
148 ROUND(cc, dd, aa, bb, F3, K3, in[14], 6); 148 ROUND(cc, dd, aa, bb, F3, K3, in[14], 6);
149 ROUND(bb, cc, dd, aa, F3, K3, in[4], 7); 149 ROUND(bb, cc, dd, aa, F3, K3, in[4], 7);
150 ROUND(aa, bb, cc, dd, F3, K3, in[9], 14); 150 ROUND(aa, bb, cc, dd, F3, K3, in[9], 14);
151 ROUND(dd, aa, bb, cc, F3, K3, in[15], 9); 151 ROUND(dd, aa, bb, cc, F3, K3, in[15], 9);
152 ROUND(cc, dd, aa, bb, F3, K3, in[8], 13); 152 ROUND(cc, dd, aa, bb, F3, K3, in[8], 13);
153 ROUND(bb, cc, dd, aa, F3, K3, in[1], 15); 153 ROUND(bb, cc, dd, aa, F3, K3, in[1], 15);
154 ROUND(aa, bb, cc, dd, F3, K3, in[2], 14); 154 ROUND(aa, bb, cc, dd, F3, K3, in[2], 14);
155 ROUND(dd, aa, bb, cc, F3, K3, in[7], 8); 155 ROUND(dd, aa, bb, cc, F3, K3, in[7], 8);
156 ROUND(cc, dd, aa, bb, F3, K3, in[0], 13); 156 ROUND(cc, dd, aa, bb, F3, K3, in[0], 13);
157 ROUND(bb, cc, dd, aa, F3, K3, in[6], 6); 157 ROUND(bb, cc, dd, aa, F3, K3, in[6], 6);
158 ROUND(aa, bb, cc, dd, F3, K3, in[13], 5); 158 ROUND(aa, bb, cc, dd, F3, K3, in[13], 5);
159 ROUND(dd, aa, bb, cc, F3, K3, in[11], 12); 159 ROUND(dd, aa, bb, cc, F3, K3, in[11], 12);
160 ROUND(cc, dd, aa, bb, F3, K3, in[5], 7); 160 ROUND(cc, dd, aa, bb, F3, K3, in[5], 7);
161 ROUND(bb, cc, dd, aa, F3, K3, in[12], 5); 161 ROUND(bb, cc, dd, aa, F3, K3, in[12], 5);
162 162
163 /* round 3: right lane */ 163 /* round 3: right lane */
164 ROUND(aaa, bbb, ccc, ddd, F2, KK3, in[15], 9); 164 ROUND(aaa, bbb, ccc, ddd, F2, KK3, in[15], 9);
165 ROUND(ddd, aaa, bbb, ccc, F2, KK3, in[5], 7); 165 ROUND(ddd, aaa, bbb, ccc, F2, KK3, in[5], 7);
166 ROUND(ccc, ddd, aaa, bbb, F2, KK3, in[1], 15); 166 ROUND(ccc, ddd, aaa, bbb, F2, KK3, in[1], 15);
167 ROUND(bbb, ccc, ddd, aaa, F2, KK3, in[3], 11); 167 ROUND(bbb, ccc, ddd, aaa, F2, KK3, in[3], 11);
168 ROUND(aaa, bbb, ccc, ddd, F2, KK3, in[7], 8); 168 ROUND(aaa, bbb, ccc, ddd, F2, KK3, in[7], 8);
169 ROUND(ddd, aaa, bbb, ccc, F2, KK3, in[14], 6); 169 ROUND(ddd, aaa, bbb, ccc, F2, KK3, in[14], 6);
170 ROUND(ccc, ddd, aaa, bbb, F2, KK3, in[6], 6); 170 ROUND(ccc, ddd, aaa, bbb, F2, KK3, in[6], 6);
171 ROUND(bbb, ccc, ddd, aaa, F2, KK3, in[9], 14); 171 ROUND(bbb, ccc, ddd, aaa, F2, KK3, in[9], 14);
172 ROUND(aaa, bbb, ccc, ddd, F2, KK3, in[11], 12); 172 ROUND(aaa, bbb, ccc, ddd, F2, KK3, in[11], 12);
173 ROUND(ddd, aaa, bbb, ccc, F2, KK3, in[8], 13); 173 ROUND(ddd, aaa, bbb, ccc, F2, KK3, in[8], 13);
174 ROUND(ccc, ddd, aaa, bbb, F2, KK3, in[12], 5); 174 ROUND(ccc, ddd, aaa, bbb, F2, KK3, in[12], 5);
175 ROUND(bbb, ccc, ddd, aaa, F2, KK3, in[2], 14); 175 ROUND(bbb, ccc, ddd, aaa, F2, KK3, in[2], 14);
176 ROUND(aaa, bbb, ccc, ddd, F2, KK3, in[10], 13); 176 ROUND(aaa, bbb, ccc, ddd, F2, KK3, in[10], 13);
177 ROUND(ddd, aaa, bbb, ccc, F2, KK3, in[0], 13); 177 ROUND(ddd, aaa, bbb, ccc, F2, KK3, in[0], 13);
178 ROUND(ccc, ddd, aaa, bbb, F2, KK3, in[4], 7); 178 ROUND(ccc, ddd, aaa, bbb, F2, KK3, in[4], 7);
179 ROUND(bbb, ccc, ddd, aaa, F2, KK3, in[13], 5); 179 ROUND(bbb, ccc, ddd, aaa, F2, KK3, in[13], 5);
180 180
181 /* Swap contents of "c" registers */ 181 /* Swap contents of "c" registers */
182 tmp = cc; cc = ccc; ccc = tmp; 182 tmp = cc; cc = ccc; ccc = tmp;
183 183
184 /* round 4: left lane */ 184 /* round 4: left lane */
185 ROUND(aa, bb, cc, dd, F4, K4, in[1], 11); 185 ROUND(aa, bb, cc, dd, F4, K4, in[1], 11);
186 ROUND(dd, aa, bb, cc, F4, K4, in[9], 12); 186 ROUND(dd, aa, bb, cc, F4, K4, in[9], 12);
187 ROUND(cc, dd, aa, bb, F4, K4, in[11], 14); 187 ROUND(cc, dd, aa, bb, F4, K4, in[11], 14);
188 ROUND(bb, cc, dd, aa, F4, K4, in[10], 15); 188 ROUND(bb, cc, dd, aa, F4, K4, in[10], 15);
189 ROUND(aa, bb, cc, dd, F4, K4, in[0], 14); 189 ROUND(aa, bb, cc, dd, F4, K4, in[0], 14);
190 ROUND(dd, aa, bb, cc, F4, K4, in[8], 15); 190 ROUND(dd, aa, bb, cc, F4, K4, in[8], 15);
191 ROUND(cc, dd, aa, bb, F4, K4, in[12], 9); 191 ROUND(cc, dd, aa, bb, F4, K4, in[12], 9);
192 ROUND(bb, cc, dd, aa, F4, K4, in[4], 8); 192 ROUND(bb, cc, dd, aa, F4, K4, in[4], 8);
193 ROUND(aa, bb, cc, dd, F4, K4, in[13], 9); 193 ROUND(aa, bb, cc, dd, F4, K4, in[13], 9);
194 ROUND(dd, aa, bb, cc, F4, K4, in[3], 14); 194 ROUND(dd, aa, bb, cc, F4, K4, in[3], 14);
195 ROUND(cc, dd, aa, bb, F4, K4, in[7], 5); 195 ROUND(cc, dd, aa, bb, F4, K4, in[7], 5);
196 ROUND(bb, cc, dd, aa, F4, K4, in[15], 6); 196 ROUND(bb, cc, dd, aa, F4, K4, in[15], 6);
197 ROUND(aa, bb, cc, dd, F4, K4, in[14], 8); 197 ROUND(aa, bb, cc, dd, F4, K4, in[14], 8);
198 ROUND(dd, aa, bb, cc, F4, K4, in[5], 6); 198 ROUND(dd, aa, bb, cc, F4, K4, in[5], 6);
199 ROUND(cc, dd, aa, bb, F4, K4, in[6], 5); 199 ROUND(cc, dd, aa, bb, F4, K4, in[6], 5);
200 ROUND(bb, cc, dd, aa, F4, K4, in[2], 12); 200 ROUND(bb, cc, dd, aa, F4, K4, in[2], 12);
201 201
202 /* round 4: right lane */ 202 /* round 4: right lane */
203 ROUND(aaa, bbb, ccc, ddd, F1, KK4, in[8], 15); 203 ROUND(aaa, bbb, ccc, ddd, F1, KK4, in[8], 15);
204 ROUND(ddd, aaa, bbb, ccc, F1, KK4, in[6], 5); 204 ROUND(ddd, aaa, bbb, ccc, F1, KK4, in[6], 5);
205 ROUND(ccc, ddd, aaa, bbb, F1, KK4, in[4], 8); 205 ROUND(ccc, ddd, aaa, bbb, F1, KK4, in[4], 8);
206 ROUND(bbb, ccc, ddd, aaa, F1, KK4, in[1], 11); 206 ROUND(bbb, ccc, ddd, aaa, F1, KK4, in[1], 11);
207 ROUND(aaa, bbb, ccc, ddd, F1, KK4, in[3], 14); 207 ROUND(aaa, bbb, ccc, ddd, F1, KK4, in[3], 14);
208 ROUND(ddd, aaa, bbb, ccc, F1, KK4, in[11], 14); 208 ROUND(ddd, aaa, bbb, ccc, F1, KK4, in[11], 14);
209 ROUND(ccc, ddd, aaa, bbb, F1, KK4, in[15], 6); 209 ROUND(ccc, ddd, aaa, bbb, F1, KK4, in[15], 6);
210 ROUND(bbb, ccc, ddd, aaa, F1, KK4, in[0], 14); 210 ROUND(bbb, ccc, ddd, aaa, F1, KK4, in[0], 14);
211 ROUND(aaa, bbb, ccc, ddd, F1, KK4, in[5], 6); 211 ROUND(aaa, bbb, ccc, ddd, F1, KK4, in[5], 6);
212 ROUND(ddd, aaa, bbb, ccc, F1, KK4, in[12], 9); 212 ROUND(ddd, aaa, bbb, ccc, F1, KK4, in[12], 9);
213 ROUND(ccc, ddd, aaa, bbb, F1, KK4, in[2], 12); 213 ROUND(ccc, ddd, aaa, bbb, F1, KK4, in[2], 12);
214 ROUND(bbb, ccc, ddd, aaa, F1, KK4, in[13], 9); 214 ROUND(bbb, ccc, ddd, aaa, F1, KK4, in[13], 9);
215 ROUND(aaa, bbb, ccc, ddd, F1, KK4, in[9], 12); 215 ROUND(aaa, bbb, ccc, ddd, F1, KK4, in[9], 12);
216 ROUND(ddd, aaa, bbb, ccc, F1, KK4, in[7], 5); 216 ROUND(ddd, aaa, bbb, ccc, F1, KK4, in[7], 5);
217 ROUND(ccc, ddd, aaa, bbb, F1, KK4, in[10], 15); 217 ROUND(ccc, ddd, aaa, bbb, F1, KK4, in[10], 15);
218 ROUND(bbb, ccc, ddd, aaa, F1, KK4, in[14], 8); 218 ROUND(bbb, ccc, ddd, aaa, F1, KK4, in[14], 8);
219 219
220 /* Swap contents of "d" registers */ 220 /* Swap contents of "d" registers */
221 tmp = dd; dd = ddd; ddd = tmp; 221 tmp = dd; dd = ddd; ddd = tmp;
222 222
223 /* combine results */ 223 /* combine results */
224 state[0] += aa; 224 state[0] += aa;
225 state[1] += bb; 225 state[1] += bb;
226 state[2] += cc; 226 state[2] += cc;
227 state[3] += dd; 227 state[3] += dd;
228 state[4] += aaa; 228 state[4] += aaa;
229 state[5] += bbb; 229 state[5] += bbb;
230 state[6] += ccc; 230 state[6] += ccc;
231 state[7] += ddd; 231 state[7] += ddd;
232 232
233 return; 233 return;
234 } 234 }
235 235
236 static inline void le32_to_cpu_array(u32 *buf, unsigned int words)
237 {
238 while (words--) {
239 le32_to_cpus(buf);
240 buf++;
241 }
242 }
243
244 static inline void cpu_to_le32_array(u32 *buf, unsigned int words)
245 {
246 while (words--) {
247 cpu_to_le32s(buf);
248 buf++;
249 }
250 }
251
252 static inline void rmd256_transform_helper(struct rmd256_ctx *ctx)
253 {
254 le32_to_cpu_array(ctx->buffer, sizeof(ctx->buffer) / sizeof(u32));
255 rmd256_transform(ctx->state, ctx->buffer);
256 }
257
258 static void rmd256_init(struct crypto_tfm *tfm) 236 static void rmd256_init(struct crypto_tfm *tfm)
259 { 237 {
260 struct rmd256_ctx *rctx = crypto_tfm_ctx(tfm); 238 struct rmd256_ctx *rctx = crypto_tfm_ctx(tfm);
261 239
262 rctx->byte_count = 0; 240 rctx->byte_count = 0;
263 241
264 rctx->state[0] = RMD_H0; 242 rctx->state[0] = RMD_H0;
265 rctx->state[1] = RMD_H1; 243 rctx->state[1] = RMD_H1;
266 rctx->state[2] = RMD_H2; 244 rctx->state[2] = RMD_H2;
267 rctx->state[3] = RMD_H3; 245 rctx->state[3] = RMD_H3;
268 rctx->state[4] = RMD_H5; 246 rctx->state[4] = RMD_H5;
269 rctx->state[5] = RMD_H6; 247 rctx->state[5] = RMD_H6;
270 rctx->state[6] = RMD_H7; 248 rctx->state[6] = RMD_H7;
271 rctx->state[7] = RMD_H8; 249 rctx->state[7] = RMD_H8;
272 250
273 memset(rctx->buffer, 0, sizeof(rctx->buffer)); 251 memset(rctx->buffer, 0, sizeof(rctx->buffer));
274 } 252 }
275 253
276 static void rmd256_update(struct crypto_tfm *tfm, const u8 *data, 254 static void rmd256_update(struct crypto_tfm *tfm, const u8 *data,
277 unsigned int len) 255 unsigned int len)
278 { 256 {
279 struct rmd256_ctx *rctx = crypto_tfm_ctx(tfm); 257 struct rmd256_ctx *rctx = crypto_tfm_ctx(tfm);
280 const u32 avail = sizeof(rctx->buffer) - (rctx->byte_count & 0x3f); 258 const u32 avail = sizeof(rctx->buffer) - (rctx->byte_count & 0x3f);
281 259
282 rctx->byte_count += len; 260 rctx->byte_count += len;
283 261
284 /* Enough space in buffer? If so copy and we're done */ 262 /* Enough space in buffer? If so copy and we're done */
285 if (avail > len) { 263 if (avail > len) {
286 memcpy((char *)rctx->buffer + (sizeof(rctx->buffer) - avail), 264 memcpy((char *)rctx->buffer + (sizeof(rctx->buffer) - avail),
287 data, len); 265 data, len);
288 return; 266 return;
289 } 267 }
290 268
291 memcpy((char *)rctx->buffer + (sizeof(rctx->buffer) - avail), 269 memcpy((char *)rctx->buffer + (sizeof(rctx->buffer) - avail),
292 data, avail); 270 data, avail);
293 271
294 rmd256_transform_helper(rctx); 272 rmd256_transform(rctx->state, rctx->buffer);
295 data += avail; 273 data += avail;
296 len -= avail; 274 len -= avail;
297 275
298 while (len >= sizeof(rctx->buffer)) { 276 while (len >= sizeof(rctx->buffer)) {
299 memcpy(rctx->buffer, data, sizeof(rctx->buffer)); 277 memcpy(rctx->buffer, data, sizeof(rctx->buffer));
300 rmd256_transform_helper(rctx); 278 rmd256_transform(rctx->state, rctx->buffer);
301 data += sizeof(rctx->buffer); 279 data += sizeof(rctx->buffer);
302 len -= sizeof(rctx->buffer); 280 len -= sizeof(rctx->buffer);
303 } 281 }
304 282
305 memcpy(rctx->buffer, data, len); 283 memcpy(rctx->buffer, data, len);
306 } 284 }
307 285
308 /* Add padding and return the message digest. */ 286 /* Add padding and return the message digest. */
309 static void rmd256_final(struct crypto_tfm *tfm, u8 *out) 287 static void rmd256_final(struct crypto_tfm *tfm, u8 *out)
310 { 288 {
311 struct rmd256_ctx *rctx = crypto_tfm_ctx(tfm); 289 struct rmd256_ctx *rctx = crypto_tfm_ctx(tfm);
312 u32 index, padlen; 290 u32 i, index, padlen;
313 u64 bits; 291 u64 bits;
292 u32 *dst = (u32 *)out;
314 static const u8 padding[64] = { 0x80, }; 293 static const u8 padding[64] = { 0x80, };
315 bits = rctx->byte_count << 3;
316 294
295 bits = cpu_to_le64(rctx->byte_count << 3);
296
317 /* Pad out to 56 mod 64 */ 297 /* Pad out to 56 mod 64 */
318 index = rctx->byte_count & 0x3f; 298 index = rctx->byte_count & 0x3f;
319 padlen = (index < 56) ? (56 - index) : ((64+56) - index); 299 padlen = (index < 56) ? (56 - index) : ((64+56) - index);
320 rmd256_update(tfm, padding, padlen); 300 rmd256_update(tfm, padding, padlen);
321 301
322 /* Append length */ 302 /* Append length */
323 rmd256_update(tfm, (const u8 *)&bits, sizeof(bits)); 303 rmd256_update(tfm, (const u8 *)&bits, sizeof(bits));
324 304
325 /* Store state in digest */ 305 /* Store state in digest */
326 memcpy(out, rctx->state, sizeof(rctx->state)); 306 for (i = 0; i < 8; i++)
307 dst[i] = cpu_to_le32(rctx->state[i]);
327 308
328 /* Wipe context */ 309 /* Wipe context */
329 memset(rctx, 0, sizeof(*rctx)); 310 memset(rctx, 0, sizeof(*rctx));
330 } 311 }
331 312
332 static struct crypto_alg alg = { 313 static struct crypto_alg alg = {
333 .cra_name = "rmd256", 314 .cra_name = "rmd256",
334 .cra_driver_name = "rmd256", 315 .cra_driver_name = "rmd256",
335 .cra_flags = CRYPTO_ALG_TYPE_DIGEST, 316 .cra_flags = CRYPTO_ALG_TYPE_DIGEST,
336 .cra_blocksize = RMD256_BLOCK_SIZE, 317 .cra_blocksize = RMD256_BLOCK_SIZE,
337 .cra_ctxsize = sizeof(struct rmd256_ctx), 318 .cra_ctxsize = sizeof(struct rmd256_ctx),
338 .cra_module = THIS_MODULE, 319 .cra_module = THIS_MODULE,
339 .cra_list = LIST_HEAD_INIT(alg.cra_list), 320 .cra_list = LIST_HEAD_INIT(alg.cra_list),
340 .cra_u = { .digest = { 321 .cra_u = { .digest = {
341 .dia_digestsize = RMD256_DIGEST_SIZE, 322 .dia_digestsize = RMD256_DIGEST_SIZE,
342 .dia_init = rmd256_init, 323 .dia_init = rmd256_init,
343 .dia_update = rmd256_update, 324 .dia_update = rmd256_update,
344 .dia_final = rmd256_final } } 325 .dia_final = rmd256_final } }
345 }; 326 };
346 327
347 static int __init rmd256_mod_init(void) 328 static int __init rmd256_mod_init(void)
348 { 329 {
349 return crypto_register_alg(&alg); 330 return crypto_register_alg(&alg);
350 } 331 }
351 332
352 static void __exit rmd256_mod_fini(void) 333 static void __exit rmd256_mod_fini(void)
353 { 334 {
354 crypto_unregister_alg(&alg); 335 crypto_unregister_alg(&alg);
355 } 336 }
356 337
357 module_init(rmd256_mod_init); 338 module_init(rmd256_mod_init);
358 module_exit(rmd256_mod_fini); 339 module_exit(rmd256_mod_fini);
359 340
360 MODULE_LICENSE("GPL"); 341 MODULE_LICENSE("GPL");