| #!/usr/bin/env perl |
| |
| ################################################################### |
| ### AES-128 [originally in CTR mode] ### |
| ### bitsliced implementation for Intel Core 2 processors ### |
| ### requires support of SSE extensions up to SSSE3 ### |
| ### Author: Emilia Käsper and Peter Schwabe ### |
| ### Date: 2009-03-19 ### |
| ### Public domain ### |
| ### ### |
| ### See http://homes.esat.kuleuven.be/~ekasper/#software for ### |
| ### further information. ### |
| ################################################################### |
| # |
| # September 2011. |
| # |
| # Started as transliteration to "perlasm" the original code has |
| # undergone following changes: |
| # |
| # - code was made position-independent; |
| # - rounds were folded into a loop resulting in >5x size reduction |
| # from 12.5KB to 2.2KB; |
| # - above was possibile thanks to mixcolumns() modification that |
| # allowed to feed its output back to aesenc[last], this was |
| # achieved at cost of two additional inter-registers moves; |
| # - some instruction reordering and interleaving; |
| # - this module doesn't implement key setup subroutine, instead it |
| # relies on conversion of "conventional" key schedule as returned |
| # by AES_set_encrypt_key (see discussion below); |
| # - first and last round keys are treated differently, which allowed |
| # to skip one shiftrows(), reduce bit-sliced key schedule and |
| # speed-up conversion by 22%; |
| # - support for 192- and 256-bit keys was added; |
| # |
| # Resulting performance in CPU cycles spent to encrypt one byte out |
| # of 4096-byte buffer with 128-bit key is: |
| # |
| # Emilia's this(*) difference |
| # |
| # Core 2 9.30 8.69 +7% |
| # Nehalem(**) 7.63 6.98 +9% |
| # Atom 17.1 17.4 -2%(***) |
| # |
| # (*) Comparison is not completely fair, because "this" is ECB, |
| # i.e. no extra processing such as counter values calculation |
| # and xor-ing input as in Emilia's CTR implementation is |
| # performed. However, the CTR calculations stand for not more |
| # than 1% of total time, so comparison is *rather* fair. |
| # |
| # (**) Results were collected on Westmere, which is considered to |
| # be equivalent to Nehalem for this code. |
| # |
| # (***) Slowdown on Atom is rather strange per se, because original |
| # implementation has a number of 9+-bytes instructions, which |
| # are bad for Atom front-end, and which I eliminated completely. |
| # In attempt to address deterioration sbox() was tested in FP |
| # SIMD "domain" (movaps instead of movdqa, xorps instead of |
| # pxor, etc.). While it resulted in nominal 4% improvement on |
| # Atom, it hurted Westmere by more than 2x factor. |
| # |
| # As for key schedule conversion subroutine. Interface to OpenSSL |
| # relies on per-invocation on-the-fly conversion. This naturally |
| # has impact on performance, especially for short inputs. Conversion |
| # time in CPU cycles and its ratio to CPU cycles spent in 8x block |
| # function is: |
| # |
| # conversion conversion/8x block |
| # Core 2 240 0.22 |
| # Nehalem 180 0.20 |
| # Atom 430 0.19 |
| # |
| # The ratio values mean that 128-byte blocks will be processed |
| # 16-18% slower, 256-byte blocks - 9-10%, 384-byte blocks - 6-7%, |
| # etc. Then keep in mind that input sizes not divisible by 128 are |
| # *effectively* slower, especially shortest ones, e.g. consecutive |
| # 144-byte blocks are processed 44% slower than one would expect, |
| # 272 - 29%, 400 - 22%, etc. Yet, despite all these "shortcomings" |
| # it's still faster than ["hyper-threading-safe" code path in] |
| # aes-x86_64.pl on all lengths above 64 bytes... |
| # |
| # October 2011. |
| # |
| # Add decryption procedure. Performance in CPU cycles spent to decrypt |
| # one byte out of 4096-byte buffer with 128-bit key is: |
| # |
| # Core 2 11.0 |
| # Nehalem 9.16 |
| # Atom 20.9 |
| # |
| # November 2011. |
| # |
| # Add bsaes_xts_[en|de]crypt. Less-than-80-bytes-block performance is |
| # suboptimal, but XTS is meant to be used with larger blocks... |
| # |
| # <appro@openssl.org> |
| |
| $flavour = shift; |
| $output = shift; |
| if ($flavour =~ /\./) { $output = $flavour; undef $flavour; } |
| |
| $win64=0; $win64=1 if ($flavour =~ /[nm]asm|mingw64/ || $output =~ /\.asm$/); |
| |
| $0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1; |
| ( $xlate="${dir}x86_64-xlate.pl" and -f $xlate ) or |
| ( $xlate="${dir}../../perlasm/x86_64-xlate.pl" and -f $xlate) or |
| die "can't locate x86_64-xlate.pl"; |
| |
| open STDOUT,"| $^X $xlate $flavour $output"; |
| |
| my ($inp,$out,$len,$key,$ivp)=("%rdi","%rsi","%rdx","%rcx"); |
| my @XMM=map("%xmm$_",(15,0..14)); # best on Atom, +10% over (0..15) |
| my $ecb=0; # suppress unreferenced ECB subroutines, spare some space... |
| |
| { |
| my ($key,$rounds,$const)=("%rax","%r10d","%r11"); |
| |
| sub Sbox { |
| # input in lsb > [b0, b1, b2, b3, b4, b5, b6, b7] < msb |
| # output in lsb > [b0, b1, b4, b6, b3, b7, b2, b5] < msb |
| my @b=@_[0..7]; |
| my @t=@_[8..11]; |
| my @s=@_[12..15]; |
| &InBasisChange (@b); |
| &Inv_GF256 (@b[6,5,0,3,7,1,4,2],@t,@s); |
| &OutBasisChange (@b[7,1,4,2,6,5,0,3]); |
| } |
| |
| sub InBasisChange { |
| # input in lsb > [b0, b1, b2, b3, b4, b5, b6, b7] < msb |
| # output in lsb > [b6, b5, b0, b3, b7, b1, b4, b2] < msb |
| my @b=@_[0..7]; |
| $code.=<<___; |
| pxor @b[6], @b[5] |
| pxor @b[1], @b[2] |
| pxor @b[0], @b[3] |
| pxor @b[2], @b[6] |
| pxor @b[0], @b[5] |
| |
| pxor @b[3], @b[6] |
| pxor @b[7], @b[3] |
| pxor @b[5], @b[7] |
| pxor @b[4], @b[3] |
| pxor @b[5], @b[4] |
| pxor @b[1], @b[3] |
| |
| pxor @b[7], @b[2] |
| pxor @b[5], @b[1] |
| ___ |
| } |
| |
| sub OutBasisChange { |
| # input in lsb > [b0, b1, b2, b3, b4, b5, b6, b7] < msb |
| # output in lsb > [b6, b1, b2, b4, b7, b0, b3, b5] < msb |
| my @b=@_[0..7]; |
| $code.=<<___; |
| pxor @b[6], @b[0] |
| pxor @b[4], @b[1] |
| pxor @b[0], @b[2] |
| pxor @b[6], @b[4] |
| pxor @b[1], @b[6] |
| |
| pxor @b[5], @b[1] |
| pxor @b[3], @b[5] |
| pxor @b[7], @b[3] |
| pxor @b[5], @b[7] |
| pxor @b[5], @b[2] |
| |
| pxor @b[7], @b[4] |
| ___ |
| } |
| |
| sub InvSbox { |
| # input in lsb > [b0, b1, b2, b3, b4, b5, b6, b7] < msb |
| # output in lsb > [b0, b1, b6, b4, b2, b7, b3, b5] < msb |
| my @b=@_[0..7]; |
| my @t=@_[8..11]; |
| my @s=@_[12..15]; |
| &InvInBasisChange (@b); |
| &Inv_GF256 (@b[5,1,2,6,3,7,0,4],@t,@s); |
| &InvOutBasisChange (@b[3,7,0,4,5,1,2,6]); |
| } |
| |
| sub InvInBasisChange { # OutBasisChange in reverse |
| my @b=@_[5,1,2,6,3,7,0,4]; |
| $code.=<<___ |
| pxor @b[7], @b[4] |
| |
| pxor @b[5], @b[7] |
| pxor @b[5], @b[2] |
| pxor @b[7], @b[3] |
| pxor @b[3], @b[5] |
| pxor @b[5], @b[1] |
| |
| pxor @b[1], @b[6] |
| pxor @b[0], @b[2] |
| pxor @b[6], @b[4] |
| pxor @b[6], @b[0] |
| pxor @b[4], @b[1] |
| ___ |
| } |
| |
| sub InvOutBasisChange { # InBasisChange in reverse |
| my @b=@_[2,5,7,3,6,1,0,4]; |
| $code.=<<___; |
| pxor @b[5], @b[1] |
| pxor @b[7], @b[2] |
| |
| pxor @b[1], @b[3] |
| pxor @b[5], @b[4] |
| pxor @b[5], @b[7] |
| pxor @b[4], @b[3] |
| pxor @b[0], @b[5] |
| pxor @b[7], @b[3] |
| pxor @b[2], @b[6] |
| pxor @b[1], @b[2] |
| pxor @b[3], @b[6] |
| |
| pxor @b[0], @b[3] |
| pxor @b[6], @b[5] |
| ___ |
| } |
| |
| sub Mul_GF4 { |
| #;************************************************************* |
| #;* Mul_GF4: Input x0-x1,y0-y1 Output x0-x1 Temp t0 (8) * |
| #;************************************************************* |
| my ($x0,$x1,$y0,$y1,$t0)=@_; |
| $code.=<<___; |
| movdqa $y0, $t0 |
| pxor $y1, $t0 |
| pand $x0, $t0 |
| pxor $x1, $x0 |
| pand $y0, $x1 |
| pand $y1, $x0 |
| pxor $x1, $x0 |
| pxor $t0, $x1 |
| ___ |
| } |
| |
| sub Mul_GF4_N { # not used, see next subroutine |
| # multiply and scale by N |
| my ($x0,$x1,$y0,$y1,$t0)=@_; |
| $code.=<<___; |
| movdqa $y0, $t0 |
| pxor $y1, $t0 |
| pand $x0, $t0 |
| pxor $x1, $x0 |
| pand $y0, $x1 |
| pand $y1, $x0 |
| pxor $x0, $x1 |
| pxor $t0, $x0 |
| ___ |
| } |
| |
| sub Mul_GF4_N_GF4 { |
| # interleaved Mul_GF4_N and Mul_GF4 |
| my ($x0,$x1,$y0,$y1,$t0, |
| $x2,$x3,$y2,$y3,$t1)=@_; |
| $code.=<<___; |
| movdqa $y0, $t0 |
| movdqa $y2, $t1 |
| pxor $y1, $t0 |
| pxor $y3, $t1 |
| pand $x0, $t0 |
| pand $x2, $t1 |
| pxor $x1, $x0 |
| pxor $x3, $x2 |
| pand $y0, $x1 |
| pand $y2, $x3 |
| pand $y1, $x0 |
| pand $y3, $x2 |
| pxor $x0, $x1 |
| pxor $x3, $x2 |
| pxor $t0, $x0 |
| pxor $t1, $x3 |
| ___ |
| } |
| sub Mul_GF16_2 { |
| my @x=@_[0..7]; |
| my @y=@_[8..11]; |
| my @t=@_[12..15]; |
| $code.=<<___; |
| movdqa @x[0], @t[0] |
| movdqa @x[1], @t[1] |
| ___ |
| &Mul_GF4 (@x[0], @x[1], @y[0], @y[1], @t[2]); |
| $code.=<<___; |
| pxor @x[2], @t[0] |
| pxor @x[3], @t[1] |
| pxor @y[2], @y[0] |
| pxor @y[3], @y[1] |
| ___ |
| Mul_GF4_N_GF4 (@t[0], @t[1], @y[0], @y[1], @t[3], |
| @x[2], @x[3], @y[2], @y[3], @t[2]); |
| $code.=<<___; |
| pxor @t[0], @x[0] |
| pxor @t[0], @x[2] |
| pxor @t[1], @x[1] |
| pxor @t[1], @x[3] |
| |
| movdqa @x[4], @t[0] |
| movdqa @x[5], @t[1] |
| pxor @x[6], @t[0] |
| pxor @x[7], @t[1] |
| ___ |
| &Mul_GF4_N_GF4 (@t[0], @t[1], @y[0], @y[1], @t[3], |
| @x[6], @x[7], @y[2], @y[3], @t[2]); |
| $code.=<<___; |
| pxor @y[2], @y[0] |
| pxor @y[3], @y[1] |
| ___ |
| &Mul_GF4 (@x[4], @x[5], @y[0], @y[1], @t[3]); |
| $code.=<<___; |
| pxor @t[0], @x[4] |
| pxor @t[0], @x[6] |
| pxor @t[1], @x[5] |
| pxor @t[1], @x[7] |
| ___ |
| } |
| sub Inv_GF256 { |
| #;******************************************************************** |
| #;* Inv_GF256: Input x0-x7 Output x0-x7 Temp t0-t3,s0-s3 (144) * |
| #;******************************************************************** |
| my @x=@_[0..7]; |
| my @t=@_[8..11]; |
| my @s=@_[12..15]; |
| # direct optimizations from hardware |
| $code.=<<___; |
| movdqa @x[4], @t[3] |
| movdqa @x[5], @t[2] |
| movdqa @x[1], @t[1] |
| movdqa @x[7], @s[1] |
| movdqa @x[0], @s[0] |
| |
| pxor @x[6], @t[3] |
| pxor @x[7], @t[2] |
| pxor @x[3], @t[1] |
| movdqa @t[3], @s[2] |
| pxor @x[6], @s[1] |
| movdqa @t[2], @t[0] |
| pxor @x[2], @s[0] |
| movdqa @t[3], @s[3] |
| |
| por @t[1], @t[2] |
| por @s[0], @t[3] |
| pxor @t[0], @s[3] |
| pand @s[0], @s[2] |
| pxor @t[1], @s[0] |
| pand @t[1], @t[0] |
| pand @s[0], @s[3] |
| movdqa @x[3], @s[0] |
| pxor @x[2], @s[0] |
| pand @s[0], @s[1] |
| pxor @s[1], @t[3] |
| pxor @s[1], @t[2] |
| movdqa @x[4], @s[1] |
| movdqa @x[1], @s[0] |
| pxor @x[5], @s[1] |
| pxor @x[0], @s[0] |
| movdqa @s[1], @t[1] |
| pand @s[0], @s[1] |
| por @s[0], @t[1] |
| pxor @s[1], @t[0] |
| pxor @s[3], @t[3] |
| pxor @s[2], @t[2] |
| pxor @s[3], @t[1] |
| movdqa @x[7], @s[0] |
| pxor @s[2], @t[0] |
| movdqa @x[6], @s[1] |
| pxor @s[2], @t[1] |
| movdqa @x[5], @s[2] |
| pand @x[3], @s[0] |
| movdqa @x[4], @s[3] |
| pand @x[2], @s[1] |
| pand @x[1], @s[2] |
| por @x[0], @s[3] |
| pxor @s[0], @t[3] |
| pxor @s[1], @t[2] |
| pxor @s[2], @t[1] |
| pxor @s[3], @t[0] |
| |
| #Inv_GF16 \t0, \t1, \t2, \t3, \s0, \s1, \s2, \s3 |
| |
| # new smaller inversion |
| |
| movdqa @t[3], @s[0] |
| pand @t[1], @t[3] |
| pxor @t[2], @s[0] |
| |
| movdqa @t[0], @s[2] |
| movdqa @s[0], @s[3] |
| pxor @t[3], @s[2] |
| pand @s[2], @s[3] |
| |
| movdqa @t[1], @s[1] |
| pxor @t[2], @s[3] |
| pxor @t[0], @s[1] |
| |
| pxor @t[2], @t[3] |
| |
| pand @t[3], @s[1] |
| |
| movdqa @s[2], @t[2] |
| pxor @t[0], @s[1] |
| |
| pxor @s[1], @t[2] |
| pxor @s[1], @t[1] |
| |
| pand @t[0], @t[2] |
| |
| pxor @t[2], @s[2] |
| pxor @t[2], @t[1] |
| |
| pand @s[3], @s[2] |
| |
| pxor @s[0], @s[2] |
| ___ |
| # output in s3, s2, s1, t1 |
| |
| # Mul_GF16_2 \x0, \x1, \x2, \x3, \x4, \x5, \x6, \x7, \t2, \t3, \t0, \t1, \s0, \s1, \s2, \s3 |
| |
| # Mul_GF16_2 \x0, \x1, \x2, \x3, \x4, \x5, \x6, \x7, \s3, \s2, \s1, \t1, \s0, \t0, \t2, \t3 |
| &Mul_GF16_2(@x,@s[3,2,1],@t[1],@s[0],@t[0,2,3]); |
| |
| ### output msb > [x3,x2,x1,x0,x7,x6,x5,x4] < lsb |
| } |
| |
| # AES linear components |
| |
| sub ShiftRows { |
| my @x=@_[0..7]; |
| my $mask=pop; |
| $code.=<<___; |
| pxor 0x00($key),@x[0] |
| pxor 0x10($key),@x[1] |
| pshufb $mask,@x[0] |
| pxor 0x20($key),@x[2] |
| pshufb $mask,@x[1] |
| pxor 0x30($key),@x[3] |
| pshufb $mask,@x[2] |
| pxor 0x40($key),@x[4] |
| pshufb $mask,@x[3] |
| pxor 0x50($key),@x[5] |
| pshufb $mask,@x[4] |
| pxor 0x60($key),@x[6] |
| pshufb $mask,@x[5] |
| pxor 0x70($key),@x[7] |
| pshufb $mask,@x[6] |
| lea 0x80($key),$key |
| pshufb $mask,@x[7] |
| ___ |
| } |
| |
| sub MixColumns { |
| # modified to emit output in order suitable for feeding back to aesenc[last] |
| my @x=@_[0..7]; |
| my @t=@_[8..15]; |
| $code.=<<___; |
| pshufd \$0x93, @x[0], @t[0] # x0 <<< 32 |
| pshufd \$0x93, @x[1], @t[1] |
| pxor @t[0], @x[0] # x0 ^ (x0 <<< 32) |
| pshufd \$0x93, @x[2], @t[2] |
| pxor @t[1], @x[1] |
| pshufd \$0x93, @x[3], @t[3] |
| pxor @t[2], @x[2] |
| pshufd \$0x93, @x[4], @t[4] |
| pxor @t[3], @x[3] |
| pshufd \$0x93, @x[5], @t[5] |
| pxor @t[4], @x[4] |
| pshufd \$0x93, @x[6], @t[6] |
| pxor @t[5], @x[5] |
| pshufd \$0x93, @x[7], @t[7] |
| pxor @t[6], @x[6] |
| pxor @t[7], @x[7] |
| |
| pxor @x[0], @t[1] |
| pxor @x[7], @t[0] |
| pxor @x[7], @t[1] |
| pshufd \$0x4E, @x[0], @x[0] # (x0 ^ (x0 <<< 32)) <<< 64) |
| pxor @x[1], @t[2] |
| pshufd \$0x4E, @x[1], @x[1] |
| pxor @x[4], @t[5] |
| pxor @t[0], @x[0] |
| pxor @x[5], @t[6] |
| pxor @t[1], @x[1] |
| pxor @x[3], @t[4] |
| pshufd \$0x4E, @x[4], @t[0] |
| pxor @x[6], @t[7] |
| pshufd \$0x4E, @x[5], @t[1] |
| pxor @x[2], @t[3] |
| pshufd \$0x4E, @x[3], @x[4] |
| pxor @x[7], @t[3] |
| pshufd \$0x4E, @x[7], @x[5] |
| pxor @x[7], @t[4] |
| pshufd \$0x4E, @x[6], @x[3] |
| pxor @t[4], @t[0] |
| pshufd \$0x4E, @x[2], @x[6] |
| pxor @t[5], @t[1] |
| |
| pxor @t[3], @x[4] |
| pxor @t[7], @x[5] |
| pxor @t[6], @x[3] |
| movdqa @t[0], @x[2] |
| pxor @t[2], @x[6] |
| movdqa @t[1], @x[7] |
| ___ |
| } |
| |
| sub InvMixColumns { |
| my @x=@_[0..7]; |
| my @t=@_[8..15]; |
| |
| $code.=<<___; |
| # multiplication by 0x0e |
| pshufd \$0x93, @x[7], @t[7] |
| movdqa @x[2], @t[2] |
| pxor @x[5], @x[7] # 7 5 |
| pxor @x[5], @x[2] # 2 5 |
| pshufd \$0x93, @x[0], @t[0] |
| movdqa @x[5], @t[5] |
| pxor @x[0], @x[5] # 5 0 [1] |
| pxor @x[1], @x[0] # 0 1 |
| pshufd \$0x93, @x[1], @t[1] |
| pxor @x[2], @x[1] # 1 25 |
| pxor @x[6], @x[0] # 01 6 [2] |
| pxor @x[3], @x[1] # 125 3 [4] |
| pshufd \$0x93, @x[3], @t[3] |
| pxor @x[0], @x[2] # 25 016 [3] |
| pxor @x[7], @x[3] # 3 75 |
| pxor @x[6], @x[7] # 75 6 [0] |
| pshufd \$0x93, @x[6], @t[6] |
| movdqa @x[4], @t[4] |
| pxor @x[4], @x[6] # 6 4 |
| pxor @x[3], @x[4] # 4 375 [6] |
| pxor @x[7], @x[3] # 375 756=36 |
| pxor @t[5], @x[6] # 64 5 [7] |
| pxor @t[2], @x[3] # 36 2 |
| pxor @t[4], @x[3] # 362 4 [5] |
| pshufd \$0x93, @t[5], @t[5] |
| ___ |
| my @y = @x[7,5,0,2,1,3,4,6]; |
| $code.=<<___; |
| # multiplication by 0x0b |
| pxor @y[0], @y[1] |
| pxor @t[0], @y[0] |
| pxor @t[1], @y[1] |
| pshufd \$0x93, @t[2], @t[2] |
| pxor @t[5], @y[0] |
| pxor @t[6], @y[1] |
| pxor @t[7], @y[0] |
| pshufd \$0x93, @t[4], @t[4] |
| pxor @t[6], @t[7] # clobber t[7] |
| pxor @y[0], @y[1] |
| |
| pxor @t[0], @y[3] |
| pshufd \$0x93, @t[0], @t[0] |
| pxor @t[1], @y[2] |
| pxor @t[1], @y[4] |
| pxor @t[2], @y[2] |
| pshufd \$0x93, @t[1], @t[1] |
| pxor @t[2], @y[3] |
| pxor @t[2], @y[5] |
| pxor @t[7], @y[2] |
| pshufd \$0x93, @t[2], @t[2] |
| pxor @t[3], @y[3] |
| pxor @t[3], @y[6] |
| pxor @t[3], @y[4] |
| pshufd \$0x93, @t[3], @t[3] |
| pxor @t[4], @y[7] |
| pxor @t[4], @y[5] |
| pxor @t[7], @y[7] |
| pxor @t[5], @y[3] |
| pxor @t[4], @y[4] |
| pxor @t[5], @t[7] # clobber t[7] even more |
| |
| pxor @t[7], @y[5] |
| pshufd \$0x93, @t[4], @t[4] |
| pxor @t[7], @y[6] |
| pxor @t[7], @y[4] |
| |
| pxor @t[5], @t[7] |
| pshufd \$0x93, @t[5], @t[5] |
| pxor @t[6], @t[7] # restore t[7] |
| |
| # multiplication by 0x0d |
| pxor @y[7], @y[4] |
| pxor @t[4], @y[7] |
| pshufd \$0x93, @t[6], @t[6] |
| pxor @t[0], @y[2] |
| pxor @t[5], @y[7] |
| pxor @t[2], @y[2] |
| pshufd \$0x93, @t[7], @t[7] |
| |
| pxor @y[1], @y[3] |
| pxor @t[1], @y[1] |
| pxor @t[0], @y[0] |
| pxor @t[0], @y[3] |
| pxor @t[5], @y[1] |
| pxor @t[5], @y[0] |
| pxor @t[7], @y[1] |
| pshufd \$0x93, @t[0], @t[0] |
| pxor @t[6], @y[0] |
| pxor @y[1], @y[3] |
| pxor @t[1], @y[4] |
| pshufd \$0x93, @t[1], @t[1] |
| |
| pxor @t[7], @y[7] |
| pxor @t[2], @y[4] |
| pxor @t[2], @y[5] |
| pshufd \$0x93, @t[2], @t[2] |
| pxor @t[6], @y[2] |
| pxor @t[3], @t[6] # clobber t[6] |
| pxor @y[7], @y[4] |
| pxor @t[6], @y[3] |
| |
| pxor @t[6], @y[6] |
| pxor @t[5], @y[5] |
| pxor @t[4], @y[6] |
| pshufd \$0x93, @t[4], @t[4] |
| pxor @t[6], @y[5] |
| pxor @t[7], @y[6] |
| pxor @t[3], @t[6] # restore t[6] |
| |
| pshufd \$0x93, @t[5], @t[5] |
| pshufd \$0x93, @t[6], @t[6] |
| pshufd \$0x93, @t[7], @t[7] |
| pshufd \$0x93, @t[3], @t[3] |
| |
| # multiplication by 0x09 |
| pxor @y[1], @y[4] |
| pxor @y[1], @t[1] # t[1]=y[1] |
| pxor @t[5], @t[0] # clobber t[0] |
| pxor @t[5], @t[1] |
| pxor @t[0], @y[3] |
| pxor @y[0], @t[0] # t[0]=y[0] |
| pxor @t[6], @t[1] |
| pxor @t[7], @t[6] # clobber t[6] |
| pxor @t[1], @y[4] |
| pxor @t[4], @y[7] |
| pxor @y[4], @t[4] # t[4]=y[4] |
| pxor @t[3], @y[6] |
| pxor @y[3], @t[3] # t[3]=y[3] |
| pxor @t[2], @y[5] |
| pxor @y[2], @t[2] # t[2]=y[2] |
| pxor @t[7], @t[3] |
| pxor @y[5], @t[5] # t[5]=y[5] |
| pxor @t[6], @t[2] |
| pxor @t[6], @t[5] |
| pxor @y[6], @t[6] # t[6]=y[6] |
| pxor @y[7], @t[7] # t[7]=y[7] |
| |
| movdqa @t[0],@XMM[0] |
| movdqa @t[1],@XMM[1] |
| movdqa @t[2],@XMM[2] |
| movdqa @t[3],@XMM[3] |
| movdqa @t[4],@XMM[4] |
| movdqa @t[5],@XMM[5] |
| movdqa @t[6],@XMM[6] |
| movdqa @t[7],@XMM[7] |
| ___ |
| } |
| |
| sub aesenc { # not used |
| my @b=@_[0..7]; |
| my @t=@_[8..15]; |
| $code.=<<___; |
| movdqa 0x30($const),@t[0] # .LSR |
| ___ |
| &ShiftRows (@b,@t[0]); |
| &Sbox (@b,@t); |
| &MixColumns (@b[0,1,4,6,3,7,2,5],@t); |
| } |
| |
| sub aesenclast { # not used |
| my @b=@_[0..7]; |
| my @t=@_[8..15]; |
| $code.=<<___; |
| movdqa 0x40($const),@t[0] # .LSRM0 |
| ___ |
| &ShiftRows (@b,@t[0]); |
| &Sbox (@b,@t); |
| $code.=<<___ |
| pxor 0x00($key),@b[0] |
| pxor 0x10($key),@b[1] |
| pxor 0x20($key),@b[4] |
| pxor 0x30($key),@b[6] |
| pxor 0x40($key),@b[3] |
| pxor 0x50($key),@b[7] |
| pxor 0x60($key),@b[2] |
| pxor 0x70($key),@b[5] |
| ___ |
| } |
| |
| sub swapmove { |
| my ($a,$b,$n,$mask,$t)=@_; |
| $code.=<<___; |
| movdqa $b,$t |
| psrlq \$$n,$b |
| pxor $a,$b |
| pand $mask,$b |
| pxor $b,$a |
| psllq \$$n,$b |
| pxor $t,$b |
| ___ |
| } |
| sub swapmove2x { |
| my ($a0,$b0,$a1,$b1,$n,$mask,$t0,$t1)=@_; |
| $code.=<<___; |
| movdqa $b0,$t0 |
| psrlq \$$n,$b0 |
| movdqa $b1,$t1 |
| psrlq \$$n,$b1 |
| pxor $a0,$b0 |
| pxor $a1,$b1 |
| pand $mask,$b0 |
| pand $mask,$b1 |
| pxor $b0,$a0 |
| psllq \$$n,$b0 |
| pxor $b1,$a1 |
| psllq \$$n,$b1 |
| pxor $t0,$b0 |
| pxor $t1,$b1 |
| ___ |
| } |
| |
| sub bitslice { |
| my @x=reverse(@_[0..7]); |
| my ($t0,$t1,$t2,$t3)=@_[8..11]; |
| $code.=<<___; |
| movdqa 0x00($const),$t0 # .LBS0 |
| movdqa 0x10($const),$t1 # .LBS1 |
| ___ |
| &swapmove2x(@x[0,1,2,3],1,$t0,$t2,$t3); |
| &swapmove2x(@x[4,5,6,7],1,$t0,$t2,$t3); |
| $code.=<<___; |
| movdqa 0x20($const),$t0 # .LBS2 |
| ___ |
| &swapmove2x(@x[0,2,1,3],2,$t1,$t2,$t3); |
| &swapmove2x(@x[4,6,5,7],2,$t1,$t2,$t3); |
| |
| &swapmove2x(@x[0,4,1,5],4,$t0,$t2,$t3); |
| &swapmove2x(@x[2,6,3,7],4,$t0,$t2,$t3); |
| } |
| |
| $code.=<<___; |
| .text |
| |
| .extern asm_AES_encrypt |
| .extern asm_AES_decrypt |
| |
| .type _bsaes_encrypt8,\@abi-omnipotent |
| .align 64 |
| _bsaes_encrypt8: |
| lea .LBS0(%rip), $const # constants table |
| |
| movdqa ($key), @XMM[9] # round 0 key |
| lea 0x10($key), $key |
| movdqa 0x50($const), @XMM[8] # .LM0SR |
| pxor @XMM[9], @XMM[0] # xor with round0 key |
| pxor @XMM[9], @XMM[1] |
| pshufb @XMM[8], @XMM[0] |
| pxor @XMM[9], @XMM[2] |
| pshufb @XMM[8], @XMM[1] |
| pxor @XMM[9], @XMM[3] |
| pshufb @XMM[8], @XMM[2] |
| pxor @XMM[9], @XMM[4] |
| pshufb @XMM[8], @XMM[3] |
| pxor @XMM[9], @XMM[5] |
| pshufb @XMM[8], @XMM[4] |
| pxor @XMM[9], @XMM[6] |
| pshufb @XMM[8], @XMM[5] |
| pxor @XMM[9], @XMM[7] |
| pshufb @XMM[8], @XMM[6] |
| pshufb @XMM[8], @XMM[7] |
| _bsaes_encrypt8_bitslice: |
| ___ |
| &bitslice (@XMM[0..7, 8..11]); |
| $code.=<<___; |
| dec $rounds |
| jmp .Lenc_sbox |
| .align 16 |
| .Lenc_loop: |
| ___ |
| &ShiftRows (@XMM[0..7, 8]); |
| $code.=".Lenc_sbox:\n"; |
| &Sbox (@XMM[0..7, 8..15]); |
| $code.=<<___; |
| dec $rounds |
| jl .Lenc_done |
| ___ |
| &MixColumns (@XMM[0,1,4,6,3,7,2,5, 8..15]); |
| $code.=<<___; |
| movdqa 0x30($const), @XMM[8] # .LSR |
| jnz .Lenc_loop |
| movdqa 0x40($const), @XMM[8] # .LSRM0 |
| jmp .Lenc_loop |
| .align 16 |
| .Lenc_done: |
| ___ |
| # output in lsb > [t0, t1, t4, t6, t3, t7, t2, t5] < msb |
| &bitslice (@XMM[0,1,4,6,3,7,2,5, 8..11]); |
| $code.=<<___; |
| movdqa ($key), @XMM[8] # last round key |
| pxor @XMM[8], @XMM[4] |
| pxor @XMM[8], @XMM[6] |
| pxor @XMM[8], @XMM[3] |
| pxor @XMM[8], @XMM[7] |
| pxor @XMM[8], @XMM[2] |
| pxor @XMM[8], @XMM[5] |
| pxor @XMM[8], @XMM[0] |
| pxor @XMM[8], @XMM[1] |
| ret |
| .size _bsaes_encrypt8,.-_bsaes_encrypt8 |
| |
| .type _bsaes_decrypt8,\@abi-omnipotent |
| .align 64 |
| _bsaes_decrypt8: |
| lea .LBS0(%rip), $const # constants table |
| |
| movdqa ($key), @XMM[9] # round 0 key |
| lea 0x10($key), $key |
| movdqa -0x30($const), @XMM[8] # .LM0ISR |
| pxor @XMM[9], @XMM[0] # xor with round0 key |
| pxor @XMM[9], @XMM[1] |
| pshufb @XMM[8], @XMM[0] |
| pxor @XMM[9], @XMM[2] |
| pshufb @XMM[8], @XMM[1] |
| pxor @XMM[9], @XMM[3] |
| pshufb @XMM[8], @XMM[2] |
| pxor @XMM[9], @XMM[4] |
| pshufb @XMM[8], @XMM[3] |
| pxor @XMM[9], @XMM[5] |
| pshufb @XMM[8], @XMM[4] |
| pxor @XMM[9], @XMM[6] |
| pshufb @XMM[8], @XMM[5] |
| pxor @XMM[9], @XMM[7] |
| pshufb @XMM[8], @XMM[6] |
| pshufb @XMM[8], @XMM[7] |
| ___ |
| &bitslice (@XMM[0..7, 8..11]); |
| $code.=<<___; |
| dec $rounds |
| jmp .Ldec_sbox |
| .align 16 |
| .Ldec_loop: |
| ___ |
| &ShiftRows (@XMM[0..7, 8]); |
| $code.=".Ldec_sbox:\n"; |
| &InvSbox (@XMM[0..7, 8..15]); |
| $code.=<<___; |
| dec $rounds |
| jl .Ldec_done |
| ___ |
| &InvMixColumns (@XMM[0,1,6,4,2,7,3,5, 8..15]); |
| $code.=<<___; |
| movdqa -0x10($const), @XMM[8] # .LISR |
| jnz .Ldec_loop |
| movdqa -0x20($const), @XMM[8] # .LISRM0 |
| jmp .Ldec_loop |
| .align 16 |
| .Ldec_done: |
| ___ |
| &bitslice (@XMM[0,1,6,4,2,7,3,5, 8..11]); |
| $code.=<<___; |
| movdqa ($key), @XMM[8] # last round key |
| pxor @XMM[8], @XMM[6] |
| pxor @XMM[8], @XMM[4] |
| pxor @XMM[8], @XMM[2] |
| pxor @XMM[8], @XMM[7] |
| pxor @XMM[8], @XMM[3] |
| pxor @XMM[8], @XMM[5] |
| pxor @XMM[8], @XMM[0] |
| pxor @XMM[8], @XMM[1] |
| ret |
| .size _bsaes_decrypt8,.-_bsaes_decrypt8 |
| ___ |
| } |
| { |
| my ($out,$inp,$rounds,$const)=("%rax","%rcx","%r10d","%r11"); |
| |
| sub bitslice_key { |
| my @x=reverse(@_[0..7]); |
| my ($bs0,$bs1,$bs2,$t2,$t3)=@_[8..12]; |
| |
| &swapmove (@x[0,1],1,$bs0,$t2,$t3); |
| $code.=<<___; |
| #&swapmove(@x[2,3],1,$t0,$t2,$t3); |
| movdqa @x[0], @x[2] |
| movdqa @x[1], @x[3] |
| ___ |
| #&swapmove2x(@x[4,5,6,7],1,$t0,$t2,$t3); |
| |
| &swapmove2x (@x[0,2,1,3],2,$bs1,$t2,$t3); |
| $code.=<<___; |
| #&swapmove2x(@x[4,6,5,7],2,$t1,$t2,$t3); |
| movdqa @x[0], @x[4] |
| movdqa @x[2], @x[6] |
| movdqa @x[1], @x[5] |
| movdqa @x[3], @x[7] |
| ___ |
| &swapmove2x (@x[0,4,1,5],4,$bs2,$t2,$t3); |
| &swapmove2x (@x[2,6,3,7],4,$bs2,$t2,$t3); |
| } |
| |
| $code.=<<___; |
| .type _bsaes_key_convert,\@abi-omnipotent |
| .align 16 |
| _bsaes_key_convert: |
| lea .Lmasks(%rip), $const |
| movdqu ($inp), %xmm7 # load round 0 key |
| lea 0x10($inp), $inp |
| movdqa 0x00($const), %xmm0 # 0x01... |
| movdqa 0x10($const), %xmm1 # 0x02... |
| movdqa 0x20($const), %xmm2 # 0x04... |
| movdqa 0x30($const), %xmm3 # 0x08... |
| movdqa 0x40($const), %xmm4 # .LM0 |
| pcmpeqd %xmm5, %xmm5 # .LNOT |
| |
| movdqu ($inp), %xmm6 # load round 1 key |
| movdqa %xmm7, ($out) # save round 0 key |
| lea 0x10($out), $out |
| dec $rounds |
| jmp .Lkey_loop |
| .align 16 |
| .Lkey_loop: |
| pshufb %xmm4, %xmm6 # .LM0 |
| |
| movdqa %xmm0, %xmm8 |
| movdqa %xmm1, %xmm9 |
| |
| pand %xmm6, %xmm8 |
| pand %xmm6, %xmm9 |
| movdqa %xmm2, %xmm10 |
| pcmpeqb %xmm0, %xmm8 |
| psllq \$4, %xmm0 # 0x10... |
| movdqa %xmm3, %xmm11 |
| pcmpeqb %xmm1, %xmm9 |
| psllq \$4, %xmm1 # 0x20... |
| |
| pand %xmm6, %xmm10 |
| pand %xmm6, %xmm11 |
| movdqa %xmm0, %xmm12 |
| pcmpeqb %xmm2, %xmm10 |
| psllq \$4, %xmm2 # 0x40... |
| movdqa %xmm1, %xmm13 |
| pcmpeqb %xmm3, %xmm11 |
| psllq \$4, %xmm3 # 0x80... |
| |
| movdqa %xmm2, %xmm14 |
| movdqa %xmm3, %xmm15 |
| pxor %xmm5, %xmm8 # "pnot" |
| pxor %xmm5, %xmm9 |
| |
| pand %xmm6, %xmm12 |
| pand %xmm6, %xmm13 |
| movdqa %xmm8, 0x00($out) # write bit-sliced round key |
| pcmpeqb %xmm0, %xmm12 |
| psrlq \$4, %xmm0 # 0x01... |
| movdqa %xmm9, 0x10($out) |
| pcmpeqb %xmm1, %xmm13 |
| psrlq \$4, %xmm1 # 0x02... |
| lea 0x10($inp), $inp |
| |
| pand %xmm6, %xmm14 |
| pand %xmm6, %xmm15 |
| movdqa %xmm10, 0x20($out) |
| pcmpeqb %xmm2, %xmm14 |
| psrlq \$4, %xmm2 # 0x04... |
| movdqa %xmm11, 0x30($out) |
| pcmpeqb %xmm3, %xmm15 |
| psrlq \$4, %xmm3 # 0x08... |
| movdqu ($inp), %xmm6 # load next round key |
| |
| pxor %xmm5, %xmm13 # "pnot" |
| pxor %xmm5, %xmm14 |
| movdqa %xmm12, 0x40($out) |
| movdqa %xmm13, 0x50($out) |
| movdqa %xmm14, 0x60($out) |
| movdqa %xmm15, 0x70($out) |
| lea 0x80($out),$out |
| dec $rounds |
| jnz .Lkey_loop |
| |
| movdqa 0x50($const), %xmm7 # .L63 |
| #movdqa %xmm6, ($out) # don't save last round key |
| ret |
| .size _bsaes_key_convert,.-_bsaes_key_convert |
| ___ |
| } |
| |
| if (0 && !$win64) { # following four functions are unsupported interface |
| # used for benchmarking... |
| $code.=<<___; |
| .globl bsaes_enc_key_convert |
| .type bsaes_enc_key_convert,\@function,2 |
| .align 16 |
| bsaes_enc_key_convert: |
| mov 240($inp),%r10d # pass rounds |
| mov $inp,%rcx # pass key |
| mov $out,%rax # pass key schedule |
| call _bsaes_key_convert |
| pxor %xmm6,%xmm7 # fix up last round key |
| movdqa %xmm7,(%rax) # save last round key |
| ret |
| .size bsaes_enc_key_convert,.-bsaes_enc_key_convert |
| |
| .globl bsaes_encrypt_128 |
| .type bsaes_encrypt_128,\@function,4 |
| .align 16 |
| bsaes_encrypt_128: |
| .Lenc128_loop: |
| movdqu 0x00($inp), @XMM[0] # load input |
| movdqu 0x10($inp), @XMM[1] |
| movdqu 0x20($inp), @XMM[2] |
| movdqu 0x30($inp), @XMM[3] |
| movdqu 0x40($inp), @XMM[4] |
| movdqu 0x50($inp), @XMM[5] |
| movdqu 0x60($inp), @XMM[6] |
| movdqu 0x70($inp), @XMM[7] |
| mov $key, %rax # pass the $key |
| lea 0x80($inp), $inp |
| mov \$10,%r10d |
| |
| call _bsaes_encrypt8 |
| |
| movdqu @XMM[0], 0x00($out) # write output |
| movdqu @XMM[1], 0x10($out) |
| movdqu @XMM[4], 0x20($out) |
| movdqu @XMM[6], 0x30($out) |
| movdqu @XMM[3], 0x40($out) |
| movdqu @XMM[7], 0x50($out) |
| movdqu @XMM[2], 0x60($out) |
| movdqu @XMM[5], 0x70($out) |
| lea 0x80($out), $out |
| sub \$0x80,$len |
| ja .Lenc128_loop |
| ret |
| .size bsaes_encrypt_128,.-bsaes_encrypt_128 |
| |
| .globl bsaes_dec_key_convert |
| .type bsaes_dec_key_convert,\@function,2 |
| .align 16 |
| bsaes_dec_key_convert: |
| mov 240($inp),%r10d # pass rounds |
| mov $inp,%rcx # pass key |
| mov $out,%rax # pass key schedule |
| call _bsaes_key_convert |
| pxor ($out),%xmm7 # fix up round 0 key |
| movdqa %xmm6,(%rax) # save last round key |
| movdqa %xmm7,($out) |
| ret |
| .size bsaes_dec_key_convert,.-bsaes_dec_key_convert |
| |
| .globl bsaes_decrypt_128 |
| .type bsaes_decrypt_128,\@function,4 |
| .align 16 |
| bsaes_decrypt_128: |
| .Ldec128_loop: |
| movdqu 0x00($inp), @XMM[0] # load input |
| movdqu 0x10($inp), @XMM[1] |
| movdqu 0x20($inp), @XMM[2] |
| movdqu 0x30($inp), @XMM[3] |
| movdqu 0x40($inp), @XMM[4] |
| movdqu 0x50($inp), @XMM[5] |
| movdqu 0x60($inp), @XMM[6] |
| movdqu 0x70($inp), @XMM[7] |
| mov $key, %rax # pass the $key |
| lea 0x80($inp), $inp |
| mov \$10,%r10d |
| |
| call _bsaes_decrypt8 |
| |
| movdqu @XMM[0], 0x00($out) # write output |
| movdqu @XMM[1], 0x10($out) |
| movdqu @XMM[6], 0x20($out) |
| movdqu @XMM[4], 0x30($out) |
| movdqu @XMM[2], 0x40($out) |
| movdqu @XMM[7], 0x50($out) |
| movdqu @XMM[3], 0x60($out) |
| movdqu @XMM[5], 0x70($out) |
| lea 0x80($out), $out |
| sub \$0x80,$len |
| ja .Ldec128_loop |
| ret |
| .size bsaes_decrypt_128,.-bsaes_decrypt_128 |
| ___ |
| } |
| { |
| ###################################################################### |
| # |
| # OpenSSL interface |
| # |
| my ($arg1,$arg2,$arg3,$arg4,$arg5,$arg6)=$win64 ? ("%rcx","%rdx","%r8","%r9","%r10","%r11d") |
| : ("%rdi","%rsi","%rdx","%rcx","%r8","%r9d"); |
| my ($inp,$out,$len,$key)=("%r12","%r13","%r14","%r15"); |
| |
| if ($ecb) { |
| $code.=<<___; |
| .globl bsaes_ecb_encrypt_blocks |
| .type bsaes_ecb_encrypt_blocks,\@abi-omnipotent |
| .align 16 |
| bsaes_ecb_encrypt_blocks: |
| mov %rsp, %rax |
| .Lecb_enc_prologue: |
| push %rbp |
| push %rbx |
| push %r12 |
| push %r13 |
| push %r14 |
| push %r15 |
| lea -0x48(%rsp),%rsp |
| ___ |
| $code.=<<___ if ($win64); |
| lea -0xa0(%rsp), %rsp |
| movaps %xmm6, 0x40(%rsp) |
| movaps %xmm7, 0x50(%rsp) |
| movaps %xmm8, 0x60(%rsp) |
| movaps %xmm9, 0x70(%rsp) |
| movaps %xmm10, 0x80(%rsp) |
| movaps %xmm11, 0x90(%rsp) |
| movaps %xmm12, 0xa0(%rsp) |
| movaps %xmm13, 0xb0(%rsp) |
| movaps %xmm14, 0xc0(%rsp) |
| movaps %xmm15, 0xd0(%rsp) |
| .Lecb_enc_body: |
| ___ |
| $code.=<<___; |
| mov %rsp,%rbp # backup %rsp |
| mov 240($arg4),%eax # rounds |
| mov $arg1,$inp # backup arguments |
| mov $arg2,$out |
| mov $arg3,$len |
| mov $arg4,$key |
| cmp \$8,$arg3 |
| jb .Lecb_enc_short |
| |
| mov %eax,%ebx # backup rounds |
| shl \$7,%rax # 128 bytes per inner round key |
| sub \$`128-32`,%rax # size of bit-sliced key schedule |
| sub %rax,%rsp |
| mov %rsp,%rax # pass key schedule |
| mov $key,%rcx # pass key |
| mov %ebx,%r10d # pass rounds |
| call _bsaes_key_convert |
| pxor %xmm6,%xmm7 # fix up last round key |
| movdqa %xmm7,(%rax) # save last round key |
| |
| sub \$8,$len |
| .Lecb_enc_loop: |
| movdqu 0x00($inp), @XMM[0] # load input |
| movdqu 0x10($inp), @XMM[1] |
| movdqu 0x20($inp), @XMM[2] |
| movdqu 0x30($inp), @XMM[3] |
| movdqu 0x40($inp), @XMM[4] |
| movdqu 0x50($inp), @XMM[5] |
| mov %rsp, %rax # pass key schedule |
| movdqu 0x60($inp), @XMM[6] |
| mov %ebx,%r10d # pass rounds |
| movdqu 0x70($inp), @XMM[7] |
| lea 0x80($inp), $inp |
| |
| call _bsaes_encrypt8 |
| |
| movdqu @XMM[0], 0x00($out) # write output |
| movdqu @XMM[1], 0x10($out) |
| movdqu @XMM[4], 0x20($out) |
| movdqu @XMM[6], 0x30($out) |
| movdqu @XMM[3], 0x40($out) |
| movdqu @XMM[7], 0x50($out) |
| movdqu @XMM[2], 0x60($out) |
| movdqu @XMM[5], 0x70($out) |
| lea 0x80($out), $out |
| sub \$8,$len |
| jnc .Lecb_enc_loop |
| |
| add \$8,$len |
| jz .Lecb_enc_done |
| |
| movdqu 0x00($inp), @XMM[0] # load input |
| mov %rsp, %rax # pass key schedule |
| mov %ebx,%r10d # pass rounds |
| cmp \$2,$len |
| jb .Lecb_enc_one |
| movdqu 0x10($inp), @XMM[1] |
| je .Lecb_enc_two |
| movdqu 0x20($inp), @XMM[2] |
| cmp \$4,$len |
| jb .Lecb_enc_three |
| movdqu 0x30($inp), @XMM[3] |
| je .Lecb_enc_four |
| movdqu 0x40($inp), @XMM[4] |
| cmp \$6,$len |
| jb .Lecb_enc_five |
| movdqu 0x50($inp), @XMM[5] |
| je .Lecb_enc_six |
| movdqu 0x60($inp), @XMM[6] |
| call _bsaes_encrypt8 |
| movdqu @XMM[0], 0x00($out) # write output |
| movdqu @XMM[1], 0x10($out) |
| movdqu @XMM[4], 0x20($out) |
| movdqu @XMM[6], 0x30($out) |
| movdqu @XMM[3], 0x40($out) |
| movdqu @XMM[7], 0x50($out) |
| movdqu @XMM[2], 0x60($out) |
| jmp .Lecb_enc_done |
| .align 16 |
| .Lecb_enc_six: |
| call _bsaes_encrypt8 |
| movdqu @XMM[0], 0x00($out) # write output |
| movdqu @XMM[1], 0x10($out) |
| movdqu @XMM[4], 0x20($out) |
| movdqu @XMM[6], 0x30($out) |
| movdqu @XMM[3], 0x40($out) |
| movdqu @XMM[7], 0x50($out) |
| jmp .Lecb_enc_done |
| .align 16 |
| .Lecb_enc_five: |
| call _bsaes_encrypt8 |
| movdqu @XMM[0], 0x00($out) # write output |
| movdqu @XMM[1], 0x10($out) |
| movdqu @XMM[4], 0x20($out) |
| movdqu @XMM[6], 0x30($out) |
| movdqu @XMM[3], 0x40($out) |
| jmp .Lecb_enc_done |
| .align 16 |
| .Lecb_enc_four: |
| call _bsaes_encrypt8 |
| movdqu @XMM[0], 0x00($out) # write output |
| movdqu @XMM[1], 0x10($out) |
| movdqu @XMM[4], 0x20($out) |
| movdqu @XMM[6], 0x30($out) |
| jmp .Lecb_enc_done |
| .align 16 |
| .Lecb_enc_three: |
| call _bsaes_encrypt8 |
| movdqu @XMM[0], 0x00($out) # write output |
| movdqu @XMM[1], 0x10($out) |
| movdqu @XMM[4], 0x20($out) |
| jmp .Lecb_enc_done |
| .align 16 |
| .Lecb_enc_two: |
| call _bsaes_encrypt8 |
| movdqu @XMM[0], 0x00($out) # write output |
| movdqu @XMM[1], 0x10($out) |
| jmp .Lecb_enc_done |
| .align 16 |
| .Lecb_enc_one: |
| call _bsaes_encrypt8 |
| movdqu @XMM[0], 0x00($out) # write output |
| jmp .Lecb_enc_done |
| .align 16 |
| .Lecb_enc_short: |
| lea ($inp), $arg1 |
| lea ($out), $arg2 |
| lea ($key), $arg3 |
| call asm_AES_encrypt |
| lea 16($inp), $inp |
| lea 16($out), $out |
| dec $len |
| jnz .Lecb_enc_short |
| |
| .Lecb_enc_done: |
| lea (%rsp),%rax |
| pxor %xmm0, %xmm0 |
| .Lecb_enc_bzero: # wipe key schedule [if any] |
| movdqa %xmm0, 0x00(%rax) |
| movdqa %xmm0, 0x10(%rax) |
| lea 0x20(%rax), %rax |
| cmp %rax, %rbp |
| jb .Lecb_enc_bzero |
| |
| lea (%rbp),%rsp # restore %rsp |
| ___ |
| $code.=<<___ if ($win64); |
| movaps 0x40(%rbp), %xmm6 |
| movaps 0x50(%rbp), %xmm7 |
| movaps 0x60(%rbp), %xmm8 |
| movaps 0x70(%rbp), %xmm9 |
| movaps 0x80(%rbp), %xmm10 |
| movaps 0x90(%rbp), %xmm11 |
| movaps 0xa0(%rbp), %xmm12 |
| movaps 0xb0(%rbp), %xmm13 |
| movaps 0xc0(%rbp), %xmm14 |
| movaps 0xd0(%rbp), %xmm15 |
| lea 0xa0(%rbp), %rsp |
| ___ |
| $code.=<<___; |
| mov 0x48(%rsp), %r15 |
| mov 0x50(%rsp), %r14 |
| mov 0x58(%rsp), %r13 |
| mov 0x60(%rsp), %r12 |
| mov 0x68(%rsp), %rbx |
| mov 0x70(%rsp), %rax |
| lea 0x78(%rsp), %rsp |
| mov %rax, %rbp |
| .Lecb_enc_epilogue: |
| ret |
| .size bsaes_ecb_encrypt_blocks,.-bsaes_ecb_encrypt_blocks |
| |
| .globl bsaes_ecb_decrypt_blocks |
| .type bsaes_ecb_decrypt_blocks,\@abi-omnipotent |
| .align 16 |
| bsaes_ecb_decrypt_blocks: |
| mov %rsp, %rax |
| .Lecb_dec_prologue: |
| push %rbp |
| push %rbx |
| push %r12 |
| push %r13 |
| push %r14 |
| push %r15 |
| lea -0x48(%rsp),%rsp |
| ___ |
| $code.=<<___ if ($win64); |
| lea -0xa0(%rsp), %rsp |
| movaps %xmm6, 0x40(%rsp) |
| movaps %xmm7, 0x50(%rsp) |
| movaps %xmm8, 0x60(%rsp) |
| movaps %xmm9, 0x70(%rsp) |
| movaps %xmm10, 0x80(%rsp) |
| movaps %xmm11, 0x90(%rsp) |
| movaps %xmm12, 0xa0(%rsp) |
| movaps %xmm13, 0xb0(%rsp) |
| movaps %xmm14, 0xc0(%rsp) |
| movaps %xmm15, 0xd0(%rsp) |
| .Lecb_dec_body: |
| ___ |
| $code.=<<___; |
| mov %rsp,%rbp # backup %rsp |
| mov 240($arg4),%eax # rounds |
| mov $arg1,$inp # backup arguments |
| mov $arg2,$out |
| mov $arg3,$len |
| mov $arg4,$key |
| cmp \$8,$arg3 |
| jb .Lecb_dec_short |
| |
| mov %eax,%ebx # backup rounds |
| shl \$7,%rax # 128 bytes per inner round key |
| sub \$`128-32`,%rax # size of bit-sliced key schedule |
| sub %rax,%rsp |
| mov %rsp,%rax # pass key schedule |
| mov $key,%rcx # pass key |
| mov %ebx,%r10d # pass rounds |
| call _bsaes_key_convert |
| pxor (%rsp),%xmm7 # fix up 0 round key |
| movdqa %xmm6,(%rax) # save last round key |
| movdqa %xmm7,(%rsp) |
| |
| sub \$8,$len |
| .Lecb_dec_loop: |
| movdqu 0x00($inp), @XMM[0] # load input |
| movdqu 0x10($inp), @XMM[1] |
| movdqu 0x20($inp), @XMM[2] |
| movdqu 0x30($inp), @XMM[3] |
| movdqu 0x40($inp), @XMM[4] |
| movdqu 0x50($inp), @XMM[5] |
| mov %rsp, %rax # pass key schedule |
| movdqu 0x60($inp), @XMM[6] |
| mov %ebx,%r10d # pass rounds |
| movdqu 0x70($inp), @XMM[7] |
| lea 0x80($inp), $inp |
| |
| call _bsaes_decrypt8 |
| |
| movdqu @XMM[0], 0x00($out) # write output |
| movdqu @XMM[1], 0x10($out) |
| movdqu @XMM[6], 0x20($out) |
| movdqu @XMM[4], 0x30($out) |
| movdqu @XMM[2], 0x40($out) |
| movdqu @XMM[7], 0x50($out) |
| movdqu @XMM[3], 0x60($out) |
| movdqu @XMM[5], 0x70($out) |
| lea 0x80($out), $out |
| sub \$8,$len |
| jnc .Lecb_dec_loop |
| |
| add \$8,$len |
| jz .Lecb_dec_done |
| |
| movdqu 0x00($inp), @XMM[0] # load input |
| mov %rsp, %rax # pass key schedule |
| mov %ebx,%r10d # pass rounds |
| cmp \$2,$len |
| jb .Lecb_dec_one |
| movdqu 0x10($inp), @XMM[1] |
| je .Lecb_dec_two |
| movdqu 0x20($inp), @XMM[2] |
| cmp \$4,$len |
| jb .Lecb_dec_three |
| movdqu 0x30($inp), @XMM[3] |
| je .Lecb_dec_four |
| movdqu 0x40($inp), @XMM[4] |
| cmp \$6,$len |
| jb .Lecb_dec_five |
| movdqu 0x50($inp), @XMM[5] |
| je .Lecb_dec_six |
| movdqu 0x60($inp), @XMM[6] |
| call _bsaes_decrypt8 |
| movdqu @XMM[0], 0x00($out) # write output |
| movdqu @XMM[1], 0x10($out) |
| movdqu @XMM[6], 0x20($out) |
| movdqu @XMM[4], 0x30($out) |
| movdqu @XMM[2], 0x40($out) |
| movdqu @XMM[7], 0x50($out) |
| movdqu @XMM[3], 0x60($out) |
| jmp .Lecb_dec_done |
| .align 16 |
| .Lecb_dec_six: |
| call _bsaes_decrypt8 |
| movdqu @XMM[0], 0x00($out) # write output |
| movdqu @XMM[1], 0x10($out) |
| movdqu @XMM[6], 0x20($out) |
| movdqu @XMM[4], 0x30($out) |
| movdqu @XMM[2], 0x40($out) |
| movdqu @XMM[7], 0x50($out) |
| jmp .Lecb_dec_done |
| .align 16 |
| .Lecb_dec_five: |
| call _bsaes_decrypt8 |
| movdqu @XMM[0], 0x00($out) # write output |
| movdqu @XMM[1], 0x10($out) |
| movdqu @XMM[6], 0x20($out) |
| movdqu @XMM[4], 0x30($out) |
| movdqu @XMM[2], 0x40($out) |
| jmp .Lecb_dec_done |
| .align 16 |
| .Lecb_dec_four: |
| call _bsaes_decrypt8 |
| movdqu @XMM[0], 0x00($out) # write output |
| movdqu @XMM[1], 0x10($out) |
| movdqu @XMM[6], 0x20($out) |
| movdqu @XMM[4], 0x30($out) |
| jmp .Lecb_dec_done |
| .align 16 |
| .Lecb_dec_three: |
| call _bsaes_decrypt8 |
| movdqu @XMM[0], 0x00($out) # write output |
| movdqu @XMM[1], 0x10($out) |
| movdqu @XMM[6], 0x20($out) |
| jmp .Lecb_dec_done |
| .align 16 |
| .Lecb_dec_two: |
| call _bsaes_decrypt8 |
| movdqu @XMM[0], 0x00($out) # write output |
| movdqu @XMM[1], 0x10($out) |
| jmp .Lecb_dec_done |
| .align 16 |
| .Lecb_dec_one: |
| call _bsaes_decrypt8 |
| movdqu @XMM[0], 0x00($out) # write output |
| jmp .Lecb_dec_done |
| .align 16 |
| .Lecb_dec_short: |
| lea ($inp), $arg1 |
| lea ($out), $arg2 |
| lea ($key), $arg3 |
| call asm_AES_decrypt |
| lea 16($inp), $inp |
| lea 16($out), $out |
| dec $len |
| jnz .Lecb_dec_short |
| |
| .Lecb_dec_done: |
| lea (%rsp),%rax |
| pxor %xmm0, %xmm0 |
| .Lecb_dec_bzero: # wipe key schedule [if any] |
| movdqa %xmm0, 0x00(%rax) |
| movdqa %xmm0, 0x10(%rax) |
| lea 0x20(%rax), %rax |
| cmp %rax, %rbp |
| jb .Lecb_dec_bzero |
| |
| lea (%rbp),%rsp # restore %rsp |
| ___ |
| $code.=<<___ if ($win64); |
| movaps 0x40(%rbp), %xmm6 |
| movaps 0x50(%rbp), %xmm7 |
| movaps 0x60(%rbp), %xmm8 |
| movaps 0x70(%rbp), %xmm9 |
| movaps 0x80(%rbp), %xmm10 |
| movaps 0x90(%rbp), %xmm11 |
| movaps 0xa0(%rbp), %xmm12 |
| movaps 0xb0(%rbp), %xmm13 |
| movaps 0xc0(%rbp), %xmm14 |
| movaps 0xd0(%rbp), %xmm15 |
| lea 0xa0(%rbp), %rsp |
| ___ |
| $code.=<<___; |
| mov 0x48(%rsp), %r15 |
| mov 0x50(%rsp), %r14 |
| mov 0x58(%rsp), %r13 |
| mov 0x60(%rsp), %r12 |
| mov 0x68(%rsp), %rbx |
| mov 0x70(%rsp), %rax |
| lea 0x78(%rsp), %rsp |
| mov %rax, %rbp |
| .Lecb_dec_epilogue: |
| ret |
| .size bsaes_ecb_decrypt_blocks,.-bsaes_ecb_decrypt_blocks |
| ___ |
| } |
| $code.=<<___; |
| .extern asm_AES_cbc_encrypt |
| .globl bsaes_cbc_encrypt |
| .type bsaes_cbc_encrypt,\@abi-omnipotent |
| .align 16 |
| bsaes_cbc_encrypt: |
| ___ |
| $code.=<<___ if ($win64); |
| mov 48(%rsp),$arg6 # pull direction flag |
| ___ |
| $code.=<<___; |
| cmp \$0,$arg6 |
| jne asm_AES_cbc_encrypt |
| cmp \$128,$arg3 |
| jb asm_AES_cbc_encrypt |
| |
| mov %rsp, %rax |
| .Lcbc_dec_prologue: |
| push %rbp |
| push %rbx |
| push %r12 |
| push %r13 |
| push %r14 |
| push %r15 |
| lea -0x48(%rsp), %rsp |
| ___ |
| $code.=<<___ if ($win64); |
| mov 0xa0(%rsp),$arg5 # pull ivp |
| lea -0xa0(%rsp), %rsp |
| movaps %xmm6, 0x40(%rsp) |
| movaps %xmm7, 0x50(%rsp) |
| movaps %xmm8, 0x60(%rsp) |
| movaps %xmm9, 0x70(%rsp) |
| movaps %xmm10, 0x80(%rsp) |
| movaps %xmm11, 0x90(%rsp) |
| movaps %xmm12, 0xa0(%rsp) |
| movaps %xmm13, 0xb0(%rsp) |
| movaps %xmm14, 0xc0(%rsp) |
| movaps %xmm15, 0xd0(%rsp) |
| .Lcbc_dec_body: |
| ___ |
| $code.=<<___; |
| mov %rsp, %rbp # backup %rsp |
| mov 240($arg4), %eax # rounds |
| mov $arg1, $inp # backup arguments |
| mov $arg2, $out |
| mov $arg3, $len |
| mov $arg4, $key |
| mov $arg5, %rbx |
| shr \$4, $len # bytes to blocks |
| |
| mov %eax, %edx # rounds |
| shl \$7, %rax # 128 bytes per inner round key |
| sub \$`128-32`, %rax # size of bit-sliced key schedule |
| sub %rax, %rsp |
| |
| mov %rsp, %rax # pass key schedule |
| mov $key, %rcx # pass key |
| mov %edx, %r10d # pass rounds |
| call _bsaes_key_convert |
| pxor (%rsp),%xmm7 # fix up 0 round key |
| movdqa %xmm6,(%rax) # save last round key |
| movdqa %xmm7,(%rsp) |
| |
| movdqu (%rbx), @XMM[15] # load IV |
| sub \$8,$len |
| .Lcbc_dec_loop: |
| movdqu 0x00($inp), @XMM[0] # load input |
| movdqu 0x10($inp), @XMM[1] |
| movdqu 0x20($inp), @XMM[2] |
| movdqu 0x30($inp), @XMM[3] |
| movdqu 0x40($inp), @XMM[4] |
| movdqu 0x50($inp), @XMM[5] |
| mov %rsp, %rax # pass key schedule |
| movdqu 0x60($inp), @XMM[6] |
| mov %edx,%r10d # pass rounds |
| movdqu 0x70($inp), @XMM[7] |
| movdqa @XMM[15], 0x20(%rbp) # put aside IV |
| |
| call _bsaes_decrypt8 |
| |
| pxor 0x20(%rbp), @XMM[0] # ^= IV |
| movdqu 0x00($inp), @XMM[8] # re-load input |
| movdqu 0x10($inp), @XMM[9] |
| pxor @XMM[8], @XMM[1] |
| movdqu 0x20($inp), @XMM[10] |
| pxor @XMM[9], @XMM[6] |
| movdqu 0x30($inp), @XMM[11] |
| pxor @XMM[10], @XMM[4] |
| movdqu 0x40($inp), @XMM[12] |
| pxor @XMM[11], @XMM[2] |
| movdqu 0x50($inp), @XMM[13] |
| pxor @XMM[12], @XMM[7] |
| movdqu 0x60($inp), @XMM[14] |
| pxor @XMM[13], @XMM[3] |
| movdqu 0x70($inp), @XMM[15] # IV |
| pxor @XMM[14], @XMM[5] |
| movdqu @XMM[0], 0x00($out) # write output |
| lea 0x80($inp), $inp |
| movdqu @XMM[1], 0x10($out) |
| movdqu @XMM[6], 0x20($out) |
| movdqu @XMM[4], 0x30($out) |
| movdqu @XMM[2], 0x40($out) |
| movdqu @XMM[7], 0x50($out) |
| movdqu @XMM[3], 0x60($out) |
| movdqu @XMM[5], 0x70($out) |
| lea 0x80($out), $out |
| sub \$8,$len |
| jnc .Lcbc_dec_loop |
| |
| add \$8,$len |
| jz .Lcbc_dec_done |
| |
| movdqu 0x00($inp), @XMM[0] # load input |
| mov %rsp, %rax # pass key schedule |
| mov %edx, %r10d # pass rounds |
| cmp \$2,$len |
| jb .Lcbc_dec_one |
| movdqu 0x10($inp), @XMM[1] |
| je .Lcbc_dec_two |
| movdqu 0x20($inp), @XMM[2] |
| cmp \$4,$len |
| jb .Lcbc_dec_three |
| movdqu 0x30($inp), @XMM[3] |
| je .Lcbc_dec_four |
| movdqu 0x40($inp), @XMM[4] |
| cmp \$6,$len |
| jb .Lcbc_dec_five |
| movdqu 0x50($inp), @XMM[5] |
| je .Lcbc_dec_six |
| movdqu 0x60($inp), @XMM[6] |
| movdqa @XMM[15], 0x20(%rbp) # put aside IV |
| call _bsaes_decrypt8 |
| pxor 0x20(%rbp), @XMM[0] # ^= IV |
| movdqu 0x00($inp), @XMM[8] # re-load input |
| movdqu 0x10($inp), @XMM[9] |
| pxor @XMM[8], @XMM[1] |
| movdqu 0x20($inp), @XMM[10] |
| pxor @XMM[9], @XMM[6] |
| movdqu 0x30($inp), @XMM[11] |
| pxor @XMM[10], @XMM[4] |
| movdqu 0x40($inp), @XMM[12] |
| pxor @XMM[11], @XMM[2] |
| movdqu 0x50($inp), @XMM[13] |
| pxor @XMM[12], @XMM[7] |
| movdqu 0x60($inp), @XMM[15] # IV |
| pxor @XMM[13], @XMM[3] |
| movdqu @XMM[0], 0x00($out) # write output |
| movdqu @XMM[1], 0x10($out) |
| movdqu @XMM[6], 0x20($out) |
| movdqu @XMM[4], 0x30($out) |
| movdqu @XMM[2], 0x40($out) |
| movdqu @XMM[7], 0x50($out) |
| movdqu @XMM[3], 0x60($out) |
| jmp .Lcbc_dec_done |
| .align 16 |
| .Lcbc_dec_six: |
| movdqa @XMM[15], 0x20(%rbp) # put aside IV |
| call _bsaes_decrypt8 |
| pxor 0x20(%rbp), @XMM[0] # ^= IV |
| movdqu 0x00($inp), @XMM[8] # re-load input |
| movdqu 0x10($inp), @XMM[9] |
| pxor @XMM[8], @XMM[1] |
| movdqu 0x20($inp), @XMM[10] |
| pxor @XMM[9], @XMM[6] |
| movdqu 0x30($inp), @XMM[11] |
| pxor @XMM[10], @XMM[4] |
| movdqu 0x40($inp), @XMM[12] |
| pxor @XMM[11], @XMM[2] |
| movdqu 0x50($inp), @XMM[15] # IV |
| pxor @XMM[12], @XMM[7] |
| movdqu @XMM[0], 0x00($out) # write output |
| movdqu @XMM[1], 0x10($out) |
| movdqu @XMM[6], 0x20($out) |
| movdqu @XMM[4], 0x30($out) |
| movdqu @XMM[2], 0x40($out) |
| movdqu @XMM[7], 0x50($out) |
| jmp .Lcbc_dec_done |
| .align 16 |
| .Lcbc_dec_five: |
| movdqa @XMM[15], 0x20(%rbp) # put aside IV |
| call _bsaes_decrypt8 |
| pxor 0x20(%rbp), @XMM[0] # ^= IV |
| movdqu 0x00($inp), @XMM[8] # re-load input |
| movdqu 0x10($inp), @XMM[9] |
| pxor @XMM[8], @XMM[1] |
| movdqu 0x20($inp), @XMM[10] |
| pxor @XMM[9], @XMM[6] |
| movdqu 0x30($inp), @XMM[11] |
| pxor @XMM[10], @XMM[4] |
| movdqu 0x40($inp), @XMM[15] # IV |
| pxor @XMM[11], @XMM[2] |
| movdqu @XMM[0], 0x00($out) # write output |
| movdqu @XMM[1], 0x10($out) |
| movdqu @XMM[6], 0x20($out) |
| movdqu @XMM[4], 0x30($out) |
| movdqu @XMM[2], 0x40($out) |
| jmp .Lcbc_dec_done |
| .align 16 |
| .Lcbc_dec_four: |
| movdqa @XMM[15], 0x20(%rbp) # put aside IV |
| call _bsaes_decrypt8 |
| pxor 0x20(%rbp), @XMM[0] # ^= IV |
| movdqu 0x00($inp), @XMM[8] # re-load input |
| movdqu 0x10($inp), @XMM[9] |
| pxor @XMM[8], @XMM[1] |
| movdqu 0x20($inp), @XMM[10] |
| pxor @XMM[9], @XMM[6] |
| movdqu 0x30($inp), @XMM[15] # IV |
| pxor @XMM[10], @XMM[4] |
| movdqu @XMM[0], 0x00($out) # write output |
| movdqu @XMM[1], 0x10($out) |
| movdqu @XMM[6], 0x20($out) |
| movdqu @XMM[4], 0x30($out) |
| jmp .Lcbc_dec_done |
| .align 16 |
| .Lcbc_dec_three: |
| movdqa @XMM[15], 0x20(%rbp) # put aside IV |
| call _bsaes_decrypt8 |
| pxor 0x20(%rbp), @XMM[0] # ^= IV |
| movdqu 0x00($inp), @XMM[8] # re-load input |
| movdqu 0x10($inp), @XMM[9] |
| pxor @XMM[8], @XMM[1] |
| movdqu 0x20($inp), @XMM[15] # IV |
| pxor @XMM[9], @XMM[6] |
| movdqu @XMM[0], 0x00($out) # write output |
| movdqu @XMM[1], 0x10($out) |
| movdqu @XMM[6], 0x20($out) |
| jmp .Lcbc_dec_done |
| .align 16 |
| .Lcbc_dec_two: |
| movdqa @XMM[15], 0x20(%rbp) # put aside IV |
| call _bsaes_decrypt8 |
| pxor 0x20(%rbp), @XMM[0] # ^= IV |
| movdqu 0x00($inp), @XMM[8] # re-load input |
| movdqu 0x10($inp), @XMM[15] # IV |
| pxor @XMM[8], @XMM[1] |
| movdqu @XMM[0], 0x00($out) # write output |
| movdqu @XMM[1], 0x10($out) |
| jmp .Lcbc_dec_done |
| .align 16 |
| .Lcbc_dec_one: |
| lea ($inp), $arg1 |
| lea 0x20(%rbp), $arg2 # buffer output |
| lea ($key), $arg3 |
| call asm_AES_decrypt # doesn't touch %xmm |
| pxor 0x20(%rbp), @XMM[15] # ^= IV |
| movdqu @XMM[15], ($out) # write output |
| movdqa @XMM[0], @XMM[15] # IV |
| |
| .Lcbc_dec_done: |
| movdqu @XMM[15], (%rbx) # return IV |
| lea (%rsp), %rax |
| pxor %xmm0, %xmm0 |
| .Lcbc_dec_bzero: # wipe key schedule [if any] |
| movdqa %xmm0, 0x00(%rax) |
| movdqa %xmm0, 0x10(%rax) |
| lea 0x20(%rax), %rax |
| cmp %rax, %rbp |
| ja .Lcbc_dec_bzero |
| |
| lea (%rbp),%rsp # restore %rsp |
| ___ |
| $code.=<<___ if ($win64); |
| movaps 0x40(%rbp), %xmm6 |
| movaps 0x50(%rbp), %xmm7 |
| movaps 0x60(%rbp), %xmm8 |
| movaps 0x70(%rbp), %xmm9 |
| movaps 0x80(%rbp), %xmm10 |
| movaps 0x90(%rbp), %xmm11 |
| movaps 0xa0(%rbp), %xmm12 |
| movaps 0xb0(%rbp), %xmm13 |
| movaps 0xc0(%rbp), %xmm14 |
| movaps 0xd0(%rbp), %xmm15 |
| lea 0xa0(%rbp), %rsp |
| ___ |
| $code.=<<___; |
| mov 0x48(%rsp), %r15 |
| mov 0x50(%rsp), %r14 |
| mov 0x58(%rsp), %r13 |
| mov 0x60(%rsp), %r12 |
| mov 0x68(%rsp), %rbx |
| mov 0x70(%rsp), %rax |
| lea 0x78(%rsp), %rsp |
| mov %rax, %rbp |
| .Lcbc_dec_epilogue: |
| ret |
| .size bsaes_cbc_encrypt,.-bsaes_cbc_encrypt |
| |
| .globl bsaes_ctr32_encrypt_blocks |
| .type bsaes_ctr32_encrypt_blocks,\@abi-omnipotent |
| .align 16 |
| bsaes_ctr32_encrypt_blocks: |
| mov %rsp, %rax |
| .Lctr_enc_prologue: |
| push %rbp |
| push %rbx |
| push %r12 |
| push %r13 |
| push %r14 |
| push %r15 |
| lea -0x48(%rsp), %rsp |
| ___ |
| $code.=<<___ if ($win64); |
| mov 0xa0(%rsp),$arg5 # pull ivp |
| lea -0xa0(%rsp), %rsp |
| movaps %xmm6, 0x40(%rsp) |
| movaps %xmm7, 0x50(%rsp) |
| movaps %xmm8, 0x60(%rsp) |
| movaps %xmm9, 0x70(%rsp) |
| movaps %xmm10, 0x80(%rsp) |
| movaps %xmm11, 0x90(%rsp) |
| movaps %xmm12, 0xa0(%rsp) |
| movaps %xmm13, 0xb0(%rsp) |
| movaps %xmm14, 0xc0(%rsp) |
| movaps %xmm15, 0xd0(%rsp) |
| .Lctr_enc_body: |
| ___ |
| $code.=<<___; |
| mov %rsp, %rbp # backup %rsp |
| movdqu ($arg5), %xmm0 # load counter |
| mov 240($arg4), %eax # rounds |
| mov $arg1, $inp # backup arguments |
| mov $arg2, $out |
| mov $arg3, $len |
| mov $arg4, $key |
| movdqa %xmm0, 0x20(%rbp) # copy counter |
| cmp \$8, $arg3 |
| jb .Lctr_enc_short |
| |
| mov %eax, %ebx # rounds |
| shl \$7, %rax # 128 bytes per inner round key |
| sub \$`128-32`, %rax # size of bit-sliced key schedule |
| sub %rax, %rsp |
| |
| mov %rsp, %rax # pass key schedule |
| mov $key, %rcx # pass key |
| mov %ebx, %r10d # pass rounds |
| call _bsaes_key_convert |
| pxor %xmm6,%xmm7 # fix up last round key |
| movdqa %xmm7,(%rax) # save last round key |
| |
| movdqa (%rsp), @XMM[9] # load round0 key |
| lea .LADD1(%rip), %r11 |
| movdqa 0x20(%rbp), @XMM[0] # counter copy |
| movdqa -0x20(%r11), @XMM[8] # .LSWPUP |
| pshufb @XMM[8], @XMM[9] # byte swap upper part |
| pshufb @XMM[8], @XMM[0] |
| movdqa @XMM[9], (%rsp) # save adjusted round0 key |
| jmp .Lctr_enc_loop |
| .align 16 |
| .Lctr_enc_loop: |
| movdqa @XMM[0], 0x20(%rbp) # save counter |
| movdqa @XMM[0], @XMM[1] # prepare 8 counter values |
| movdqa @XMM[0], @XMM[2] |
| paddd 0x00(%r11), @XMM[1] # .LADD1 |
| movdqa @XMM[0], @XMM[3] |
| paddd 0x10(%r11), @XMM[2] # .LADD2 |
| movdqa @XMM[0], @XMM[4] |
| paddd 0x20(%r11), @XMM[3] # .LADD3 |
| movdqa @XMM[0], @XMM[5] |
| paddd 0x30(%r11), @XMM[4] # .LADD4 |
| movdqa @XMM[0], @XMM[6] |
| paddd 0x40(%r11), @XMM[5] # .LADD5 |
| movdqa @XMM[0], @XMM[7] |
| paddd 0x50(%r11), @XMM[6] # .LADD6 |
| paddd 0x60(%r11), @XMM[7] # .LADD7 |
| |
| # Borrow prologue from _bsaes_encrypt8 to use the opportunity |
| # to flip byte order in 32-bit counter |
| movdqa (%rsp), @XMM[9] # round 0 key |
| lea 0x10(%rsp), %rax # pass key schedule |
| movdqa -0x10(%r11), @XMM[8] # .LSWPUPM0SR |
| pxor @XMM[9], @XMM[0] # xor with round0 key |
| pxor @XMM[9], @XMM[1] |
| pshufb @XMM[8], @XMM[0] |
| pxor @XMM[9], @XMM[2] |
| pshufb @XMM[8], @XMM[1] |
| pxor @XMM[9], @XMM[3] |
| pshufb @XMM[8], @XMM[2] |
| pxor @XMM[9], @XMM[4] |
| pshufb @XMM[8], @XMM[3] |
| pxor @XMM[9], @XMM[5] |
| pshufb @XMM[8], @XMM[4] |
| pxor @XMM[9], @XMM[6] |
| pshufb @XMM[8], @XMM[5] |
| pxor @XMM[9], @XMM[7] |
| pshufb @XMM[8], @XMM[6] |
| lea .LBS0(%rip), %r11 # constants table |
| pshufb @XMM[8], @XMM[7] |
| mov %ebx,%r10d # pass rounds |
| |
| call _bsaes_encrypt8_bitslice |
| |
| sub \$8,$len |
| jc .Lctr_enc_loop_done |
| |
| movdqu 0x00($inp), @XMM[8] # load input |
| movdqu 0x10($inp), @XMM[9] |
| movdqu 0x20($inp), @XMM[10] |
| movdqu 0x30($inp), @XMM[11] |
| movdqu 0x40($inp), @XMM[12] |
| movdqu 0x50($inp), @XMM[13] |
| movdqu 0x60($inp), @XMM[14] |
| movdqu 0x70($inp), @XMM[15] |
| lea 0x80($inp),$inp |
| pxor @XMM[0], @XMM[8] |
| movdqa 0x20(%rbp), @XMM[0] # load counter |
| pxor @XMM[9], @XMM[1] |
| movdqu @XMM[8], 0x00($out) # write output |
| pxor @XMM[10], @XMM[4] |
| movdqu @XMM[1], 0x10($out) |
| pxor @XMM[11], @XMM[6] |
| movdqu @XMM[4], 0x20($out) |
| pxor @XMM[12], @XMM[3] |
| movdqu @XMM[6], 0x30($out) |
| pxor @XMM[13], @XMM[7] |
| movdqu @XMM[3], 0x40($out) |
| pxor @XMM[14], @XMM[2] |
| movdqu @XMM[7], 0x50($out) |
| pxor @XMM[15], @XMM[5] |
| movdqu @XMM[2], 0x60($out) |
| lea .LADD1(%rip), %r11 |
| movdqu @XMM[5], 0x70($out) |
| lea 0x80($out), $out |
| paddd 0x70(%r11), @XMM[0] # .LADD8 |
| jnz .Lctr_enc_loop |
| |
| jmp .Lctr_enc_done |
| .align 16 |
| .Lctr_enc_loop_done: |
| add \$8, $len |
| movdqu 0x00($inp), @XMM[8] # load input |
| pxor @XMM[8], @XMM[0] |
| movdqu @XMM[0], 0x00($out) # write output |
| cmp \$2,$len |
| jb .Lctr_enc_done |
| movdqu 0x10($inp), @XMM[9] |
| pxor @XMM[9], @XMM[1] |
| movdqu @XMM[1], 0x10($out) |
| je .Lctr_enc_done |
| movdqu 0x20($inp), @XMM[10] |
| pxor @XMM[10], @XMM[4] |
| movdqu @XMM[4], 0x20($out) |
| cmp \$4,$len |
| jb .Lctr_enc_done |
| movdqu 0x30($inp), @XMM[11] |
| pxor @XMM[11], @XMM[6] |
| movdqu @XMM[6], 0x30($out) |
| je .Lctr_enc_done |
| movdqu 0x40($inp), @XMM[12] |
| pxor @XMM[12], @XMM[3] |
| movdqu @XMM[3], 0x40($out) |
| cmp \$6,$len |
| jb .Lctr_enc_done |
| movdqu 0x50($inp), @XMM[13] |
| pxor @XMM[13], @XMM[7] |
| movdqu @XMM[7], 0x50($out) |
| je .Lctr_enc_done |
| movdqu 0x60($inp), @XMM[14] |
| pxor @XMM[14], @XMM[2] |
| movdqu @XMM[2], 0x60($out) |
| jmp .Lctr_enc_done |
| |
| .align 16 |
| .Lctr_enc_short: |
| lea 0x20(%rbp), $arg1 |
| lea 0x30(%rbp), $arg2 |
| lea ($key), $arg3 |
| call asm_AES_encrypt |
| movdqu ($inp), @XMM[1] |
| lea 16($inp), $inp |
| mov 0x2c(%rbp), %eax # load 32-bit counter |
| bswap %eax |
| pxor 0x30(%rbp), @XMM[1] |
| inc %eax # increment |
| movdqu @XMM[1], ($out) |
| bswap %eax |
| lea 16($out), $out |
| mov %eax, 0x2c(%rsp) # save 32-bit counter |
| dec $len |
| jnz .Lctr_enc_short |
| |
| .Lctr_enc_done: |
| lea (%rsp), %rax |
| pxor %xmm0, %xmm0 |
| .Lctr_enc_bzero: # wipe key schedule [if any] |
| movdqa %xmm0, 0x00(%rax) |
| movdqa %xmm0, 0x10(%rax) |
| lea 0x20(%rax), %rax |
| cmp %rax, %rbp |
| ja .Lctr_enc_bzero |
| |
| lea (%rbp),%rsp # restore %rsp |
| ___ |
| $code.=<<___ if ($win64); |
| movaps 0x40(%rbp), %xmm6 |
| movaps 0x50(%rbp), %xmm7 |
| movaps 0x60(%rbp), %xmm8 |
| movaps 0x70(%rbp), %xmm9 |
| movaps 0x80(%rbp), %xmm10 |
| movaps 0x90(%rbp), %xmm11 |
| movaps 0xa0(%rbp), %xmm12 |
| movaps 0xb0(%rbp), %xmm13 |
| movaps 0xc0(%rbp), %xmm14 |
| movaps 0xd0(%rbp), %xmm15 |
| lea 0xa0(%rbp), %rsp |
| ___ |
| $code.=<<___; |
| mov 0x48(%rsp), %r15 |
| mov 0x50(%rsp), %r14 |
| mov 0x58(%rsp), %r13 |
| mov 0x60(%rsp), %r12 |
| mov 0x68(%rsp), %rbx |
| mov 0x70(%rsp), %rax |
| lea 0x78(%rsp), %rsp |
| mov %rax, %rbp |
| .Lctr_enc_epilogue: |
| ret |
| .size bsaes_ctr32_encrypt_blocks,.-bsaes_ctr32_encrypt_blocks |
| ___ |
| ###################################################################### |
| # void bsaes_xts_[en|de]crypt(const char *inp,char *out,size_t len, |
| # const AES_KEY *key1, const AES_KEY *key2, |
| # const unsigned char iv[16]); |
| # |
| my ($twmask,$twres,$twtmp)=@XMM[13..15]; |
| $code.=<<___; |
| .globl bsaes_xts_encrypt |
| .type bsaes_xts_encrypt,\@abi-omnipotent |
| .align 16 |
| bsaes_xts_encrypt: |
| mov %rsp, %rax |
| .Lxts_enc_prologue: |
| push %rbp |
| push %rbx |
| push %r12 |
| push %r13 |
| push %r14 |
| push %r15 |
| lea -0x48(%rsp), %rsp |
| ___ |
| $code.=<<___ if ($win64); |
| mov 0xa0(%rsp),$arg5 # pull key2 |
| mov 0xa8(%rsp),$arg6 # pull ivp |
| lea -0xa0(%rsp), %rsp |
| movaps %xmm6, 0x40(%rsp) |
| movaps %xmm7, 0x50(%rsp) |
| movaps %xmm8, 0x60(%rsp) |
| movaps %xmm9, 0x70(%rsp) |
| movaps %xmm10, 0x80(%rsp) |
| movaps %xmm11, 0x90(%rsp) |
| movaps %xmm12, 0xa0(%rsp) |
| movaps %xmm13, 0xb0(%rsp) |
| movaps %xmm14, 0xc0(%rsp) |
| movaps %xmm15, 0xd0(%rsp) |
| .Lxts_enc_body: |
| ___ |
| $code.=<<___; |
| mov %rsp, %rbp # backup %rsp |
| mov $arg1, $inp # backup arguments |
| mov $arg2, $out |
| mov $arg3, $len |
| mov $arg4, $key |
| |
| lea ($arg6), $arg1 |
| lea 0x20(%rbp), $arg2 |
| lea ($arg5), $arg3 |
| call asm_AES_encrypt # generate initial tweak |
| |
| mov 240($key), %eax # rounds |
| mov $len, %rbx # backup $len |
| |
| mov %eax, %edx # rounds |
| shl \$7, %rax # 128 bytes per inner round key |
| sub \$`128-32`, %rax # size of bit-sliced key schedule |
| sub %rax, %rsp |
| |
| mov %rsp, %rax # pass key schedule |
| mov $key, %rcx # pass key |
| mov %edx, %r10d # pass rounds |
| call _bsaes_key_convert |
| pxor %xmm6, %xmm7 # fix up last round key |
| movdqa %xmm7, (%rax) # save last round key |
| |
| and \$-16, $len |
| sub \$0x80, %rsp # place for tweak[8] |
| movdqa 0x20(%rbp), @XMM[7] # initial tweak |
| |
| pxor $twtmp, $twtmp |
| movdqa .Lxts_magic(%rip), $twmask |
| pcmpgtd @XMM[7], $twtmp # broadcast upper bits |
| |
| sub \$0x80, $len |
| jc .Lxts_enc_short |
| jmp .Lxts_enc_loop |
| |
| .align 16 |
| .Lxts_enc_loop: |
| ___ |
| for ($i=0;$i<7;$i++) { |
| $code.=<<___; |
| pshufd \$0x13, $twtmp, $twres |
| pxor $twtmp, $twtmp |
| movdqa @XMM[7], @XMM[$i] |
| movdqa @XMM[7], `0x10*$i`(%rsp)# save tweak[$i] |
| paddq @XMM[7], @XMM[7] # psllq 1,$tweak |
| pand $twmask, $twres # isolate carry and residue |
| pcmpgtd @XMM[7], $twtmp # broadcast upper bits |
| pxor $twres, @XMM[7] |
| ___ |
| $code.=<<___ if ($i>=1); |
| movdqu `0x10*($i-1)`($inp), @XMM[8+$i-1] |
| ___ |
| $code.=<<___ if ($i>=2); |
| pxor @XMM[8+$i-2], @XMM[$i-2]# input[] ^ tweak[] |
| ___ |
| } |
| $code.=<<___; |
| movdqu 0x60($inp), @XMM[8+6] |
| pxor @XMM[8+5], @XMM[5] |
| movdqu 0x70($inp), @XMM[8+7] |
| lea 0x80($inp), $inp |
| movdqa @XMM[7], 0x70(%rsp) |
| pxor @XMM[8+6], @XMM[6] |
| lea 0x80(%rsp), %rax # pass key schedule |
| pxor @XMM[8+7], @XMM[7] |
| mov %edx, %r10d # pass rounds |
| |
| call _bsaes_encrypt8 |
| |
| pxor 0x00(%rsp), @XMM[0] # ^= tweak[] |
| pxor 0x10(%rsp), @XMM[1] |
| movdqu @XMM[0], 0x00($out) # write output |
| pxor 0x20(%rsp), @XMM[4] |
| movdqu @XMM[1], 0x10($out) |
| pxor 0x30(%rsp), @XMM[6] |
| movdqu @XMM[4], 0x20($out) |
| pxor 0x40(%rsp), @XMM[3] |
| movdqu @XMM[6], 0x30($out) |
| pxor 0x50(%rsp), @XMM[7] |
| movdqu @XMM[3], 0x40($out) |
| pxor 0x60(%rsp), @XMM[2] |
| movdqu @XMM[7], 0x50($out) |
| pxor 0x70(%rsp), @XMM[5] |
| movdqu @XMM[2], 0x60($out) |
| movdqu @XMM[5], 0x70($out) |
| lea 0x80($out), $out |
| |
| movdqa 0x70(%rsp), @XMM[7] # prepare next iteration tweak |
| pxor $twtmp, $twtmp |
| movdqa .Lxts_magic(%rip), $twmask |
| pcmpgtd @XMM[7], $twtmp |
| pshufd \$0x13, $twtmp, $twres |
| pxor $twtmp, $twtmp |
| paddq @XMM[7], @XMM[7] # psllq 1,$tweak |
| pand $twmask, $twres # isolate carry and residue |
| pcmpgtd @XMM[7], $twtmp # broadcast upper bits |
| pxor $twres, @XMM[7] |
| |
| sub \$0x80,$len |
| jnc .Lxts_enc_loop |
| |
| .Lxts_enc_short: |
| add \$0x80, $len |
| jz .Lxts_enc_done |
| ___ |
| for ($i=0;$i<7;$i++) { |
| $code.=<<___; |
| pshufd \$0x13, $twtmp, $twres |
| pxor $twtmp, $twtmp |
| movdqa @XMM[7], @XMM[$i] |
| movdqa @XMM[7], `0x10*$i`(%rsp)# save tweak[$i] |
| paddq @XMM[7], @XMM[7] # psllq 1,$tweak |
| pand $twmask, $twres # isolate carry and residue |
| pcmpgtd @XMM[7], $twtmp # broadcast upper bits |
| pxor $twres, @XMM[7] |
| ___ |
| $code.=<<___ if ($i>=1); |
| movdqu `0x10*($i-1)`($inp), @XMM[8+$i-1] |
| cmp \$`0x10*$i`,$len |
| je .Lxts_enc_$i |
| ___ |
| $code.=<<___ if ($i>=2); |
| pxor @XMM[8+$i-2], @XMM[$i-2]# input[] ^ tweak[] |
| ___ |
| } |
| $code.=<<___; |
| movdqu 0x60($inp), @XMM[8+6] |
| pxor @XMM[8+5], @XMM[5] |
| movdqa @XMM[7], 0x70(%rsp) |
| lea 0x70($inp), $inp |
| pxor @XMM[8+6], @XMM[6] |
| lea 0x80(%rsp), %rax # pass key schedule |
| mov %edx, %r10d # pass rounds |
| |
| call _bsaes_encrypt8 |
| |
| pxor 0x00(%rsp), @XMM[0] # ^= tweak[] |
| pxor 0x10(%rsp), @XMM[1] |
| movdqu @XMM[0], 0x00($out) # write output |
| pxor 0x20(%rsp), @XMM[4] |
| movdqu @XMM[1], 0x10($out) |
| pxor 0x30(%rsp), @XMM[6] |
| movdqu @XMM[4], 0x20($out) |
| pxor 0x40(%rsp), @XMM[3] |
| movdqu @XMM[6], 0x30($out) |
| pxor 0x50(%rsp), @XMM[7] |
| movdqu @XMM[3], 0x40($out) |
| pxor 0x60(%rsp), @XMM[2] |
| movdqu @XMM[7], 0x50($out) |
| movdqu @XMM[2], 0x60($out) |
| lea 0x70($out), $out |
| |
| movdqa 0x70(%rsp), @XMM[7] # next iteration tweak |
| jmp .Lxts_enc_done |
| .align 16 |
| .Lxts_enc_6: |
| pxor @XMM[8+4], @XMM[4] |
| lea 0x60($inp), $inp |
| pxor @XMM[8+5], @XMM[5] |
| lea 0x80(%rsp), %rax # pass key schedule |
| mov %edx, %r10d # pass rounds |
| |
| call _bsaes_encrypt8 |
| |
| pxor 0x00(%rsp), @XMM[0] # ^= tweak[] |
| pxor 0x10(%rsp), @XMM[1] |
| movdqu @XMM[0], 0x00($out) # write output |
| pxor 0x20(%rsp), @XMM[4] |
| movdqu @XMM[1], 0x10($out) |
| pxor 0x30(%rsp), @XMM[6] |
| movdqu @XMM[4], 0x20($out) |
| pxor 0x40(%rsp), @XMM[3] |
| movdqu @XMM[6], 0x30($out) |
| pxor 0x50(%rsp), @XMM[7] |
| movdqu @XMM[3], 0x40($out) |
| movdqu @XMM[7], 0x50($out) |
| lea 0x60($out), $out |
| |
| movdqa 0x60(%rsp), @XMM[7] # next iteration tweak |
| jmp .Lxts_enc_done |
| .align 16 |
| .Lxts_enc_5: |
| pxor @XMM[8+3], @XMM[3] |
| lea 0x50($inp), $inp |
| pxor @XMM[8+4], @XMM[4] |
| lea 0x80(%rsp), %rax # pass key schedule |
| mov %edx, %r10d # pass rounds |
| |
| call _bsaes_encrypt8 |
| |
| pxor 0x00(%rsp), @XMM[0] # ^= tweak[] |
| pxor 0x10(%rsp), @XMM[1] |
| movdqu @XMM[0], 0x00($out) # write output |
| pxor 0x20(%rsp), @XMM[4] |
| movdqu @XMM[1], 0x10($out) |
| pxor 0x30(%rsp), @XMM[6] |
| movdqu @XMM[4], 0x20($out) |
| pxor 0x40(%rsp), @XMM[3] |
| movdqu @XMM[6], 0x30($out) |
| movdqu @XMM[3], 0x40($out) |
| lea 0x50($out), $out |
| |
| movdqa 0x50(%rsp), @XMM[7] # next iteration tweak |
| jmp .Lxts_enc_done |
| .align 16 |
| .Lxts_enc_4: |
| pxor @XMM[8+2], @XMM[2] |
| lea 0x40($inp), $inp |
| pxor @XMM[8+3], @XMM[3] |
| lea 0x80(%rsp), %rax # pass key schedule |
| mov %edx, %r10d # pass rounds |
| |
| call _bsaes_encrypt8 |
| |
| pxor 0x00(%rsp), @XMM[0] # ^= tweak[] |
| pxor 0x10(%rsp), @XMM[1] |
| movdqu @XMM[0], 0x00($out) # write output |
| pxor 0x20(%rsp), @XMM[4] |
| movdqu @XMM[1], 0x10($out) |
| pxor 0x30(%rsp), @XMM[6] |
| movdqu @XMM[4], 0x20($out) |
| movdqu @XMM[6], 0x30($out) |
| lea 0x40($out), $out |
| |
| movdqa 0x40(%rsp), @XMM[7] # next iteration tweak |
| jmp .Lxts_enc_done |
| .align 16 |
| .Lxts_enc_3: |
| pxor @XMM[8+1], @XMM[1] |
| lea 0x30($inp), $inp |
| pxor @XMM[8+2], @XMM[2] |
| lea 0x80(%rsp), %rax # pass key schedule |
| mov %edx, %r10d # pass rounds |
| |
| call _bsaes_encrypt8 |
| |
| pxor 0x00(%rsp), @XMM[0] # ^= tweak[] |
| pxor 0x10(%rsp), @XMM[1] |
| movdqu @XMM[0], 0x00($out) # write output |
| pxor 0x20(%rsp), @XMM[4] |
| movdqu @XMM[1], 0x10($out) |
| movdqu @XMM[4], 0x20($out) |
| lea 0x30($out), $out |
| |
| movdqa 0x30(%rsp), @XMM[7] # next iteration tweak |
| jmp .Lxts_enc_done |
| .align 16 |
| .Lxts_enc_2: |
| pxor @XMM[8+0], @XMM[0] |
| lea 0x20($inp), $inp |
| pxor @XMM[8+1], @XMM[1] |
| lea 0x80(%rsp), %rax # pass key schedule |
| mov %edx, %r10d # pass rounds |
| |
| call _bsaes_encrypt8 |
| |
| pxor 0x00(%rsp), @XMM[0] # ^= tweak[] |
| pxor 0x10(%rsp), @XMM[1] |
| movdqu @XMM[0], 0x00($out) # write output |
| movdqu @XMM[1], 0x10($out) |
| lea 0x20($out), $out |
| |
| movdqa 0x20(%rsp), @XMM[7] # next iteration tweak |
| jmp .Lxts_enc_done |
| .align 16 |
| .Lxts_enc_1: |
| pxor @XMM[0], @XMM[8] |
| lea 0x10($inp), $inp |
| movdqa @XMM[8], 0x20(%rbp) |
| lea 0x20(%rbp), $arg1 |
| lea 0x20(%rbp), $arg2 |
| lea ($key), $arg3 |
| call asm_AES_encrypt # doesn't touch %xmm |
| pxor 0x20(%rbp), @XMM[0] # ^= tweak[] |
| #pxor @XMM[8], @XMM[0] |
| #lea 0x80(%rsp), %rax # pass key schedule |
| #mov %edx, %r10d # pass rounds |
| #call _bsaes_encrypt8 |
| #pxor 0x00(%rsp), @XMM[0] # ^= tweak[] |
| movdqu @XMM[0], 0x00($out) # write output |
| lea 0x10($out), $out |
| |
| movdqa 0x10(%rsp), @XMM[7] # next iteration tweak |
| |
| .Lxts_enc_done: |
| and \$15, %ebx |
| jz .Lxts_enc_ret |
| mov $out, %rdx |
| |
| .Lxts_enc_steal: |
| movzb ($inp), %eax |
| movzb -16(%rdx), %ecx |
| lea 1($inp), $inp |
| mov %al, -16(%rdx) |
| mov %cl, 0(%rdx) |
| lea 1(%rdx), %rdx |
| sub \$1,%ebx |
| jnz .Lxts_enc_steal |
| |
| movdqu -16($out), @XMM[0] |
| lea 0x20(%rbp), $arg1 |
| pxor @XMM[7], @XMM[0] |
| lea 0x20(%rbp), $arg2 |
| movdqa @XMM[0], 0x20(%rbp) |
| lea ($key), $arg3 |
| call asm_AES_encrypt # doesn't touch %xmm |
| pxor 0x20(%rbp), @XMM[7] |
| movdqu @XMM[7], -16($out) |
| |
| .Lxts_enc_ret: |
| lea (%rsp), %rax |
| pxor %xmm0, %xmm0 |
| .Lxts_enc_bzero: # wipe key schedule [if any] |
| movdqa %xmm0, 0x00(%rax) |
| movdqa %xmm0, 0x10(%rax) |
| lea 0x20(%rax), %rax |
| cmp %rax, %rbp |
| ja .Lxts_enc_bzero |
| |
| lea (%rbp),%rsp # restore %rsp |
| ___ |
| $code.=<<___ if ($win64); |
| movaps 0x40(%rbp), %xmm6 |
| movaps 0x50(%rbp), %xmm7 |
| movaps 0x60(%rbp), %xmm8 |
| movaps 0x70(%rbp), %xmm9 |
| movaps 0x80(%rbp), %xmm10 |
| movaps 0x90(%rbp), %xmm11 |
| movaps 0xa0(%rbp), %xmm12 |
| movaps 0xb0(%rbp), %xmm13 |
| movaps 0xc0(%rbp), %xmm14 |
| movaps 0xd0(%rbp), %xmm15 |
| lea 0xa0(%rbp), %rsp |
| ___ |
| $code.=<<___; |
| mov 0x48(%rsp), %r15 |
| mov 0x50(%rsp), %r14 |
| mov 0x58(%rsp), %r13 |
| mov 0x60(%rsp), %r12 |
| mov 0x68(%rsp), %rbx |
| mov 0x70(%rsp), %rax |
| lea 0x78(%rsp), %rsp |
| mov %rax, %rbp |
| .Lxts_enc_epilogue: |
| ret |
| .size bsaes_xts_encrypt,.-bsaes_xts_encrypt |
| |
| .globl bsaes_xts_decrypt |
| .type bsaes_xts_decrypt,\@abi-omnipotent |
| .align 16 |
| bsaes_xts_decrypt: |
| mov %rsp, %rax |
| .Lxts_dec_prologue: |
| push %rbp |
| push %rbx |
| push %r12 |
| push %r13 |
| push %r14 |
| push %r15 |
| lea -0x48(%rsp), %rsp |
| ___ |
| $code.=<<___ if ($win64); |
| mov 0xa0(%rsp),$arg5 # pull key2 |
| mov 0xa8(%rsp),$arg6 # pull ivp |
| lea -0xa0(%rsp), %rsp |
| movaps %xmm6, 0x40(%rsp) |
| movaps %xmm7, 0x50(%rsp) |
| movaps %xmm8, 0x60(%rsp) |
| movaps %xmm9, 0x70(%rsp) |
| movaps %xmm10, 0x80(%rsp) |
| movaps %xmm11, 0x90(%rsp) |
| movaps %xmm12, 0xa0(%rsp) |
| movaps %xmm13, 0xb0(%rsp) |
| movaps %xmm14, 0xc0(%rsp) |
| movaps %xmm15, 0xd0(%rsp) |
| .Lxts_dec_body: |
| ___ |
| $code.=<<___; |
| mov %rsp, %rbp # backup %rsp |
| mov $arg1, $inp # backup arguments |
| mov $arg2, $out |
| mov $arg3, $len |
| mov $arg4, $key |
| |
| lea ($arg6), $arg1 |
| lea 0x20(%rbp), $arg2 |
| lea ($arg5), $arg3 |
| call asm_AES_encrypt # generate initial tweak |
| |
| mov 240($key), %eax # rounds |
| mov $len, %rbx # backup $len |
| |
| mov %eax, %edx # rounds |
| shl \$7, %rax # 128 bytes per inner round key |
| sub \$`128-32`, %rax # size of bit-sliced key schedule |
| sub %rax, %rsp |
| |
| mov %rsp, %rax # pass key schedule |
| mov $key, %rcx # pass key |
| mov %edx, %r10d # pass rounds |
| call _bsaes_key_convert |
| pxor (%rsp), %xmm7 # fix up round 0 key |
| movdqa %xmm6, (%rax) # save last round key |
| movdqa %xmm7, (%rsp) |
| |
| xor %eax, %eax # if ($len%16) len-=16; |
| and \$-16, $len |
| test \$15, %ebx |
| setnz %al |
| shl \$4, %rax |
| sub %rax, $len |
| |
| sub \$0x80, %rsp # place for tweak[8] |
| movdqa 0x20(%rbp), @XMM[7] # initial tweak |
| |
| pxor $twtmp, $twtmp |
| movdqa .Lxts_magic(%rip), $twmask |
| pcmpgtd @XMM[7], $twtmp # broadcast upper bits |
| |
| sub \$0x80, $len |
| jc .Lxts_dec_short |
| jmp .Lxts_dec_loop |
| |
| .align 16 |
| .Lxts_dec_loop: |
| ___ |
| for ($i=0;$i<7;$i++) { |
| $code.=<<___; |
| pshufd \$0x13, $twtmp, $twres |
| pxor $twtmp, $twtmp |
| movdqa @XMM[7], @XMM[$i] |
| movdqa @XMM[7], `0x10*$i`(%rsp)# save tweak[$i] |
| paddq @XMM[7], @XMM[7] # psllq 1,$tweak |
| pand $twmask, $twres # isolate carry and residue |
| pcmpgtd @XMM[7], $twtmp # broadcast upper bits |
| pxor $twres, @XMM[7] |
| ___ |
| $code.=<<___ if ($i>=1); |
| movdqu `0x10*($i-1)`($inp), @XMM[8+$i-1] |
| ___ |
| $code.=<<___ if ($i>=2); |
| pxor @XMM[8+$i-2], @XMM[$i-2]# input[] ^ tweak[] |
| ___ |
| } |
| $code.=<<___; |
| movdqu 0x60($inp), @XMM[8+6] |
| pxor @XMM[8+5], @XMM[5] |
| movdqu 0x70($inp), @XMM[8+7] |
| lea 0x80($inp), $inp |
| movdqa @XMM[7], 0x70(%rsp) |
| pxor @XMM[8+6], @XMM[6] |
| lea 0x80(%rsp), %rax # pass key schedule |
| pxor @XMM[8+7], @XMM[7] |
| mov %edx, %r10d # pass rounds |
| |
| call _bsaes_decrypt8 |
| |
| pxor 0x00(%rsp), @XMM[0] # ^= tweak[] |
| pxor 0x10(%rsp), @XMM[1] |
| movdqu @XMM[0], 0x00($out) # write output |
| pxor 0x20(%rsp), @XMM[6] |
| movdqu @XMM[1], 0x10($out) |
| pxor 0x30(%rsp), @XMM[4] |
| movdqu @XMM[6], 0x20($out) |
| pxor 0x40(%rsp), @XMM[2] |
| movdqu @XMM[4], 0x30($out) |
| pxor 0x50(%rsp), @XMM[7] |
| movdqu @XMM[2], 0x40($out) |
| pxor 0x60(%rsp), @XMM[3] |
| movdqu @XMM[7], 0x50($out) |
| pxor 0x70(%rsp), @XMM[5] |
| movdqu @XMM[3], 0x60($out) |
| movdqu @XMM[5], 0x70($out) |
| lea 0x80($out), $out |
| |
| movdqa 0x70(%rsp), @XMM[7] # prepare next iteration tweak |
| pxor $twtmp, $twtmp |
| movdqa .Lxts_magic(%rip), $twmask |
| pcmpgtd @XMM[7], $twtmp |
| pshufd \$0x13, $twtmp, $twres |
| pxor $twtmp, $twtmp |
| paddq @XMM[7], @XMM[7] # psllq 1,$tweak |
| pand $twmask, $twres # isolate carry and residue |
| pcmpgtd @XMM[7], $twtmp # broadcast upper bits |
| pxor $twres, @XMM[7] |
| |
| sub \$0x80,$len |
| jnc .Lxts_dec_loop |
| |
| .Lxts_dec_short: |
| add \$0x80, $len |
| jz .Lxts_dec_done |
| ___ |
| for ($i=0;$i<7;$i++) { |
| $code.=<<___; |
| pshufd \$0x13, $twtmp, $twres |
| pxor $twtmp, $twtmp |
| movdqa @XMM[7], @XMM[$i] |
| movdqa @XMM[7], `0x10*$i`(%rsp)# save tweak[$i] |
| paddq @XMM[7], @XMM[7] # psllq 1,$tweak |
| pand $twmask, $twres # isolate carry and residue |
| pcmpgtd @XMM[7], $twtmp # broadcast upper bits |
| pxor $twres, @XMM[7] |
| ___ |
| $code.=<<___ if ($i>=1); |
| movdqu `0x10*($i-1)`($inp), @XMM[8+$i-1] |
| cmp \$`0x10*$i`,$len |
| je .Lxts_dec_$i |
| ___ |
| $code.=<<___ if ($i>=2); |
| pxor @XMM[8+$i-2], @XMM[$i-2]# input[] ^ tweak[] |
| ___ |
| } |
| $code.=<<___; |
| movdqu 0x60($inp), @XMM[8+6] |
| pxor @XMM[8+5], @XMM[5] |
| movdqa @XMM[7], 0x70(%rsp) |
| lea 0x70($inp), $inp |
| pxor @XMM[8+6], @XMM[6] |
| lea 0x80(%rsp), %rax # pass key schedule |
| mov %edx, %r10d # pass rounds |
| |
| call _bsaes_decrypt8 |
| |
| pxor 0x00(%rsp), @XMM[0] # ^= tweak[] |
| pxor 0x10(%rsp), @XMM[1] |
| movdqu @XMM[0], 0x00($out) # write output |
| pxor 0x20(%rsp), @XMM[6] |
| movdqu @XMM[1], 0x10($out) |
| pxor 0x30(%rsp), @XMM[4] |
| movdqu @XMM[6], 0x20($out) |
| pxor 0x40(%rsp), @XMM[2] |
| movdqu @XMM[4], 0x30($out) |
| pxor 0x50(%rsp), @XMM[7] |
| movdqu @XMM[2], 0x40($out) |
| pxor 0x60(%rsp), @XMM[3] |
| movdqu @XMM[7], 0x50($out) |
| movdqu @XMM[3], 0x60($out) |
| lea 0x70($out), $out |
| |
| movdqa 0x70(%rsp), @XMM[7] # next iteration tweak |
| jmp .Lxts_dec_done |
| .align 16 |
| .Lxts_dec_6: |
| pxor @XMM[8+4], @XMM[4] |
| lea 0x60($inp), $inp |
| pxor @XMM[8+5], @XMM[5] |
| lea 0x80(%rsp), %rax # pass key schedule |
| mov %edx, %r10d # pass rounds |
| |
| call _bsaes_decrypt8 |
| |
| pxor 0x00(%rsp), @XMM[0] # ^= tweak[] |
| pxor 0x10(%rsp), @XMM[1] |
| movdqu @XMM[0], 0x00($out) # write output |
| pxor 0x20(%rsp), @XMM[6] |
| movdqu @XMM[1], 0x10($out) |
| pxor 0x30(%rsp), @XMM[4] |
| movdqu @XMM[6], 0x20($out) |
| pxor 0x40(%rsp), @XMM[2] |
| movdqu @XMM[4], 0x30($out) |
| pxor 0x50(%rsp), @XMM[7] |
| movdqu @XMM[2], 0x40($out) |
| movdqu @XMM[7], 0x50($out) |
| lea 0x60($out), $out |
| |
| movdqa 0x60(%rsp), @XMM[7] # next iteration tweak |
| jmp .Lxts_dec_done |
| .align 16 |
| .Lxts_dec_5: |
| pxor @XMM[8+3], @XMM[3] |
| lea 0x50($inp), $inp |
| pxor @XMM[8+4], @XMM[4] |
| lea 0x80(%rsp), %rax # pass key schedule |
| mov %edx, %r10d # pass rounds |
| |
| call _bsaes_decrypt8 |
| |
| pxor 0x00(%rsp), @XMM[0] # ^= tweak[] |
| pxor 0x10(%rsp), @XMM[1] |
| movdqu @XMM[0], 0x00($out) # write output |
| pxor 0x20(%rsp), @XMM[6] |
| movdqu @XMM[1], 0x10($out) |
| pxor 0x30(%rsp), @XMM[4] |
| movdqu @XMM[6], 0x20($out) |
| pxor 0x40(%rsp), @XMM[2] |
| movdqu @XMM[4], 0x30($out) |
| movdqu @XMM[2], 0x40($out) |
| lea 0x50($out), $out |
| |
| movdqa 0x50(%rsp), @XMM[7] # next iteration tweak |
| jmp .Lxts_dec_done |
| .align 16 |
| .Lxts_dec_4: |
| pxor @XMM[8+2], @XMM[2] |
| lea 0x40($inp), $inp |
| pxor @XMM[8+3], @XMM[3] |
| lea 0x80(%rsp), %rax # pass key schedule |
| mov %edx, %r10d # pass rounds |
| |
| call _bsaes_decrypt8 |
| |
| pxor 0x00(%rsp), @XMM[0] # ^= tweak[] |
| pxor 0x10(%rsp), @XMM[1] |
| movdqu @XMM[0], 0x00($out) # write output |
| pxor 0x20(%rsp), @XMM[6] |
| movdqu @XMM[1], 0x10($out) |
| pxor 0x30(%rsp), @XMM[4] |
| movdqu @XMM[6], 0x20($out) |
| movdqu @XMM[4], 0x30($out) |
| lea 0x40($out), $out |
| |
| movdqa 0x40(%rsp), @XMM[7] # next iteration tweak |
| jmp .Lxts_dec_done |
| .align 16 |
| .Lxts_dec_3: |
| pxor @XMM[8+1], @XMM[1] |
| lea 0x30($inp), $inp |
| pxor @XMM[8+2], @XMM[2] |
| lea 0x80(%rsp), %rax # pass key schedule |
| mov %edx, %r10d # pass rounds |
| |
| call _bsaes_decrypt8 |
| |
| pxor 0x00(%rsp), @XMM[0] # ^= tweak[] |
| pxor 0x10(%rsp), @XMM[1] |
| movdqu @XMM[0], 0x00($out) # write output |
| pxor 0x20(%rsp), @XMM[6] |
| movdqu @XMM[1], 0x10($out) |
| movdqu @XMM[6], 0x20($out) |
| lea 0x30($out), $out |
| |
| movdqa 0x30(%rsp), @XMM[7] # next iteration tweak |
| jmp .Lxts_dec_done |
| .align 16 |
| .Lxts_dec_2: |
| pxor @XMM[8+0], @XMM[0] |
| lea 0x20($inp), $inp |
| pxor @XMM[8+1], @XMM[1] |
| lea 0x80(%rsp), %rax # pass key schedule |
| mov %edx, %r10d # pass rounds |
| |
| call _bsaes_decrypt8 |
| |
| pxor 0x00(%rsp), @XMM[0] # ^= tweak[] |
| pxor 0x10(%rsp), @XMM[1] |
| movdqu @XMM[0], 0x00($out) # write output |
| movdqu @XMM[1], 0x10($out) |
| lea 0x20($out), $out |
| |
| movdqa 0x20(%rsp), @XMM[7] # next iteration tweak |
| jmp .Lxts_dec_done |
| .align 16 |
| .Lxts_dec_1: |
| pxor @XMM[0], @XMM[8] |
| lea 0x10($inp), $inp |
| movdqa @XMM[8], 0x20(%rbp) |
| lea 0x20(%rbp), $arg1 |
| lea 0x20(%rbp), $arg2 |
| lea ($key), $arg3 |
| call asm_AES_decrypt # doesn't touch %xmm |
| pxor 0x20(%rbp), @XMM[0] # ^= tweak[] |
| #pxor @XMM[8], @XMM[0] |
| #lea 0x80(%rsp), %rax # pass key schedule |
| #mov %edx, %r10d # pass rounds |
| #call _bsaes_decrypt8 |
| #pxor 0x00(%rsp), @XMM[0] # ^= tweak[] |
| movdqu @XMM[0], 0x00($out) # write output |
| lea 0x10($out), $out |
| |
| movdqa 0x10(%rsp), @XMM[7] # next iteration tweak |
| |
| .Lxts_dec_done: |
| and \$15, %ebx |
| jz .Lxts_dec_ret |
| |
| pxor $twtmp, $twtmp |
| movdqa .Lxts_magic(%rip), $twmask |
| pcmpgtd @XMM[7], $twtmp |
| pshufd \$0x13, $twtmp, $twres |
| movdqa @XMM[7], @XMM[6] |
| paddq @XMM[7], @XMM[7] # psllq 1,$tweak |
| pand $twmask, $twres # isolate carry and residue |
| movdqu ($inp), @XMM[0] |
| pxor $twres, @XMM[7] |
| |
| lea 0x20(%rbp), $arg1 |
| pxor @XMM[7], @XMM[0] |
| lea 0x20(%rbp), $arg2 |
| movdqa @XMM[0], 0x20(%rbp) |
| lea ($key), $arg3 |
| call asm_AES_decrypt # doesn't touch %xmm |
| pxor 0x20(%rbp), @XMM[7] |
| mov $out, %rdx |
| movdqu @XMM[7], ($out) |
| |
| .Lxts_dec_steal: |
| movzb 16($inp), %eax |
| movzb (%rdx), %ecx |
| lea 1($inp), $inp |
| mov %al, (%rdx) |
| mov %cl, 16(%rdx) |
| lea 1(%rdx), %rdx |
| sub \$1,%ebx |
| jnz .Lxts_dec_steal |
| |
| movdqu ($out), @XMM[0] |
| lea 0x20(%rbp), $arg1 |
| pxor @XMM[6], @XMM[0] |
| lea 0x20(%rbp), $arg2 |
| movdqa @XMM[0], 0x20(%rbp) |
| lea ($key), $arg3 |
| call asm_AES_decrypt # doesn't touch %xmm |
| pxor 0x20(%rbp), @XMM[6] |
| movdqu @XMM[6], ($out) |
| |
| .Lxts_dec_ret: |
| lea (%rsp), %rax |
| pxor %xmm0, %xmm0 |
| .Lxts_dec_bzero: # wipe key schedule [if any] |
| movdqa %xmm0, 0x00(%rax) |
| movdqa %xmm0, 0x10(%rax) |
| lea 0x20(%rax), %rax |
| cmp %rax, %rbp |
| ja .Lxts_dec_bzero |
| |
| lea (%rbp),%rsp # restore %rsp |
| ___ |
| $code.=<<___ if ($win64); |
| movaps 0x40(%rbp), %xmm6 |
| movaps 0x50(%rbp), %xmm7 |
| movaps 0x60(%rbp), %xmm8 |
| movaps 0x70(%rbp), %xmm9 |
| movaps 0x80(%rbp), %xmm10 |
| movaps 0x90(%rbp), %xmm11 |
| movaps 0xa0(%rbp), %xmm12 |
| movaps 0xb0(%rbp), %xmm13 |
| movaps 0xc0(%rbp), %xmm14 |
| movaps 0xd0(%rbp), %xmm15 |
| lea 0xa0(%rbp), %rsp |
| ___ |
| $code.=<<___; |
| mov 0x48(%rsp), %r15 |
| mov 0x50(%rsp), %r14 |
| mov 0x58(%rsp), %r13 |
| mov 0x60(%rsp), %r12 |
| mov 0x68(%rsp), %rbx |
| mov 0x70(%rsp), %rax |
| lea 0x78(%rsp), %rsp |
| mov %rax, %rbp |
| .Lxts_dec_epilogue: |
| ret |
| .size bsaes_xts_decrypt,.-bsaes_xts_decrypt |
| ___ |
| } |
| $code.=<<___; |
| .type _bsaes_const,\@object |
| .align 64 |
| _bsaes_const: |
| .LM0ISR: # InvShiftRows constants |
| .quad 0x0a0e0206070b0f03, 0x0004080c0d010509 |
| .LISRM0: |
| .quad 0x01040b0e0205080f, 0x0306090c00070a0d |
| .LISR: |
| .quad 0x0504070602010003, 0x0f0e0d0c080b0a09 |
| .LBS0: # bit-slice constants |
| .quad 0x5555555555555555, 0x5555555555555555 |
| .LBS1: |
| .quad 0x3333333333333333, 0x3333333333333333 |
| .LBS2: |
| .quad 0x0f0f0f0f0f0f0f0f, 0x0f0f0f0f0f0f0f0f |
| .LSR: # shiftrows constants |
| .quad 0x0504070600030201, 0x0f0e0d0c0a09080b |
| .LSRM0: |
| .quad 0x0304090e00050a0f, 0x01060b0c0207080d |
| .LM0SR: |
| .quad 0x0a0e02060f03070b, 0x0004080c05090d01 |
| .LSWPUP: # byte-swap upper dword |
| .quad 0x0706050403020100, 0x0c0d0e0f0b0a0908 |
| .LSWPUPM0SR: |
| .quad 0x0a0d02060c03070b, 0x0004080f05090e01 |
| .LADD1: # counter increment constants |
| .quad 0x0000000000000000, 0x0000000100000000 |
| .LADD2: |
| .quad 0x0000000000000000, 0x0000000200000000 |
| .LADD3: |
| .quad 0x0000000000000000, 0x0000000300000000 |
| .LADD4: |
| .quad 0x0000000000000000, 0x0000000400000000 |
| .LADD5: |
| .quad 0x0000000000000000, 0x0000000500000000 |
| .LADD6: |
| .quad 0x0000000000000000, 0x0000000600000000 |
| .LADD7: |
| .quad 0x0000000000000000, 0x0000000700000000 |
| .LADD8: |
| .quad 0x0000000000000000, 0x0000000800000000 |
| .Lxts_magic: |
| .long 0x87,0,1,0 |
| .Lmasks: |
| .quad 0x0101010101010101, 0x0101010101010101 |
| .quad 0x0202020202020202, 0x0202020202020202 |
| .quad 0x0404040404040404, 0x0404040404040404 |
| .quad 0x0808080808080808, 0x0808080808080808 |
| .LM0: |
| .quad 0x02060a0e03070b0f, 0x0004080c0105090d |
| .L63: |
| .quad 0x6363636363636363, 0x6363636363636363 |
| .asciz "Bit-sliced AES for x86_64/SSSE3, Emilia Käsper, Peter Schwabe, Andy Polyakov" |
| .align 64 |
| .size _bsaes_const,.-_bsaes_const |
| ___ |
| |
| # EXCEPTION_DISPOSITION handler (EXCEPTION_RECORD *rec,ULONG64 frame, |
| # CONTEXT *context,DISPATCHER_CONTEXT *disp) |
| if ($win64) { |
| $rec="%rcx"; |
| $frame="%rdx"; |
| $context="%r8"; |
| $disp="%r9"; |
| |
| $code.=<<___; |
| .extern __imp_RtlVirtualUnwind |
| .type se_handler,\@abi-omnipotent |
| .align 16 |
| se_handler: |
| push %rsi |
| push %rdi |
| push %rbx |
| push %rbp |
| push %r12 |
| push %r13 |
| push %r14 |
| push %r15 |
| pushfq |
| sub \$64,%rsp |
| |
| mov 120($context),%rax # pull context->Rax |
| mov 248($context),%rbx # pull context->Rip |
| |
| mov 8($disp),%rsi # disp->ImageBase |
| mov 56($disp),%r11 # disp->HandlerData |
| |
| mov 0(%r11),%r10d # HandlerData[0] |
| lea (%rsi,%r10),%r10 # prologue label |
| cmp %r10,%rbx # context->Rip<prologue label |
| jb .Lin_prologue |
| |
| mov 152($context),%rax # pull context->Rsp |
| |
| mov 4(%r11),%r10d # HandlerData[1] |
| lea (%rsi,%r10),%r10 # epilogue label |
| cmp %r10,%rbx # context->Rip>=epilogue label |
| jae .Lin_prologue |
| |
| mov 160($context),%rax # pull context->Rbp |
| |
| lea 0x40(%rax),%rsi # %xmm save area |
| lea 512($context),%rdi # &context.Xmm6 |
| mov \$20,%ecx # 10*sizeof(%xmm0)/sizeof(%rax) |
| .long 0xa548f3fc # cld; rep movsq |
| lea 0xa0(%rax),%rax # adjust stack pointer |
| |
| mov 0x70(%rax),%rbp |
| mov 0x68(%rax),%rbx |
| mov 0x60(%rax),%r12 |
| mov 0x58(%rax),%r13 |
| mov 0x50(%rax),%r14 |
| mov 0x48(%rax),%r15 |
| lea 0x78(%rax),%rax # adjust stack pointer |
| mov %rbx,144($context) # restore context->Rbx |
| mov %rbp,160($context) # restore context->Rbp |
| mov %r12,216($context) # restore context->R12 |
| mov %r13,224($context) # restore context->R13 |
| mov %r14,232($context) # restore context->R14 |
| mov %r15,240($context) # restore context->R15 |
| |
| .Lin_prologue: |
| mov %rax,152($context) # restore context->Rsp |
| |
| mov 40($disp),%rdi # disp->ContextRecord |
| mov $context,%rsi # context |
| mov \$`1232/8`,%ecx # sizeof(CONTEXT) |
| .long 0xa548f3fc # cld; rep movsq |
| |
| mov $disp,%rsi |
| xor %rcx,%rcx # arg1, UNW_FLAG_NHANDLER |
| mov 8(%rsi),%rdx # arg2, disp->ImageBase |
| mov 0(%rsi),%r8 # arg3, disp->ControlPc |
| mov 16(%rsi),%r9 # arg4, disp->FunctionEntry |
| mov 40(%rsi),%r10 # disp->ContextRecord |
| lea 56(%rsi),%r11 # &disp->HandlerData |
| lea 24(%rsi),%r12 # &disp->EstablisherFrame |
| mov %r10,32(%rsp) # arg5 |
| mov %r11,40(%rsp) # arg6 |
| mov %r12,48(%rsp) # arg7 |
| mov %rcx,56(%rsp) # arg8, (NULL) |
| call *__imp_RtlVirtualUnwind(%rip) |
| |
| mov \$1,%eax # ExceptionContinueSearch |
| add \$64,%rsp |
| popfq |
| pop %r15 |
| pop %r14 |
| pop %r13 |
| pop %r12 |
| pop %rbp |
| pop %rbx |
| pop %rdi |
| pop %rsi |
| ret |
| .size se_handler,.-se_handler |
| |
| .section .pdata |
| .align 4 |
| ___ |
| $code.=<<___ if ($ecb); |
| .rva .Lecb_enc_prologue |
| .rva .Lecb_enc_epilogue |
| .rva .Lecb_enc_info |
| |
| .rva .Lecb_dec_prologue |
| .rva .Lecb_dec_epilogue |
| .rva .Lecb_dec_info |
| ___ |
| $code.=<<___; |
| .rva .Lcbc_dec_prologue |
| .rva .Lcbc_dec_epilogue |
| .rva .Lcbc_dec_info |
| |
| .rva .Lctr_enc_prologue |
| .rva .Lctr_enc_epilogue |
| .rva .Lctr_enc_info |
| |
| .rva .Lxts_enc_prologue |
| .rva .Lxts_enc_epilogue |
| .rva .Lxts_enc_info |
| |
| .rva .Lxts_dec_prologue |
| .rva .Lxts_dec_epilogue |
| .rva .Lxts_dec_info |
| |
| .section .xdata |
| .align 8 |
| ___ |
| $code.=<<___ if ($ecb); |
| .Lecb_enc_info: |
| .byte 9,0,0,0 |
| .rva se_handler |
| .rva .Lecb_enc_body,.Lecb_enc_epilogue # HandlerData[] |
| .Lecb_dec_info: |
| .byte 9,0,0,0 |
| .rva se_handler |
| .rva .Lecb_dec_body,.Lecb_dec_epilogue # HandlerData[] |
| ___ |
| $code.=<<___; |
| .Lcbc_dec_info: |
| .byte 9,0,0,0 |
| .rva se_handler |
| .rva .Lcbc_dec_body,.Lcbc_dec_epilogue # HandlerData[] |
| .Lctr_enc_info: |
| .byte 9,0,0,0 |
| .rva se_handler |
| .rva .Lctr_enc_body,.Lctr_enc_epilogue # HandlerData[] |
| .Lxts_enc_info: |
| .byte 9,0,0,0 |
| .rva se_handler |
| .rva .Lxts_enc_body,.Lxts_enc_epilogue # HandlerData[] |
| .Lxts_dec_info: |
| .byte 9,0,0,0 |
| .rva se_handler |
| .rva .Lxts_dec_body,.Lxts_dec_epilogue # HandlerData[] |
| ___ |
| } |
| |
| $code =~ s/\`([^\`]*)\`/eval($1)/gem; |
| |
| print $code; |
| |
| close STDOUT; |
