arch/x86/crypto/twofish-x86_64-asm_64-3way.S

   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
 279 twofish_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