1/*
2 * Twofish Cipher 3-way parallel algorithm (x86_64)
3 *
4 * Copyright (C) 2011 Jussi Kivilinna <jussi.kivilinna@mbnet.fi>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
19 * USA
20 *
21 */
22
23.file "twofish-x86_64-asm-3way.S"
24.text
25
26/* structure of crypto context */
27#define s0	0
28#define s1	1024
29#define s2	2048
30#define s3	3072
31#define w	4096
32#define k	4128
33
34/**********************************************************************
35  3-way twofish
36 **********************************************************************/
37#define CTX %rdi
38#define RIO %rdx
39
40#define RAB0 %rax
41#define RAB1 %rbx
42#define RAB2 %rcx
43
44#define RAB0d %eax
45#define RAB1d %ebx
46#define RAB2d %ecx
47
48#define RAB0bh %ah
49#define RAB1bh %bh
50#define RAB2bh %ch
51
52#define RAB0bl %al
53#define RAB1bl %bl
54#define RAB2bl %cl
55
56#define RCD0 %r8
57#define RCD1 %r9
58#define RCD2 %r10
59
60#define RCD0d %r8d
61#define RCD1d %r9d
62#define RCD2d %r10d
63
64#define RX0 %rbp
65#define RX1 %r11
66#define RX2 %r12
67
68#define RX0d %ebp
69#define RX1d %r11d
70#define RX2d %r12d
71
72#define RY0 %r13
73#define RY1 %r14
74#define RY2 %r15
75
76#define RY0d %r13d
77#define RY1d %r14d
78#define RY2d %r15d
79
80#define RT0 %rdx
81#define RT1 %rsi
82
83#define RT0d %edx
84#define RT1d %esi
85
86#define do16bit_ror(rot, op1, op2, T0, T1, tmp1, tmp2, ab, dst) \
87	movzbl ab ## bl,		tmp2 ## d; \
88	movzbl ab ## bh,		tmp1 ## d; \
89	rorq $(rot),			ab; \
90	op1##l T0(CTX, tmp2, 4),	dst ## d; \
91	op2##l T1(CTX, tmp1, 4),	dst ## d;
92
93/*
94 * Combined G1 & G2 function. Reordered with help of rotates to have moves
95 * at begining.
96 */
97#define g1g2_3(ab, cd, Tx0, Tx1, Tx2, Tx3, Ty0, Ty1, Ty2, Ty3, x, y) \
98	/* G1,1 && G2,1 */ \
99	do16bit_ror(32, mov, xor, Tx0, Tx1, RT0, x ## 0, ab ## 0, x ## 0); \
100	do16bit_ror(48, mov, xor, Ty1, Ty2, RT0, y ## 0, ab ## 0, y ## 0); \
101	\
102	do16bit_ror(32, mov, xor, Tx0, Tx1, RT0, x ## 1, ab ## 1, x ## 1); \
103	do16bit_ror(48, mov, xor, Ty1, Ty2, RT0, y ## 1, ab ## 1, y ## 1); \
104	\
105	do16bit_ror(32, mov, xor, Tx0, Tx1, RT0, x ## 2, ab ## 2, x ## 2); \
106	do16bit_ror(48, mov, xor, Ty1, Ty2, RT0, y ## 2, ab ## 2, y ## 2); \
107	\
108	/* G1,2 && G2,2 */ \
109	do16bit_ror(32, xor, xor, Tx2, Tx3, RT0, RT1, ab ## 0, x ## 0); \
110	do16bit_ror(16, xor, xor, Ty3, Ty0, RT0, RT1, ab ## 0, y ## 0); \
111	xchgq cd ## 0, ab ## 0; \
112	\
113	do16bit_ror(32, xor, xor, Tx2, Tx3, RT0, RT1, ab ## 1, x ## 1); \
114	do16bit_ror(16, xor, xor, Ty3, Ty0, RT0, RT1, ab ## 1, y ## 1); \
115	xchgq cd ## 1, ab ## 1; \
116	\
117	do16bit_ror(32, xor, xor, Tx2, Tx3, RT0, RT1, ab ## 2, x ## 2); \
118	do16bit_ror(16, xor, xor, Ty3, Ty0, RT0, RT1, ab ## 2, y ## 2); \
119	xchgq cd ## 2, ab ## 2;
120
121#define enc_round_end(ab, x, y, n) \
122	addl y ## d,			x ## d; \
123	addl x ## d,			y ## d; \
124	addl k+4*(2*(n))(CTX),		x ## d; \
125	xorl ab ## d,			x ## d; \
126	addl k+4*(2*(n)+1)(CTX),	y ## d; \
127	shrq $32,			ab; \
128	roll $1,			ab ## d; \
129	xorl y ## d,			ab ## d; \
130	shlq $32,			ab; \
131	rorl $1,			x ## d; \
132	orq x,				ab;
133
134#define dec_round_end(ba, x, y, n) \
135	addl y ## d,			x ## d; \
136	addl x ## d,			y ## d; \
137	addl k+4*(2*(n))(CTX),		x ## d; \
138	addl k+4*(2*(n)+1)(CTX),	y ## d; \
139	xorl ba ## d,			y ## d; \
140	shrq $32,			ba; \
141	roll $1,			ba ## d; \
142	xorl x ## d,			ba ## d; \
143	shlq $32,			ba; \
144	rorl $1,			y ## d; \
145	orq y,				ba;
146
147#define encrypt_round3(ab, cd, n) \
148	g1g2_3(ab, cd, s0, s1, s2, s3, s0, s1, s2, s3, RX, RY); \
149	\
150	enc_round_end(ab ## 0, RX0, RY0, n); \
151	enc_round_end(ab ## 1, RX1, RY1, n); \
152	enc_round_end(ab ## 2, RX2, RY2, n);
153
154#define decrypt_round3(ba, dc, n) \
155	g1g2_3(ba, dc, s1, s2, s3, s0, s3, s0, s1, s2, RY, RX); \
156	\
157	dec_round_end(ba ## 0, RX0, RY0, n); \
158	dec_round_end(ba ## 1, RX1, RY1, n); \
159	dec_round_end(ba ## 2, RX2, RY2, n);
160
161#define encrypt_cycle3(ab, cd, n) \
162	encrypt_round3(ab, cd, n*2); \
163	encrypt_round3(ab, cd, (n*2)+1);
164
165#define decrypt_cycle3(ba, dc, n) \
166	decrypt_round3(ba, dc, (n*2)+1); \
167	decrypt_round3(ba, dc, (n*2));
168
169#define inpack3(in, n, xy, m) \
170	movq 4*(n)(in),			xy ## 0; \
171	xorq w+4*m(CTX),		xy ## 0; \
172	\
173	movq 4*(4+(n))(in),		xy ## 1; \
174	xorq w+4*m(CTX),		xy ## 1; \
175	\
176	movq 4*(8+(n))(in),		xy ## 2; \
177	xorq w+4*m(CTX),		xy ## 2;
178
179#define outunpack3(op, out, n, xy, m) \
180	xorq w+4*m(CTX),		xy ## 0; \
181	op ## q xy ## 0,		4*(n)(out); \
182	\
183	xorq w+4*m(CTX),		xy ## 1; \
184	op ## q xy ## 1,		4*(4+(n))(out); \
185	\
186	xorq w+4*m(CTX),		xy ## 2; \
187	op ## q xy ## 2,		4*(8+(n))(out);
188
189#define inpack_enc3() \
190	inpack3(RIO, 0, RAB, 0); \
191	inpack3(RIO, 2, RCD, 2);
192
193#define outunpack_enc3(op) \
194	outunpack3(op, RIO, 2, RAB, 6); \
195	outunpack3(op, RIO, 0, RCD, 4);
196
197#define inpack_dec3() \
198	inpack3(RIO, 0, RAB, 4); \
199	rorq $32,			RAB0; \
200	rorq $32,			RAB1; \
201	rorq $32,			RAB2; \
202	inpack3(RIO, 2, RCD, 6); \
203	rorq $32,			RCD0; \
204	rorq $32,			RCD1; \
205	rorq $32,			RCD2;
206
207#define outunpack_dec3() \
208	rorq $32,			RCD0; \
209	rorq $32,			RCD1; \
210	rorq $32,			RCD2; \
211	outunpack3(mov, RIO, 0, RCD, 0); \
212	rorq $32,			RAB0; \
213	rorq $32,			RAB1; \
214	rorq $32,			RAB2; \
215	outunpack3(mov, RIO, 2, RAB, 2);
216
217.align 8
218.global __twofish_enc_blk_3way
219.type   __twofish_enc_blk_3way,@function;
220
221__twofish_enc_blk_3way:
222	/* input:
223	 *	%rdi: ctx, CTX
224	 *	%rsi: dst
225	 *	%rdx: src, RIO
226	 *	%rcx: bool, if true: xor output
227	 */
228	pushq %r15;
229	pushq %r14;
230	pushq %r13;
231	pushq %r12;
232	pushq %rbp;
233	pushq %rbx;
234
235	pushq %rcx; /* bool xor */
236	pushq %rsi; /* dst */
237
238	inpack_enc3();
239
240	encrypt_cycle3(RAB, RCD, 0);
241	encrypt_cycle3(RAB, RCD, 1);
242	encrypt_cycle3(RAB, RCD, 2);
243	encrypt_cycle3(RAB, RCD, 3);
244	encrypt_cycle3(RAB, RCD, 4);
245	encrypt_cycle3(RAB, RCD, 5);
246	encrypt_cycle3(RAB, RCD, 6);
247	encrypt_cycle3(RAB, RCD, 7);
248
249	popq RIO; /* dst */
250	popq %rbp; /* bool xor */
251
252	testb %bpl, %bpl;
253	jnz __enc_xor3;
254
255	outunpack_enc3(mov);
256
257	popq %rbx;
258	popq %rbp;
259	popq %r12;
260	popq %r13;
261	popq %r14;
262	popq %r15;
263	ret;
264
265__enc_xor3:
266	outunpack_enc3(xor);
267
268	popq %rbx;
269	popq %rbp;
270	popq %r12;
271	popq %r13;
272	popq %r14;
273	popq %r15;
274	ret;
275
276.global twofish_dec_blk_3way
277.type   twofish_dec_blk_3way,@function;
278
279twofish_dec_blk_3way:
280	/* input:
281	 *	%rdi: ctx, CTX
282	 *	%rsi: dst
283	 *	%rdx: src, RIO
284	 */
285	pushq %r15;
286	pushq %r14;
287	pushq %r13;
288	pushq %r12;
289	pushq %rbp;
290	pushq %rbx;
291
292	pushq %rsi; /* dst */
293
294	inpack_dec3();
295
296	decrypt_cycle3(RAB, RCD, 7);
297	decrypt_cycle3(RAB, RCD, 6);
298	decrypt_cycle3(RAB, RCD, 5);
299	decrypt_cycle3(RAB, RCD, 4);
300	decrypt_cycle3(RAB, RCD, 3);
301	decrypt_cycle3(RAB, RCD, 2);
302	decrypt_cycle3(RAB, RCD, 1);
303	decrypt_cycle3(RAB, RCD, 0);
304
305	popq RIO; /* dst */
306
307	outunpack_dec3();
308
309	popq %rbx;
310	popq %rbp;
311	popq %r12;
312	popq %r13;
313	popq %r14;
314	popq %r15;
315	ret;
316
317