crypto/aes/asm/aesni-x86.pl

   1 #!/usr/bin/env perl
   2
   3 # ====================================================================
   4 # Written by Andy Polyakov <appro@fy.chalmers.se> for the OpenSSL
   5 # project. The module is, however, dual licensed under OpenSSL and
   6 # CRYPTOGAMS licenses depending on where you obtain it. For further
   7 # details see http://www.openssl.org/~appro/cryptogams/.
   8 # ====================================================================
   9 #
  10 # This module implements support for Intel AES-NI extension. In
  11 # OpenSSL context it's used with Intel engine, but can also be used as
  12 # drop-in replacement for crypto/aes/asm/aes-586.pl [see below for
  13 # details].
  14
  15 $PREFIX="aesni";        # if $PREFIX is set to "AES", the script
  16                         # generates drop-in replacement for
  17                         # crypto/aes/asm/aes-586.pl:-)
  18 $inline=1;              # inline _aesni_[en|de]crypt
  19
  20 $0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1;
  21 push(@INC,"${dir}","${dir}../../perlasm");
  22 require "x86asm.pl";
  23
  24 &asm_init($ARGV[0],$0);
  25
  26 if ($PREFIX eq "aesni") { $movekey=*movaps; }
  27 else                    { $movekey=*movups; }
  28
  29 $len="eax";
  30 $rounds="ecx";
  31 $key="edx";
  32 $inp="esi";
  33 $out="edi";
  34 $rounds_="ebx"; # backup copy for $rounds
  35 $key_="ebp";    # backup copy for $key
  36
  37 $inout0="xmm0";
  38 $inout1="xmm1";
  39 $inout2="xmm2";
  40 $rndkey0="xmm3";
  41 $rndkey1="xmm4";
  42 $ivec="xmm5";
  43 $in0="xmm6";
  44 $in1="xmm7";    $inout3="xmm7";
  45 \f
  46 # Inline version of internal aesni_[en|de]crypt1
  47 sub aesni_inline_generate1
  48 { my $p=shift;
  49
  50     &$movekey           ($rndkey0,&QWP(0,$key));
  51     &$movekey           ($rndkey1,&QWP(16,$key));
  52     &lea                ($key,&DWP(32,$key));
  53     &pxor               ($inout0,$rndkey0);
  54     &set_label("${p}1_loop");
  55         eval"&aes${p}   ($inout0,$rndkey1)";
  56         &dec            ($rounds);
  57         &$movekey       ($rndkey1,&QWP(0,$key));
  58         &lea            ($key,&DWP(16,$key));
  59     &jnz                (&label("${p}1_loop"));
  60     eval"&aes${p}last   ($inout0,$rndkey1)";
  61 }
  62
  63 sub aesni_generate1     # fully unrolled loop
  64 { my $p=shift;
  65
  66     &function_begin_B("_aesni_${p}rypt1");
  67         &$movekey       ($rndkey0,&QWP(0,$key));
  68         &$movekey       ($rndkey1,&QWP(0x10,$key));
  69         &cmp            ($rounds,11);
  70         &pxor           ($inout0,$rndkey0);
  71         &$movekey       ($rndkey0,&QWP(0x20,$key));
  72         &lea            ($key,&DWP(0x30,$key));
  73         &jb             (&label("${p}128"));
  74         &lea            ($key,&DWP(0x20,$key));
  75         &je             (&label("${p}192"));
  76         &lea            ($key,&DWP(0x20,$key));
  77         eval"&aes${p}   ($inout0,$rndkey1)";
  78         &$movekey       ($rndkey1,&QWP(-0x40,$key));
  79         eval"&aes${p}   ($inout0,$rndkey0)";
  80         &$movekey       ($rndkey0,&QWP(-0x30,$key));
  81     &set_label("${p}192");
  82         eval"&aes${p}   ($inout0,$rndkey1)";
  83         &$movekey       ($rndkey1,&QWP(-0x20,$key));
  84         eval"&aes${p}   ($inout0,$rndkey0)";
  85         &$movekey       ($rndkey0,&QWP(-0x10,$key));
  86     &set_label("${p}128");
  87         eval"&aes${p}   ($inout0,$rndkey1)";
  88         &$movekey       ($rndkey1,&QWP(0,$key));
  89         eval"&aes${p}   ($inout0,$rndkey0)";
  90         &$movekey       ($rndkey0,&QWP(0x10,$key));
  91         eval"&aes${p}   ($inout0,$rndkey1)";
  92         &$movekey       ($rndkey1,&QWP(0x20,$key));
  93         eval"&aes${p}   ($inout0,$rndkey0)";
  94         &$movekey       ($rndkey0,&QWP(0x30,$key));
  95         eval"&aes${p}   ($inout0,$rndkey1)";
  96         &$movekey       ($rndkey1,&QWP(0x40,$key));
  97         eval"&aes${p}   ($inout0,$rndkey0)";
  98         &$movekey       ($rndkey0,&QWP(0x50,$key));
  99         eval"&aes${p}   ($inout0,$rndkey1)";
 100         &$movekey       ($rndkey1,&QWP(0x60,$key));
 101         eval"&aes${p}   ($inout0,$rndkey0)";
 102         &$movekey       ($rndkey0,&QWP(0x70,$key));
 103         eval"&aes${p}   ($inout0,$rndkey1)";
 104     eval"&aes${p}last   ($inout0,$rndkey0)";
 105     &ret();
 106     &function_end_B("_aesni_${p}rypt1");
 107 }
 108 \f
 109 # void $PREFIX_encrypt (const void *inp,void *out,const AES_KEY *key);
 110 &aesni_generate1("enc") if (!$inline);
 111 &function_begin_B("${PREFIX}_encrypt");
 112         &mov    ("eax",&wparam(0));
 113         &mov    ($key,&wparam(2));
 114         &movups ($inout0,&QWP(0,"eax"));
 115         &mov    ($rounds,&DWP(240,$key));
 116         &mov    ("eax",&wparam(1));
 117         if ($inline)
 118         {   &aesni_inline_generate1("enc");     }
 119         else
 120         {   &call       ("_aesni_encrypt1");    }
 121         &movups (&QWP(0,"eax"),$inout0);
 122         &ret    ();
 123 &function_end_B("${PREFIX}_encrypt");
 124
 125 # void $PREFIX_decrypt (const void *inp,void *out,const AES_KEY *key);
 126 &aesni_generate1("dec") if(!$inline);
 127 &function_begin_B("${PREFIX}_decrypt");
 128         &mov    ("eax",&wparam(0));
 129         &mov    ($key,&wparam(2));
 130         &movups ($inout0,&QWP(0,"eax"));
 131         &mov    ($rounds,&DWP(240,$key));
 132         &mov    ("eax",&wparam(1));
 133         if ($inline)
 134         {   &aesni_inline_generate1("dec");     }
 135         else
 136         {   &call       ("_aesni_decrypt1");    }
 137         &movups (&QWP(0,"eax"),$inout0);
 138         &ret    ();
 139 &function_end_B("${PREFIX}_decrypt");
 140
 141 # _aesni_[en|de]crypt[34] are private interfaces, N denotes interleave
 142 # factor. Why 3x subroutine is used in loops? Even though aes[enc|dec]
 143 # latency is 6, it turned out that it can be scheduled only every
 144 # *second* cycle. Thus 3x interleave is the one providing optimal
 145 # utilization, i.e. when subroutine's throughput is virtually same as
 146 # of non-interleaved subroutine [for number of input blocks up to 3].
 147 # This is why it makes no sense to implement 2x subroutine. As soon
 148 # as/if Intel improves throughput by making it possible to schedule
 149 # the instructions in question *every* cycles I would have to
 150 # implement 6x interleave and use it in loop...
 151 sub aesni_generate3
 152 { my $p=shift;
 153
 154     &function_begin_B("_aesni_${p}rypt3");
 155         &$movekey       ($rndkey0,&QWP(0,$key));
 156         &shr            ($rounds,1);
 157         &$movekey       ($rndkey1,&QWP(16,$key));
 158         &lea            ($key,&DWP(32,$key));
 159         &pxor           ($inout0,$rndkey0);
 160         &pxor           ($inout1,$rndkey0);
 161         &pxor           ($inout2,$rndkey0);
 162         &jmp            (&label("${p}3_loop"));
 163     &set_label("${p}3_loop",16);
 164         eval"&aes${p}   ($inout0,$rndkey1)";
 165         &$movekey       ($rndkey0,&QWP(0,$key));
 166         eval"&aes${p}   ($inout1,$rndkey1)";
 167         &dec            ($rounds);
 168         eval"&aes${p}   ($inout2,$rndkey1)";
 169         &$movekey       ($rndkey1,&QWP(16,$key));
 170         eval"&aes${p}   ($inout0,$rndkey0)";
 171         &lea            ($key,&DWP(32,$key));
 172         eval"&aes${p}   ($inout1,$rndkey0)";
 173         eval"&aes${p}   ($inout2,$rndkey0)";
 174         &jnz            (&label("${p}3_loop"));
 175     eval"&aes${p}       ($inout0,$rndkey1)";
 176     &$movekey           ($rndkey0,&QWP(0,$key));
 177     eval"&aes${p}       ($inout1,$rndkey1)";
 178     eval"&aes${p}       ($inout2,$rndkey1)";
 179     eval"&aes${p}last   ($inout0,$rndkey0)";
 180     eval"&aes${p}last   ($inout1,$rndkey0)";
 181     eval"&aes${p}last   ($inout2,$rndkey0)";
 182     &ret();
 183     &function_end_B("_aesni_${p}rypt3");
 184 }
 185
 186 # 4x interleave is implemented to improve small block performance,
 187 # most notably [and naturally] 4 block by ~30%. One can argue that one
 188 # should have implemented 5x as well, but improvement  would be <20%,
 189 # so it's not worth it...
 190 sub aesni_generate4
 191 { my $p=shift;
 192
 193     &function_begin_B("_aesni_${p}rypt4");
 194         &$movekey       ($rndkey0,&QWP(0,$key));
 195         &$movekey       ($rndkey1,&QWP(16,$key));
 196         &shr            ($rounds,1);
 197         &lea            ($key,&DWP(32,$key));
 198         &pxor           ($inout0,$rndkey0);
 199         &pxor           ($inout1,$rndkey0);
 200         &pxor           ($inout2,$rndkey0);
 201         &pxor           ($inout3,$rndkey0);
 202         &jmp            (&label("${p}3_loop"));
 203     &set_label("${p}3_loop",16);
 204         eval"&aes${p}   ($inout0,$rndkey1)";
 205         &$movekey       ($rndkey0,&QWP(0,$key));
 206         eval"&aes${p}   ($inout1,$rndkey1)";
 207         &dec            ($rounds);
 208         eval"&aes${p}   ($inout2,$rndkey1)";
 209         eval"&aes${p}   ($inout3,$rndkey1)";
 210         &$movekey       ($rndkey1,&QWP(16,$key));
 211         eval"&aes${p}   ($inout0,$rndkey0)";
 212         &lea            ($key,&DWP(32,$key));
 213         eval"&aes${p}   ($inout1,$rndkey0)";
 214         eval"&aes${p}   ($inout2,$rndkey0)";
 215         eval"&aes${p}   ($inout3,$rndkey0)";
 216         &jnz            (&label("${p}3_loop"));
 217     eval"&aes${p}       ($inout0,$rndkey1)";
 218     &$movekey           ($rndkey0,&QWP(0,$key));
 219     eval"&aes${p}       ($inout1,$rndkey1)";
 220     eval"&aes${p}       ($inout2,$rndkey1)";
 221     eval"&aes${p}       ($inout3,$rndkey1)";
 222     eval"&aes${p}last   ($inout0,$rndkey0)";
 223     eval"&aes${p}last   ($inout1,$rndkey0)";
 224     eval"&aes${p}last   ($inout2,$rndkey0)";
 225     eval"&aes${p}last   ($inout3,$rndkey0)";
 226     &ret();
 227     &function_end_B("_aesni_${p}rypt4");
 228 }
 229 &aesni_generate3("enc") if ($PREFIX eq "aesni");
 230 &aesni_generate3("dec");
 231 &aesni_generate4("enc") if ($PREFIX eq "aesni");
 232 &aesni_generate4("dec");
 233 \f
 234 if ($PREFIX eq "aesni") {
 235 ######################################################################
 236 # void aesni_ecb_encrypt (const void *in, void *out,
 237 #                         size_t length, const AES_KEY *key,
 238 #                         int enc);
 239 &function_begin("aesni_ecb_encrypt");
 240         &mov    ($inp,&wparam(0));
 241         &mov    ($out,&wparam(1));
 242         &mov    ($len,&wparam(2));
 243         &mov    ($key,&wparam(3));
 244         &mov    ($rounds,&wparam(4));
 245         &cmp    ($len,16);
 246         &jb     (&label("ecb_ret"));
 247         &and    ($len,-16);
 248         &test   ($rounds,$rounds)
 249         &mov    ($rounds,&DWP(240,$key));
 250         &mov    ($key_,$key);           # backup $key
 251         &mov    ($rounds_,$rounds);     # backup $rounds
 252         &jz     (&label("ecb_decrypt"));
 253
 254         &cmp    ($len,0x40);
 255         &jbe    (&label("ecb_enc_tail"));
 256         &sub    ($len,0x40);
 257         &jmp    (&label("ecb_enc_loop3"));
 258
 259 &set_label("ecb_enc_loop3",16);
 260         &movups ($inout0,&QWP(0,$inp));
 261         &movups ($inout1,&QWP(0x10,$inp));
 262         &movups ($inout2,&QWP(0x20,$inp));
 263         &call   ("_aesni_encrypt3");
 264         &sub    ($len,0x30);
 265         &lea    ($inp,&DWP(0x30,$inp));
 266         &lea    ($out,&DWP(0x30,$out));
 267         &movups (&QWP(-0x30,$out),$inout0);
 268         &mov    ($key,$key_);           # restore $key
 269         &movups (&QWP(-0x20,$out),$inout1);
 270         &mov    ($rounds,$rounds_);     # restore $rounds
 271         &movups (&QWP(-0x10,$out),$inout2);
 272         &ja     (&label("ecb_enc_loop3"));
 273
 274         &add    ($len,0x40);
 275         &jz     (&label("ecb_ret"));
 276
 277 &set_label("ecb_enc_tail");
 278         &cmp    ($len,0x20);
 279         &movups ($inout0,&QWP(0,$inp));
 280         &jb     (&label("ecb_enc_one"));
 281         &movups ($inout1,&QWP(0x10,$inp));
 282         &je     (&label("ecb_enc_two"));
 283         &cmp    ($len,0x30);
 284         &movups ($inout2,&QWP(0x20,$inp));
 285         &je     (&label("ecb_enc_three"));
 286         &movups ($inout3,&QWP(0x30,$inp));
 287         &call   ("_aesni_encrypt4");
 288         &movups (&QWP(0,$out),$inout0);
 289         &movups (&QWP(0x10,$out),$inout1);
 290         &movups (&QWP(0x20,$out),$inout2);
 291         &movups (&QWP(0x30,$out),$inout3);
 292         jmp     (&label("ecb_ret"));
 293
 294 &set_label("ecb_enc_one",16);
 295         if ($inline)
 296         {   &aesni_inline_generate1("enc");     }
 297         else
 298         {   &call       ("_aesni_encrypt1");    }
 299         &movups (&QWP(0,$out),$inout0);
 300         &jmp    (&label("ecb_ret"));
 301
 302 &set_label("ecb_enc_two",16);
 303         &call   ("_aesni_encrypt3");
 304         &movups (&QWP(0,$out),$inout0);
 305         &movups (&QWP(0x10,$out),$inout1);
 306         &jmp    (&label("ecb_ret"));
 307
 308 &set_label("ecb_enc_three",16);
 309         &call   ("_aesni_encrypt3");
 310         &movups (&QWP(0,$out),$inout0);
 311         &movups (&QWP(0x10,$out),$inout1);
 312         &movups (&QWP(0x20,$out),$inout2);
 313         &jmp    (&label("ecb_ret"));
 314 ######################################################################
 315 &set_label("ecb_decrypt",16);
 316         &cmp    ($len,0x40);
 317         &jbe    (&label("ecb_dec_tail"));
 318         &sub    ($len,0x40);
 319         &jmp    (&label("ecb_dec_loop3"));
 320
 321 &set_label("ecb_dec_loop3",16);
 322         &movups ($inout0,&QWP(0,$inp));
 323         &movups ($inout1,&QWP(0x10,$inp));
 324         &movups ($inout2,&QWP(0x20,$inp));
 325         &call   ("_aesni_decrypt3");
 326         &sub    ($len,0x30);
 327         &lea    ($inp,&DWP(0x30,$inp));
 328         &lea    ($out,&DWP(0x30,$out));
 329         &movups (&QWP(-0x30,$out),$inout0);
 330         &mov    ($key,$key_);           # restore $key
 331         &movups (&QWP(-0x20,$out),$inout1);
 332         &mov    ($rounds,$rounds_);     # restore $rounds
 333         &movups (&QWP(-0x10,$out),$inout2);
 334         &ja     (&label("ecb_dec_loop3"));
 335
 336         &add    ($len,0x40);
 337         &jz     (&label("ecb_ret"));
 338
 339 &set_label("ecb_dec_tail");
 340         &cmp    ($len,0x20);
 341         &movups ($inout0,&QWP(0,$inp));
 342         &jb     (&label("ecb_dec_one"));
 343         &movups ($inout1,&QWP(0x10,$inp));
 344         &je     (&label("ecb_dec_two"));
 345         &cmp    ($len,0x30);
 346         &movups ($inout2,&QWP(0x20,$inp));
 347         &je     (&label("ecb_dec_three"));
 348         &movups ($inout3,&QWP(0x30,$inp));
 349         &call   ("_aesni_decrypt4");
 350         &movups (&QWP(0,$out),$inout0);
 351         &movups (&QWP(0x10,$out),$inout1);
 352         &movups (&QWP(0x20,$out),$inout2);
 353         &movups (&QWP(0x30,$out),$inout3);
 354         &jmp    (&label("ecb_ret"));
 355
 356 &set_label("ecb_dec_one",16);
 357         if ($inline)
 358         {   &aesni_inline_generate1("dec");     }
 359         else
 360         {   &call       ("_aesni_decrypt1");    }
 361         &movups (&QWP(0,$out),$inout0);
 362         &jmp    (&label("ecb_ret"));
 363
 364 &set_label("ecb_dec_two",16);
 365         &call   ("_aesni_decrypt3");
 366         &movups (&QWP(0,$out),$inout0);
 367         &movups (&QWP(0x10,$out),$inout1);
 368         &jmp    (&label("ecb_ret"));
 369
 370 &set_label("ecb_dec_three",16);
 371         &call   ("_aesni_decrypt3");
 372         &movups (&QWP(0,$out),$inout0);
 373         &movups (&QWP(0x10,$out),$inout1);
 374         &movups (&QWP(0x20,$out),$inout2);
 375
 376 &set_label("ecb_ret");
 377 &function_end("aesni_ecb_encrypt");
 378 \f
 379 ######################################################################
 380 # handles only complete blocks, operates on 32-bit counter and
 381 # does not update *ivec! (see engine/eng_aesni.c for details)
 382 #
 383 # void aesni_ctr32_encrypt_blocks (const void *in, void *out,
 384 #                         size_t blocks, const AES_KEY *key,
 385 #                         const char *ivec);
 386 &function_begin("aesni_ctr32_encrypt_blocks");
 387         &mov    ($inp,&wparam(0));
 388         &mov    ($out,&wparam(1));
 389         &mov    ($len,&wparam(2));
 390         &mov    ($key,&wparam(3));
 391         &mov    ($rounds_,&wparam(4));
 392         &mov    ($key_,"esp");
 393         &sub    ("esp",60);
 394         &and    ("esp",-16);                    # align stack
 395         &mov    (&DWP(48,"esp"),$key_);
 396
 397         &movups ($inout3,&QWP(0,$rounds_));     # load ivec
 398
 399         # compose byte-swap control mask for pshufb on stack
 400         &mov    (&DWP(0,"esp"),0x0c0d0e0f);
 401         &mov    (&DWP(4,"esp"),0x08090a0b);
 402         &mov    (&DWP(8,"esp"),0x04050607);
 403         &mov    (&DWP(12,"esp"),0x00010203);
 404
 405         # compose counter increment vector on stack
 406         &mov    ($rounds,3);
 407         &xor    ($key_,$key_);
 408         &mov    (&DWP(16,"esp"),$rounds);
 409         &mov    (&DWP(20,"esp"),$rounds);
 410         &mov    (&DWP(24,"esp"),$rounds);
 411         &mov    (&DWP(28,"esp"),$key_);
 412
 413         &pextrd ($rounds_,$inout3,3);           # pull 32-bit counter
 414         &pinsrd ($inout3,$key_,3);              # wipe 32-bit counter
 415
 416         &mov    ($rounds,&DWP(240,$key));       # key->rounds
 417         &movaps ($rndkey0,&QWP(0,"esp"));       # load byte-swap mask
 418
 419         # $ivec is vector of 3 32-bit counters
 420         &pxor   ($ivec,$ivec);
 421         &bswap  ($rounds_);
 422         &pinsrd ($ivec,$rounds_,0);
 423         &inc    ($rounds_);
 424         &pinsrd ($ivec,$rounds_,1);
 425         &inc    ($rounds_);
 426         &pinsrd ($ivec,$rounds_,2);
 427
 428         &cmp    ($len,4);
 429         &pshufb ($ivec,$rndkey0);               # byte swap
 430         &jbe    (&label("ctr32_tail"));
 431         &movaps (&QWP(32,"esp"),$inout3);       # save counter-less ivec
 432         &mov    ($rounds_,$rounds);
 433         &mov    ($key_,$key);
 434         &sub    ($len,4);
 435         &jmp    (&label("ctr32_loop3"));
 436
 437 &set_label("ctr32_loop3",16);
 438         &pshufd ($inout0,$ivec,3<<6);           # place counter to upper dword
 439         &pshufd ($inout1,$ivec,2<<6);
 440         &pshufd ($inout2,$ivec,1<<6);
 441         &por    ($inout0,$inout3);              # merge counter-less ivec
 442         &por    ($inout1,$inout3);
 443         &por    ($inout2,$inout3);
 444
 445         &call   ("_aesni_encrypt3");
 446
 447          &movaps($rndkey0,&QWP(0,"esp"));       # load byte-swap mask
 448         &movups ($in0,&QWP(0,$inp));
 449         &movups ($in1,&QWP(0x10,$inp));
 450         &movups ($rndkey1,&QWP(0x20,$inp));
 451          &pshufb($ivec,$rndkey0);               # byte swap
 452          &paddd ($ivec,&QWP(16,"esp"));         # counter increment
 453         &pxor   ($in0,$inout0);
 454         &pxor   ($in1,$inout1);
 455         &pxor   ($rndkey1,$inout2);
 456         &movups (&QWP(0,$out),$in0);
 457         &movups (&QWP(0x10,$out),$in1);
 458         &movups (&QWP(0x20,$out),$rndkey1);
 459         &movaps ($inout3,&QWP(32,"esp"));       # load counter-less ivec
 460          &pshufb($ivec,$rndkey0);               # byte swap
 461
 462         &sub    ($len,3);
 463         &lea    ($inp,&DWP(0x30,$inp));
 464         &lea    ($out,&DWP(0x30,$out));
 465         &mov    ($key,$key_);
 466         &mov    ($rounds,$rounds_);
 467         &ja     (&label("ctr32_loop3"));
 468
 469         &add    ($len,4);
 470         &pextrd ($rounds_,$ivec,1);             # might need last counter value
 471         &jz     (&label("ctr32_ret"));
 472         &bswap  ($rounds_);
 473
 474 &set_label("ctr32_tail");
 475         &cmp    ($len,2);
 476         &pshufd ($inout0,$ivec,3<<6);
 477         &pshufd ($inout1,$ivec,2<<6);
 478         &pshufd ($inout2,$ivec,1<<6);
 479         &por    ($inout0,$inout3);
 480         &jb     (&label("ctr32_one"));
 481         &por    ($inout1,$inout3);
 482         &je     (&label("ctr32_two"));
 483         &cmp    ($len,3);
 484         &por    ($inout2,$inout3);
 485         &je     (&label("ctr32_three"));
 486
 487         &inc    ($rounds_);                     # compose last counter value
 488         &bswap  ($rounds_);
 489         &pinsrd ($inout3,$rounds_,3);
 490
 491         &call   ("_aesni_encrypt4");
 492
 493         &movups ($in0,&QWP(0,$inp));
 494         &movups ($rndkey1,&QWP(0x10,$inp));
 495         &movups ($rndkey0,&QWP(0x20,$inp));
 496         &movups ($ivec,&QWP(0x30,$inp));
 497         &pxor   ($in0,$inout0);
 498         &pxor   ($rndkey1,$inout1);
 499         &pxor   ($rndkey0,$inout2);
 500         &pxor   ($ivec,$inout3);
 501         &movups (&QWP(0,$out),$in0);
 502         &movups (&QWP(0x10,$out),$rndkey1);
 503         &movups (&QWP(0x20,$out),$rndkey0);
 504         &movups (&QWP(0x30,$out),$ivec);
 505         &jmp    (&label("ctr32_ret"));
 506
 507 &set_label("ctr32_one",16);
 508         if ($inline)
 509         {   &aesni_inline_generate1("enc");     }
 510         else
 511         {   &call       ("_aesni_encrypt1");    }
 512         &movups ($in0,&QWP(0,$inp));
 513         &pxor   ($in0,$inout0);
 514         &movups (&QWP(0,$out),$in0);
 515         &jmp    (&label("ctr32_ret"));
 516
 517 &set_label("ctr32_two",16);
 518         &call   ("_aesni_encrypt3");
 519         &movups ($in0,&QWP(0,$inp));
 520         &movups ($in1,&QWP(0x10,$inp));
 521         &pxor   ($in0,$inout0);
 522         &pxor   ($in1,$inout1);
 523         &movups (&QWP(0,$out),$in0);
 524         &movups (&QWP(0x10,$out),$in1);
 525         &jmp    (&label("ctr32_ret"));
 526
 527 &set_label("ctr32_three",16);
 528         &call   ("_aesni_encrypt3");
 529         &movups ($in0,&QWP(0,$inp));
 530         &movups ($in1,&QWP(0x10,$inp));
 531         &movups ($rndkey1,&QWP(0x20,$inp));
 532         &pxor   ($in0,$inout0);
 533         &pxor   ($in1,$inout1);
 534         &pxor   ($rndkey1,$inout2);
 535         &movups (&QWP(0,$out),$in0);
 536         &movups (&QWP(0x10,$out),$in1);
 537         &movups (&QWP(0x20,$out),$rndkey1);
 538
 539 &set_label("ctr32_ret");
 540         &mov    ("esp",&DWP(48,"esp"));
 541 &function_end("aesni_ctr32_encrypt_blocks");
 542 }
 543 \f
 544 ######################################################################
 545 # void $PREFIX_cbc_encrypt (const void *inp, void *out,
 546 #                           size_t length, const AES_KEY *key,
 547 #                           unsigned char *ivp,const int enc);
 548 &function_begin("${PREFIX}_cbc_encrypt");
 549         &mov    ($inp,&wparam(0));
 550         &mov    ($out,&wparam(1));
 551         &mov    ($len,&wparam(2));
 552         &mov    ($key,&wparam(3));
 553         &test   ($len,$len);
 554         &mov    ($key_,&wparam(4));
 555         &jz     (&label("cbc_ret"));
 556
 557         &cmp    (&wparam(5),0);
 558         &movups ($ivec,&QWP(0,$key_));  # load IV
 559         &mov    ($rounds,&DWP(240,$key));
 560         &mov    ($key_,$key);           # backup $key
 561         &mov    ($rounds_,$rounds);     # backup $rounds
 562         &je     (&label("cbc_decrypt"));
 563
 564         &movaps ($inout0,$ivec);
 565         &cmp    ($len,16);
 566         &jb     (&label("cbc_enc_tail"));
 567         &sub    ($len,16);
 568         &jmp    (&label("cbc_enc_loop"));
 569
 570 &set_label("cbc_enc_loop",16);
 571         &movups ($ivec,&QWP(0,$inp));
 572         &lea    ($inp,&DWP(16,$inp));
 573         &pxor   ($inout0,$ivec);
 574         if ($inline)
 575         {   &aesni_inline_generate1("enc");     }
 576         else
 577         {   &call       ("_aesni_encrypt1");    }
 578         &sub    ($len,16);
 579         &lea    ($out,&DWP(16,$out));
 580         &mov    ($rounds,$rounds_);     # restore $rounds
 581         &mov    ($key,$key_);           # restore $key
 582         &movups (&QWP(-16,$out),$inout0);
 583         &jnc    (&label("cbc_enc_loop"));
 584         &add    ($len,16);
 585         &jnz    (&label("cbc_enc_tail"));
 586         &movaps ($ivec,$inout0);
 587         &jmp    (&label("cbc_ret"));
 588
 589 &set_label("cbc_enc_tail");
 590         &mov    ("ecx",$len);           # zaps $rounds
 591         &data_word(0xA4F3F689);         # rep movsb
 592         &mov    ("ecx",16);             # zero tail
 593         &sub    ("ecx",$len);
 594         &xor    ("eax","eax");          # zaps $len
 595         &data_word(0xAAF3F689);         # rep stosb
 596         &lea    ($out,&DWP(-16,$out));  # rewind $out by 1 block
 597         &mov    ($rounds,$rounds_);     # restore $rounds
 598         &mov    ($inp,$out);            # $inp and $out are the same
 599         &mov    ($key,$key_);           # restore $key
 600         &jmp    (&label("cbc_enc_loop"));
 601 ######################################################################
 602 &set_label("cbc_decrypt",16);
 603         &cmp    ($len,0x40);
 604         &jbe    (&label("cbc_dec_tail"));
 605         &sub    ($len,0x40);
 606         &jmp    (&label("cbc_dec_loop3"));
 607
 608 &set_label("cbc_dec_loop3",16);
 609         &movups ($inout0,&QWP(0,$inp));
 610         &movups ($inout1,&QWP(0x10,$inp));
 611         &movups ($inout2,&QWP(0x20,$inp));
 612         &movaps ($in0,$inout0);
 613         &movaps ($in1,$inout1);
 614         &call   ("_aesni_decrypt3");
 615         &sub    ($len,0x30);
 616         &lea    ($inp,&DWP(0x30,$inp));
 617         &lea    ($out,&DWP(0x30,$out));
 618         &pxor   ($inout0,$ivec);
 619         &pxor   ($inout1,$in0);
 620         &movups ($ivec,&QWP(-0x10,$inp));
 621         &pxor   ($inout2,$in1);
 622         &movups (&QWP(-0x30,$out),$inout0);
 623         &mov    ($rounds,$rounds_)      # restore $rounds
 624         &movups (&QWP(-0x20,$out),$inout1);
 625         &mov    ($key,$key_);           # restore $key
 626         &movups (&QWP(-0x10,$out),$inout2);
 627         &ja     (&label("cbc_dec_loop3"));
 628
 629         &add    ($len,0x40);
 630         &jz     (&label("cbc_ret"));
 631
 632 &set_label("cbc_dec_tail");
 633         &movups ($inout0,&QWP(0,$inp));
 634         &cmp    ($len,0x10);
 635         &movaps ($in0,$inout0);
 636         &jbe    (&label("cbc_dec_one"));
 637         &movups ($inout1,&QWP(0x10,$inp));
 638         &cmp    ($len,0x20);
 639         &movaps ($in1,$inout1);
 640         &jbe    (&label("cbc_dec_two"));
 641         &movups ($inout2,&QWP(0x20,$inp));
 642         &cmp    ($len,0x30);
 643         &jbe    (&label("cbc_dec_three"));
 644         &movups ($inout3,&QWP(0x30,$inp));
 645         &call   ("_aesni_decrypt4");
 646         &movups ($rndkey0,&QWP(0x10,$inp));
 647         &movups ($rndkey1,&QWP(0x20,$inp));
 648         &pxor   ($inout0,$ivec);
 649         &pxor   ($inout1,$in0);
 650         &movups ($ivec,&QWP(0x30,$inp));
 651         &movups (&QWP(0,$out),$inout0);
 652         &pxor   ($inout2,$rndkey0);
 653         &pxor   ($inout3,$rndkey1);
 654         &movups (&QWP(0x10,$out),$inout1);
 655         &movups (&QWP(0x20,$out),$inout2);
 656         &movaps ($inout0,$inout3);
 657         &lea    ($out,&DWP(0x30,$out));
 658         &jmp    (&label("cbc_dec_tail_collected"));
 659
 660 &set_label("cbc_dec_one");
 661         if ($inline)
 662         {   &aesni_inline_generate1("dec");     }
 663         else
 664         {   &call       ("_aesni_decrypt1");    }
 665         &pxor   ($inout0,$ivec);
 666         &movaps ($ivec,$in0);
 667         &jmp    (&label("cbc_dec_tail_collected"));
 668
 669 &set_label("cbc_dec_two");
 670         &call   ("_aesni_decrypt3");
 671         &pxor   ($inout0,$ivec);
 672         &pxor   ($inout1,$in0);
 673         &movups (&QWP(0,$out),$inout0);
 674         &movaps ($inout0,$inout1);
 675         &movaps ($ivec,$in1);
 676         &lea    ($out,&DWP(0x10,$out));
 677         &jmp    (&label("cbc_dec_tail_collected"));
 678
 679 &set_label("cbc_dec_three");
 680         &call   ("_aesni_decrypt3");
 681         &pxor   ($inout0,$ivec);
 682         &pxor   ($inout1,$in0);
 683         &pxor   ($inout2,$in1);
 684         &movups (&QWP(0,$out),$inout0);
 685         &movups (&QWP(0x10,$out),$inout1);
 686         &movaps ($inout0,$inout2);
 687         &movups ($ivec,&QWP(0x20,$inp));
 688         &lea    ($out,&DWP(0x20,$out));
 689
 690 &set_label("cbc_dec_tail_collected");
 691         &and    ($len,15);
 692         &jnz    (&label("cbc_dec_tail_partial"));
 693         &movups (&QWP(0,$out),$inout0);
 694         &jmp    (&label("cbc_ret"));
 695
 696 &set_label("cbc_dec_tail_partial");
 697         &mov    ($key_,"esp");
 698         &sub    ("esp",16);
 699         &and    ("esp",-16);
 700         &movaps (&QWP(0,"esp"),$inout0);
 701         &mov    ($inp,"esp");
 702         &mov    ("ecx",$len);
 703         &data_word(0xA4F3F689);         # rep movsb
 704         &mov    ("esp",$key_);
 705
 706 &set_label("cbc_ret");
 707         &mov    ($key_,&wparam(4));
 708         &movups (&QWP(0,$key_),$ivec);  # output IV
 709 &function_end("${PREFIX}_cbc_encrypt");
 710 \f
 711 ######################################################################
 712 # Mechanical port from aesni-x86_64.pl.
 713 #
 714 # _aesni_set_encrypt_key is private interface,
 715 # input:
 716 #       "eax"   const unsigned char *userKey
 717 #       $rounds int bits
 718 #       $key    AES_KEY *key
 719 # output:
 720 #       "eax"   return code
 721 #       $round  rounds
 722
 723 &function_begin_B("_aesni_set_encrypt_key");
 724         &test   ("eax","eax");
 725         &jz     (&label("bad_pointer"));
 726         &test   ($key,$key);
 727         &jz     (&label("bad_pointer"));
 728
 729         &movups ("xmm0",&QWP(0,"eax")); # pull first 128 bits of *userKey
 730         &pxor   ("xmm4","xmm4");        # low dword of xmm4 is assumed 0
 731         &lea    ($key,&DWP(16,$key));
 732         &cmp    ($rounds,256);
 733         &je     (&label("14rounds"));
 734         &cmp    ($rounds,192);
 735         &je     (&label("12rounds"));
 736         &cmp    ($rounds,128);
 737         &jne    (&label("bad_keybits"));
 738
 739 &set_label("10rounds",16);
 740         &mov            ($rounds,9);
 741         &$movekey       (&QWP(-16,$key),"xmm0");        # round 0
 742         &aeskeygenassist("xmm1","xmm0",0x01);           # round 1
 743         &call           (&label("key_128_cold"));
 744         &aeskeygenassist("xmm1","xmm0",0x2);            # round 2
 745         &call           (&label("key_128"));
 746         &aeskeygenassist("xmm1","xmm0",0x04);           # round 3
 747         &call           (&label("key_128"));
 748         &aeskeygenassist("xmm1","xmm0",0x08);           # round 4
 749         &call           (&label("key_128"));
 750         &aeskeygenassist("xmm1","xmm0",0x10);           # round 5
 751         &call           (&label("key_128"));
 752         &aeskeygenassist("xmm1","xmm0",0x20);           # round 6
 753         &call           (&label("key_128"));
 754         &aeskeygenassist("xmm1","xmm0",0x40);           # round 7
 755         &call           (&label("key_128"));
 756         &aeskeygenassist("xmm1","xmm0",0x80);           # round 8
 757         &call           (&label("key_128"));
 758         &aeskeygenassist("xmm1","xmm0",0x1b);           # round 9
 759         &call           (&label("key_128"));
 760         &aeskeygenassist("xmm1","xmm0",0x36);           # round 10
 761         &call           (&label("key_128"));
 762         &$movekey       (&QWP(0,$key),"xmm0");
 763         &mov            (&DWP(80,$key),$rounds);
 764         &xor            ("eax","eax");
 765         &ret();
 766
 767 &set_label("key_128",16);
 768         &$movekey       (&QWP(0,$key),"xmm0");
 769         &lea            ($key,&DWP(16,$key));
 770 &set_label("key_128_cold");
 771         &shufps         ("xmm4","xmm0",0b00010000);
 772         &pxor           ("xmm0","xmm4");
 773         &shufps         ("xmm4","xmm0",0b10001100,);
 774         &pxor           ("xmm0","xmm4");
 775         &pshufd         ("xmm1","xmm1",0b11111111);     # critical path
 776         &pxor           ("xmm0","xmm1");
 777         &ret();
 778
 779 &set_label("12rounds",16);
 780         &movq           ("xmm2",&QWP(16,"eax"));        # remaining 1/3 of *userKey
 781         &mov            ($rounds,11);
 782         &$movekey       (&QWP(-16,$key),"xmm0")         # round 0
 783         &aeskeygenassist("xmm1","xmm2",0x01);           # round 1,2
 784         &call           (&label("key_192a_cold"));
 785         &aeskeygenassist("xmm1","xmm2",0x02);           # round 2,3
 786         &call           (&label("key_192b"));
 787         &aeskeygenassist("xmm1","xmm2",0x04);           # round 4,5
 788         &call           (&label("key_192a"));
 789         &aeskeygenassist("xmm1","xmm2",0x08);           # round 5,6
 790         &call           (&label("key_192b"));
 791         &aeskeygenassist("xmm1","xmm2",0x10);           # round 7,8
 792         &call           (&label("key_192a"));
 793         &aeskeygenassist("xmm1","xmm2",0x20);           # round 8,9
 794         &call           (&label("key_192b"));
 795         &aeskeygenassist("xmm1","xmm2",0x40);           # round 10,11
 796         &call           (&label("key_192a"));
 797         &aeskeygenassist("xmm1","xmm2",0x80);           # round 11,12
 798         &call           (&label("key_192b"));
 799         &$movekey       (&QWP(0,$key),"xmm0");
 800         &mov            (&DWP(48,$key),$rounds);
 801         &xor            ("eax","eax");
 802         &ret();
 803
 804 &set_label("key_192a",16);
 805         &$movekey       (&QWP(0,$key),"xmm0");
 806         &lea            ($key,&DWP(16,$key));
 807 &set_label("key_192a_cold",16);
 808         &movaps         ("xmm5","xmm2");
 809 &set_label("key_192b_warm");
 810         &shufps         ("xmm4","xmm0",0b00010000);
 811         &movaps         ("xmm3","xmm2");
 812         &pxor           ("xmm0","xmm4");
 813         &shufps         ("xmm4","xmm0",0b10001100);
 814         &pslldq         ("xmm3",4);
 815         &pxor           ("xmm0","xmm4");
 816         &pshufd         ("xmm1","xmm1",0b01010101);     # critical path
 817         &pxor           ("xmm2","xmm3");
 818         &pxor           ("xmm0","xmm1");
 819         &pshufd         ("xmm3","xmm0",0b11111111);
 820         &pxor           ("xmm2","xmm3");
 821         &ret();
 822
 823 &set_label("key_192b",16);
 824         &movaps         ("xmm3","xmm0");
 825         &shufps         ("xmm5","xmm0",0b01000100);
 826         &$movekey       (&QWP(0,$key),"xmm5");
 827         &shufps         ("xmm3","xmm2",0b01001110);
 828         &$movekey       (&QWP(16,$key),"xmm3");
 829         &lea            ($key,&DWP(32,$key));
 830         &jmp            (&label("key_192b_warm"));
 831
 832 &set_label("14rounds",16);
 833         &movups         ("xmm2",&QWP(16,"eax"));        # remaining half of *userKey
 834         &mov            ($rounds,13);
 835         &lea            ($key,&DWP(16,$key));
 836         &$movekey       (&QWP(-32,$key),"xmm0");        # round 0
 837         &$movekey       (&QWP(-16,$key),"xmm2");        # round 1
 838         &aeskeygenassist("xmm1","xmm2",0x01);           # round 2
 839         &call           (&label("key_256a_cold"));
 840         &aeskeygenassist("xmm1","xmm0",0x01);           # round 3
 841         &call           (&label("key_256b"));
 842         &aeskeygenassist("xmm1","xmm2",0x02);           # round 4
 843         &call           (&label("key_256a"));
 844         &aeskeygenassist("xmm1","xmm0",0x02);           # round 5
 845         &call           (&label("key_256b"));
 846         &aeskeygenassist("xmm1","xmm2",0x04);           # round 6
 847         &call           (&label("key_256a"));
 848         &aeskeygenassist("xmm1","xmm0",0x04);           # round 7
 849         &call           (&label("key_256b"));
 850         &aeskeygenassist("xmm1","xmm2",0x08);           # round 8
 851         &call           (&label("key_256a"));
 852         &aeskeygenassist("xmm1","xmm0",0x08);           # round 9
 853         &call           (&label("key_256b"));
 854         &aeskeygenassist("xmm1","xmm2",0x10);           # round 10
 855         &call           (&label("key_256a"));
 856         &aeskeygenassist("xmm1","xmm0",0x10);           # round 11
 857         &call           (&label("key_256b"));
 858         &aeskeygenassist("xmm1","xmm2",0x20);           # round 12
 859         &call           (&label("key_256a"));
 860         &aeskeygenassist("xmm1","xmm0",0x20);           # round 13
 861         &call           (&label("key_256b"));
 862         &aeskeygenassist("xmm1","xmm2",0x40);           # round 14
 863         &call           (&label("key_256a"));
 864         &$movekey       (&QWP(0,$key),"xmm0");
 865         &mov            (&DWP(16,$key),$rounds);
 866         &xor            ("eax","eax");
 867         &ret();
 868
 869 &set_label("key_256a",16);
 870         &$movekey       (&QWP(0,$key),"xmm2");
 871         &lea            ($key,&DWP(16,$key));
 872 &set_label("key_256a_cold");
 873         &shufps         ("xmm4","xmm0",0b00010000);
 874         &pxor           ("xmm0","xmm4");
 875         &shufps         ("xmm4","xmm0",0b10001100);
 876         &pxor           ("xmm0","xmm4");
 877         &pshufd         ("xmm1","xmm1",0b11111111);     # critical path
 878         &pxor           ("xmm0","xmm1");
 879         &ret();
 880
 881 &set_label("key_256b",16);
 882         &$movekey       (&QWP(0,$key),"xmm0");
 883         &lea            ($key,&DWP(16,$key));
 884
 885         &shufps         ("xmm4","xmm2",0b00010000);
 886         &pxor           ("xmm2","xmm4");
 887         &shufps         ("xmm4","xmm2",0b10001100);
 888         &pxor           ("xmm2","xmm4");
 889         &pshufd         ("xmm1","xmm1",0b10101010);     # critical path
 890         &pxor           ("xmm2","xmm1");
 891         &ret();
 892
 893 &set_label("bad_pointer",4);
 894         &mov    ("eax",-1);
 895         &ret    ();
 896 &set_label("bad_keybits",4);
 897         &mov    ("eax",-2);
 898         &ret    ();
 899 &function_end_B("_aesni_set_encrypt_key");
 900
 901 # int $PREFIX_set_encrypt_key (const unsigned char *userKey, int bits,
 902 #                              AES_KEY *key)
 903 &function_begin_B("${PREFIX}_set_encrypt_key");
 904         &mov    ("eax",&wparam(0));
 905         &mov    ($rounds,&wparam(1));
 906         &mov    ($key,&wparam(2));
 907         &call   ("_aesni_set_encrypt_key");
 908         &ret    ();
 909 &function_end_B("${PREFIX}_set_encrypt_key");
 910
 911 # int $PREFIX_set_decrypt_key (const unsigned char *userKey, int bits,
 912 #                              AES_KEY *key)
 913 &function_begin_B("${PREFIX}_set_decrypt_key");
 914         &mov    ("eax",&wparam(0));
 915         &mov    ($rounds,&wparam(1));
 916         &mov    ($key,&wparam(2));
 917         &call   ("_aesni_set_encrypt_key");
 918         &mov    ($key,&wparam(2));
 919         &shl    ($rounds,4)     # rounds-1 after _aesni_set_encrypt_key
 920         &test   ("eax","eax");
 921         &jnz    (&label("dec_key_ret"));
 922         &lea    ("eax",&DWP(16,$key,$rounds));  # end of key schedule
 923
 924         &$movekey       ("xmm0",&QWP(0,$key));  # just swap
 925         &$movekey       ("xmm1",&QWP(0,"eax"));
 926         &$movekey       (&QWP(0,"eax"),"xmm0");
 927         &$movekey       (&QWP(0,$key),"xmm1");
 928         &lea            ($key,&DWP(16,$key));
 929         &lea            ("eax",&DWP(-16,"eax"));
 930
 931 &set_label("dec_key_inverse");
 932         &$movekey       ("xmm0",&QWP(0,$key));  # swap and inverse
 933         &$movekey       ("xmm1",&QWP(0,"eax"));
 934         &aesimc         ("xmm0","xmm0");
 935         &aesimc         ("xmm1","xmm1");
 936         &lea            ($key,&DWP(16,$key));
 937         &lea            ("eax",&DWP(-16,"eax"));
 938         &cmp            ("eax",$key);
 939         &$movekey       (&QWP(16,"eax"),"xmm0");
 940         &$movekey       (&QWP(-16,$key),"xmm1");
 941         &ja             (&label("dec_key_inverse"));
 942
 943         &$movekey       ("xmm0",&QWP(0,$key));  # inverse middle
 944         &aesimc         ("xmm0","xmm0");
 945         &$movekey       (&QWP(0,$key),"xmm0");
 946
 947         &xor            ("eax","eax");          # return success
 948 &set_label("dec_key_ret");
 949         &ret    ();
 950 &function_end_B("${PREFIX}_set_decrypt_key");
 951 &asciz("AES for Intel AES-NI, CRYPTOGAMS by <appro\@openssl.org>");
 952
 953 &asm_finish();