arch/x86/crypto/twofish-i586-asm_32.S

   1 /***************************************************************************
   2 *   Copyright (C) 2006 by Joachim Fritschi, <jfritschi@freenet.de>        *
   3 *                                                                         *
   4 *   This program is free software; you can redistribute it and/or modify  *
   5 *   it under the terms of the GNU General Public License as published by  *
   6 *   the Free Software Foundation; either version 2 of the License, or     *
   7 *   (at your option) any later version.                                   *
   8 *                                                                         *
   9 *   This program is distributed in the hope that it will be useful,       *
  10 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  11 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  12 *   GNU General Public License for more details.                          *
  13 *                                                                         *
  14 *   You should have received a copy of the GNU General Public License     *
  15 *   along with this program; if not, write to the                         *
  16 *   Free Software Foundation, Inc.,                                       *
  17 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  18 ***************************************************************************/
  19
  20 .file "twofish-i586-asm.S"
  21 .text
  22
  23 #include <asm/asm-offsets.h>
  24
  25 /* return address at 0 */
  26
  27 #define in_blk    12  /* input byte array address parameter*/
  28 #define out_blk   8  /* output byte array address parameter*/
  29 #define ctx       4  /* Twofish context structure */
  30
  31 #define a_offset        0
  32 #define b_offset        4
  33 #define c_offset        8
  34 #define d_offset        12
  35
  36 /* Structure of the crypto context struct*/
  37
  38 #define s0      0       /* S0 Array 256 Words each */
  39 #define s1      1024    /* S1 Array */
  40 #define s2      2048    /* S2 Array */
  41 #define s3      3072    /* S3 Array */
  42 #define w       4096    /* 8 whitening keys (word) */
  43 #define k       4128    /* key 1-32 ( word ) */
  44
  45 /* define a few register aliases to allow macro substitution */
  46
  47 #define R0D    %eax
  48 #define R0B    %al
  49 #define R0H    %ah
  50
  51 #define R1D    %ebx
  52 #define R1B    %bl
  53 #define R1H    %bh
  54
  55 #define R2D    %ecx
  56 #define R2B    %cl
  57 #define R2H    %ch
  58
  59 #define R3D    %edx
  60 #define R3B    %dl
  61 #define R3H    %dh
  62
  63
  64 /* performs input whitening */
  65 #define input_whitening(src,context,offset)\
  66         xor     w+offset(context),      src;
  67
  68 /* performs input whitening */
  69 #define output_whitening(src,context,offset)\
  70         xor     w+16+offset(context),   src;
  71
  72 /*
  73  * a input register containing a (rotated 16)
  74  * b input register containing b
  75  * c input register containing c
  76  * d input register containing d (already rol $1)
  77  * operations on a and b are interleaved to increase performance
  78  */
  79 #define encrypt_round(a,b,c,d,round)\
  80         push    d ## D;\
  81         movzx   b ## B,         %edi;\
  82         mov     s1(%ebp,%edi,4),d ## D;\
  83         movzx   a ## B,         %edi;\
  84         mov     s2(%ebp,%edi,4),%esi;\
  85         movzx   b ## H,         %edi;\
  86         ror     $16,            b ## D;\
  87         xor     s2(%ebp,%edi,4),d ## D;\
  88         movzx   a ## H,         %edi;\
  89         ror     $16,            a ## D;\
  90         xor     s3(%ebp,%edi,4),%esi;\
  91         movzx   b ## B,         %edi;\
  92         xor     s3(%ebp,%edi,4),d ## D;\
  93         movzx   a ## B,         %edi;\
  94         xor     (%ebp,%edi,4),  %esi;\
  95         movzx   b ## H,         %edi;\
  96         ror     $15,            b ## D;\
  97         xor     (%ebp,%edi,4),  d ## D;\
  98         movzx   a ## H,         %edi;\
  99         xor     s1(%ebp,%edi,4),%esi;\
 100         pop     %edi;\
 101         add     d ## D,         %esi;\
 102         add     %esi,           d ## D;\
 103         add     k+round(%ebp),  %esi;\
 104         xor     %esi,           c ## D;\
 105         rol     $15,            c ## D;\
 106         add     k+4+round(%ebp),d ## D;\
 107         xor     %edi,           d ## D;
 108
 109 /*
 110  * a input register containing a (rotated 16)
 111  * b input register containing b
 112  * c input register containing c
 113  * d input register containing d (already rol $1)
 114  * operations on a and b are interleaved to increase performance
 115  * last round has different rotations for the output preparation
 116  */
 117 #define encrypt_last_round(a,b,c,d,round)\
 118         push    d ## D;\
 119         movzx   b ## B,         %edi;\
 120         mov     s1(%ebp,%edi,4),d ## D;\
 121         movzx   a ## B,         %edi;\
 122         mov     s2(%ebp,%edi,4),%esi;\
 123         movzx   b ## H,         %edi;\
 124         ror     $16,            b ## D;\
 125         xor     s2(%ebp,%edi,4),d ## D;\
 126         movzx   a ## H,         %edi;\
 127         ror     $16,            a ## D;\
 128         xor     s3(%ebp,%edi,4),%esi;\
 129         movzx   b ## B,         %edi;\
 130         xor     s3(%ebp,%edi,4),d ## D;\
 131         movzx   a ## B,         %edi;\
 132         xor     (%ebp,%edi,4),  %esi;\
 133         movzx   b ## H,         %edi;\
 134         ror     $16,            b ## D;\
 135         xor     (%ebp,%edi,4),  d ## D;\
 136         movzx   a ## H,         %edi;\
 137         xor     s1(%ebp,%edi,4),%esi;\
 138         pop     %edi;\
 139         add     d ## D,         %esi;\
 140         add     %esi,           d ## D;\
 141         add     k+round(%ebp),  %esi;\
 142         xor     %esi,           c ## D;\
 143         ror     $1,             c ## D;\
 144         add     k+4+round(%ebp),d ## D;\
 145         xor     %edi,           d ## D;
 146
 147 /*
 148  * a input register containing a
 149  * b input register containing b (rotated 16)
 150  * c input register containing c
 151  * d input register containing d (already rol $1)
 152  * operations on a and b are interleaved to increase performance
 153  */
 154 #define decrypt_round(a,b,c,d,round)\
 155         push    c ## D;\
 156         movzx   a ## B,         %edi;\
 157         mov     (%ebp,%edi,4),  c ## D;\
 158         movzx   b ## B,         %edi;\
 159         mov     s3(%ebp,%edi,4),%esi;\
 160         movzx   a ## H,         %edi;\
 161         ror     $16,            a ## D;\
 162         xor     s1(%ebp,%edi,4),c ## D;\
 163         movzx   b ## H,         %edi;\
 164         ror     $16,            b ## D;\
 165         xor     (%ebp,%edi,4),  %esi;\
 166         movzx   a ## B,         %edi;\
 167         xor     s2(%ebp,%edi,4),c ## D;\
 168         movzx   b ## B,         %edi;\
 169         xor     s1(%ebp,%edi,4),%esi;\
 170         movzx   a ## H,         %edi;\
 171         ror     $15,            a ## D;\
 172         xor     s3(%ebp,%edi,4),c ## D;\
 173         movzx   b ## H,         %edi;\
 174         xor     s2(%ebp,%edi,4),%esi;\
 175         pop     %edi;\
 176         add     %esi,           c ## D;\
 177         add     c ## D,         %esi;\
 178         add     k+round(%ebp),  c ## D;\
 179         xor     %edi,           c ## D;\
 180         add     k+4+round(%ebp),%esi;\
 181         xor     %esi,           d ## D;\
 182         rol     $15,            d ## D;
 183
 184 /*
 185  * a input register containing a
 186  * b input register containing b (rotated 16)
 187  * c input register containing c
 188  * d input register containing d (already rol $1)
 189  * operations on a and b are interleaved to increase performance
 190  * last round has different rotations for the output preparation
 191  */
 192 #define decrypt_last_round(a,b,c,d,round)\
 193         push    c ## D;\
 194         movzx   a ## B,         %edi;\
 195         mov     (%ebp,%edi,4),  c ## D;\
 196         movzx   b ## B,         %edi;\
 197         mov     s3(%ebp,%edi,4),%esi;\
 198         movzx   a ## H,         %edi;\
 199         ror     $16,            a ## D;\
 200         xor     s1(%ebp,%edi,4),c ## D;\
 201         movzx   b ## H,         %edi;\
 202         ror     $16,            b ## D;\
 203         xor     (%ebp,%edi,4),  %esi;\
 204         movzx   a ## B,         %edi;\
 205         xor     s2(%ebp,%edi,4),c ## D;\
 206         movzx   b ## B,         %edi;\
 207         xor     s1(%ebp,%edi,4),%esi;\
 208         movzx   a ## H,         %edi;\
 209         ror     $16,            a ## D;\
 210         xor     s3(%ebp,%edi,4),c ## D;\
 211         movzx   b ## H,         %edi;\
 212         xor     s2(%ebp,%edi,4),%esi;\
 213         pop     %edi;\
 214         add     %esi,           c ## D;\
 215         add     c ## D,         %esi;\
 216         add     k+round(%ebp),  c ## D;\
 217         xor     %edi,           c ## D;\
 218         add     k+4+round(%ebp),%esi;\
 219         xor     %esi,           d ## D;\
 220         ror     $1,             d ## D;
 221
 222 .align 4
 223 .global twofish_enc_blk
 224 .global twofish_dec_blk
 225
 226 twofish_enc_blk:
 227         push    %ebp                    /* save registers according to calling convention*/
 228         push    %ebx
 229         push    %esi
 230         push    %edi
 231
 232         mov     ctx + 16(%esp), %ebp    /* abuse the base pointer: set new base
 233                                          * pointer to the ctx address */
 234         mov     in_blk+16(%esp),%edi    /* input address in edi */
 235
 236         mov     (%edi),         %eax
 237         mov     b_offset(%edi), %ebx
 238         mov     c_offset(%edi), %ecx
 239         mov     d_offset(%edi), %edx
 240         input_whitening(%eax,%ebp,a_offset)
 241         ror     $16,    %eax
 242         input_whitening(%ebx,%ebp,b_offset)
 243         input_whitening(%ecx,%ebp,c_offset)
 244         input_whitening(%edx,%ebp,d_offset)
 245         rol     $1,     %edx
 246
 247         encrypt_round(R0,R1,R2,R3,0);
 248         encrypt_round(R2,R3,R0,R1,8);
 249         encrypt_round(R0,R1,R2,R3,2*8);
 250         encrypt_round(R2,R3,R0,R1,3*8);
 251         encrypt_round(R0,R1,R2,R3,4*8);
 252         encrypt_round(R2,R3,R0,R1,5*8);
 253         encrypt_round(R0,R1,R2,R3,6*8);
 254         encrypt_round(R2,R3,R0,R1,7*8);
 255         encrypt_round(R0,R1,R2,R3,8*8);
 256         encrypt_round(R2,R3,R0,R1,9*8);
 257         encrypt_round(R0,R1,R2,R3,10*8);
 258         encrypt_round(R2,R3,R0,R1,11*8);
 259         encrypt_round(R0,R1,R2,R3,12*8);
 260         encrypt_round(R2,R3,R0,R1,13*8);
 261         encrypt_round(R0,R1,R2,R3,14*8);
 262         encrypt_last_round(R2,R3,R0,R1,15*8);
 263
 264         output_whitening(%eax,%ebp,c_offset)
 265         output_whitening(%ebx,%ebp,d_offset)
 266         output_whitening(%ecx,%ebp,a_offset)
 267         output_whitening(%edx,%ebp,b_offset)
 268         mov     out_blk+16(%esp),%edi;
 269         mov     %eax,           c_offset(%edi)
 270         mov     %ebx,           d_offset(%edi)
 271         mov     %ecx,           (%edi)
 272         mov     %edx,           b_offset(%edi)
 273
 274         pop     %edi
 275         pop     %esi
 276         pop     %ebx
 277         pop     %ebp
 278         mov     $1,     %eax
 279         ret
 280
 281 twofish_dec_blk:
 282         push    %ebp                    /* save registers according to calling convention*/
 283         push    %ebx
 284         push    %esi
 285         push    %edi
 286
 287
 288         mov     ctx + 16(%esp), %ebp    /* abuse the base pointer: set new base
 289                                          * pointer to the ctx address */
 290         mov     in_blk+16(%esp),%edi    /* input address in edi */
 291
 292         mov     (%edi),         %eax
 293         mov     b_offset(%edi), %ebx
 294         mov     c_offset(%edi), %ecx
 295         mov     d_offset(%edi), %edx
 296         output_whitening(%eax,%ebp,a_offset)
 297         output_whitening(%ebx,%ebp,b_offset)
 298         ror     $16,    %ebx
 299         output_whitening(%ecx,%ebp,c_offset)
 300         output_whitening(%edx,%ebp,d_offset)
 301         rol     $1,     %ecx
 302
 303         decrypt_round(R0,R1,R2,R3,15*8);
 304         decrypt_round(R2,R3,R0,R1,14*8);
 305         decrypt_round(R0,R1,R2,R3,13*8);
 306         decrypt_round(R2,R3,R0,R1,12*8);
 307         decrypt_round(R0,R1,R2,R3,11*8);
 308         decrypt_round(R2,R3,R0,R1,10*8);
 309         decrypt_round(R0,R1,R2,R3,9*8);
 310         decrypt_round(R2,R3,R0,R1,8*8);
 311         decrypt_round(R0,R1,R2,R3,7*8);
 312         decrypt_round(R2,R3,R0,R1,6*8);
 313         decrypt_round(R0,R1,R2,R3,5*8);
 314         decrypt_round(R2,R3,R0,R1,4*8);
 315         decrypt_round(R0,R1,R2,R3,3*8);
 316         decrypt_round(R2,R3,R0,R1,2*8);
 317         decrypt_round(R0,R1,R2,R3,1*8);
 318         decrypt_last_round(R2,R3,R0,R1,0);
 319
 320         input_whitening(%eax,%ebp,c_offset)
 321         input_whitening(%ebx,%ebp,d_offset)
 322         input_whitening(%ecx,%ebp,a_offset)
 323         input_whitening(%edx,%ebp,b_offset)
 324         mov     out_blk+16(%esp),%edi;
 325         mov     %eax,           c_offset(%edi)
 326         mov     %ebx,           d_offset(%edi)
 327         mov     %ecx,           (%edi)
 328         mov     %edx,           b_offset(%edi)
 329
 330         pop     %edi
 331         pop     %esi
 332         pop     %ebx
 333         pop     %ebp
 334         mov     $1,     %eax
 335         ret