Pedantic polish to aes-586.pl:-)
[openssl.git] / crypto / aes / asm / aes-586.pl
index 59a2d0d..e279420 100755 (executable)
@@ -6,7 +6,7 @@
 # forms are granted according to the OpenSSL license.
 # ====================================================================
 #
-# Version 3.3.
+# Version 3.5.
 #
 # You might fail to appreciate this module performance from the first
 # try. If compared to "vanilla" linux-ia32-icc target, i.e. considered
 # misaligned, which unfortunately has negative impact on elder IA-32
 # implementations, Pentium suffered 30% penalty, PIII - 10%.
 #
+# Version 3.3 avoids L1 cache aliasing between stack frame and
+# S-boxes, and 3.4 - L1 cache aliasing even between key schedule. The
+# latter is achieved by copying the key schedule to controlled place in
+# stack. This unfortunately has rather strong impact on small block CBC
+# performance, ~2x deterioration on 16-byte block if compared to 3.3.
+#
+# Version 3.5 checks if there is L1 cache aliasing between user-supplied
+# key schedule and S-boxes and abstains from copying the former if
+# there is no. This allows end-user to consciously retain small block
+# performance by aligning key schedule in specific manner.
+#
 # Current ECB performance numbers for 128-bit key in CPU cycles per
 # processed byte [measure commonly used by AES benchmarkers] are:
 #
@@ -81,6 +92,12 @@ $s3="edx";
 $key="edi";
 $acc="esi";
 
+$compromise=0;         # $compromise=128 abstains from copying key
+                       # schedule to stack when encrypting inputs
+                       # shorter than 128 bytes at the cost of
+                       # risksing aliasing with S-boxes. In return
+                       # you get way better, up to +70%, small block
+                       # performance.
 $small_footprint=1;    # $small_footprint=1 code is ~5% slower [on
                        # recent ยต-archs], but ~5 times smaller!
                        # I favor compact code to minimize cache
@@ -414,7 +431,7 @@ sub _data_word() { my $i; while(defined($i=shift)) { &data_word($i,$i); } }
 #rcon:
        &data_word(0x00000001, 0x00000002, 0x00000004, 0x00000008);
        &data_word(0x00000010, 0x00000020, 0x00000040, 0x00000080);
-       &data_word(0x0000001b, 0x00000036);
+       &data_word(0x0000001b, 0x00000036, 0, 0, 0, 0, 0, 0);
 &function_end_B("_x86_AES_encrypt");
 
 # void AES_encrypt (const void *inp,void *out,const AES_KEY *key);
@@ -792,6 +809,8 @@ my $_key=&DWP(32,"esp");    #copy of wparam(3)
 my $_ivp=&DWP(36,"esp");       #copy of wparam(4)
 my $_tmp=&DWP(40,"esp");       #volatile variable
 my $ivec=&DWP(44,"esp");       #ivec[16]
+my $aes_key=&DWP(60,"esp");    #copy of aes_key
+my $mark=&DWP(60+240,"esp");   #copy of aes_key->rounds
 
 &public_label("AES_Te");
 &public_label("AES_Td");
@@ -804,28 +823,37 @@ my $ivec=&DWP(44,"esp");  #ivec[16]
        &set_label("pic_point");
        &blindpop("ebp");
 
+       &pushf  ();
+       &cld    ();
+
        &cmp    (&wparam(5),0);
        &je     (&label("DECRYPT"));
 
        &lea    ("ebp",&DWP(&label("AES_Te")."-".&label("pic_point"),"ebp"));
 
        # allocate aligned stack frame...
-       &lea    ($key,&DWP(-44,"esp"));
+       &lea    ($key,&DWP(-64-244,"esp"));
        &and    ($key,-64);
 
        # ... and make sure it doesn't alias with AES_Te modulo 4096
-       &mov    ($s1,"ebp");
+       &mov    ($s0,"ebp");
+       &lea    ($s1,&DWP(2048,"ebp"));
        &mov    ($s3,$key);
-       &and    ($s1,0xfff);            # t = %ebp&0xfff
+       &and    ($s0,0xfff);            # s = %ebp&0xfff
+       &and    ($s1,0xfff);            # e = (%ebp+2048)&0xfff
        &and    ($s3,0xfff);            # p = %esp&0xfff
 
-       &cmp    ($s3,$s1);              # if (p<t) goto ok
-       &jb     (&label("te_ok"));
-       &lea    ($acc,&DWP(2048,$s1));
-       &cmp    ($s3,$acc);             # if (p>=(t+2048)) goto ok
-       &jae    (&label("te_ok"));
-       &sub    ($s1,$s3);              # t -= p
-       &lea    ($key,&DWP(-64,$key,$s1));# %esp -= (p-t)+64
+       &cmp    ($s3,$s1);              # if (p>=e) %esp =- (p-e);
+       &jb     (&label("te_break_out"));
+       &sub    ($s3,$s1);
+       &sub    ($key,$s3);
+       &jmp    (&label("te_ok"));
+       &set_label("te_break_out");     # else %esp -= (p-s)&0xfff + framesz;
+       &sub    ($s3,$s0);
+       &and    ($s3,0xfff);
+       &add    ($s3,64+256);
+       &sub    ($key,$s3);
+       &align  (4);
        &set_label("te_ok");
 
        &mov    ($s0,&wparam(0));       # load inp
@@ -843,6 +871,28 @@ my $ivec=&DWP(44,"esp");   #ivec[16]
        &mov    ($_key,$s3);            # save copy of key
        &mov    ($_ivp,$acc);           # save copy of ivp
 
+       &mov    ($mark,0);              # copy of aes_key->rounds = 0;
+       if ($compromise) {
+               &cmp    ($s2,$compromise);
+               &jb     (&label("skip_ecopy"));
+       }
+       # do we copy key schedule to stack?
+       &mov    ($s1 eq "ebx" ? $s1 : "",$s3);
+       &mov    ($s2 eq "ecx" ? $s2 : "",244/4);
+       &sub    ($s1,"ebp");
+       &mov    ("esi",$s3);
+       &and    ($s1,0xfff);
+       &lea    ("edi",$aes_key);
+       &cmp    ($s1,2048);
+       &jb     (&label("do_ecopy"));
+       &cmp    ($s1,4096-244);
+       &jb     (&label("skip_ecopy"));
+       &align  (4);
+       &set_label("do_ecopy");
+               &mov    ($_key,"edi");
+               &data_word(0xA5F3F689); # rep movsd
+       &set_label("skip_ecopy");
+
        &mov    ($acc,$s0);
        &mov    ($key,16);
        &align  (4);
@@ -906,28 +956,40 @@ my $ivec=&DWP(44,"esp");  #ivec[16]
        &mov    (&DWP(4,$acc),$s1);
        &mov    (&DWP(8,$acc),$s2);
        &mov    (&DWP(12,$acc),$s3);
+
+       &cmp    ($mark,0);              # was the key schedule copied?
+       &mov    ("edi",$_key);
        &mov    ("esp",$_esp);
+       &je     (&label("skip_ezero"));
+       # zero copy of key schedule
+       &mov    ("ecx",240/4);
+       &xor    ("eax","eax");
+       &align  (4);
+       &data_word(0xABF3F689); # rep stosd
+       &set_label("skip_ezero")
+       &popf   ();
     &set_label("enc_out");
        &function_end_A();
+       &pushf  ();                     # kludge, never executed
 
     &align     (4);
     &set_label("enc_tail");
        &push   ($key eq "edi" ? $key : "");    # push ivp
-       &pushf  ();
        &mov    ($key,$_out);                   # load out
        &mov    ($s1,16);
        &sub    ($s1,$s2);
        &cmp    ($key,$acc);                    # compare with inp
        &je     (&label("enc_in_place"));
-       &data_word(0x90A4F3FC); # cld; rep movsb; nop   # copy input
+       &align  (4);
+       &data_word(0xA4F3F689); # rep movsb     # copy input
        &jmp    (&label("enc_skip_in_place"));
     &set_label("enc_in_place");
        &lea    ($key,&DWP(0,$key,$s2));
     &set_label("enc_skip_in_place");
        &mov    ($s2,$s1);
        &xor    ($s0,$s0);
-       &data_word(0x90AAF3FC); # cld; rep stosb; nop   # zero tail
-       &popf   ();
+       &align  (4);
+       &data_word(0xAAF3F689); # rep stosb     # zero tail
        &pop    ($key);                         # pop ivp
 
        &mov    ($acc,$_out);                   # output as input
@@ -942,22 +1004,28 @@ my $ivec=&DWP(44,"esp"); #ivec[16]
        &lea    ("ebp",&DWP(&label("AES_Td")."-".&label("pic_point"),"ebp"));
 
        # allocate aligned stack frame...
-       &lea    ($key,&DWP(-64,"esp"));
+       &lea    ($key,&DWP(-64-244,"esp"));
        &and    ($key,-64);
 
        # ... and make sure it doesn't alias with AES_Td modulo 4096
-       &mov    ($s1,"ebp");
+       &mov    ($s0,"ebp");
+       &lea    ($s1,&DWP(3072,"ebp"));
        &mov    ($s3,$key);
-       &and    ($s1,0xfff);            # t = %ebp&0xfff
+       &and    ($s0,0xfff);            # s = %ebp&0xfff
+       &and    ($s1,0xfff);            # e = (%ebp+3072)&0xfff
        &and    ($s3,0xfff);            # p = %esp&0xfff
 
-       &cmp    ($s3,$s1);              # if (p<t) goto ok
-       &jb     (&label("td_ok"));
-       &lea    ($acc,&DWP(3072,$s1));
-       &cmp    ($s3,$acc);             # if (p>=(t+3072)) goto ok
-       &jae    (&label("td_ok"));
-       &sub    ($s1,$s3);              # t -= p
-       &lea    ($key,&DWP(-64,$key,$s1));# %esp -= (p-t)+64
+       &cmp    ($s3,$s1);              # if (p>=e) %esp =- (p-e);
+       &jb     (&label("td_break_out"));
+       &sub    ($s3,$s1);
+       &sub    ($key,$s3);
+       &jmp    (&label("td_ok"));
+       &set_label("td_break_out");     # else %esp -= (p-s)&0xfff + framesz;
+       &sub    ($s3,$s0);
+       &and    ($s3,0xfff);
+       &add    ($s3,64+256);
+       &sub    ($key,$s3);
+       &align  (4);
        &set_label("td_ok");
 
        &mov    ($s0,&wparam(0));       # load inp
@@ -975,6 +1043,28 @@ my $ivec=&DWP(44,"esp");  #ivec[16]
        &mov    ($_key,$s3);            # save copy of key
        &mov    ($_ivp,$acc);           # save copy of ivp
 
+       &mov    ($mark,0);              # copy of aes_key->rounds = 0;
+       if ($compromise) {
+               &cmp    ($s2,$compromise);
+               &jb     (&label("skip_dcopy"));
+       }
+       # do we copy key schedule to stack?
+       &mov    ($s1 eq "ebx" ? $s1 : "",$s3);
+       &mov    ($s2 eq "ecx" ? $s2 : "",244/4);
+       &sub    ($s1,"ebp");
+       &mov    ("esi",$s3);
+       &and    ($s1,0xfff);
+       &lea    ("edi",$aes_key);
+       &cmp    ($s1,3072);
+       &jb     (&label("do_dcopy"));
+       &cmp    ($s1,4096-244);
+       &jb     (&label("skip_dcopy"));
+       &align  (4);
+       &set_label("do_dcopy");
+               &mov    ($_key,"edi");
+               &data_word(0xA5F3F689); # rep movsd
+       &set_label("skip_dcopy");
+
        &mov    ($acc,$s0);
        &mov    ($key,24);
        &align  (4);
@@ -1053,10 +1143,8 @@ my $ivec=&DWP(44,"esp"); #ivec[16]
        &lea    ($s2 eq "ecx" ? $s2 : "",&DWP(16,$acc));
        &mov    ($acc eq "esi" ? $acc : "",$key);
        &mov    ($key eq "edi" ? $key : "",$_out);      # load out
-       &pushf  ();
-       &data_word(0x90A4F3FC); # cld; rep movsb; nop   # copy output
-       &popf   ();
-       &mov    ($key,$_inp);           # use inp as temp ivp
+       &data_word(0xA4F3F689); # rep movsb             # copy output
+       &mov    ($key,$_inp);                           # use inp as temp ivp
        &jmp    (&label("dec_end"));
 
     &align     (4);
@@ -1122,13 +1210,21 @@ my $ivec=&DWP(44,"esp");        #ivec[16]
        &lea    ($key,&DWP(0,$key,$s2));
        &lea    ($acc,&DWP(16,$acc,$s2));
        &neg    ($s2 eq "ecx" ? $s2 : "");
-       &pushf  ();
-       &data_word(0x90A4F3FC); # cld; rep movsb; nop   # restore tail
-       &popf   ();
+       &data_word(0xA4F3F689); # rep movsb     # restore tail
 
     &align     (4);
     &set_label("dec_out");
+    &cmp       ($mark,0);              # was the key schedule copied?
+    &mov       ("edi",$_key);
     &mov       ("esp",$_esp);
+    &je                (&label("skip_dzero"));
+    # zero copy of key schedule
+    &mov       ("ecx",240/4);
+    &xor       ("eax","eax");
+    &align     (4);
+    &data_word(0xABF3F689);    # rep stosd
+    &set_label("skip_dzero")
+    &popf      ();
 &function_end("AES_cbc_encrypt");
 }