270 lines
7.5 KiB
Perl
270 lines
7.5 KiB
Perl
#!/usr/bin/env perl
|
|
|
|
# ====================================================================
|
|
# [Re]written by Andy Polyakov <appro@fy.chalmers.se> for the OpenSSL
|
|
# project. The module is, however, dual licensed under OpenSSL and
|
|
# CRYPTOGAMS licenses depending on where you obtain it. For further
|
|
# details see http://www.openssl.org/~appro/cryptogams/.
|
|
# ====================================================================
|
|
|
|
# At some point it became apparent that the original SSLeay RC4
|
|
# assembler implementation performs suboptimally on latest IA-32
|
|
# microarchitectures. After re-tuning performance has changed as
|
|
# following:
|
|
#
|
|
# Pentium -10%
|
|
# Pentium III +12%
|
|
# AMD +50%(*)
|
|
# P4 +250%(**)
|
|
#
|
|
# (*) This number is actually a trade-off:-) It's possible to
|
|
# achieve +72%, but at the cost of -48% off PIII performance.
|
|
# In other words code performing further 13% faster on AMD
|
|
# would perform almost 2 times slower on Intel PIII...
|
|
# For reference! This code delivers ~80% of rc4-amd64.pl
|
|
# performance on the same Opteron machine.
|
|
# (**) This number requires compressed key schedule set up by
|
|
# RC4_set_key [see commentary below for further details].
|
|
#
|
|
# <appro@fy.chalmers.se>
|
|
|
|
$0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1;
|
|
push(@INC,"${dir}","${dir}../../perlasm");
|
|
require "x86asm.pl";
|
|
|
|
&asm_init($ARGV[0],"rc4-586.pl");
|
|
|
|
$xx="eax";
|
|
$yy="ebx";
|
|
$tx="ecx";
|
|
$ty="edx";
|
|
$inp="esi";
|
|
$out="ebp";
|
|
$dat="edi";
|
|
|
|
sub RC4_loop {
|
|
my $i=shift;
|
|
my $func = ($i==0)?*mov:*or;
|
|
|
|
&add (&LB($yy),&LB($tx));
|
|
&mov ($ty,&DWP(0,$dat,$yy,4));
|
|
&mov (&DWP(0,$dat,$yy,4),$tx);
|
|
&mov (&DWP(0,$dat,$xx,4),$ty);
|
|
&add ($ty,$tx);
|
|
&inc (&LB($xx));
|
|
&and ($ty,0xff);
|
|
&ror ($out,8) if ($i!=0);
|
|
if ($i<3) {
|
|
&mov ($tx,&DWP(0,$dat,$xx,4));
|
|
} else {
|
|
&mov ($tx,&wparam(3)); # reload [re-biased] out
|
|
}
|
|
&$func ($out,&DWP(0,$dat,$ty,4));
|
|
}
|
|
|
|
# void RC4(RC4_KEY *key,size_t len,const unsigned char *inp,unsigned char *out);
|
|
&function_begin("RC4");
|
|
&mov ($dat,&wparam(0)); # load key schedule pointer
|
|
&mov ($ty, &wparam(1)); # load len
|
|
&mov ($inp,&wparam(2)); # load inp
|
|
&mov ($out,&wparam(3)); # load out
|
|
|
|
&xor ($xx,$xx); # avoid partial register stalls
|
|
&xor ($yy,$yy);
|
|
|
|
&cmp ($ty,0); # safety net
|
|
&je (&label("abort"));
|
|
|
|
&mov (&LB($xx),&BP(0,$dat)); # load key->x
|
|
&mov (&LB($yy),&BP(4,$dat)); # load key->y
|
|
&add ($dat,8);
|
|
|
|
&lea ($tx,&DWP(0,$inp,$ty));
|
|
&sub ($out,$inp); # re-bias out
|
|
&mov (&wparam(1),$tx); # save input+len
|
|
|
|
&inc (&LB($xx));
|
|
|
|
# detect compressed key schedule...
|
|
&cmp (&DWP(256,$dat),-1);
|
|
&je (&label("RC4_CHAR"));
|
|
|
|
&mov ($tx,&DWP(0,$dat,$xx,4));
|
|
|
|
&and ($ty,-4); # how many 4-byte chunks?
|
|
&jz (&label("loop1"));
|
|
|
|
&lea ($ty,&DWP(-4,$inp,$ty));
|
|
&mov (&wparam(2),$ty); # save input+(len/4)*4-4
|
|
&mov (&wparam(3),$out); # $out as accumulator in this loop
|
|
|
|
&set_label("loop4",16);
|
|
for ($i=0;$i<4;$i++) { RC4_loop($i); }
|
|
&ror ($out,8);
|
|
&xor ($out,&DWP(0,$inp));
|
|
&cmp ($inp,&wparam(2)); # compare to input+(len/4)*4-4
|
|
&mov (&DWP(0,$tx,$inp),$out);# $tx holds re-biased out here
|
|
&lea ($inp,&DWP(4,$inp));
|
|
&mov ($tx,&DWP(0,$dat,$xx,4));
|
|
&jb (&label("loop4"));
|
|
|
|
&cmp ($inp,&wparam(1)); # compare to input+len
|
|
&je (&label("done"));
|
|
&mov ($out,&wparam(3)); # restore $out
|
|
|
|
&set_label("loop1",16);
|
|
&add (&LB($yy),&LB($tx));
|
|
&mov ($ty,&DWP(0,$dat,$yy,4));
|
|
&mov (&DWP(0,$dat,$yy,4),$tx);
|
|
&mov (&DWP(0,$dat,$xx,4),$ty);
|
|
&add ($ty,$tx);
|
|
&inc (&LB($xx));
|
|
&and ($ty,0xff);
|
|
&mov ($ty,&DWP(0,$dat,$ty,4));
|
|
&xor (&LB($ty),&BP(0,$inp));
|
|
&lea ($inp,&DWP(1,$inp));
|
|
&mov ($tx,&DWP(0,$dat,$xx,4));
|
|
&cmp ($inp,&wparam(1)); # compare to input+len
|
|
&mov (&BP(-1,$out,$inp),&LB($ty));
|
|
&jb (&label("loop1"));
|
|
|
|
&jmp (&label("done"));
|
|
|
|
# this is essentially Intel P4 specific codepath...
|
|
&set_label("RC4_CHAR",16);
|
|
&movz ($tx,&BP(0,$dat,$xx));
|
|
# strangely enough unrolled loop performs over 20% slower...
|
|
&set_label("cloop1");
|
|
&add (&LB($yy),&LB($tx));
|
|
&movz ($ty,&BP(0,$dat,$yy));
|
|
&mov (&BP(0,$dat,$yy),&LB($tx));
|
|
&mov (&BP(0,$dat,$xx),&LB($ty));
|
|
&add (&LB($ty),&LB($tx));
|
|
&movz ($ty,&BP(0,$dat,$ty));
|
|
&add (&LB($xx),1);
|
|
&xor (&LB($ty),&BP(0,$inp));
|
|
&lea ($inp,&DWP(1,$inp));
|
|
&movz ($tx,&BP(0,$dat,$xx));
|
|
&cmp ($inp,&wparam(1));
|
|
&mov (&BP(-1,$out,$inp),&LB($ty));
|
|
&jb (&label("cloop1"));
|
|
|
|
&set_label("done");
|
|
&dec (&LB($xx));
|
|
&mov (&BP(-4,$dat),&LB($yy)); # save key->y
|
|
&mov (&BP(-8,$dat),&LB($xx)); # save key->x
|
|
&set_label("abort");
|
|
&function_end("RC4");
|
|
|
|
########################################################################
|
|
|
|
$inp="esi";
|
|
$out="edi";
|
|
$idi="ebp";
|
|
$ido="ecx";
|
|
$idx="edx";
|
|
|
|
&external_label("OPENSSL_ia32cap_P");
|
|
|
|
# void RC4_set_key(RC4_KEY *key,int len,const unsigned char *data);
|
|
&function_begin("RC4_set_key");
|
|
&mov ($out,&wparam(0)); # load key
|
|
&mov ($idi,&wparam(1)); # load len
|
|
&mov ($inp,&wparam(2)); # load data
|
|
&picmeup($idx,"OPENSSL_ia32cap_P");
|
|
|
|
&lea ($out,&DWP(2*4,$out)); # &key->data
|
|
&lea ($inp,&DWP(0,$inp,$idi)); # $inp to point at the end
|
|
&neg ($idi);
|
|
&xor ("eax","eax");
|
|
&mov (&DWP(-4,$out),$idi); # borrow key->y
|
|
|
|
&bt (&DWP(0,$idx),20); # check for bit#20
|
|
&jc (&label("c1stloop"));
|
|
|
|
&set_label("w1stloop",16);
|
|
&mov (&DWP(0,$out,"eax",4),"eax"); # key->data[i]=i;
|
|
&add (&LB("eax"),1); # i++;
|
|
&jnc (&label("w1stloop"));
|
|
|
|
&xor ($ido,$ido);
|
|
&xor ($idx,$idx);
|
|
|
|
&set_label("w2ndloop",16);
|
|
&mov ("eax",&DWP(0,$out,$ido,4));
|
|
&add (&LB($idx),&BP(0,$inp,$idi));
|
|
&add (&LB($idx),&LB("eax"));
|
|
&add ($idi,1);
|
|
&mov ("ebx",&DWP(0,$out,$idx,4));
|
|
&jnz (&label("wnowrap"));
|
|
&mov ($idi,&DWP(-4,$out));
|
|
&set_label("wnowrap");
|
|
&mov (&DWP(0,$out,$idx,4),"eax");
|
|
&mov (&DWP(0,$out,$ido,4),"ebx");
|
|
&add (&LB($ido),1);
|
|
&jnc (&label("w2ndloop"));
|
|
&jmp (&label("exit"));
|
|
|
|
# Unlike all other x86 [and x86_64] implementations, Intel P4 core
|
|
# [including EM64T] was found to perform poorly with above "32-bit" key
|
|
# schedule, a.k.a. RC4_INT. Performance improvement for IA-32 hand-coded
|
|
# assembler turned out to be 3.5x if re-coded for compressed 8-bit one,
|
|
# a.k.a. RC4_CHAR! It's however inappropriate to just switch to 8-bit
|
|
# schedule for x86[_64], because non-P4 implementations suffer from
|
|
# significant performance losses then, e.g. PIII exhibits >2x
|
|
# deterioration, and so does Opteron. In order to assure optimal
|
|
# all-round performance, we detect P4 at run-time and set up compressed
|
|
# key schedule, which is recognized by RC4 procedure.
|
|
|
|
&set_label("c1stloop",16);
|
|
&mov (&BP(0,$out,"eax"),&LB("eax")); # key->data[i]=i;
|
|
&add (&LB("eax"),1); # i++;
|
|
&jnc (&label("c1stloop"));
|
|
|
|
&xor ($ido,$ido);
|
|
&xor ($idx,$idx);
|
|
&xor ("ebx","ebx");
|
|
|
|
&set_label("c2ndloop",16);
|
|
&mov (&LB("eax"),&BP(0,$out,$ido));
|
|
&add (&LB($idx),&BP(0,$inp,$idi));
|
|
&add (&LB($idx),&LB("eax"));
|
|
&add ($idi,1);
|
|
&mov (&LB("ebx"),&BP(0,$out,$idx));
|
|
&jnz (&label("cnowrap"));
|
|
&mov ($idi,&DWP(-4,$out));
|
|
&set_label("cnowrap");
|
|
&mov (&BP(0,$out,$idx),&LB("eax"));
|
|
&mov (&BP(0,$out,$ido),&LB("ebx"));
|
|
&add (&LB($ido),1);
|
|
&jnc (&label("c2ndloop"));
|
|
|
|
&mov (&DWP(256,$out),-1); # mark schedule as compressed
|
|
|
|
&set_label("exit");
|
|
&xor ("eax","eax");
|
|
&mov (&DWP(-8,$out),"eax"); # key->x=0;
|
|
&mov (&DWP(-4,$out),"eax"); # key->y=0;
|
|
&function_end("RC4_set_key");
|
|
|
|
# const char *RC4_options(void);
|
|
&function_begin_B("RC4_options");
|
|
&call (&label("pic_point"));
|
|
&set_label("pic_point");
|
|
&blindpop("eax");
|
|
&lea ("eax",&DWP(&label("opts")."-".&label("pic_point"),"eax"));
|
|
&picmeup("edx","OPENSSL_ia32cap_P");
|
|
&bt (&DWP(0,"edx"),20);
|
|
&jnc (&label("skip"));
|
|
&add ("eax",12);
|
|
&set_label("skip");
|
|
&ret ();
|
|
&set_label("opts",64);
|
|
&asciz ("rc4(4x,int)");
|
|
&asciz ("rc4(1x,char)");
|
|
&asciz ("RC4 for x86, CRYPTOGAMS by <appro\@openssl.org>");
|
|
&align (64);
|
|
&function_end_B("RC4_options");
|
|
|
|
&asm_finish();
|
|
|