diff options
Diffstat (limited to 'src')
39 files changed, 18486 insertions, 149 deletions
diff --git a/src/lib/libcrypto/bn/asm/mips3-mont.pl b/src/lib/libcrypto/bn/asm/mips3-mont.pl new file mode 100644 index 0000000000..8f9156e02a --- /dev/null +++ b/src/lib/libcrypto/bn/asm/mips3-mont.pl | |||
| @@ -0,0 +1,327 @@ | |||
| 1 | #!/usr/bin/env perl | ||
| 2 | # | ||
| 3 | # ==================================================================== | ||
| 4 | # Written by Andy Polyakov <appro@fy.chalmers.se> for the OpenSSL | ||
| 5 | # project. The module is, however, dual licensed under OpenSSL and | ||
| 6 | # CRYPTOGAMS licenses depending on where you obtain it. For further | ||
| 7 | # details see http://www.openssl.org/~appro/cryptogams/. | ||
| 8 | # ==================================================================== | ||
| 9 | |||
| 10 | # This module doesn't present direct interest for OpenSSL, because it | ||
| 11 | # doesn't provide better performance for longer keys. While 512-bit | ||
| 12 | # RSA private key operations are 40% faster, 1024-bit ones are hardly | ||
| 13 | # faster at all, while longer key operations are slower by up to 20%. | ||
| 14 | # It might be of interest to embedded system developers though, as | ||
| 15 | # it's smaller than 1KB, yet offers ~3x improvement over compiler | ||
| 16 | # generated code. | ||
| 17 | # | ||
| 18 | # The module targets N32 and N64 MIPS ABIs and currently is a bit | ||
| 19 | # IRIX-centric, i.e. is likely to require adaptation for other OSes. | ||
| 20 | |||
| 21 | # int bn_mul_mont( | ||
| 22 | $rp="a0"; # BN_ULONG *rp, | ||
| 23 | $ap="a1"; # const BN_ULONG *ap, | ||
| 24 | $bp="a2"; # const BN_ULONG *bp, | ||
| 25 | $np="a3"; # const BN_ULONG *np, | ||
| 26 | $n0="a4"; # const BN_ULONG *n0, | ||
| 27 | $num="a5"; # int num); | ||
| 28 | |||
| 29 | $lo0="a6"; | ||
| 30 | $hi0="a7"; | ||
| 31 | $lo1="v0"; | ||
| 32 | $hi1="v1"; | ||
| 33 | $aj="t0"; | ||
| 34 | $bi="t1"; | ||
| 35 | $nj="t2"; | ||
| 36 | $tp="t3"; | ||
| 37 | $alo="s0"; | ||
| 38 | $ahi="s1"; | ||
| 39 | $nlo="s2"; | ||
| 40 | $nhi="s3"; | ||
| 41 | $tj="s4"; | ||
| 42 | $i="s5"; | ||
| 43 | $j="s6"; | ||
| 44 | $fp="t8"; | ||
| 45 | $m1="t9"; | ||
| 46 | |||
| 47 | $FRAME=8*(2+8); | ||
| 48 | |||
| 49 | $code=<<___; | ||
| 50 | #include <asm.h> | ||
| 51 | #include <regdef.h> | ||
| 52 | |||
| 53 | .text | ||
| 54 | |||
| 55 | .set noat | ||
| 56 | .set reorder | ||
| 57 | |||
| 58 | .align 5 | ||
| 59 | .globl bn_mul_mont | ||
| 60 | .ent bn_mul_mont | ||
| 61 | bn_mul_mont: | ||
| 62 | .set noreorder | ||
| 63 | PTR_SUB sp,64 | ||
| 64 | move $fp,sp | ||
| 65 | .frame $fp,64,ra | ||
| 66 | slt AT,$num,4 | ||
| 67 | li v0,0 | ||
| 68 | beqzl AT,.Lproceed | ||
| 69 | nop | ||
| 70 | jr ra | ||
| 71 | PTR_ADD sp,$fp,64 | ||
| 72 | .set reorder | ||
| 73 | .align 5 | ||
| 74 | .Lproceed: | ||
| 75 | ld $n0,0($n0) | ||
| 76 | ld $bi,0($bp) # bp[0] | ||
| 77 | ld $aj,0($ap) # ap[0] | ||
| 78 | ld $nj,0($np) # np[0] | ||
| 79 | PTR_SUB sp,16 # place for two extra words | ||
| 80 | sll $num,3 | ||
| 81 | li AT,-4096 | ||
| 82 | PTR_SUB sp,$num | ||
| 83 | and sp,AT | ||
| 84 | |||
| 85 | sd s0,0($fp) | ||
| 86 | sd s1,8($fp) | ||
| 87 | sd s2,16($fp) | ||
| 88 | sd s3,24($fp) | ||
| 89 | sd s4,32($fp) | ||
| 90 | sd s5,40($fp) | ||
| 91 | sd s6,48($fp) | ||
| 92 | sd s7,56($fp) | ||
| 93 | |||
| 94 | dmultu $aj,$bi | ||
| 95 | ld $alo,8($ap) | ||
| 96 | ld $nlo,8($np) | ||
| 97 | mflo $lo0 | ||
| 98 | mfhi $hi0 | ||
| 99 | dmultu $lo0,$n0 | ||
| 100 | mflo $m1 | ||
| 101 | |||
| 102 | dmultu $alo,$bi | ||
| 103 | mflo $alo | ||
| 104 | mfhi $ahi | ||
| 105 | |||
| 106 | dmultu $nj,$m1 | ||
| 107 | mflo $lo1 | ||
| 108 | mfhi $hi1 | ||
| 109 | dmultu $nlo,$m1 | ||
| 110 | daddu $lo1,$lo0 | ||
| 111 | sltu AT,$lo1,$lo0 | ||
| 112 | daddu $hi1,AT | ||
| 113 | mflo $nlo | ||
| 114 | mfhi $nhi | ||
| 115 | |||
| 116 | move $tp,sp | ||
| 117 | li $j,16 | ||
| 118 | .align 4 | ||
| 119 | .L1st: | ||
| 120 | .set noreorder | ||
| 121 | PTR_ADD $aj,$ap,$j | ||
| 122 | ld $aj,($aj) | ||
| 123 | PTR_ADD $nj,$np,$j | ||
| 124 | ld $nj,($nj) | ||
| 125 | |||
| 126 | dmultu $aj,$bi | ||
| 127 | daddu $lo0,$alo,$hi0 | ||
| 128 | daddu $lo1,$nlo,$hi1 | ||
| 129 | sltu AT,$lo0,$hi0 | ||
| 130 | sltu s7,$lo1,$hi1 | ||
| 131 | daddu $hi0,$ahi,AT | ||
| 132 | daddu $hi1,$nhi,s7 | ||
| 133 | mflo $alo | ||
| 134 | mfhi $ahi | ||
| 135 | |||
| 136 | daddu $lo1,$lo0 | ||
| 137 | sltu AT,$lo1,$lo0 | ||
| 138 | dmultu $nj,$m1 | ||
| 139 | daddu $hi1,AT | ||
| 140 | addu $j,8 | ||
| 141 | sd $lo1,($tp) | ||
| 142 | sltu s7,$j,$num | ||
| 143 | mflo $nlo | ||
| 144 | mfhi $nhi | ||
| 145 | |||
| 146 | bnez s7,.L1st | ||
| 147 | PTR_ADD $tp,8 | ||
| 148 | .set reorder | ||
| 149 | |||
| 150 | daddu $lo0,$alo,$hi0 | ||
| 151 | sltu AT,$lo0,$hi0 | ||
| 152 | daddu $hi0,$ahi,AT | ||
| 153 | |||
| 154 | daddu $lo1,$nlo,$hi1 | ||
| 155 | sltu s7,$lo1,$hi1 | ||
| 156 | daddu $hi1,$nhi,s7 | ||
| 157 | daddu $lo1,$lo0 | ||
| 158 | sltu AT,$lo1,$lo0 | ||
| 159 | daddu $hi1,AT | ||
| 160 | |||
| 161 | sd $lo1,($tp) | ||
| 162 | |||
| 163 | daddu $hi1,$hi0 | ||
| 164 | sltu AT,$hi1,$hi0 | ||
| 165 | sd $hi1,8($tp) | ||
| 166 | sd AT,16($tp) | ||
| 167 | |||
| 168 | li $i,8 | ||
| 169 | .align 4 | ||
| 170 | .Louter: | ||
| 171 | PTR_ADD $bi,$bp,$i | ||
| 172 | ld $bi,($bi) | ||
| 173 | ld $aj,($ap) | ||
| 174 | ld $alo,8($ap) | ||
| 175 | ld $tj,(sp) | ||
| 176 | |||
| 177 | dmultu $aj,$bi | ||
| 178 | ld $nj,($np) | ||
| 179 | ld $nlo,8($np) | ||
| 180 | mflo $lo0 | ||
| 181 | mfhi $hi0 | ||
| 182 | daddu $lo0,$tj | ||
| 183 | dmultu $lo0,$n0 | ||
| 184 | sltu AT,$lo0,$tj | ||
| 185 | daddu $hi0,AT | ||
| 186 | mflo $m1 | ||
| 187 | |||
| 188 | dmultu $alo,$bi | ||
| 189 | mflo $alo | ||
| 190 | mfhi $ahi | ||
| 191 | |||
| 192 | dmultu $nj,$m1 | ||
| 193 | mflo $lo1 | ||
| 194 | mfhi $hi1 | ||
| 195 | |||
| 196 | dmultu $nlo,$m1 | ||
| 197 | daddu $lo1,$lo0 | ||
| 198 | sltu AT,$lo1,$lo0 | ||
| 199 | daddu $hi1,AT | ||
| 200 | mflo $nlo | ||
| 201 | mfhi $nhi | ||
| 202 | |||
| 203 | move $tp,sp | ||
| 204 | li $j,16 | ||
| 205 | ld $tj,8($tp) | ||
| 206 | .align 4 | ||
| 207 | .Linner: | ||
| 208 | .set noreorder | ||
| 209 | PTR_ADD $aj,$ap,$j | ||
| 210 | ld $aj,($aj) | ||
| 211 | PTR_ADD $nj,$np,$j | ||
| 212 | ld $nj,($nj) | ||
| 213 | |||
| 214 | dmultu $aj,$bi | ||
| 215 | daddu $lo0,$alo,$hi0 | ||
| 216 | daddu $lo1,$nlo,$hi1 | ||
| 217 | sltu AT,$lo0,$hi0 | ||
| 218 | sltu s7,$lo1,$hi1 | ||
| 219 | daddu $hi0,$ahi,AT | ||
| 220 | daddu $hi1,$nhi,s7 | ||
| 221 | mflo $alo | ||
| 222 | mfhi $ahi | ||
| 223 | |||
| 224 | daddu $lo0,$tj | ||
| 225 | addu $j,8 | ||
| 226 | dmultu $nj,$m1 | ||
| 227 | sltu AT,$lo0,$tj | ||
| 228 | daddu $lo1,$lo0 | ||
| 229 | daddu $hi0,AT | ||
| 230 | sltu s7,$lo1,$lo0 | ||
| 231 | ld $tj,16($tp) | ||
| 232 | daddu $hi1,s7 | ||
| 233 | sltu AT,$j,$num | ||
| 234 | mflo $nlo | ||
| 235 | mfhi $nhi | ||
| 236 | sd $lo1,($tp) | ||
| 237 | bnez AT,.Linner | ||
| 238 | PTR_ADD $tp,8 | ||
| 239 | .set reorder | ||
| 240 | |||
| 241 | daddu $lo0,$alo,$hi0 | ||
| 242 | sltu AT,$lo0,$hi0 | ||
| 243 | daddu $hi0,$ahi,AT | ||
| 244 | daddu $lo0,$tj | ||
| 245 | sltu s7,$lo0,$tj | ||
| 246 | daddu $hi0,s7 | ||
| 247 | |||
| 248 | ld $tj,16($tp) | ||
| 249 | daddu $lo1,$nlo,$hi1 | ||
| 250 | sltu AT,$lo1,$hi1 | ||
| 251 | daddu $hi1,$nhi,AT | ||
| 252 | daddu $lo1,$lo0 | ||
| 253 | sltu s7,$lo1,$lo0 | ||
| 254 | daddu $hi1,s7 | ||
| 255 | sd $lo1,($tp) | ||
| 256 | |||
| 257 | daddu $lo1,$hi1,$hi0 | ||
| 258 | sltu $hi1,$lo1,$hi0 | ||
| 259 | daddu $lo1,$tj | ||
| 260 | sltu AT,$lo1,$tj | ||
| 261 | daddu $hi1,AT | ||
| 262 | sd $lo1,8($tp) | ||
| 263 | sd $hi1,16($tp) | ||
| 264 | |||
| 265 | addu $i,8 | ||
| 266 | sltu s7,$i,$num | ||
| 267 | bnez s7,.Louter | ||
| 268 | |||
| 269 | .set noreorder | ||
| 270 | PTR_ADD $tj,sp,$num # &tp[num] | ||
| 271 | move $tp,sp | ||
| 272 | move $ap,sp | ||
| 273 | li $hi0,0 # clear borrow bit | ||
| 274 | |||
| 275 | .align 4 | ||
| 276 | .Lsub: ld $lo0,($tp) | ||
| 277 | ld $lo1,($np) | ||
| 278 | PTR_ADD $tp,8 | ||
| 279 | PTR_ADD $np,8 | ||
| 280 | dsubu $lo1,$lo0,$lo1 # tp[i]-np[i] | ||
| 281 | sgtu AT,$lo1,$lo0 | ||
| 282 | dsubu $lo0,$lo1,$hi0 | ||
| 283 | sgtu $hi0,$lo0,$lo1 | ||
| 284 | sd $lo0,($rp) | ||
| 285 | or $hi0,AT | ||
| 286 | sltu AT,$tp,$tj | ||
| 287 | bnez AT,.Lsub | ||
| 288 | PTR_ADD $rp,8 | ||
| 289 | |||
| 290 | dsubu $hi0,$hi1,$hi0 # handle upmost overflow bit | ||
| 291 | move $tp,sp | ||
| 292 | PTR_SUB $rp,$num # restore rp | ||
| 293 | not $hi1,$hi0 | ||
| 294 | |||
| 295 | and $ap,$hi0,sp | ||
| 296 | and $bp,$hi1,$rp | ||
| 297 | or $ap,$ap,$bp # ap=borrow?tp:rp | ||
| 298 | |||
| 299 | .align 4 | ||
| 300 | .Lcopy: ld $aj,($ap) | ||
| 301 | PTR_ADD $ap,8 | ||
| 302 | PTR_ADD $tp,8 | ||
| 303 | sd zero,-8($tp) | ||
| 304 | sltu AT,$tp,$tj | ||
| 305 | sd $aj,($rp) | ||
| 306 | bnez AT,.Lcopy | ||
| 307 | PTR_ADD $rp,8 | ||
| 308 | |||
| 309 | ld s0,0($fp) | ||
| 310 | ld s1,8($fp) | ||
| 311 | ld s2,16($fp) | ||
| 312 | ld s3,24($fp) | ||
| 313 | ld s4,32($fp) | ||
| 314 | ld s5,40($fp) | ||
| 315 | ld s6,48($fp) | ||
| 316 | ld s7,56($fp) | ||
| 317 | li v0,1 | ||
| 318 | jr ra | ||
| 319 | PTR_ADD sp,$fp,64 | ||
| 320 | .set reorder | ||
| 321 | END(bn_mul_mont) | ||
| 322 | .rdata | ||
| 323 | .asciiz "Montgomery Multiplication for MIPS III/IV, CRYPTOGAMS by <appro\@openssl.org>" | ||
| 324 | ___ | ||
| 325 | |||
| 326 | print $code; | ||
| 327 | close STDOUT; | ||
diff --git a/src/lib/libcrypto/x509v3/v3_addr.c b/src/lib/libcrypto/x509v3/v3_addr.c index a37f844d3c..efdf7c3ba7 100644 --- a/src/lib/libcrypto/x509v3/v3_addr.c +++ b/src/lib/libcrypto/x509v3/v3_addr.c | |||
| @@ -61,7 +61,7 @@ | |||
| 61 | 61 | ||
| 62 | #include <stdio.h> | 62 | #include <stdio.h> |
| 63 | #include <stdlib.h> | 63 | #include <stdlib.h> |
| 64 | #include <assert.h> | 64 | |
| 65 | #include "cryptlib.h" | 65 | #include "cryptlib.h" |
| 66 | #include <openssl/conf.h> | 66 | #include <openssl/conf.h> |
| 67 | #include <openssl/asn1.h> | 67 | #include <openssl/asn1.h> |
| @@ -128,7 +128,7 @@ static int length_from_afi(const unsigned afi) | |||
| 128 | /* | 128 | /* |
| 129 | * Extract the AFI from an IPAddressFamily. | 129 | * Extract the AFI from an IPAddressFamily. |
| 130 | */ | 130 | */ |
| 131 | unsigned v3_addr_get_afi(const IPAddressFamily *f) | 131 | unsigned int v3_addr_get_afi(const IPAddressFamily *f) |
| 132 | { | 132 | { |
| 133 | return ((f != NULL && | 133 | return ((f != NULL && |
| 134 | f->addressFamily != NULL && | 134 | f->addressFamily != NULL && |
| @@ -147,7 +147,7 @@ static void addr_expand(unsigned char *addr, | |||
| 147 | const int length, | 147 | const int length, |
| 148 | const unsigned char fill) | 148 | const unsigned char fill) |
| 149 | { | 149 | { |
| 150 | assert(bs->length >= 0 && bs->length <= length); | 150 | OPENSSL_assert(bs->length >= 0 && bs->length <= length); |
| 151 | if (bs->length > 0) { | 151 | if (bs->length > 0) { |
| 152 | memcpy(addr, bs->data, bs->length); | 152 | memcpy(addr, bs->data, bs->length); |
| 153 | if ((bs->flags & 7) != 0) { | 153 | if ((bs->flags & 7) != 0) { |
| @@ -190,6 +190,8 @@ static int i2r_address(BIO *out, | |||
| 190 | BIO_printf(out, "%x%s", (addr[i] << 8) | addr[i+1], (i < 14 ? ":" : "")); | 190 | BIO_printf(out, "%x%s", (addr[i] << 8) | addr[i+1], (i < 14 ? ":" : "")); |
| 191 | if (i < 16) | 191 | if (i < 16) |
| 192 | BIO_puts(out, ":"); | 192 | BIO_puts(out, ":"); |
| 193 | if (i == 0) | ||
| 194 | BIO_puts(out, ":"); | ||
| 193 | break; | 195 | break; |
| 194 | default: | 196 | default: |
| 195 | for (i = 0; i < bs->length; i++) | 197 | for (i = 0; i < bs->length; i++) |
| @@ -243,7 +245,7 @@ static int i2r_IPAddrBlocks(X509V3_EXT_METHOD *method, | |||
| 243 | int i; | 245 | int i; |
| 244 | for (i = 0; i < sk_IPAddressFamily_num(addr); i++) { | 246 | for (i = 0; i < sk_IPAddressFamily_num(addr); i++) { |
| 245 | IPAddressFamily *f = sk_IPAddressFamily_value(addr, i); | 247 | IPAddressFamily *f = sk_IPAddressFamily_value(addr, i); |
| 246 | const unsigned afi = v3_addr_get_afi(f); | 248 | const unsigned int afi = v3_addr_get_afi(f); |
| 247 | switch (afi) { | 249 | switch (afi) { |
| 248 | case IANA_AFI_IPV4: | 250 | case IANA_AFI_IPV4: |
| 249 | BIO_printf(out, "%*sIPv4", indent, ""); | 251 | BIO_printf(out, "%*sIPv4", indent, ""); |
| @@ -453,7 +455,7 @@ static int make_addressRange(IPAddressOrRange **result, | |||
| 453 | if ((aor = IPAddressOrRange_new()) == NULL) | 455 | if ((aor = IPAddressOrRange_new()) == NULL) |
| 454 | return 0; | 456 | return 0; |
| 455 | aor->type = IPAddressOrRange_addressRange; | 457 | aor->type = IPAddressOrRange_addressRange; |
| 456 | assert(aor->u.addressRange == NULL); | 458 | OPENSSL_assert(aor->u.addressRange == NULL); |
| 457 | if ((aor->u.addressRange = IPAddressRange_new()) == NULL) | 459 | if ((aor->u.addressRange = IPAddressRange_new()) == NULL) |
| 458 | goto err; | 460 | goto err; |
| 459 | if (aor->u.addressRange->min == NULL && | 461 | if (aor->u.addressRange->min == NULL && |
| @@ -522,7 +524,7 @@ static IPAddressFamily *make_IPAddressFamily(IPAddrBlocks *addr, | |||
| 522 | 524 | ||
| 523 | for (i = 0; i < sk_IPAddressFamily_num(addr); i++) { | 525 | for (i = 0; i < sk_IPAddressFamily_num(addr); i++) { |
| 524 | f = sk_IPAddressFamily_value(addr, i); | 526 | f = sk_IPAddressFamily_value(addr, i); |
| 525 | assert(f->addressFamily->data != NULL); | 527 | OPENSSL_assert(f->addressFamily->data != NULL); |
| 526 | if (f->addressFamily->length == keylen && | 528 | if (f->addressFamily->length == keylen && |
| 527 | !memcmp(f->addressFamily->data, key, keylen)) | 529 | !memcmp(f->addressFamily->data, key, keylen)) |
| 528 | return f; | 530 | return f; |
| @@ -654,7 +656,7 @@ static void extract_min_max(IPAddressOrRange *aor, | |||
| 654 | unsigned char *max, | 656 | unsigned char *max, |
| 655 | int length) | 657 | int length) |
| 656 | { | 658 | { |
| 657 | assert(aor != NULL && min != NULL && max != NULL); | 659 | OPENSSL_assert(aor != NULL && min != NULL && max != NULL); |
| 658 | switch (aor->type) { | 660 | switch (aor->type) { |
| 659 | case IPAddressOrRange_addressPrefix: | 661 | case IPAddressOrRange_addressPrefix: |
| 660 | addr_expand(min, aor->u.addressPrefix, length, 0x00); | 662 | addr_expand(min, aor->u.addressPrefix, length, 0x00); |
| @@ -880,7 +882,7 @@ int v3_addr_canonize(IPAddrBlocks *addr) | |||
| 880 | } | 882 | } |
| 881 | (void)sk_IPAddressFamily_set_cmp_func(addr, IPAddressFamily_cmp); | 883 | (void)sk_IPAddressFamily_set_cmp_func(addr, IPAddressFamily_cmp); |
| 882 | sk_IPAddressFamily_sort(addr); | 884 | sk_IPAddressFamily_sort(addr); |
| 883 | assert(v3_addr_is_canonical(addr)); | 885 | OPENSSL_assert(v3_addr_is_canonical(addr)); |
| 884 | return 1; | 886 | return 1; |
| 885 | } | 887 | } |
| 886 | 888 | ||
| @@ -1127,7 +1129,10 @@ int v3_addr_subset(IPAddrBlocks *a, IPAddrBlocks *b) | |||
| 1127 | for (i = 0; i < sk_IPAddressFamily_num(a); i++) { | 1129 | for (i = 0; i < sk_IPAddressFamily_num(a); i++) { |
| 1128 | IPAddressFamily *fa = sk_IPAddressFamily_value(a, i); | 1130 | IPAddressFamily *fa = sk_IPAddressFamily_value(a, i); |
| 1129 | int j = sk_IPAddressFamily_find(b, fa); | 1131 | int j = sk_IPAddressFamily_find(b, fa); |
| 1130 | IPAddressFamily *fb = sk_IPAddressFamily_value(b, j); | 1132 | IPAddressFamily *fb; |
| 1133 | fb = sk_IPAddressFamily_value(b, j); | ||
| 1134 | if (fb == NULL) | ||
| 1135 | return 0; | ||
| 1131 | if (!addr_contains(fb->ipAddressChoice->u.addressesOrRanges, | 1136 | if (!addr_contains(fb->ipAddressChoice->u.addressesOrRanges, |
| 1132 | fa->ipAddressChoice->u.addressesOrRanges, | 1137 | fa->ipAddressChoice->u.addressesOrRanges, |
| 1133 | length_from_afi(v3_addr_get_afi(fb)))) | 1138 | length_from_afi(v3_addr_get_afi(fb)))) |
| @@ -1164,9 +1169,9 @@ static int v3_addr_validate_path_internal(X509_STORE_CTX *ctx, | |||
| 1164 | int i, j, ret = 1; | 1169 | int i, j, ret = 1; |
| 1165 | X509 *x = NULL; | 1170 | X509 *x = NULL; |
| 1166 | 1171 | ||
| 1167 | assert(chain != NULL && sk_X509_num(chain) > 0); | 1172 | OPENSSL_assert(chain != NULL && sk_X509_num(chain) > 0); |
| 1168 | assert(ctx != NULL || ext != NULL); | 1173 | OPENSSL_assert(ctx != NULL || ext != NULL); |
| 1169 | assert(ctx == NULL || ctx->verify_cb != NULL); | 1174 | OPENSSL_assert(ctx == NULL || ctx->verify_cb != NULL); |
| 1170 | 1175 | ||
| 1171 | /* | 1176 | /* |
| 1172 | * Figure out where to start. If we don't have an extension to | 1177 | * Figure out where to start. If we don't have an extension to |
| @@ -1178,7 +1183,7 @@ static int v3_addr_validate_path_internal(X509_STORE_CTX *ctx, | |||
| 1178 | } else { | 1183 | } else { |
| 1179 | i = 0; | 1184 | i = 0; |
| 1180 | x = sk_X509_value(chain, i); | 1185 | x = sk_X509_value(chain, i); |
| 1181 | assert(x != NULL); | 1186 | OPENSSL_assert(x != NULL); |
| 1182 | if ((ext = x->rfc3779_addr) == NULL) | 1187 | if ((ext = x->rfc3779_addr) == NULL) |
| 1183 | goto done; | 1188 | goto done; |
| 1184 | } | 1189 | } |
| @@ -1197,7 +1202,7 @@ static int v3_addr_validate_path_internal(X509_STORE_CTX *ctx, | |||
| 1197 | */ | 1202 | */ |
| 1198 | for (i++; i < sk_X509_num(chain); i++) { | 1203 | for (i++; i < sk_X509_num(chain); i++) { |
| 1199 | x = sk_X509_value(chain, i); | 1204 | x = sk_X509_value(chain, i); |
| 1200 | assert(x != NULL); | 1205 | OPENSSL_assert(x != NULL); |
| 1201 | if (!v3_addr_is_canonical(x->rfc3779_addr)) | 1206 | if (!v3_addr_is_canonical(x->rfc3779_addr)) |
| 1202 | validation_err(X509_V_ERR_INVALID_EXTENSION); | 1207 | validation_err(X509_V_ERR_INVALID_EXTENSION); |
| 1203 | if (x->rfc3779_addr == NULL) { | 1208 | if (x->rfc3779_addr == NULL) { |
diff --git a/src/lib/libssl/src/apps/genpkey.c b/src/lib/libssl/src/apps/genpkey.c new file mode 100644 index 0000000000..6dfda08b9e --- /dev/null +++ b/src/lib/libssl/src/apps/genpkey.c | |||
| @@ -0,0 +1,440 @@ | |||
| 1 | /* apps/genpkey.c */ | ||
| 2 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL | ||
| 3 | * project 2006 | ||
| 4 | */ | ||
| 5 | /* ==================================================================== | ||
| 6 | * Copyright (c) 2006 The OpenSSL Project. All rights reserved. | ||
| 7 | * | ||
| 8 | * Redistribution and use in source and binary forms, with or without | ||
| 9 | * modification, are permitted provided that the following conditions | ||
| 10 | * are met: | ||
| 11 | * | ||
| 12 | * 1. Redistributions of source code must retain the above copyright | ||
| 13 | * notice, this list of conditions and the following disclaimer. | ||
| 14 | * | ||
| 15 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 16 | * notice, this list of conditions and the following disclaimer in | ||
| 17 | * the documentation and/or other materials provided with the | ||
| 18 | * distribution. | ||
| 19 | * | ||
| 20 | * 3. All advertising materials mentioning features or use of this | ||
| 21 | * software must display the following acknowledgment: | ||
| 22 | * "This product includes software developed by the OpenSSL Project | ||
| 23 | * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" | ||
| 24 | * | ||
| 25 | * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to | ||
| 26 | * endorse or promote products derived from this software without | ||
| 27 | * prior written permission. For written permission, please contact | ||
| 28 | * licensing@OpenSSL.org. | ||
| 29 | * | ||
| 30 | * 5. Products derived from this software may not be called "OpenSSL" | ||
| 31 | * nor may "OpenSSL" appear in their names without prior written | ||
| 32 | * permission of the OpenSSL Project. | ||
| 33 | * | ||
| 34 | * 6. Redistributions of any form whatsoever must retain the following | ||
| 35 | * acknowledgment: | ||
| 36 | * "This product includes software developed by the OpenSSL Project | ||
| 37 | * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" | ||
| 38 | * | ||
| 39 | * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY | ||
| 40 | * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 41 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | ||
| 42 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR | ||
| 43 | * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | ||
| 44 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | ||
| 45 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
| 46 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 47 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | ||
| 48 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | ||
| 49 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED | ||
| 50 | * OF THE POSSIBILITY OF SUCH DAMAGE. | ||
| 51 | * ==================================================================== | ||
| 52 | * | ||
| 53 | * This product includes cryptographic software written by Eric Young | ||
| 54 | * (eay@cryptsoft.com). This product includes software written by Tim | ||
| 55 | * Hudson (tjh@cryptsoft.com). | ||
| 56 | * | ||
| 57 | */ | ||
| 58 | #include <stdio.h> | ||
| 59 | #include <string.h> | ||
| 60 | #include "apps.h" | ||
| 61 | #include <openssl/pem.h> | ||
| 62 | #include <openssl/err.h> | ||
| 63 | #include <openssl/evp.h> | ||
| 64 | #ifndef OPENSSL_NO_ENGINE | ||
| 65 | #include <openssl/engine.h> | ||
| 66 | #endif | ||
| 67 | |||
| 68 | static int init_keygen_file(BIO *err, EVP_PKEY_CTX **pctx, | ||
| 69 | const char *file, ENGINE *e); | ||
| 70 | static int genpkey_cb(EVP_PKEY_CTX *ctx); | ||
| 71 | |||
| 72 | #define PROG genpkey_main | ||
| 73 | |||
| 74 | int MAIN(int, char **); | ||
| 75 | |||
| 76 | int MAIN(int argc, char **argv) | ||
| 77 | { | ||
| 78 | ENGINE *e = NULL; | ||
| 79 | char **args, *outfile = NULL; | ||
| 80 | char *passarg = NULL; | ||
| 81 | BIO *in = NULL, *out = NULL; | ||
| 82 | const EVP_CIPHER *cipher = NULL; | ||
| 83 | int outformat; | ||
| 84 | int text = 0; | ||
| 85 | EVP_PKEY *pkey=NULL; | ||
| 86 | EVP_PKEY_CTX *ctx = NULL; | ||
| 87 | char *pass = NULL; | ||
| 88 | int badarg = 0; | ||
| 89 | int ret = 1, rv; | ||
| 90 | |||
| 91 | int do_param = 0; | ||
| 92 | |||
| 93 | if (bio_err == NULL) | ||
| 94 | bio_err = BIO_new_fp (stderr, BIO_NOCLOSE); | ||
| 95 | |||
| 96 | if (!load_config(bio_err, NULL)) | ||
| 97 | goto end; | ||
| 98 | |||
| 99 | outformat=FORMAT_PEM; | ||
| 100 | |||
| 101 | ERR_load_crypto_strings(); | ||
| 102 | OpenSSL_add_all_algorithms(); | ||
| 103 | args = argv + 1; | ||
| 104 | while (!badarg && *args && *args[0] == '-') | ||
| 105 | { | ||
| 106 | if (!strcmp(*args,"-outform")) | ||
| 107 | { | ||
| 108 | if (args[1]) | ||
| 109 | { | ||
| 110 | args++; | ||
| 111 | outformat=str2fmt(*args); | ||
| 112 | } | ||
| 113 | else badarg = 1; | ||
| 114 | } | ||
| 115 | else if (!strcmp(*args,"-pass")) | ||
| 116 | { | ||
| 117 | if (!args[1]) goto bad; | ||
| 118 | passarg= *(++args); | ||
| 119 | } | ||
| 120 | #ifndef OPENSSL_NO_ENGINE | ||
| 121 | else if (strcmp(*args,"-engine") == 0) | ||
| 122 | { | ||
| 123 | if (!args[1]) | ||
| 124 | goto bad; | ||
| 125 | e = setup_engine(bio_err, *(++args), 0); | ||
| 126 | } | ||
| 127 | #endif | ||
| 128 | else if (!strcmp (*args, "-paramfile")) | ||
| 129 | { | ||
| 130 | if (!args[1]) | ||
| 131 | goto bad; | ||
| 132 | args++; | ||
| 133 | if (do_param == 1) | ||
| 134 | goto bad; | ||
| 135 | if (!init_keygen_file(bio_err, &ctx, *args, e)) | ||
| 136 | goto end; | ||
| 137 | } | ||
| 138 | else if (!strcmp (*args, "-out")) | ||
| 139 | { | ||
| 140 | if (args[1]) | ||
| 141 | { | ||
| 142 | args++; | ||
| 143 | outfile = *args; | ||
| 144 | } | ||
| 145 | else badarg = 1; | ||
| 146 | } | ||
| 147 | else if (strcmp(*args,"-algorithm") == 0) | ||
| 148 | { | ||
| 149 | if (!args[1]) | ||
| 150 | goto bad; | ||
| 151 | if (!init_gen_str(bio_err, &ctx, *(++args),e, do_param)) | ||
| 152 | goto end; | ||
| 153 | } | ||
| 154 | else if (strcmp(*args,"-pkeyopt") == 0) | ||
| 155 | { | ||
| 156 | if (!args[1]) | ||
| 157 | goto bad; | ||
| 158 | if (!ctx) | ||
| 159 | { | ||
| 160 | BIO_puts(bio_err, "No keytype specified\n"); | ||
| 161 | goto bad; | ||
| 162 | } | ||
| 163 | else if (pkey_ctrl_string(ctx, *(++args)) <= 0) | ||
| 164 | { | ||
| 165 | BIO_puts(bio_err, "parameter setting error\n"); | ||
| 166 | ERR_print_errors(bio_err); | ||
| 167 | goto end; | ||
| 168 | } | ||
| 169 | } | ||
| 170 | else if (strcmp(*args,"-genparam") == 0) | ||
| 171 | { | ||
| 172 | if (ctx) | ||
| 173 | goto bad; | ||
| 174 | do_param = 1; | ||
| 175 | } | ||
| 176 | else if (strcmp(*args,"-text") == 0) | ||
| 177 | text=1; | ||
| 178 | else | ||
| 179 | { | ||
| 180 | cipher = EVP_get_cipherbyname(*args + 1); | ||
| 181 | if (!cipher) | ||
| 182 | { | ||
| 183 | BIO_printf(bio_err, "Unknown cipher %s\n", | ||
| 184 | *args + 1); | ||
| 185 | badarg = 1; | ||
| 186 | } | ||
| 187 | if (do_param == 1) | ||
| 188 | badarg = 1; | ||
| 189 | } | ||
| 190 | args++; | ||
| 191 | } | ||
| 192 | |||
| 193 | if (!ctx) | ||
| 194 | badarg = 1; | ||
| 195 | |||
| 196 | if (badarg) | ||
| 197 | { | ||
| 198 | bad: | ||
| 199 | BIO_printf(bio_err, "Usage: genpkey [options]\n"); | ||
| 200 | BIO_printf(bio_err, "where options may be\n"); | ||
| 201 | BIO_printf(bio_err, "-out file output file\n"); | ||
| 202 | BIO_printf(bio_err, "-outform X output format (DER or PEM)\n"); | ||
| 203 | BIO_printf(bio_err, "-pass arg output file pass phrase source\n"); | ||
| 204 | BIO_printf(bio_err, "-<cipher> use cipher <cipher> to encrypt the key\n"); | ||
| 205 | #ifndef OPENSSL_NO_ENGINE | ||
| 206 | BIO_printf(bio_err, "-engine e use engine e, possibly a hardware device.\n"); | ||
| 207 | #endif | ||
| 208 | BIO_printf(bio_err, "-paramfile file parameters file\n"); | ||
| 209 | BIO_printf(bio_err, "-algorithm alg the public key algorithm\n"); | ||
| 210 | BIO_printf(bio_err, "-pkeyopt opt:value set the public key algorithm option <opt>\n" | ||
| 211 | " to value <value>\n"); | ||
| 212 | BIO_printf(bio_err, "-genparam generate parameters, not key\n"); | ||
| 213 | BIO_printf(bio_err, "-text print the in text\n"); | ||
| 214 | BIO_printf(bio_err, "NB: options order may be important! See the manual page.\n"); | ||
| 215 | goto end; | ||
| 216 | } | ||
| 217 | |||
| 218 | if (!app_passwd(bio_err, passarg, NULL, &pass, NULL)) | ||
| 219 | { | ||
| 220 | BIO_puts(bio_err, "Error getting password\n"); | ||
| 221 | goto end; | ||
| 222 | } | ||
| 223 | |||
| 224 | if (outfile) | ||
| 225 | { | ||
| 226 | if (!(out = BIO_new_file (outfile, "wb"))) | ||
| 227 | { | ||
| 228 | BIO_printf(bio_err, | ||
| 229 | "Can't open output file %s\n", outfile); | ||
| 230 | goto end; | ||
| 231 | } | ||
| 232 | } | ||
| 233 | else | ||
| 234 | { | ||
| 235 | out = BIO_new_fp (stdout, BIO_NOCLOSE); | ||
| 236 | #ifdef OPENSSL_SYS_VMS | ||
| 237 | { | ||
| 238 | BIO *tmpbio = BIO_new(BIO_f_linebuffer()); | ||
| 239 | out = BIO_push(tmpbio, out); | ||
| 240 | } | ||
| 241 | #endif | ||
| 242 | } | ||
| 243 | |||
| 244 | EVP_PKEY_CTX_set_cb(ctx, genpkey_cb); | ||
| 245 | EVP_PKEY_CTX_set_app_data(ctx, bio_err); | ||
| 246 | |||
| 247 | if (do_param) | ||
| 248 | { | ||
| 249 | if (EVP_PKEY_paramgen(ctx, &pkey) <= 0) | ||
| 250 | { | ||
| 251 | BIO_puts(bio_err, "Error generating parameters\n"); | ||
| 252 | ERR_print_errors(bio_err); | ||
| 253 | goto end; | ||
| 254 | } | ||
| 255 | } | ||
| 256 | else | ||
| 257 | { | ||
| 258 | if (EVP_PKEY_keygen(ctx, &pkey) <= 0) | ||
| 259 | { | ||
| 260 | BIO_puts(bio_err, "Error generating key\n"); | ||
| 261 | ERR_print_errors(bio_err); | ||
| 262 | goto end; | ||
| 263 | } | ||
| 264 | } | ||
| 265 | |||
| 266 | if (do_param) | ||
| 267 | rv = PEM_write_bio_Parameters(out, pkey); | ||
| 268 | else if (outformat == FORMAT_PEM) | ||
| 269 | rv = PEM_write_bio_PrivateKey(out, pkey, cipher, NULL, 0, | ||
| 270 | NULL, pass); | ||
| 271 | else if (outformat == FORMAT_ASN1) | ||
| 272 | rv = i2d_PrivateKey_bio(out, pkey); | ||
| 273 | else | ||
| 274 | { | ||
| 275 | BIO_printf(bio_err, "Bad format specified for key\n"); | ||
| 276 | goto end; | ||
| 277 | } | ||
| 278 | |||
| 279 | if (rv <= 0) | ||
| 280 | { | ||
| 281 | BIO_puts(bio_err, "Error writing key\n"); | ||
| 282 | ERR_print_errors(bio_err); | ||
| 283 | } | ||
| 284 | |||
| 285 | if (text) | ||
| 286 | { | ||
| 287 | if (do_param) | ||
| 288 | rv = EVP_PKEY_print_params(out, pkey, 0, NULL); | ||
| 289 | else | ||
| 290 | rv = EVP_PKEY_print_private(out, pkey, 0, NULL); | ||
| 291 | |||
| 292 | if (rv <= 0) | ||
| 293 | { | ||
| 294 | BIO_puts(bio_err, "Error printing key\n"); | ||
| 295 | ERR_print_errors(bio_err); | ||
| 296 | } | ||
| 297 | } | ||
| 298 | |||
| 299 | ret = 0; | ||
| 300 | |||
| 301 | end: | ||
| 302 | if (pkey) | ||
| 303 | EVP_PKEY_free(pkey); | ||
| 304 | if (ctx) | ||
| 305 | EVP_PKEY_CTX_free(ctx); | ||
| 306 | if (out) | ||
| 307 | BIO_free_all(out); | ||
| 308 | BIO_free(in); | ||
| 309 | if (pass) | ||
| 310 | OPENSSL_free(pass); | ||
| 311 | |||
| 312 | return ret; | ||
| 313 | } | ||
| 314 | |||
| 315 | static int init_keygen_file(BIO *err, EVP_PKEY_CTX **pctx, | ||
| 316 | const char *file, ENGINE *e) | ||
| 317 | { | ||
| 318 | BIO *pbio; | ||
| 319 | EVP_PKEY *pkey = NULL; | ||
| 320 | EVP_PKEY_CTX *ctx = NULL; | ||
| 321 | if (*pctx) | ||
| 322 | { | ||
| 323 | BIO_puts(err, "Parameters already set!\n"); | ||
| 324 | return 0; | ||
| 325 | } | ||
| 326 | |||
| 327 | pbio = BIO_new_file(file, "r"); | ||
| 328 | if (!pbio) | ||
| 329 | { | ||
| 330 | BIO_printf(err, "Can't open parameter file %s\n", file); | ||
| 331 | return 0; | ||
| 332 | } | ||
| 333 | |||
| 334 | pkey = PEM_read_bio_Parameters(pbio, NULL); | ||
| 335 | BIO_free(pbio); | ||
| 336 | |||
| 337 | if (!pkey) | ||
| 338 | { | ||
| 339 | BIO_printf(bio_err, "Error reading parameter file %s\n", file); | ||
| 340 | return 0; | ||
| 341 | } | ||
| 342 | |||
| 343 | ctx = EVP_PKEY_CTX_new(pkey, e); | ||
| 344 | if (!ctx) | ||
| 345 | goto err; | ||
| 346 | if (EVP_PKEY_keygen_init(ctx) <= 0) | ||
| 347 | goto err; | ||
| 348 | EVP_PKEY_free(pkey); | ||
| 349 | *pctx = ctx; | ||
| 350 | return 1; | ||
| 351 | |||
| 352 | err: | ||
| 353 | BIO_puts(err, "Error initializing context\n"); | ||
| 354 | ERR_print_errors(err); | ||
| 355 | if (ctx) | ||
| 356 | EVP_PKEY_CTX_free(ctx); | ||
| 357 | if (pkey) | ||
| 358 | EVP_PKEY_free(pkey); | ||
| 359 | return 0; | ||
| 360 | |||
| 361 | } | ||
| 362 | |||
| 363 | int init_gen_str(BIO *err, EVP_PKEY_CTX **pctx, | ||
| 364 | const char *algname, ENGINE *e, int do_param) | ||
| 365 | { | ||
| 366 | EVP_PKEY_CTX *ctx = NULL; | ||
| 367 | const EVP_PKEY_ASN1_METHOD *ameth; | ||
| 368 | ENGINE *tmpeng = NULL; | ||
| 369 | int pkey_id; | ||
| 370 | |||
| 371 | if (*pctx) | ||
| 372 | { | ||
| 373 | BIO_puts(err, "Algorithm already set!\n"); | ||
| 374 | return 0; | ||
| 375 | } | ||
| 376 | |||
| 377 | ameth = EVP_PKEY_asn1_find_str(&tmpeng, algname, -1); | ||
| 378 | |||
| 379 | #ifndef OPENSSL_NO_ENGINE | ||
| 380 | if (!ameth && e) | ||
| 381 | ameth = ENGINE_get_pkey_asn1_meth_str(e, algname, -1); | ||
| 382 | #endif | ||
| 383 | |||
| 384 | if (!ameth) | ||
| 385 | { | ||
| 386 | BIO_printf(bio_err, "Algorithm %s not found\n", algname); | ||
| 387 | return 0; | ||
| 388 | } | ||
| 389 | |||
| 390 | ERR_clear_error(); | ||
| 391 | |||
| 392 | EVP_PKEY_asn1_get0_info(&pkey_id, NULL, NULL, NULL, NULL, ameth); | ||
| 393 | #ifndef OPENSSL_NO_ENGINE | ||
| 394 | if (tmpeng) | ||
| 395 | ENGINE_finish(tmpeng); | ||
| 396 | #endif | ||
| 397 | ctx = EVP_PKEY_CTX_new_id(pkey_id, e); | ||
| 398 | |||
| 399 | if (!ctx) | ||
| 400 | goto err; | ||
| 401 | if (do_param) | ||
| 402 | { | ||
| 403 | if (EVP_PKEY_paramgen_init(ctx) <= 0) | ||
| 404 | goto err; | ||
| 405 | } | ||
| 406 | else | ||
| 407 | { | ||
| 408 | if (EVP_PKEY_keygen_init(ctx) <= 0) | ||
| 409 | goto err; | ||
| 410 | } | ||
| 411 | |||
| 412 | *pctx = ctx; | ||
| 413 | return 1; | ||
| 414 | |||
| 415 | err: | ||
| 416 | BIO_printf(err, "Error initializing %s context\n", algname); | ||
| 417 | ERR_print_errors(err); | ||
| 418 | if (ctx) | ||
| 419 | EVP_PKEY_CTX_free(ctx); | ||
| 420 | return 0; | ||
| 421 | |||
| 422 | } | ||
| 423 | |||
| 424 | static int genpkey_cb(EVP_PKEY_CTX *ctx) | ||
| 425 | { | ||
| 426 | char c='*'; | ||
| 427 | BIO *b = EVP_PKEY_CTX_get_app_data(ctx); | ||
| 428 | int p; | ||
| 429 | p = EVP_PKEY_CTX_get_keygen_info(ctx, 0); | ||
| 430 | if (p == 0) c='.'; | ||
| 431 | if (p == 1) c='+'; | ||
| 432 | if (p == 2) c='*'; | ||
| 433 | if (p == 3) c='\n'; | ||
| 434 | BIO_write(b,&c,1); | ||
| 435 | (void)BIO_flush(b); | ||
| 436 | #ifdef LINT | ||
| 437 | p=n; | ||
| 438 | #endif | ||
| 439 | return 1; | ||
| 440 | } | ||
diff --git a/src/lib/libssl/src/apps/pkey.c b/src/lib/libssl/src/apps/pkey.c new file mode 100644 index 0000000000..17e6702fb1 --- /dev/null +++ b/src/lib/libssl/src/apps/pkey.c | |||
| @@ -0,0 +1,284 @@ | |||
| 1 | /* apps/pkey.c */ | ||
| 2 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL | ||
| 3 | * project 2006 | ||
| 4 | */ | ||
| 5 | /* ==================================================================== | ||
| 6 | * Copyright (c) 2006 The OpenSSL Project. All rights reserved. | ||
| 7 | * | ||
| 8 | * Redistribution and use in source and binary forms, with or without | ||
| 9 | * modification, are permitted provided that the following conditions | ||
| 10 | * are met: | ||
| 11 | * | ||
| 12 | * 1. Redistributions of source code must retain the above copyright | ||
| 13 | * notice, this list of conditions and the following disclaimer. | ||
| 14 | * | ||
| 15 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 16 | * notice, this list of conditions and the following disclaimer in | ||
| 17 | * the documentation and/or other materials provided with the | ||
| 18 | * distribution. | ||
| 19 | * | ||
| 20 | * 3. All advertising materials mentioning features or use of this | ||
| 21 | * software must display the following acknowledgment: | ||
| 22 | * "This product includes software developed by the OpenSSL Project | ||
| 23 | * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" | ||
| 24 | * | ||
| 25 | * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to | ||
| 26 | * endorse or promote products derived from this software without | ||
| 27 | * prior written permission. For written permission, please contact | ||
| 28 | * licensing@OpenSSL.org. | ||
| 29 | * | ||
| 30 | * 5. Products derived from this software may not be called "OpenSSL" | ||
| 31 | * nor may "OpenSSL" appear in their names without prior written | ||
| 32 | * permission of the OpenSSL Project. | ||
| 33 | * | ||
| 34 | * 6. Redistributions of any form whatsoever must retain the following | ||
| 35 | * acknowledgment: | ||
| 36 | * "This product includes software developed by the OpenSSL Project | ||
| 37 | * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" | ||
| 38 | * | ||
| 39 | * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY | ||
| 40 | * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 41 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | ||
| 42 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR | ||
| 43 | * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | ||
| 44 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | ||
| 45 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
| 46 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 47 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | ||
| 48 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | ||
| 49 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED | ||
| 50 | * OF THE POSSIBILITY OF SUCH DAMAGE. | ||
| 51 | * ==================================================================== | ||
| 52 | * | ||
| 53 | * This product includes cryptographic software written by Eric Young | ||
| 54 | * (eay@cryptsoft.com). This product includes software written by Tim | ||
| 55 | * Hudson (tjh@cryptsoft.com). | ||
| 56 | * | ||
| 57 | */ | ||
| 58 | #include <stdio.h> | ||
| 59 | #include <string.h> | ||
| 60 | #include "apps.h" | ||
| 61 | #include <openssl/pem.h> | ||
| 62 | #include <openssl/err.h> | ||
| 63 | #include <openssl/evp.h> | ||
| 64 | |||
| 65 | #define PROG pkey_main | ||
| 66 | |||
| 67 | int MAIN(int, char **); | ||
| 68 | |||
| 69 | int MAIN(int argc, char **argv) | ||
| 70 | { | ||
| 71 | ENGINE *e = NULL; | ||
| 72 | char **args, *infile = NULL, *outfile = NULL; | ||
| 73 | char *passargin = NULL, *passargout = NULL; | ||
| 74 | BIO *in = NULL, *out = NULL; | ||
| 75 | const EVP_CIPHER *cipher = NULL; | ||
| 76 | int informat, outformat; | ||
| 77 | int pubin = 0, pubout = 0, pubtext = 0, text = 0, noout = 0; | ||
| 78 | EVP_PKEY *pkey=NULL; | ||
| 79 | char *passin = NULL, *passout = NULL; | ||
| 80 | int badarg = 0; | ||
| 81 | #ifndef OPENSSL_NO_ENGINE | ||
| 82 | char *engine=NULL; | ||
| 83 | #endif | ||
| 84 | int ret = 1; | ||
| 85 | |||
| 86 | if (bio_err == NULL) | ||
| 87 | bio_err = BIO_new_fp (stderr, BIO_NOCLOSE); | ||
| 88 | |||
| 89 | if (!load_config(bio_err, NULL)) | ||
| 90 | goto end; | ||
| 91 | |||
| 92 | informat=FORMAT_PEM; | ||
| 93 | outformat=FORMAT_PEM; | ||
| 94 | |||
| 95 | ERR_load_crypto_strings(); | ||
| 96 | OpenSSL_add_all_algorithms(); | ||
| 97 | args = argv + 1; | ||
| 98 | while (!badarg && *args && *args[0] == '-') | ||
| 99 | { | ||
| 100 | if (!strcmp(*args,"-inform")) | ||
| 101 | { | ||
| 102 | if (args[1]) | ||
| 103 | { | ||
| 104 | args++; | ||
| 105 | informat=str2fmt(*args); | ||
| 106 | } | ||
| 107 | else badarg = 1; | ||
| 108 | } | ||
| 109 | else if (!strcmp(*args,"-outform")) | ||
| 110 | { | ||
| 111 | if (args[1]) | ||
| 112 | { | ||
| 113 | args++; | ||
| 114 | outformat=str2fmt(*args); | ||
| 115 | } | ||
| 116 | else badarg = 1; | ||
| 117 | } | ||
| 118 | else if (!strcmp(*args,"-passin")) | ||
| 119 | { | ||
| 120 | if (!args[1]) goto bad; | ||
| 121 | passargin= *(++args); | ||
| 122 | } | ||
| 123 | else if (!strcmp(*args,"-passout")) | ||
| 124 | { | ||
| 125 | if (!args[1]) goto bad; | ||
| 126 | passargout= *(++args); | ||
| 127 | } | ||
| 128 | #ifndef OPENSSL_NO_ENGINE | ||
| 129 | else if (strcmp(*args,"-engine") == 0) | ||
| 130 | { | ||
| 131 | if (!args[1]) goto bad; | ||
| 132 | engine= *(++args); | ||
| 133 | } | ||
| 134 | #endif | ||
| 135 | else if (!strcmp (*args, "-in")) | ||
| 136 | { | ||
| 137 | if (args[1]) | ||
| 138 | { | ||
| 139 | args++; | ||
| 140 | infile = *args; | ||
| 141 | } | ||
| 142 | else badarg = 1; | ||
| 143 | } | ||
| 144 | else if (!strcmp (*args, "-out")) | ||
| 145 | { | ||
| 146 | if (args[1]) | ||
| 147 | { | ||
| 148 | args++; | ||
| 149 | outfile = *args; | ||
| 150 | } | ||
| 151 | else badarg = 1; | ||
| 152 | } | ||
| 153 | else if (strcmp(*args,"-pubin") == 0) | ||
| 154 | { | ||
| 155 | pubin=1; | ||
| 156 | pubout=1; | ||
| 157 | pubtext=1; | ||
| 158 | } | ||
| 159 | else if (strcmp(*args,"-pubout") == 0) | ||
| 160 | pubout=1; | ||
| 161 | else if (strcmp(*args,"-text_pub") == 0) | ||
| 162 | { | ||
| 163 | pubtext=1; | ||
| 164 | text=1; | ||
| 165 | } | ||
| 166 | else if (strcmp(*args,"-text") == 0) | ||
| 167 | text=1; | ||
| 168 | else if (strcmp(*args,"-noout") == 0) | ||
| 169 | noout=1; | ||
| 170 | else | ||
| 171 | { | ||
| 172 | cipher = EVP_get_cipherbyname(*args + 1); | ||
| 173 | if (!cipher) | ||
| 174 | { | ||
| 175 | BIO_printf(bio_err, "Unknown cipher %s\n", | ||
| 176 | *args + 1); | ||
| 177 | badarg = 1; | ||
| 178 | } | ||
| 179 | } | ||
| 180 | args++; | ||
| 181 | } | ||
| 182 | |||
| 183 | if (badarg) | ||
| 184 | { | ||
| 185 | bad: | ||
| 186 | BIO_printf(bio_err, "Usage pkey [options]\n"); | ||
| 187 | BIO_printf(bio_err, "where options are\n"); | ||
| 188 | BIO_printf(bio_err, "-in file input file\n"); | ||
| 189 | BIO_printf(bio_err, "-inform X input format (DER or PEM)\n"); | ||
| 190 | BIO_printf(bio_err, "-passin arg input file pass phrase source\n"); | ||
| 191 | BIO_printf(bio_err, "-outform X output format (DER or PEM)\n"); | ||
| 192 | BIO_printf(bio_err, "-out file output file\n"); | ||
| 193 | BIO_printf(bio_err, "-passout arg output file pass phrase source\n"); | ||
| 194 | #ifndef OPENSSL_NO_ENGINE | ||
| 195 | BIO_printf(bio_err, "-engine e use engine e, possibly a hardware device.\n"); | ||
| 196 | #endif | ||
| 197 | return 1; | ||
| 198 | } | ||
| 199 | |||
| 200 | #ifndef OPENSSL_NO_ENGINE | ||
| 201 | e = setup_engine(bio_err, engine, 0); | ||
| 202 | #endif | ||
| 203 | |||
| 204 | if (!app_passwd(bio_err, passargin, passargout, &passin, &passout)) | ||
| 205 | { | ||
| 206 | BIO_printf(bio_err, "Error getting passwords\n"); | ||
| 207 | goto end; | ||
| 208 | } | ||
| 209 | |||
| 210 | if (outfile) | ||
| 211 | { | ||
| 212 | if (!(out = BIO_new_file (outfile, "wb"))) | ||
| 213 | { | ||
| 214 | BIO_printf(bio_err, | ||
| 215 | "Can't open output file %s\n", outfile); | ||
| 216 | goto end; | ||
| 217 | } | ||
| 218 | } | ||
| 219 | else | ||
| 220 | { | ||
| 221 | out = BIO_new_fp (stdout, BIO_NOCLOSE); | ||
| 222 | #ifdef OPENSSL_SYS_VMS | ||
| 223 | { | ||
| 224 | BIO *tmpbio = BIO_new(BIO_f_linebuffer()); | ||
| 225 | out = BIO_push(tmpbio, out); | ||
| 226 | } | ||
| 227 | #endif | ||
| 228 | } | ||
| 229 | |||
| 230 | if (pubin) | ||
| 231 | pkey = load_pubkey(bio_err, infile, informat, 1, | ||
| 232 | passin, e, "Public Key"); | ||
| 233 | else | ||
| 234 | pkey = load_key(bio_err, infile, informat, 1, | ||
| 235 | passin, e, "key"); | ||
| 236 | if (!pkey) | ||
| 237 | goto end; | ||
| 238 | |||
| 239 | if (!noout) | ||
| 240 | { | ||
| 241 | if (outformat == FORMAT_PEM) | ||
| 242 | { | ||
| 243 | if (pubout) | ||
| 244 | PEM_write_bio_PUBKEY(out,pkey); | ||
| 245 | else | ||
| 246 | PEM_write_bio_PrivateKey(out, pkey, cipher, | ||
| 247 | NULL, 0, NULL, passout); | ||
| 248 | } | ||
| 249 | else if (outformat == FORMAT_ASN1) | ||
| 250 | { | ||
| 251 | if (pubout) | ||
| 252 | i2d_PUBKEY_bio(out, pkey); | ||
| 253 | else | ||
| 254 | i2d_PrivateKey_bio(out, pkey); | ||
| 255 | } | ||
| 256 | else | ||
| 257 | { | ||
| 258 | BIO_printf(bio_err, "Bad format specified for key\n"); | ||
| 259 | goto end; | ||
| 260 | } | ||
| 261 | |||
| 262 | } | ||
| 263 | |||
| 264 | if (text) | ||
| 265 | { | ||
| 266 | if (pubtext) | ||
| 267 | EVP_PKEY_print_public(out, pkey, 0, NULL); | ||
| 268 | else | ||
| 269 | EVP_PKEY_print_private(out, pkey, 0, NULL); | ||
| 270 | } | ||
| 271 | |||
| 272 | ret = 0; | ||
| 273 | |||
| 274 | end: | ||
| 275 | EVP_PKEY_free(pkey); | ||
| 276 | BIO_free_all(out); | ||
| 277 | BIO_free(in); | ||
| 278 | if (passin) | ||
| 279 | OPENSSL_free(passin); | ||
| 280 | if (passout) | ||
| 281 | OPENSSL_free(passout); | ||
| 282 | |||
| 283 | return ret; | ||
| 284 | } | ||
diff --git a/src/lib/libssl/src/apps/pkeyparam.c b/src/lib/libssl/src/apps/pkeyparam.c new file mode 100644 index 0000000000..4319eb4de5 --- /dev/null +++ b/src/lib/libssl/src/apps/pkeyparam.c | |||
| @@ -0,0 +1,201 @@ | |||
| 1 | /* apps/pkeyparam.c */ | ||
| 2 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL | ||
| 3 | * project 2006 | ||
| 4 | */ | ||
| 5 | /* ==================================================================== | ||
| 6 | * Copyright (c) 2006 The OpenSSL Project. All rights reserved. | ||
| 7 | * | ||
| 8 | * Redistribution and use in source and binary forms, with or without | ||
| 9 | * modification, are permitted provided that the following conditions | ||
| 10 | * are met: | ||
| 11 | * | ||
| 12 | * 1. Redistributions of source code must retain the above copyright | ||
| 13 | * notice, this list of conditions and the following disclaimer. | ||
| 14 | * | ||
| 15 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 16 | * notice, this list of conditions and the following disclaimer in | ||
| 17 | * the documentation and/or other materials provided with the | ||
| 18 | * distribution. | ||
| 19 | * | ||
| 20 | * 3. All advertising materials mentioning features or use of this | ||
| 21 | * software must display the following acknowledgment: | ||
| 22 | * "This product includes software developed by the OpenSSL Project | ||
| 23 | * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" | ||
| 24 | * | ||
| 25 | * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to | ||
| 26 | * endorse or promote products derived from this software without | ||
| 27 | * prior written permission. For written permission, please contact | ||
| 28 | * licensing@OpenSSL.org. | ||
| 29 | * | ||
| 30 | * 5. Products derived from this software may not be called "OpenSSL" | ||
| 31 | * nor may "OpenSSL" appear in their names without prior written | ||
| 32 | * permission of the OpenSSL Project. | ||
| 33 | * | ||
| 34 | * 6. Redistributions of any form whatsoever must retain the following | ||
| 35 | * acknowledgment: | ||
| 36 | * "This product includes software developed by the OpenSSL Project | ||
| 37 | * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" | ||
| 38 | * | ||
| 39 | * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY | ||
| 40 | * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 41 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | ||
| 42 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR | ||
| 43 | * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | ||
| 44 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | ||
| 45 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
| 46 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 47 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | ||
| 48 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | ||
| 49 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED | ||
| 50 | * OF THE POSSIBILITY OF SUCH DAMAGE. | ||
| 51 | * ==================================================================== | ||
| 52 | * | ||
| 53 | * This product includes cryptographic software written by Eric Young | ||
| 54 | * (eay@cryptsoft.com). This product includes software written by Tim | ||
| 55 | * Hudson (tjh@cryptsoft.com). | ||
| 56 | * | ||
| 57 | */ | ||
| 58 | #include <stdio.h> | ||
| 59 | #include <string.h> | ||
| 60 | #include "apps.h" | ||
| 61 | #include <openssl/pem.h> | ||
| 62 | #include <openssl/err.h> | ||
| 63 | #include <openssl/evp.h> | ||
| 64 | |||
| 65 | #define PROG pkeyparam_main | ||
| 66 | |||
| 67 | int MAIN(int, char **); | ||
| 68 | |||
| 69 | int MAIN(int argc, char **argv) | ||
| 70 | { | ||
| 71 | char **args, *infile = NULL, *outfile = NULL; | ||
| 72 | BIO *in = NULL, *out = NULL; | ||
| 73 | int text = 0, noout = 0; | ||
| 74 | EVP_PKEY *pkey=NULL; | ||
| 75 | int badarg = 0; | ||
| 76 | #ifndef OPENSSL_NO_ENGINE | ||
| 77 | ENGINE *e = NULL; | ||
| 78 | char *engine=NULL; | ||
| 79 | #endif | ||
| 80 | int ret = 1; | ||
| 81 | |||
| 82 | if (bio_err == NULL) | ||
| 83 | bio_err = BIO_new_fp (stderr, BIO_NOCLOSE); | ||
| 84 | |||
| 85 | if (!load_config(bio_err, NULL)) | ||
| 86 | goto end; | ||
| 87 | |||
| 88 | ERR_load_crypto_strings(); | ||
| 89 | OpenSSL_add_all_algorithms(); | ||
| 90 | args = argv + 1; | ||
| 91 | while (!badarg && *args && *args[0] == '-') | ||
| 92 | { | ||
| 93 | if (!strcmp (*args, "-in")) | ||
| 94 | { | ||
| 95 | if (args[1]) | ||
| 96 | { | ||
| 97 | args++; | ||
| 98 | infile = *args; | ||
| 99 | } | ||
| 100 | else badarg = 1; | ||
| 101 | } | ||
| 102 | else if (!strcmp (*args, "-out")) | ||
| 103 | { | ||
| 104 | if (args[1]) | ||
| 105 | { | ||
| 106 | args++; | ||
| 107 | outfile = *args; | ||
| 108 | } | ||
| 109 | else badarg = 1; | ||
| 110 | } | ||
| 111 | #ifndef OPENSSL_NO_ENGINE | ||
| 112 | else if (strcmp(*args,"-engine") == 0) | ||
| 113 | { | ||
| 114 | if (!args[1]) goto bad; | ||
| 115 | engine= *(++args); | ||
| 116 | } | ||
| 117 | #endif | ||
| 118 | |||
| 119 | else if (strcmp(*args,"-text") == 0) | ||
| 120 | text=1; | ||
| 121 | else if (strcmp(*args,"-noout") == 0) | ||
| 122 | noout=1; | ||
| 123 | args++; | ||
| 124 | } | ||
| 125 | |||
| 126 | if (badarg) | ||
| 127 | { | ||
| 128 | #ifndef OPENSSL_NO_ENGINE | ||
| 129 | bad: | ||
| 130 | #endif | ||
| 131 | BIO_printf(bio_err, "Usage pkeyparam [options]\n"); | ||
| 132 | BIO_printf(bio_err, "where options are\n"); | ||
| 133 | BIO_printf(bio_err, "-in file input file\n"); | ||
| 134 | BIO_printf(bio_err, "-out file output file\n"); | ||
| 135 | BIO_printf(bio_err, "-text print parameters as text\n"); | ||
| 136 | BIO_printf(bio_err, "-noout don't output encoded parameters\n"); | ||
| 137 | #ifndef OPENSSL_NO_ENGINE | ||
| 138 | BIO_printf(bio_err, "-engine e use engine e, possibly a hardware device.\n"); | ||
| 139 | #endif | ||
| 140 | return 1; | ||
| 141 | } | ||
| 142 | |||
| 143 | #ifndef OPENSSL_NO_ENGINE | ||
| 144 | e = setup_engine(bio_err, engine, 0); | ||
| 145 | #endif | ||
| 146 | |||
| 147 | if (infile) | ||
| 148 | { | ||
| 149 | if (!(in = BIO_new_file (infile, "r"))) | ||
| 150 | { | ||
| 151 | BIO_printf(bio_err, | ||
| 152 | "Can't open input file %s\n", infile); | ||
| 153 | goto end; | ||
| 154 | } | ||
| 155 | } | ||
| 156 | else | ||
| 157 | in = BIO_new_fp (stdin, BIO_NOCLOSE); | ||
| 158 | |||
| 159 | if (outfile) | ||
| 160 | { | ||
| 161 | if (!(out = BIO_new_file (outfile, "w"))) | ||
| 162 | { | ||
| 163 | BIO_printf(bio_err, | ||
| 164 | "Can't open output file %s\n", outfile); | ||
| 165 | goto end; | ||
| 166 | } | ||
| 167 | } | ||
| 168 | else | ||
| 169 | { | ||
| 170 | out = BIO_new_fp (stdout, BIO_NOCLOSE); | ||
| 171 | #ifdef OPENSSL_SYS_VMS | ||
| 172 | { | ||
| 173 | BIO *tmpbio = BIO_new(BIO_f_linebuffer()); | ||
| 174 | out = BIO_push(tmpbio, out); | ||
| 175 | } | ||
| 176 | #endif | ||
| 177 | } | ||
| 178 | |||
| 179 | pkey = PEM_read_bio_Parameters(in, NULL); | ||
| 180 | if (!pkey) | ||
| 181 | { | ||
| 182 | BIO_printf(bio_err, "Error reading paramters\n"); | ||
| 183 | ERR_print_errors(bio_err); | ||
| 184 | goto end; | ||
| 185 | } | ||
| 186 | |||
| 187 | if (!noout) | ||
| 188 | PEM_write_bio_Parameters(out,pkey); | ||
| 189 | |||
| 190 | if (text) | ||
| 191 | EVP_PKEY_print_params(out, pkey, 0, NULL); | ||
| 192 | |||
| 193 | ret = 0; | ||
| 194 | |||
| 195 | end: | ||
| 196 | EVP_PKEY_free(pkey); | ||
| 197 | BIO_free_all(out); | ||
| 198 | BIO_free(in); | ||
| 199 | |||
| 200 | return ret; | ||
| 201 | } | ||
diff --git a/src/lib/libssl/src/apps/pkeyutl.c b/src/lib/libssl/src/apps/pkeyutl.c new file mode 100644 index 0000000000..b808e1ef49 --- /dev/null +++ b/src/lib/libssl/src/apps/pkeyutl.c | |||
| @@ -0,0 +1,570 @@ | |||
| 1 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL | ||
| 2 | * project 2006. | ||
| 3 | */ | ||
| 4 | /* ==================================================================== | ||
| 5 | * Copyright (c) 2006 The OpenSSL Project. All rights reserved. | ||
| 6 | * | ||
| 7 | * Redistribution and use in source and binary forms, with or without | ||
| 8 | * modification, are permitted provided that the following conditions | ||
| 9 | * are met: | ||
| 10 | * | ||
| 11 | * 1. Redistributions of source code must retain the above copyright | ||
| 12 | * notice, this list of conditions and the following disclaimer. | ||
| 13 | * | ||
| 14 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 15 | * notice, this list of conditions and the following disclaimer in | ||
| 16 | * the documentation and/or other materials provided with the | ||
| 17 | * distribution. | ||
| 18 | * | ||
| 19 | * 3. All advertising materials mentioning features or use of this | ||
| 20 | * software must display the following acknowledgment: | ||
| 21 | * "This product includes software developed by the OpenSSL Project | ||
| 22 | * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" | ||
| 23 | * | ||
| 24 | * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to | ||
| 25 | * endorse or promote products derived from this software without | ||
| 26 | * prior written permission. For written permission, please contact | ||
| 27 | * licensing@OpenSSL.org. | ||
| 28 | * | ||
| 29 | * 5. Products derived from this software may not be called "OpenSSL" | ||
| 30 | * nor may "OpenSSL" appear in their names without prior written | ||
| 31 | * permission of the OpenSSL Project. | ||
| 32 | * | ||
| 33 | * 6. Redistributions of any form whatsoever must retain the following | ||
| 34 | * acknowledgment: | ||
| 35 | * "This product includes software developed by the OpenSSL Project | ||
| 36 | * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" | ||
| 37 | * | ||
| 38 | * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY | ||
| 39 | * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 40 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | ||
| 41 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR | ||
| 42 | * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | ||
| 43 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | ||
| 44 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
| 45 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 46 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | ||
| 47 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | ||
| 48 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED | ||
| 49 | * OF THE POSSIBILITY OF SUCH DAMAGE. | ||
| 50 | * ==================================================================== | ||
| 51 | * | ||
| 52 | * This product includes cryptographic software written by Eric Young | ||
| 53 | * (eay@cryptsoft.com). This product includes software written by Tim | ||
| 54 | * Hudson (tjh@cryptsoft.com). | ||
| 55 | * | ||
| 56 | */ | ||
| 57 | |||
| 58 | |||
| 59 | #include "apps.h" | ||
| 60 | #include <string.h> | ||
| 61 | #include <openssl/err.h> | ||
| 62 | #include <openssl/pem.h> | ||
| 63 | #include <openssl/evp.h> | ||
| 64 | |||
| 65 | #define KEY_PRIVKEY 1 | ||
| 66 | #define KEY_PUBKEY 2 | ||
| 67 | #define KEY_CERT 3 | ||
| 68 | |||
| 69 | static void usage(void); | ||
| 70 | |||
| 71 | #undef PROG | ||
| 72 | |||
| 73 | #define PROG pkeyutl_main | ||
| 74 | |||
| 75 | static EVP_PKEY_CTX *init_ctx(int *pkeysize, | ||
| 76 | char *keyfile, int keyform, int key_type, | ||
| 77 | char *passargin, int pkey_op, ENGINE *e); | ||
| 78 | |||
| 79 | static int setup_peer(BIO *err, EVP_PKEY_CTX *ctx, int peerform, | ||
| 80 | const char *file); | ||
| 81 | |||
| 82 | static int do_keyop(EVP_PKEY_CTX *ctx, int pkey_op, | ||
| 83 | unsigned char *out, size_t *poutlen, | ||
| 84 | unsigned char *in, size_t inlen); | ||
| 85 | |||
| 86 | int MAIN(int argc, char **); | ||
| 87 | |||
| 88 | int MAIN(int argc, char **argv) | ||
| 89 | { | ||
| 90 | BIO *in = NULL, *out = NULL; | ||
| 91 | char *infile = NULL, *outfile = NULL, *sigfile = NULL; | ||
| 92 | ENGINE *e = NULL; | ||
| 93 | int pkey_op = EVP_PKEY_OP_SIGN, key_type = KEY_PRIVKEY; | ||
| 94 | int keyform = FORMAT_PEM, peerform = FORMAT_PEM; | ||
| 95 | char badarg = 0, rev = 0; | ||
| 96 | char hexdump = 0, asn1parse = 0; | ||
| 97 | EVP_PKEY_CTX *ctx = NULL; | ||
| 98 | char *passargin = NULL; | ||
| 99 | int keysize = -1; | ||
| 100 | |||
| 101 | unsigned char *buf_in = NULL, *buf_out = NULL, *sig = NULL; | ||
| 102 | size_t buf_outlen; | ||
| 103 | int buf_inlen = 0, siglen = -1; | ||
| 104 | |||
| 105 | int ret = 1, rv = -1; | ||
| 106 | |||
| 107 | argc--; | ||
| 108 | argv++; | ||
| 109 | |||
| 110 | if(!bio_err) bio_err = BIO_new_fp(stderr, BIO_NOCLOSE); | ||
| 111 | |||
| 112 | if (!load_config(bio_err, NULL)) | ||
| 113 | goto end; | ||
| 114 | ERR_load_crypto_strings(); | ||
| 115 | OpenSSL_add_all_algorithms(); | ||
| 116 | |||
| 117 | while(argc >= 1) | ||
| 118 | { | ||
| 119 | if (!strcmp(*argv,"-in")) | ||
| 120 | { | ||
| 121 | if (--argc < 1) badarg = 1; | ||
| 122 | infile= *(++argv); | ||
| 123 | } | ||
| 124 | else if (!strcmp(*argv,"-out")) | ||
| 125 | { | ||
| 126 | if (--argc < 1) badarg = 1; | ||
| 127 | outfile= *(++argv); | ||
| 128 | } | ||
| 129 | else if (!strcmp(*argv,"-sigfile")) | ||
| 130 | { | ||
| 131 | if (--argc < 1) badarg = 1; | ||
| 132 | sigfile= *(++argv); | ||
| 133 | } | ||
| 134 | else if(!strcmp(*argv, "-inkey")) | ||
| 135 | { | ||
| 136 | if (--argc < 1) | ||
| 137 | badarg = 1; | ||
| 138 | else | ||
| 139 | { | ||
| 140 | ctx = init_ctx(&keysize, | ||
| 141 | *(++argv), keyform, key_type, | ||
| 142 | passargin, pkey_op, e); | ||
| 143 | if (!ctx) | ||
| 144 | { | ||
| 145 | BIO_puts(bio_err, | ||
| 146 | "Error initializing context\n"); | ||
| 147 | ERR_print_errors(bio_err); | ||
| 148 | badarg = 1; | ||
| 149 | } | ||
| 150 | } | ||
| 151 | } | ||
| 152 | else if (!strcmp(*argv,"-peerkey")) | ||
| 153 | { | ||
| 154 | if (--argc < 1) | ||
| 155 | badarg = 1; | ||
| 156 | else if (!setup_peer(bio_err, ctx, peerform, *(++argv))) | ||
| 157 | badarg = 1; | ||
| 158 | } | ||
| 159 | else if (!strcmp(*argv,"-passin")) | ||
| 160 | { | ||
| 161 | if (--argc < 1) badarg = 1; | ||
| 162 | passargin= *(++argv); | ||
| 163 | } | ||
| 164 | else if (strcmp(*argv,"-peerform") == 0) | ||
| 165 | { | ||
| 166 | if (--argc < 1) badarg = 1; | ||
| 167 | peerform=str2fmt(*(++argv)); | ||
| 168 | } | ||
| 169 | else if (strcmp(*argv,"-keyform") == 0) | ||
| 170 | { | ||
| 171 | if (--argc < 1) badarg = 1; | ||
| 172 | keyform=str2fmt(*(++argv)); | ||
| 173 | } | ||
| 174 | #ifndef OPENSSL_NO_ENGINE | ||
| 175 | else if(!strcmp(*argv, "-engine")) | ||
| 176 | { | ||
| 177 | if (--argc < 1) | ||
| 178 | badarg = 1; | ||
| 179 | else | ||
| 180 | e = setup_engine(bio_err, *(++argv), 0); | ||
| 181 | } | ||
| 182 | #endif | ||
| 183 | else if(!strcmp(*argv, "-pubin")) | ||
| 184 | key_type = KEY_PUBKEY; | ||
| 185 | else if(!strcmp(*argv, "-certin")) | ||
| 186 | key_type = KEY_CERT; | ||
| 187 | else if(!strcmp(*argv, "-asn1parse")) | ||
| 188 | asn1parse = 1; | ||
| 189 | else if(!strcmp(*argv, "-hexdump")) | ||
| 190 | hexdump = 1; | ||
| 191 | else if(!strcmp(*argv, "-sign")) | ||
| 192 | pkey_op = EVP_PKEY_OP_SIGN; | ||
| 193 | else if(!strcmp(*argv, "-verify")) | ||
| 194 | pkey_op = EVP_PKEY_OP_VERIFY; | ||
| 195 | else if(!strcmp(*argv, "-verifyrecover")) | ||
| 196 | pkey_op = EVP_PKEY_OP_VERIFYRECOVER; | ||
| 197 | else if(!strcmp(*argv, "-rev")) | ||
| 198 | rev = 1; | ||
| 199 | else if(!strcmp(*argv, "-encrypt")) | ||
| 200 | pkey_op = EVP_PKEY_OP_ENCRYPT; | ||
| 201 | else if(!strcmp(*argv, "-decrypt")) | ||
| 202 | pkey_op = EVP_PKEY_OP_DECRYPT; | ||
| 203 | else if(!strcmp(*argv, "-derive")) | ||
| 204 | pkey_op = EVP_PKEY_OP_DERIVE; | ||
| 205 | else if (strcmp(*argv,"-pkeyopt") == 0) | ||
| 206 | { | ||
| 207 | if (--argc < 1) | ||
| 208 | badarg = 1; | ||
| 209 | else if (!ctx) | ||
| 210 | { | ||
| 211 | BIO_puts(bio_err, | ||
| 212 | "-pkeyopt command before -inkey\n"); | ||
| 213 | badarg = 1; | ||
| 214 | } | ||
| 215 | else if (pkey_ctrl_string(ctx, *(++argv)) <= 0) | ||
| 216 | { | ||
| 217 | BIO_puts(bio_err, "parameter setting error\n"); | ||
| 218 | ERR_print_errors(bio_err); | ||
| 219 | goto end; | ||
| 220 | } | ||
| 221 | } | ||
| 222 | else badarg = 1; | ||
| 223 | if(badarg) | ||
| 224 | { | ||
| 225 | usage(); | ||
| 226 | goto end; | ||
| 227 | } | ||
| 228 | argc--; | ||
| 229 | argv++; | ||
| 230 | } | ||
| 231 | |||
| 232 | if (!ctx) | ||
| 233 | { | ||
| 234 | usage(); | ||
| 235 | goto end; | ||
| 236 | } | ||
| 237 | |||
| 238 | if (sigfile && (pkey_op != EVP_PKEY_OP_VERIFY)) | ||
| 239 | { | ||
| 240 | BIO_puts(bio_err, "Signature file specified for non verify\n"); | ||
| 241 | goto end; | ||
| 242 | } | ||
| 243 | |||
| 244 | if (!sigfile && (pkey_op == EVP_PKEY_OP_VERIFY)) | ||
| 245 | { | ||
| 246 | BIO_puts(bio_err, "No signature file specified for verify\n"); | ||
| 247 | goto end; | ||
| 248 | } | ||
| 249 | |||
| 250 | /* FIXME: seed PRNG only if needed */ | ||
| 251 | app_RAND_load_file(NULL, bio_err, 0); | ||
| 252 | |||
| 253 | if (pkey_op != EVP_PKEY_OP_DERIVE) | ||
| 254 | { | ||
| 255 | if(infile) | ||
| 256 | { | ||
| 257 | if(!(in = BIO_new_file(infile, "rb"))) | ||
| 258 | { | ||
| 259 | BIO_puts(bio_err, | ||
| 260 | "Error Opening Input File\n"); | ||
| 261 | ERR_print_errors(bio_err); | ||
| 262 | goto end; | ||
| 263 | } | ||
| 264 | } | ||
| 265 | else | ||
| 266 | in = BIO_new_fp(stdin, BIO_NOCLOSE); | ||
| 267 | } | ||
| 268 | |||
| 269 | if(outfile) | ||
| 270 | { | ||
| 271 | if(!(out = BIO_new_file(outfile, "wb"))) | ||
| 272 | { | ||
| 273 | BIO_printf(bio_err, "Error Creating Output File\n"); | ||
| 274 | ERR_print_errors(bio_err); | ||
| 275 | goto end; | ||
| 276 | } | ||
| 277 | } | ||
| 278 | else | ||
| 279 | { | ||
| 280 | out = BIO_new_fp(stdout, BIO_NOCLOSE); | ||
| 281 | #ifdef OPENSSL_SYS_VMS | ||
| 282 | { | ||
| 283 | BIO *tmpbio = BIO_new(BIO_f_linebuffer()); | ||
| 284 | out = BIO_push(tmpbio, out); | ||
| 285 | } | ||
| 286 | #endif | ||
| 287 | } | ||
| 288 | |||
| 289 | if (sigfile) | ||
| 290 | { | ||
| 291 | BIO *sigbio = BIO_new_file(sigfile, "rb"); | ||
| 292 | if (!sigbio) | ||
| 293 | { | ||
| 294 | BIO_printf(bio_err, "Can't open signature file %s\n", | ||
| 295 | sigfile); | ||
| 296 | goto end; | ||
| 297 | } | ||
| 298 | siglen = bio_to_mem(&sig, keysize * 10, sigbio); | ||
| 299 | BIO_free(sigbio); | ||
| 300 | if (siglen <= 0) | ||
| 301 | { | ||
| 302 | BIO_printf(bio_err, "Error reading signature data\n"); | ||
| 303 | goto end; | ||
| 304 | } | ||
| 305 | } | ||
| 306 | |||
| 307 | if (in) | ||
| 308 | { | ||
| 309 | /* Read the input data */ | ||
| 310 | buf_inlen = bio_to_mem(&buf_in, keysize * 10, in); | ||
| 311 | if(buf_inlen <= 0) | ||
| 312 | { | ||
| 313 | BIO_printf(bio_err, "Error reading input Data\n"); | ||
| 314 | exit(1); | ||
| 315 | } | ||
| 316 | if(rev) | ||
| 317 | { | ||
| 318 | size_t i; | ||
| 319 | unsigned char ctmp; | ||
| 320 | size_t l = (size_t)buf_inlen; | ||
| 321 | for(i = 0; i < l/2; i++) | ||
| 322 | { | ||
| 323 | ctmp = buf_in[i]; | ||
| 324 | buf_in[i] = buf_in[l - 1 - i]; | ||
| 325 | buf_in[l - 1 - i] = ctmp; | ||
| 326 | } | ||
| 327 | } | ||
| 328 | } | ||
| 329 | |||
| 330 | if(pkey_op == EVP_PKEY_OP_VERIFY) | ||
| 331 | { | ||
| 332 | rv = EVP_PKEY_verify(ctx, sig, (size_t)siglen, | ||
| 333 | buf_in, (size_t)buf_inlen); | ||
| 334 | if (rv == 0) | ||
| 335 | BIO_puts(out, "Signature Verification Failure\n"); | ||
| 336 | else if (rv == 1) | ||
| 337 | BIO_puts(out, "Signature Verified Successfully\n"); | ||
| 338 | if (rv >= 0) | ||
| 339 | goto end; | ||
| 340 | } | ||
| 341 | else | ||
| 342 | { | ||
| 343 | rv = do_keyop(ctx, pkey_op, NULL, (size_t *)&buf_outlen, | ||
| 344 | buf_in, (size_t)buf_inlen); | ||
| 345 | if (rv > 0) | ||
| 346 | { | ||
| 347 | buf_out = OPENSSL_malloc(buf_outlen); | ||
| 348 | if (!buf_out) | ||
| 349 | rv = -1; | ||
| 350 | else | ||
| 351 | rv = do_keyop(ctx, pkey_op, | ||
| 352 | buf_out, (size_t *)&buf_outlen, | ||
| 353 | buf_in, (size_t)buf_inlen); | ||
| 354 | } | ||
| 355 | } | ||
| 356 | |||
| 357 | if(rv <= 0) | ||
| 358 | { | ||
| 359 | BIO_printf(bio_err, "Public Key operation error\n"); | ||
| 360 | ERR_print_errors(bio_err); | ||
| 361 | goto end; | ||
| 362 | } | ||
| 363 | ret = 0; | ||
| 364 | if(asn1parse) | ||
| 365 | { | ||
| 366 | if(!ASN1_parse_dump(out, buf_out, buf_outlen, 1, -1)) | ||
| 367 | ERR_print_errors(bio_err); | ||
| 368 | } | ||
| 369 | else if(hexdump) | ||
| 370 | BIO_dump(out, (char *)buf_out, buf_outlen); | ||
| 371 | else | ||
| 372 | BIO_write(out, buf_out, buf_outlen); | ||
| 373 | |||
| 374 | end: | ||
| 375 | if (ctx) | ||
| 376 | EVP_PKEY_CTX_free(ctx); | ||
| 377 | BIO_free(in); | ||
| 378 | BIO_free_all(out); | ||
| 379 | if (buf_in) | ||
| 380 | OPENSSL_free(buf_in); | ||
| 381 | if (buf_out) | ||
| 382 | OPENSSL_free(buf_out); | ||
| 383 | if (sig) | ||
| 384 | OPENSSL_free(sig); | ||
| 385 | return ret; | ||
| 386 | } | ||
| 387 | |||
| 388 | static void usage() | ||
| 389 | { | ||
| 390 | BIO_printf(bio_err, "Usage: pkeyutl [options]\n"); | ||
| 391 | BIO_printf(bio_err, "-in file input file\n"); | ||
| 392 | BIO_printf(bio_err, "-out file output file\n"); | ||
| 393 | BIO_printf(bio_err, "-signature file signature file (verify operation only)\n"); | ||
| 394 | BIO_printf(bio_err, "-inkey file input key\n"); | ||
| 395 | BIO_printf(bio_err, "-keyform arg private key format - default PEM\n"); | ||
| 396 | BIO_printf(bio_err, "-pubin input is a public key\n"); | ||
| 397 | BIO_printf(bio_err, "-certin input is a certificate carrying a public key\n"); | ||
| 398 | BIO_printf(bio_err, "-pkeyopt X:Y public key options\n"); | ||
| 399 | BIO_printf(bio_err, "-sign sign with private key\n"); | ||
| 400 | BIO_printf(bio_err, "-verify verify with public key\n"); | ||
| 401 | BIO_printf(bio_err, "-verifyrecover verify with public key, recover original data\n"); | ||
| 402 | BIO_printf(bio_err, "-encrypt encrypt with public key\n"); | ||
| 403 | BIO_printf(bio_err, "-decrypt decrypt with private key\n"); | ||
| 404 | BIO_printf(bio_err, "-derive derive shared secret\n"); | ||
| 405 | BIO_printf(bio_err, "-hexdump hex dump output\n"); | ||
| 406 | #ifndef OPENSSL_NO_ENGINE | ||
| 407 | BIO_printf(bio_err, "-engine e use engine e, possibly a hardware device.\n"); | ||
| 408 | #endif | ||
| 409 | BIO_printf(bio_err, "-passin arg pass phrase source\n"); | ||
| 410 | |||
| 411 | } | ||
| 412 | |||
| 413 | static EVP_PKEY_CTX *init_ctx(int *pkeysize, | ||
| 414 | char *keyfile, int keyform, int key_type, | ||
| 415 | char *passargin, int pkey_op, ENGINE *e) | ||
| 416 | { | ||
| 417 | EVP_PKEY *pkey = NULL; | ||
| 418 | EVP_PKEY_CTX *ctx = NULL; | ||
| 419 | char *passin = NULL; | ||
| 420 | int rv = -1; | ||
| 421 | X509 *x; | ||
| 422 | if(((pkey_op == EVP_PKEY_OP_SIGN) || (pkey_op == EVP_PKEY_OP_DECRYPT) | ||
| 423 | || (pkey_op == EVP_PKEY_OP_DERIVE)) | ||
| 424 | && (key_type != KEY_PRIVKEY)) | ||
| 425 | { | ||
| 426 | BIO_printf(bio_err, "A private key is needed for this operation\n"); | ||
| 427 | goto end; | ||
| 428 | } | ||
| 429 | if(!app_passwd(bio_err, passargin, NULL, &passin, NULL)) | ||
| 430 | { | ||
| 431 | BIO_printf(bio_err, "Error getting password\n"); | ||
| 432 | goto end; | ||
| 433 | } | ||
| 434 | switch(key_type) | ||
| 435 | { | ||
| 436 | case KEY_PRIVKEY: | ||
| 437 | pkey = load_key(bio_err, keyfile, keyform, 0, | ||
| 438 | passin, e, "Private Key"); | ||
| 439 | break; | ||
| 440 | |||
| 441 | case KEY_PUBKEY: | ||
| 442 | pkey = load_pubkey(bio_err, keyfile, keyform, 0, | ||
| 443 | NULL, e, "Public Key"); | ||
| 444 | break; | ||
| 445 | |||
| 446 | case KEY_CERT: | ||
| 447 | x = load_cert(bio_err, keyfile, keyform, | ||
| 448 | NULL, e, "Certificate"); | ||
| 449 | if(x) | ||
| 450 | { | ||
| 451 | pkey = X509_get_pubkey(x); | ||
| 452 | X509_free(x); | ||
| 453 | } | ||
| 454 | break; | ||
| 455 | |||
| 456 | } | ||
| 457 | |||
| 458 | *pkeysize = EVP_PKEY_size(pkey); | ||
| 459 | |||
| 460 | if (!pkey) | ||
| 461 | goto end; | ||
| 462 | |||
| 463 | ctx = EVP_PKEY_CTX_new(pkey, e); | ||
| 464 | |||
| 465 | EVP_PKEY_free(pkey); | ||
| 466 | |||
| 467 | if (!ctx) | ||
| 468 | goto end; | ||
| 469 | |||
| 470 | switch(pkey_op) | ||
| 471 | { | ||
| 472 | case EVP_PKEY_OP_SIGN: | ||
| 473 | rv = EVP_PKEY_sign_init(ctx); | ||
| 474 | break; | ||
| 475 | |||
| 476 | case EVP_PKEY_OP_VERIFY: | ||
| 477 | rv = EVP_PKEY_verify_init(ctx); | ||
| 478 | break; | ||
| 479 | |||
| 480 | case EVP_PKEY_OP_VERIFYRECOVER: | ||
| 481 | rv = EVP_PKEY_verify_recover_init(ctx); | ||
| 482 | break; | ||
| 483 | |||
| 484 | case EVP_PKEY_OP_ENCRYPT: | ||
| 485 | rv = EVP_PKEY_encrypt_init(ctx); | ||
| 486 | break; | ||
| 487 | |||
| 488 | case EVP_PKEY_OP_DECRYPT: | ||
| 489 | rv = EVP_PKEY_decrypt_init(ctx); | ||
| 490 | break; | ||
| 491 | |||
| 492 | case EVP_PKEY_OP_DERIVE: | ||
| 493 | rv = EVP_PKEY_derive_init(ctx); | ||
| 494 | break; | ||
| 495 | } | ||
| 496 | |||
| 497 | if (rv <= 0) | ||
| 498 | { | ||
| 499 | EVP_PKEY_CTX_free(ctx); | ||
| 500 | ctx = NULL; | ||
| 501 | } | ||
| 502 | |||
| 503 | end: | ||
| 504 | |||
| 505 | if (passin) | ||
| 506 | OPENSSL_free(passin); | ||
| 507 | |||
| 508 | return ctx; | ||
| 509 | |||
| 510 | |||
| 511 | } | ||
| 512 | |||
| 513 | static int setup_peer(BIO *err, EVP_PKEY_CTX *ctx, int peerform, | ||
| 514 | const char *file) | ||
| 515 | { | ||
| 516 | EVP_PKEY *peer = NULL; | ||
| 517 | int ret; | ||
| 518 | if (!ctx) | ||
| 519 | { | ||
| 520 | BIO_puts(err, "-peerkey command before -inkey\n"); | ||
| 521 | return 0; | ||
| 522 | } | ||
| 523 | |||
| 524 | peer = load_pubkey(bio_err, file, peerform, 0, NULL, NULL, "Peer Key"); | ||
| 525 | |||
| 526 | if (!peer) | ||
| 527 | { | ||
| 528 | BIO_printf(bio_err, "Error reading peer key %s\n", file); | ||
| 529 | ERR_print_errors(err); | ||
| 530 | return 0; | ||
| 531 | } | ||
| 532 | |||
| 533 | ret = EVP_PKEY_derive_set_peer(ctx, peer); | ||
| 534 | |||
| 535 | EVP_PKEY_free(peer); | ||
| 536 | if (ret <= 0) | ||
| 537 | ERR_print_errors(err); | ||
| 538 | return ret; | ||
| 539 | } | ||
| 540 | |||
| 541 | static int do_keyop(EVP_PKEY_CTX *ctx, int pkey_op, | ||
| 542 | unsigned char *out, size_t *poutlen, | ||
| 543 | unsigned char *in, size_t inlen) | ||
| 544 | { | ||
| 545 | int rv = 0; | ||
| 546 | switch(pkey_op) | ||
| 547 | { | ||
| 548 | case EVP_PKEY_OP_VERIFYRECOVER: | ||
| 549 | rv = EVP_PKEY_verify_recover(ctx, out, poutlen, in, inlen); | ||
| 550 | break; | ||
| 551 | |||
| 552 | case EVP_PKEY_OP_SIGN: | ||
| 553 | rv = EVP_PKEY_sign(ctx, out, poutlen, in, inlen); | ||
| 554 | break; | ||
| 555 | |||
| 556 | case EVP_PKEY_OP_ENCRYPT: | ||
| 557 | rv = EVP_PKEY_encrypt(ctx, out, poutlen, in, inlen); | ||
| 558 | break; | ||
| 559 | |||
| 560 | case EVP_PKEY_OP_DECRYPT: | ||
| 561 | rv = EVP_PKEY_decrypt(ctx, out, poutlen, in, inlen); | ||
| 562 | break; | ||
| 563 | |||
| 564 | case EVP_PKEY_OP_DERIVE: | ||
| 565 | rv = EVP_PKEY_derive(ctx, out, poutlen); | ||
| 566 | break; | ||
| 567 | |||
| 568 | } | ||
| 569 | return rv; | ||
| 570 | } | ||
diff --git a/src/lib/libssl/src/apps/ts.c b/src/lib/libssl/src/apps/ts.c new file mode 100644 index 0000000000..74e7e932b3 --- /dev/null +++ b/src/lib/libssl/src/apps/ts.c | |||
| @@ -0,0 +1,1144 @@ | |||
| 1 | /* apps/ts.c */ | ||
| 2 | /* Written by Zoltan Glozik (zglozik@stones.com) for the OpenSSL | ||
| 3 | * project 2002. | ||
| 4 | */ | ||
| 5 | /* ==================================================================== | ||
| 6 | * Copyright (c) 2001 The OpenSSL Project. All rights reserved. | ||
| 7 | * | ||
| 8 | * Redistribution and use in source and binary forms, with or without | ||
| 9 | * modification, are permitted provided that the following conditions | ||
| 10 | * are met: | ||
| 11 | * | ||
| 12 | * 1. Redistributions of source code must retain the above copyright | ||
| 13 | * notice, this list of conditions and the following disclaimer. | ||
| 14 | * | ||
| 15 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 16 | * notice, this list of conditions and the following disclaimer in | ||
| 17 | * the documentation and/or other materials provided with the | ||
| 18 | * distribution. | ||
| 19 | * | ||
| 20 | * 3. All advertising materials mentioning features or use of this | ||
| 21 | * software must display the following acknowledgment: | ||
| 22 | * "This product includes software developed by the OpenSSL Project | ||
| 23 | * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" | ||
| 24 | * | ||
| 25 | * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to | ||
| 26 | * endorse or promote products derived from this software without | ||
| 27 | * prior written permission. For written permission, please contact | ||
| 28 | * licensing@OpenSSL.org. | ||
| 29 | * | ||
| 30 | * 5. Products derived from this software may not be called "OpenSSL" | ||
| 31 | * nor may "OpenSSL" appear in their names without prior written | ||
| 32 | * permission of the OpenSSL Project. | ||
| 33 | * | ||
| 34 | * 6. Redistributions of any form whatsoever must retain the following | ||
| 35 | * acknowledgment: | ||
| 36 | * "This product includes software developed by the OpenSSL Project | ||
| 37 | * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" | ||
| 38 | * | ||
| 39 | * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY | ||
| 40 | * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 41 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | ||
| 42 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR | ||
| 43 | * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | ||
| 44 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | ||
| 45 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
| 46 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 47 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | ||
| 48 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | ||
| 49 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED | ||
| 50 | * OF THE POSSIBILITY OF SUCH DAMAGE. | ||
| 51 | * ==================================================================== | ||
| 52 | * | ||
| 53 | * This product includes cryptographic software written by Eric Young | ||
| 54 | * (eay@cryptsoft.com). This product includes software written by Tim | ||
| 55 | * Hudson (tjh@cryptsoft.com). | ||
| 56 | * | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | #include <stdlib.h> | ||
| 61 | #include <string.h> | ||
| 62 | #include "apps.h" | ||
| 63 | #include <openssl/bio.h> | ||
| 64 | #include <openssl/err.h> | ||
| 65 | #include <openssl/pem.h> | ||
| 66 | #include <openssl/rand.h> | ||
| 67 | #include <openssl/ts.h> | ||
| 68 | #include <openssl/bn.h> | ||
| 69 | |||
| 70 | #undef PROG | ||
| 71 | #define PROG ts_main | ||
| 72 | |||
| 73 | /* Length of the nonce of the request in bits (must be a multiple of 8). */ | ||
| 74 | #define NONCE_LENGTH 64 | ||
| 75 | |||
| 76 | /* Macro definitions for the configuration file. */ | ||
| 77 | #define ENV_OID_FILE "oid_file" | ||
| 78 | |||
| 79 | /* Local function declarations. */ | ||
| 80 | |||
| 81 | static ASN1_OBJECT *txt2obj(const char *oid); | ||
| 82 | static CONF *load_config_file(const char *configfile); | ||
| 83 | |||
| 84 | /* Query related functions. */ | ||
| 85 | static int query_command(const char *data, char *digest, | ||
| 86 | const EVP_MD *md, const char *policy, int no_nonce, | ||
| 87 | int cert, const char *in, const char *out, int text); | ||
| 88 | static BIO *BIO_open_with_default(const char *file, const char *mode, | ||
| 89 | FILE *default_fp); | ||
| 90 | static TS_REQ *create_query(BIO *data_bio, char *digest, const EVP_MD *md, | ||
| 91 | const char *policy, int no_nonce, int cert); | ||
| 92 | static int create_digest(BIO *input, char *digest, | ||
| 93 | const EVP_MD *md, unsigned char **md_value); | ||
| 94 | static ASN1_INTEGER *create_nonce(int bits); | ||
| 95 | |||
| 96 | /* Reply related functions. */ | ||
| 97 | static int reply_command(CONF *conf, char *section, char *engine, | ||
| 98 | char *queryfile, char *passin, char *inkey, | ||
| 99 | char *signer, char *chain, const char *policy, | ||
| 100 | char *in, int token_in, char *out, int token_out, | ||
| 101 | int text); | ||
| 102 | static TS_RESP *read_PKCS7(BIO *in_bio); | ||
| 103 | static TS_RESP *create_response(CONF *conf, const char *section, char *engine, | ||
| 104 | char *queryfile, char *passin, char *inkey, | ||
| 105 | char *signer, char *chain, const char *policy); | ||
| 106 | static ASN1_INTEGER * MS_CALLBACK serial_cb(TS_RESP_CTX *ctx, void *data); | ||
| 107 | static ASN1_INTEGER *next_serial(const char *serialfile); | ||
| 108 | static int save_ts_serial(const char *serialfile, ASN1_INTEGER *serial); | ||
| 109 | |||
| 110 | /* Verify related functions. */ | ||
| 111 | static int verify_command(char *data, char *digest, char *queryfile, | ||
| 112 | char *in, int token_in, | ||
| 113 | char *ca_path, char *ca_file, char *untrusted); | ||
| 114 | static TS_VERIFY_CTX *create_verify_ctx(char *data, char *digest, | ||
| 115 | char *queryfile, | ||
| 116 | char *ca_path, char *ca_file, | ||
| 117 | char *untrusted); | ||
| 118 | static X509_STORE *create_cert_store(char *ca_path, char *ca_file); | ||
| 119 | static int MS_CALLBACK verify_cb(int ok, X509_STORE_CTX *ctx); | ||
| 120 | |||
| 121 | /* Main function definition. */ | ||
| 122 | int MAIN(int, char **); | ||
| 123 | |||
| 124 | int MAIN(int argc, char **argv) | ||
| 125 | { | ||
| 126 | int ret = 1; | ||
| 127 | char *configfile = NULL; | ||
| 128 | char *section = NULL; | ||
| 129 | CONF *conf = NULL; | ||
| 130 | enum mode { | ||
| 131 | CMD_NONE, CMD_QUERY, CMD_REPLY, CMD_VERIFY | ||
| 132 | } mode = CMD_NONE; | ||
| 133 | char *data = NULL; | ||
| 134 | char *digest = NULL; | ||
| 135 | const EVP_MD *md = NULL; | ||
| 136 | char *rnd = NULL; | ||
| 137 | char *policy = NULL; | ||
| 138 | int no_nonce = 0; | ||
| 139 | int cert = 0; | ||
| 140 | char *in = NULL; | ||
| 141 | char *out = NULL; | ||
| 142 | int text = 0; | ||
| 143 | char *queryfile = NULL; | ||
| 144 | char *passin = NULL; /* Password source. */ | ||
| 145 | char *password =NULL; /* Password itself. */ | ||
| 146 | char *inkey = NULL; | ||
| 147 | char *signer = NULL; | ||
| 148 | char *chain = NULL; | ||
| 149 | char *ca_path = NULL; | ||
| 150 | char *ca_file = NULL; | ||
| 151 | char *untrusted = NULL; | ||
| 152 | char *engine = NULL; | ||
| 153 | /* Input is ContentInfo instead of TimeStampResp. */ | ||
| 154 | int token_in = 0; | ||
| 155 | /* Output is ContentInfo instead of TimeStampResp. */ | ||
| 156 | int token_out = 0; | ||
| 157 | int free_bio_err = 0; | ||
| 158 | |||
| 159 | ERR_load_crypto_strings(); | ||
| 160 | apps_startup(); | ||
| 161 | |||
| 162 | if (bio_err == NULL && (bio_err = BIO_new(BIO_s_file())) != NULL) | ||
| 163 | { | ||
| 164 | free_bio_err = 1; | ||
| 165 | BIO_set_fp(bio_err, stderr, BIO_NOCLOSE | BIO_FP_TEXT); | ||
| 166 | } | ||
| 167 | |||
| 168 | for (argc--, argv++; argc > 0; argc--, argv++) | ||
| 169 | { | ||
| 170 | if (strcmp(*argv, "-config") == 0) | ||
| 171 | { | ||
| 172 | if (argc-- < 1) goto usage; | ||
| 173 | configfile = *++argv; | ||
| 174 | } | ||
| 175 | else if (strcmp(*argv, "-section") == 0) | ||
| 176 | { | ||
| 177 | if (argc-- < 1) goto usage; | ||
| 178 | section = *++argv; | ||
| 179 | } | ||
| 180 | else if (strcmp(*argv, "-query") == 0) | ||
| 181 | { | ||
| 182 | if (mode != CMD_NONE) goto usage; | ||
| 183 | mode = CMD_QUERY; | ||
| 184 | } | ||
| 185 | else if (strcmp(*argv, "-data") == 0) | ||
| 186 | { | ||
| 187 | if (argc-- < 1) goto usage; | ||
| 188 | data = *++argv; | ||
| 189 | } | ||
| 190 | else if (strcmp(*argv, "-digest") == 0) | ||
| 191 | { | ||
| 192 | if (argc-- < 1) goto usage; | ||
| 193 | digest = *++argv; | ||
| 194 | } | ||
| 195 | else if (strcmp(*argv, "-rand") == 0) | ||
| 196 | { | ||
| 197 | if (argc-- < 1) goto usage; | ||
| 198 | rnd = *++argv; | ||
| 199 | } | ||
| 200 | else if (strcmp(*argv, "-policy") == 0) | ||
| 201 | { | ||
| 202 | if (argc-- < 1) goto usage; | ||
| 203 | policy = *++argv; | ||
| 204 | } | ||
| 205 | else if (strcmp(*argv, "-no_nonce") == 0) | ||
| 206 | { | ||
| 207 | no_nonce = 1; | ||
| 208 | } | ||
| 209 | else if (strcmp(*argv, "-cert") == 0) | ||
| 210 | { | ||
| 211 | cert = 1; | ||
| 212 | } | ||
| 213 | else if (strcmp(*argv, "-in") == 0) | ||
| 214 | { | ||
| 215 | if (argc-- < 1) goto usage; | ||
| 216 | in = *++argv; | ||
| 217 | } | ||
| 218 | else if (strcmp(*argv, "-token_in") == 0) | ||
| 219 | { | ||
| 220 | token_in = 1; | ||
| 221 | } | ||
| 222 | else if (strcmp(*argv, "-out") == 0) | ||
| 223 | { | ||
| 224 | if (argc-- < 1) goto usage; | ||
| 225 | out = *++argv; | ||
| 226 | } | ||
| 227 | else if (strcmp(*argv, "-token_out") == 0) | ||
| 228 | { | ||
| 229 | token_out = 1; | ||
| 230 | } | ||
| 231 | else if (strcmp(*argv, "-text") == 0) | ||
| 232 | { | ||
| 233 | text = 1; | ||
| 234 | } | ||
| 235 | else if (strcmp(*argv, "-reply") == 0) | ||
| 236 | { | ||
| 237 | if (mode != CMD_NONE) goto usage; | ||
| 238 | mode = CMD_REPLY; | ||
| 239 | } | ||
| 240 | else if (strcmp(*argv, "-queryfile") == 0) | ||
| 241 | { | ||
| 242 | if (argc-- < 1) goto usage; | ||
| 243 | queryfile = *++argv; | ||
| 244 | } | ||
| 245 | else if (strcmp(*argv, "-passin") == 0) | ||
| 246 | { | ||
| 247 | if (argc-- < 1) goto usage; | ||
| 248 | passin = *++argv; | ||
| 249 | } | ||
| 250 | else if (strcmp(*argv, "-inkey") == 0) | ||
| 251 | { | ||
| 252 | if (argc-- < 1) goto usage; | ||
| 253 | inkey = *++argv; | ||
| 254 | } | ||
| 255 | else if (strcmp(*argv, "-signer") == 0) | ||
| 256 | { | ||
| 257 | if (argc-- < 1) goto usage; | ||
| 258 | signer = *++argv; | ||
| 259 | } | ||
| 260 | else if (strcmp(*argv, "-chain") == 0) | ||
| 261 | { | ||
| 262 | if (argc-- < 1) goto usage; | ||
| 263 | chain = *++argv; | ||
| 264 | } | ||
| 265 | else if (strcmp(*argv, "-verify") == 0) | ||
| 266 | { | ||
| 267 | if (mode != CMD_NONE) goto usage; | ||
| 268 | mode = CMD_VERIFY; | ||
| 269 | } | ||
| 270 | else if (strcmp(*argv, "-CApath") == 0) | ||
| 271 | { | ||
| 272 | if (argc-- < 1) goto usage; | ||
| 273 | ca_path = *++argv; | ||
| 274 | } | ||
| 275 | else if (strcmp(*argv, "-CAfile") == 0) | ||
| 276 | { | ||
| 277 | if (argc-- < 1) goto usage; | ||
| 278 | ca_file = *++argv; | ||
| 279 | } | ||
| 280 | else if (strcmp(*argv, "-untrusted") == 0) | ||
| 281 | { | ||
| 282 | if (argc-- < 1) goto usage; | ||
| 283 | untrusted = *++argv; | ||
| 284 | } | ||
| 285 | else if (strcmp(*argv, "-engine") == 0) | ||
| 286 | { | ||
| 287 | if (argc-- < 1) goto usage; | ||
| 288 | engine = *++argv; | ||
| 289 | } | ||
| 290 | else if ((md = EVP_get_digestbyname(*argv + 1)) != NULL) | ||
| 291 | { | ||
| 292 | /* empty. */ | ||
| 293 | } | ||
| 294 | else | ||
| 295 | goto usage; | ||
| 296 | } | ||
| 297 | |||
| 298 | /* Seed the random number generator if it is going to be used. */ | ||
| 299 | if (mode == CMD_QUERY && !no_nonce) | ||
| 300 | { | ||
| 301 | if (!app_RAND_load_file(NULL, bio_err, 1) && rnd == NULL) | ||
| 302 | BIO_printf(bio_err, "warning, not much extra random " | ||
| 303 | "data, consider using the -rand option\n"); | ||
| 304 | if (rnd != NULL) | ||
| 305 | BIO_printf(bio_err,"%ld semi-random bytes loaded\n", | ||
| 306 | app_RAND_load_files(rnd)); | ||
| 307 | } | ||
| 308 | |||
| 309 | /* Get the password if required. */ | ||
| 310 | if(mode == CMD_REPLY && passin && | ||
| 311 | !app_passwd(bio_err, passin, NULL, &password, NULL)) | ||
| 312 | { | ||
| 313 | BIO_printf(bio_err,"Error getting password.\n"); | ||
| 314 | goto cleanup; | ||
| 315 | } | ||
| 316 | |||
| 317 | /* Check consistency of parameters and execute | ||
| 318 | the appropriate function. */ | ||
| 319 | switch (mode) | ||
| 320 | { | ||
| 321 | case CMD_NONE: | ||
| 322 | goto usage; | ||
| 323 | case CMD_QUERY: | ||
| 324 | /* Data file and message imprint cannot be specified | ||
| 325 | at the same time. */ | ||
| 326 | ret = data != NULL && digest != NULL; | ||
| 327 | if (ret) goto usage; | ||
| 328 | /* Load the config file for possible policy OIDs. */ | ||
| 329 | conf = load_config_file(configfile); | ||
| 330 | ret = !query_command(data, digest, md, policy, no_nonce, cert, | ||
| 331 | in, out, text); | ||
| 332 | break; | ||
| 333 | case CMD_REPLY: | ||
| 334 | conf = load_config_file(configfile); | ||
| 335 | if (in == NULL) | ||
| 336 | { | ||
| 337 | ret = !(queryfile != NULL && conf != NULL && !token_in); | ||
| 338 | if (ret) goto usage; | ||
| 339 | } | ||
| 340 | else | ||
| 341 | { | ||
| 342 | /* 'in' and 'queryfile' are exclusive. */ | ||
| 343 | ret = !(queryfile == NULL); | ||
| 344 | if (ret) goto usage; | ||
| 345 | } | ||
| 346 | |||
| 347 | ret = !reply_command(conf, section, engine, queryfile, | ||
| 348 | password, inkey, signer, chain, policy, | ||
| 349 | in, token_in, out, token_out, text); | ||
| 350 | break; | ||
| 351 | case CMD_VERIFY: | ||
| 352 | ret = !(((queryfile && !data && !digest) | ||
| 353 | || (!queryfile && data && !digest) | ||
| 354 | || (!queryfile && !data && digest)) | ||
| 355 | && in != NULL); | ||
| 356 | if (ret) goto usage; | ||
| 357 | |||
| 358 | ret = !verify_command(data, digest, queryfile, in, token_in, | ||
| 359 | ca_path, ca_file, untrusted); | ||
| 360 | } | ||
| 361 | |||
| 362 | goto cleanup; | ||
| 363 | |||
| 364 | usage: | ||
| 365 | BIO_printf(bio_err, "usage:\n" | ||
| 366 | "ts -query [-rand file%cfile%c...] [-config configfile] " | ||
| 367 | "[-data file_to_hash] [-digest digest_bytes]" | ||
| 368 | "[-md2|-md4|-md5|-sha|-sha1|-mdc2|-ripemd160] " | ||
| 369 | "[-policy object_id] [-no_nonce] [-cert] " | ||
| 370 | "[-in request.tsq] [-out request.tsq] [-text]\n", | ||
| 371 | LIST_SEPARATOR_CHAR, LIST_SEPARATOR_CHAR); | ||
| 372 | BIO_printf(bio_err, "or\n" | ||
| 373 | "ts -reply [-config configfile] [-section tsa_section] " | ||
| 374 | "[-queryfile request.tsq] [-passin password] " | ||
| 375 | "[-signer tsa_cert.pem] [-inkey private_key.pem] " | ||
| 376 | "[-chain certs_file.pem] [-policy object_id] " | ||
| 377 | "[-in response.tsr] [-token_in] " | ||
| 378 | "[-out response.tsr] [-token_out] [-text] [-engine id]\n"); | ||
| 379 | BIO_printf(bio_err, "or\n" | ||
| 380 | "ts -verify [-data file_to_hash] [-digest digest_bytes] " | ||
| 381 | "[-queryfile request.tsq] " | ||
| 382 | "-in response.tsr [-token_in] " | ||
| 383 | "-CApath ca_path -CAfile ca_file.pem " | ||
| 384 | "-untrusted cert_file.pem\n"); | ||
| 385 | cleanup: | ||
| 386 | /* Clean up. */ | ||
| 387 | app_RAND_write_file(NULL, bio_err); | ||
| 388 | NCONF_free(conf); | ||
| 389 | OPENSSL_free(password); | ||
| 390 | OBJ_cleanup(); | ||
| 391 | if (free_bio_err) | ||
| 392 | { | ||
| 393 | BIO_free_all(bio_err); | ||
| 394 | bio_err = NULL; | ||
| 395 | } | ||
| 396 | |||
| 397 | OPENSSL_EXIT(ret); | ||
| 398 | } | ||
| 399 | |||
| 400 | /* | ||
| 401 | * Configuration file-related function definitions. | ||
| 402 | */ | ||
| 403 | |||
| 404 | static ASN1_OBJECT *txt2obj(const char *oid) | ||
| 405 | { | ||
| 406 | ASN1_OBJECT *oid_obj = NULL; | ||
| 407 | |||
| 408 | if (!(oid_obj = OBJ_txt2obj(oid, 0))) | ||
| 409 | BIO_printf(bio_err, "cannot convert %s to OID\n", oid); | ||
| 410 | |||
| 411 | return oid_obj; | ||
| 412 | } | ||
| 413 | |||
| 414 | static CONF *load_config_file(const char *configfile) | ||
| 415 | { | ||
| 416 | CONF *conf = NULL; | ||
| 417 | long errorline = -1; | ||
| 418 | |||
| 419 | if (!configfile) configfile = getenv("OPENSSL_CONF"); | ||
| 420 | if (!configfile) configfile = getenv("SSLEAY_CONF"); | ||
| 421 | |||
| 422 | if (configfile && | ||
| 423 | (!(conf = NCONF_new(NULL)) || | ||
| 424 | NCONF_load(conf, configfile, &errorline) <= 0)) | ||
| 425 | { | ||
| 426 | if (errorline <= 0) | ||
| 427 | BIO_printf(bio_err, "error loading the config file " | ||
| 428 | "'%s'\n", configfile); | ||
| 429 | else | ||
| 430 | BIO_printf(bio_err, "error on line %ld of config file " | ||
| 431 | "'%s'\n", errorline, configfile); | ||
| 432 | } | ||
| 433 | |||
| 434 | if (conf != NULL) | ||
| 435 | { | ||
| 436 | const char *p; | ||
| 437 | |||
| 438 | BIO_printf(bio_err,"Using configuration from %s\n", configfile); | ||
| 439 | p = NCONF_get_string(conf, NULL, ENV_OID_FILE); | ||
| 440 | if (p != NULL) | ||
| 441 | { | ||
| 442 | BIO *oid_bio = BIO_new_file(p, "r"); | ||
| 443 | if (!oid_bio) | ||
| 444 | ERR_print_errors(bio_err); | ||
| 445 | else | ||
| 446 | { | ||
| 447 | OBJ_create_objects(oid_bio); | ||
| 448 | BIO_free_all(oid_bio); | ||
| 449 | } | ||
| 450 | } | ||
| 451 | else | ||
| 452 | ERR_clear_error(); | ||
| 453 | if(!add_oid_section(bio_err, conf)) | ||
| 454 | ERR_print_errors(bio_err); | ||
| 455 | } | ||
| 456 | return conf; | ||
| 457 | } | ||
| 458 | |||
| 459 | /* | ||
| 460 | * Query-related method definitions. | ||
| 461 | */ | ||
| 462 | |||
| 463 | static int query_command(const char *data, char *digest, const EVP_MD *md, | ||
| 464 | const char *policy, int no_nonce, | ||
| 465 | int cert, const char *in, const char *out, int text) | ||
| 466 | { | ||
| 467 | int ret = 0; | ||
| 468 | TS_REQ *query = NULL; | ||
| 469 | BIO *in_bio = NULL; | ||
| 470 | BIO *data_bio = NULL; | ||
| 471 | BIO *out_bio = NULL; | ||
| 472 | |||
| 473 | /* Build query object either from file or from scratch. */ | ||
| 474 | if (in != NULL) | ||
| 475 | { | ||
| 476 | if ((in_bio = BIO_new_file(in, "rb")) == NULL) goto end; | ||
| 477 | query = d2i_TS_REQ_bio(in_bio, NULL); | ||
| 478 | } | ||
| 479 | else | ||
| 480 | { | ||
| 481 | /* Open the file if no explicit digest bytes were specified. */ | ||
| 482 | if (!digest | ||
| 483 | && !(data_bio = BIO_open_with_default(data, "rb", stdin))) | ||
| 484 | goto end; | ||
| 485 | /* Creating the query object. */ | ||
| 486 | query = create_query(data_bio, digest, md, | ||
| 487 | policy, no_nonce, cert); | ||
| 488 | /* Saving the random number generator state. */ | ||
| 489 | } | ||
| 490 | if (query == NULL) goto end; | ||
| 491 | |||
| 492 | /* Write query either in ASN.1 or in text format. */ | ||
| 493 | if ((out_bio = BIO_open_with_default(out, "wb", stdout)) == NULL) | ||
| 494 | goto end; | ||
| 495 | if (text) | ||
| 496 | { | ||
| 497 | /* Text output. */ | ||
| 498 | if (!TS_REQ_print_bio(out_bio, query)) | ||
| 499 | goto end; | ||
| 500 | } | ||
| 501 | else | ||
| 502 | { | ||
| 503 | /* ASN.1 output. */ | ||
| 504 | if (!i2d_TS_REQ_bio(out_bio, query)) | ||
| 505 | goto end; | ||
| 506 | } | ||
| 507 | |||
| 508 | ret = 1; | ||
| 509 | |||
| 510 | end: | ||
| 511 | ERR_print_errors(bio_err); | ||
| 512 | |||
| 513 | /* Clean up. */ | ||
| 514 | BIO_free_all(in_bio); | ||
| 515 | BIO_free_all(data_bio); | ||
| 516 | BIO_free_all(out_bio); | ||
| 517 | TS_REQ_free(query); | ||
| 518 | |||
| 519 | return ret; | ||
| 520 | } | ||
| 521 | |||
| 522 | static BIO *BIO_open_with_default(const char *file, const char *mode, | ||
| 523 | FILE *default_fp) | ||
| 524 | { | ||
| 525 | return file == NULL ? | ||
| 526 | BIO_new_fp(default_fp, BIO_NOCLOSE) | ||
| 527 | : BIO_new_file(file, mode); | ||
| 528 | } | ||
| 529 | |||
| 530 | static TS_REQ *create_query(BIO *data_bio, char *digest, const EVP_MD *md, | ||
| 531 | const char *policy, int no_nonce, int cert) | ||
| 532 | { | ||
| 533 | int ret = 0; | ||
| 534 | TS_REQ *ts_req = NULL; | ||
| 535 | int len; | ||
| 536 | TS_MSG_IMPRINT *msg_imprint = NULL; | ||
| 537 | X509_ALGOR *algo = NULL; | ||
| 538 | unsigned char *data = NULL; | ||
| 539 | ASN1_OBJECT *policy_obj = NULL; | ||
| 540 | ASN1_INTEGER *nonce_asn1 = NULL; | ||
| 541 | |||
| 542 | /* Setting default message digest. */ | ||
| 543 | if (!md && !(md = EVP_get_digestbyname("sha1"))) goto err; | ||
| 544 | |||
| 545 | /* Creating request object. */ | ||
| 546 | if (!(ts_req = TS_REQ_new())) goto err; | ||
| 547 | |||
| 548 | /* Setting version. */ | ||
| 549 | if (!TS_REQ_set_version(ts_req, 1)) goto err; | ||
| 550 | |||
| 551 | /* Creating and adding MSG_IMPRINT object. */ | ||
| 552 | if (!(msg_imprint = TS_MSG_IMPRINT_new())) goto err; | ||
| 553 | |||
| 554 | /* Adding algorithm. */ | ||
| 555 | if (!(algo = X509_ALGOR_new())) goto err; | ||
| 556 | if (!(algo->algorithm = OBJ_nid2obj(EVP_MD_type(md)))) goto err; | ||
| 557 | if (!(algo->parameter = ASN1_TYPE_new())) goto err; | ||
| 558 | algo->parameter->type = V_ASN1_NULL; | ||
| 559 | if (!TS_MSG_IMPRINT_set_algo(msg_imprint, algo)) goto err; | ||
| 560 | |||
| 561 | /* Adding message digest. */ | ||
| 562 | if ((len = create_digest(data_bio, digest, md, &data)) == 0) | ||
| 563 | goto err; | ||
| 564 | if (!TS_MSG_IMPRINT_set_msg(msg_imprint, data, len)) goto err; | ||
| 565 | |||
| 566 | if (!TS_REQ_set_msg_imprint(ts_req, msg_imprint)) goto err; | ||
| 567 | |||
| 568 | /* Setting policy if requested. */ | ||
| 569 | if (policy && !(policy_obj = txt2obj(policy))) goto err; | ||
| 570 | if (policy_obj && !TS_REQ_set_policy_id(ts_req, policy_obj)) goto err; | ||
| 571 | |||
| 572 | /* Setting nonce if requested. */ | ||
| 573 | if (!no_nonce && !(nonce_asn1 = create_nonce(NONCE_LENGTH))) goto err; | ||
| 574 | if (nonce_asn1 && !TS_REQ_set_nonce(ts_req, nonce_asn1)) goto err; | ||
| 575 | |||
| 576 | /* Setting certificate request flag if requested. */ | ||
| 577 | if (!TS_REQ_set_cert_req(ts_req, cert)) goto err; | ||
| 578 | |||
| 579 | ret = 1; | ||
| 580 | err: | ||
| 581 | if (!ret) | ||
| 582 | { | ||
| 583 | TS_REQ_free(ts_req); | ||
| 584 | ts_req = NULL; | ||
| 585 | BIO_printf(bio_err, "could not create query\n"); | ||
| 586 | } | ||
| 587 | TS_MSG_IMPRINT_free(msg_imprint); | ||
| 588 | X509_ALGOR_free(algo); | ||
| 589 | OPENSSL_free(data); | ||
| 590 | ASN1_OBJECT_free(policy_obj); | ||
| 591 | ASN1_INTEGER_free(nonce_asn1); | ||
| 592 | return ts_req; | ||
| 593 | } | ||
| 594 | |||
| 595 | static int create_digest(BIO *input, char *digest, const EVP_MD *md, | ||
| 596 | unsigned char **md_value) | ||
| 597 | { | ||
| 598 | int md_value_len; | ||
| 599 | |||
| 600 | md_value_len = EVP_MD_size(md); | ||
| 601 | if (md_value_len < 0) | ||
| 602 | goto err; | ||
| 603 | if (input) | ||
| 604 | { | ||
| 605 | /* Digest must be computed from an input file. */ | ||
| 606 | EVP_MD_CTX md_ctx; | ||
| 607 | unsigned char buffer[4096]; | ||
| 608 | int length; | ||
| 609 | |||
| 610 | *md_value = OPENSSL_malloc(md_value_len); | ||
| 611 | if (*md_value == 0) goto err; | ||
| 612 | |||
| 613 | EVP_DigestInit(&md_ctx, md); | ||
| 614 | while ((length = BIO_read(input, buffer, sizeof(buffer))) > 0) | ||
| 615 | { | ||
| 616 | EVP_DigestUpdate(&md_ctx, buffer, length); | ||
| 617 | } | ||
| 618 | EVP_DigestFinal(&md_ctx, *md_value, NULL); | ||
| 619 | } | ||
| 620 | else | ||
| 621 | { | ||
| 622 | /* Digest bytes are specified with digest. */ | ||
| 623 | long digest_len; | ||
| 624 | *md_value = string_to_hex(digest, &digest_len); | ||
| 625 | if (!*md_value || md_value_len != digest_len) | ||
| 626 | { | ||
| 627 | OPENSSL_free(*md_value); | ||
| 628 | *md_value = NULL; | ||
| 629 | BIO_printf(bio_err, "bad digest, %d bytes " | ||
| 630 | "must be specified\n", md_value_len); | ||
| 631 | goto err; | ||
| 632 | } | ||
| 633 | } | ||
| 634 | |||
| 635 | return md_value_len; | ||
| 636 | err: | ||
| 637 | return 0; | ||
| 638 | } | ||
| 639 | |||
| 640 | static ASN1_INTEGER *create_nonce(int bits) | ||
| 641 | { | ||
| 642 | unsigned char buf[20]; | ||
| 643 | ASN1_INTEGER *nonce = NULL; | ||
| 644 | int len = (bits - 1) / 8 + 1; | ||
| 645 | int i; | ||
| 646 | |||
| 647 | /* Generating random byte sequence. */ | ||
| 648 | if (len > (int)sizeof(buf)) goto err; | ||
| 649 | if (!RAND_bytes(buf, len)) goto err; | ||
| 650 | |||
| 651 | /* Find the first non-zero byte and creating ASN1_INTEGER object. */ | ||
| 652 | for (i = 0; i < len && !buf[i]; ++i); | ||
| 653 | if (!(nonce = ASN1_INTEGER_new())) goto err; | ||
| 654 | OPENSSL_free(nonce->data); | ||
| 655 | /* Allocate at least one byte. */ | ||
| 656 | nonce->length = len - i; | ||
| 657 | if (!(nonce->data = OPENSSL_malloc(nonce->length + 1))) goto err; | ||
| 658 | memcpy(nonce->data, buf + i, nonce->length); | ||
| 659 | |||
| 660 | return nonce; | ||
| 661 | err: | ||
| 662 | BIO_printf(bio_err, "could not create nonce\n"); | ||
| 663 | ASN1_INTEGER_free(nonce); | ||
| 664 | return NULL; | ||
| 665 | } | ||
| 666 | /* | ||
| 667 | * Reply-related method definitions. | ||
| 668 | */ | ||
| 669 | |||
| 670 | static int reply_command(CONF *conf, char *section, char *engine, | ||
| 671 | char *queryfile, char *passin, char *inkey, | ||
| 672 | char *signer, char *chain, const char *policy, | ||
| 673 | char *in, int token_in, | ||
| 674 | char *out, int token_out, int text) | ||
| 675 | { | ||
| 676 | int ret = 0; | ||
| 677 | TS_RESP *response = NULL; | ||
| 678 | BIO *in_bio = NULL; | ||
| 679 | BIO *query_bio = NULL; | ||
| 680 | BIO *inkey_bio = NULL; | ||
| 681 | BIO *signer_bio = NULL; | ||
| 682 | BIO *out_bio = NULL; | ||
| 683 | |||
| 684 | /* Build response object either from response or query. */ | ||
| 685 | if (in != NULL) | ||
| 686 | { | ||
| 687 | if ((in_bio = BIO_new_file(in, "rb")) == NULL) goto end; | ||
| 688 | if (token_in) | ||
| 689 | { | ||
| 690 | /* We have a ContentInfo (PKCS7) object, add | ||
| 691 | 'granted' status info around it. */ | ||
| 692 | response = read_PKCS7(in_bio); | ||
| 693 | } | ||
| 694 | else | ||
| 695 | { | ||
| 696 | /* We have a ready-made TS_RESP object. */ | ||
| 697 | response = d2i_TS_RESP_bio(in_bio, NULL); | ||
| 698 | } | ||
| 699 | } | ||
| 700 | else | ||
| 701 | { | ||
| 702 | response = create_response(conf, section, engine, queryfile, | ||
| 703 | passin, inkey, signer, chain, | ||
| 704 | policy); | ||
| 705 | if (response) | ||
| 706 | BIO_printf(bio_err, "Response has been generated.\n"); | ||
| 707 | else | ||
| 708 | BIO_printf(bio_err, "Response is not generated.\n"); | ||
| 709 | } | ||
| 710 | if (response == NULL) goto end; | ||
| 711 | |||
| 712 | /* Write response either in ASN.1 or text format. */ | ||
| 713 | if ((out_bio = BIO_open_with_default(out, "wb", stdout)) == NULL) | ||
| 714 | goto end; | ||
| 715 | if (text) | ||
| 716 | { | ||
| 717 | /* Text output. */ | ||
| 718 | if (token_out) | ||
| 719 | { | ||
| 720 | TS_TST_INFO *tst_info = TS_RESP_get_tst_info(response); | ||
| 721 | if (!TS_TST_INFO_print_bio(out_bio, tst_info)) goto end; | ||
| 722 | } | ||
| 723 | else | ||
| 724 | { | ||
| 725 | if (!TS_RESP_print_bio(out_bio, response)) goto end; | ||
| 726 | } | ||
| 727 | } | ||
| 728 | else | ||
| 729 | { | ||
| 730 | /* ASN.1 DER output. */ | ||
| 731 | if (token_out) | ||
| 732 | { | ||
| 733 | PKCS7 *token = TS_RESP_get_token(response); | ||
| 734 | if (!i2d_PKCS7_bio(out_bio, token)) goto end; | ||
| 735 | } | ||
| 736 | else | ||
| 737 | { | ||
| 738 | if (!i2d_TS_RESP_bio(out_bio, response)) goto end; | ||
| 739 | } | ||
| 740 | } | ||
| 741 | |||
| 742 | ret = 1; | ||
| 743 | |||
| 744 | end: | ||
| 745 | ERR_print_errors(bio_err); | ||
| 746 | |||
| 747 | /* Clean up. */ | ||
| 748 | BIO_free_all(in_bio); | ||
| 749 | BIO_free_all(query_bio); | ||
| 750 | BIO_free_all(inkey_bio); | ||
| 751 | BIO_free_all(signer_bio); | ||
| 752 | BIO_free_all(out_bio); | ||
| 753 | TS_RESP_free(response); | ||
| 754 | |||
| 755 | return ret; | ||
| 756 | } | ||
| 757 | |||
| 758 | /* Reads a PKCS7 token and adds default 'granted' status info to it. */ | ||
| 759 | static TS_RESP *read_PKCS7(BIO *in_bio) | ||
| 760 | { | ||
| 761 | int ret = 0; | ||
| 762 | PKCS7 *token = NULL; | ||
| 763 | TS_TST_INFO *tst_info = NULL; | ||
| 764 | TS_RESP *resp = NULL; | ||
| 765 | TS_STATUS_INFO *si = NULL; | ||
| 766 | |||
| 767 | /* Read PKCS7 object and extract the signed time stamp info. */ | ||
| 768 | if (!(token = d2i_PKCS7_bio(in_bio, NULL))) goto end; | ||
| 769 | if (!(tst_info = PKCS7_to_TS_TST_INFO(token))) goto end; | ||
| 770 | |||
| 771 | /* Creating response object. */ | ||
| 772 | if (!(resp = TS_RESP_new())) goto end; | ||
| 773 | |||
| 774 | /* Create granted status info. */ | ||
| 775 | if (!(si = TS_STATUS_INFO_new())) goto end; | ||
| 776 | if (!(ASN1_INTEGER_set(si->status, TS_STATUS_GRANTED))) goto end; | ||
| 777 | if (!TS_RESP_set_status_info(resp, si)) goto end; | ||
| 778 | |||
| 779 | /* Setting encapsulated token. */ | ||
| 780 | TS_RESP_set_tst_info(resp, token, tst_info); | ||
| 781 | token = NULL; /* Ownership is lost. */ | ||
| 782 | tst_info = NULL; /* Ownership is lost. */ | ||
| 783 | |||
| 784 | ret = 1; | ||
| 785 | end: | ||
| 786 | PKCS7_free(token); | ||
| 787 | TS_TST_INFO_free(tst_info); | ||
| 788 | if (!ret) | ||
| 789 | { | ||
| 790 | TS_RESP_free(resp); | ||
| 791 | resp = NULL; | ||
| 792 | } | ||
| 793 | TS_STATUS_INFO_free(si); | ||
| 794 | return resp; | ||
| 795 | } | ||
| 796 | |||
| 797 | static TS_RESP *create_response(CONF *conf, const char *section, char *engine, | ||
| 798 | char *queryfile, char *passin, char *inkey, | ||
| 799 | char *signer, char *chain, const char *policy) | ||
| 800 | { | ||
| 801 | int ret = 0; | ||
| 802 | TS_RESP *response = NULL; | ||
| 803 | BIO *query_bio = NULL; | ||
| 804 | TS_RESP_CTX *resp_ctx = NULL; | ||
| 805 | |||
| 806 | if (!(query_bio = BIO_new_file(queryfile, "rb"))) | ||
| 807 | goto end; | ||
| 808 | |||
| 809 | /* Getting TSA configuration section. */ | ||
| 810 | if (!(section = TS_CONF_get_tsa_section(conf, section))) | ||
| 811 | goto end; | ||
| 812 | |||
| 813 | /* Setting up response generation context. */ | ||
| 814 | if (!(resp_ctx = TS_RESP_CTX_new())) goto end; | ||
| 815 | |||
| 816 | /* Setting serial number provider callback. */ | ||
| 817 | if (!TS_CONF_set_serial(conf, section, serial_cb, resp_ctx)) goto end; | ||
| 818 | #ifndef OPENSSL_NO_ENGINE | ||
| 819 | /* Setting default OpenSSL engine. */ | ||
| 820 | if (!TS_CONF_set_crypto_device(conf, section, engine)) goto end; | ||
| 821 | #endif | ||
| 822 | |||
| 823 | /* Setting TSA signer certificate. */ | ||
| 824 | if (!TS_CONF_set_signer_cert(conf, section, signer, resp_ctx)) goto end; | ||
| 825 | |||
| 826 | /* Setting TSA signer certificate chain. */ | ||
| 827 | if (!TS_CONF_set_certs(conf, section, chain, resp_ctx)) goto end; | ||
| 828 | |||
| 829 | /* Setting TSA signer private key. */ | ||
| 830 | if (!TS_CONF_set_signer_key(conf, section, inkey, passin, resp_ctx)) | ||
| 831 | goto end; | ||
| 832 | |||
| 833 | /* Setting default policy OID. */ | ||
| 834 | if (!TS_CONF_set_def_policy(conf, section, policy, resp_ctx)) goto end; | ||
| 835 | |||
| 836 | /* Setting acceptable policy OIDs. */ | ||
| 837 | if (!TS_CONF_set_policies(conf, section, resp_ctx)) goto end; | ||
| 838 | |||
| 839 | /* Setting the acceptable one-way hash algorithms. */ | ||
| 840 | if (!TS_CONF_set_digests(conf, section, resp_ctx)) goto end; | ||
| 841 | |||
| 842 | /* Setting guaranteed time stamp accuracy. */ | ||
| 843 | if (!TS_CONF_set_accuracy(conf, section, resp_ctx)) goto end; | ||
| 844 | |||
| 845 | /* Setting the precision of the time. */ | ||
| 846 | if (!TS_CONF_set_clock_precision_digits(conf, section, resp_ctx)) | ||
| 847 | goto end; | ||
| 848 | |||
| 849 | /* Setting the ordering flaf if requested. */ | ||
| 850 | if (!TS_CONF_set_ordering(conf, section, resp_ctx)) goto end; | ||
| 851 | |||
| 852 | /* Setting the TSA name required flag if requested. */ | ||
| 853 | if (!TS_CONF_set_tsa_name(conf, section, resp_ctx)) goto end; | ||
| 854 | |||
| 855 | /* Setting the ESS cert id chain flag if requested. */ | ||
| 856 | if (!TS_CONF_set_ess_cert_id_chain(conf, section, resp_ctx)) goto end; | ||
| 857 | |||
| 858 | /* Creating the response. */ | ||
| 859 | if (!(response = TS_RESP_create_response(resp_ctx, query_bio))) | ||
| 860 | goto end; | ||
| 861 | |||
| 862 | ret = 1; | ||
| 863 | end: | ||
| 864 | if (!ret) | ||
| 865 | { | ||
| 866 | TS_RESP_free(response); | ||
| 867 | response = NULL; | ||
| 868 | } | ||
| 869 | TS_RESP_CTX_free(resp_ctx); | ||
| 870 | BIO_free_all(query_bio); | ||
| 871 | |||
| 872 | return response; | ||
| 873 | } | ||
| 874 | |||
| 875 | static ASN1_INTEGER * MS_CALLBACK serial_cb(TS_RESP_CTX *ctx, void *data) | ||
| 876 | { | ||
| 877 | const char *serial_file = (const char *) data; | ||
| 878 | ASN1_INTEGER *serial = next_serial(serial_file); | ||
| 879 | |||
| 880 | if (!serial) | ||
| 881 | { | ||
| 882 | TS_RESP_CTX_set_status_info(ctx, TS_STATUS_REJECTION, | ||
| 883 | "Error during serial number " | ||
| 884 | "generation."); | ||
| 885 | TS_RESP_CTX_add_failure_info(ctx, | ||
| 886 | TS_INFO_ADD_INFO_NOT_AVAILABLE); | ||
| 887 | } | ||
| 888 | else | ||
| 889 | save_ts_serial(serial_file, serial); | ||
| 890 | |||
| 891 | return serial; | ||
| 892 | } | ||
| 893 | |||
| 894 | static ASN1_INTEGER *next_serial(const char *serialfile) | ||
| 895 | { | ||
| 896 | int ret = 0; | ||
| 897 | BIO *in = NULL; | ||
| 898 | ASN1_INTEGER *serial = NULL; | ||
| 899 | BIGNUM *bn = NULL; | ||
| 900 | |||
| 901 | if (!(serial = ASN1_INTEGER_new())) goto err; | ||
| 902 | |||
| 903 | if (!(in = BIO_new_file(serialfile, "r"))) | ||
| 904 | { | ||
| 905 | ERR_clear_error(); | ||
| 906 | BIO_printf(bio_err, "Warning: could not open file %s for " | ||
| 907 | "reading, using serial number: 1\n", serialfile); | ||
| 908 | if (!ASN1_INTEGER_set(serial, 1)) goto err; | ||
| 909 | } | ||
| 910 | else | ||
| 911 | { | ||
| 912 | char buf[1024]; | ||
| 913 | if (!a2i_ASN1_INTEGER(in, serial, buf, sizeof(buf))) | ||
| 914 | { | ||
| 915 | BIO_printf(bio_err, "unable to load number from %s\n", | ||
| 916 | serialfile); | ||
| 917 | goto err; | ||
| 918 | } | ||
| 919 | if (!(bn = ASN1_INTEGER_to_BN(serial, NULL))) goto err; | ||
| 920 | ASN1_INTEGER_free(serial); | ||
| 921 | serial = NULL; | ||
| 922 | if (!BN_add_word(bn, 1)) goto err; | ||
| 923 | if (!(serial = BN_to_ASN1_INTEGER(bn, NULL))) goto err; | ||
| 924 | } | ||
| 925 | ret = 1; | ||
| 926 | err: | ||
| 927 | if (!ret) | ||
| 928 | { | ||
| 929 | ASN1_INTEGER_free(serial); | ||
| 930 | serial = NULL; | ||
| 931 | } | ||
| 932 | BIO_free_all(in); | ||
| 933 | BN_free(bn); | ||
| 934 | return serial; | ||
| 935 | } | ||
| 936 | |||
| 937 | static int save_ts_serial(const char *serialfile, ASN1_INTEGER *serial) | ||
| 938 | { | ||
| 939 | int ret = 0; | ||
| 940 | BIO *out = NULL; | ||
| 941 | |||
| 942 | if (!(out = BIO_new_file(serialfile, "w"))) goto err; | ||
| 943 | if (i2a_ASN1_INTEGER(out, serial) <= 0) goto err; | ||
| 944 | if (BIO_puts(out, "\n") <= 0) goto err; | ||
| 945 | ret = 1; | ||
| 946 | err: | ||
| 947 | if (!ret) | ||
| 948 | BIO_printf(bio_err, "could not save serial number to %s\n", | ||
| 949 | serialfile); | ||
| 950 | BIO_free_all(out); | ||
| 951 | return ret; | ||
| 952 | } | ||
| 953 | |||
| 954 | /* | ||
| 955 | * Verify-related method definitions. | ||
| 956 | */ | ||
| 957 | |||
| 958 | static int verify_command(char *data, char *digest, char *queryfile, | ||
| 959 | char *in, int token_in, | ||
| 960 | char *ca_path, char *ca_file, char *untrusted) | ||
| 961 | { | ||
| 962 | BIO *in_bio = NULL; | ||
| 963 | PKCS7 *token = NULL; | ||
| 964 | TS_RESP *response = NULL; | ||
| 965 | TS_VERIFY_CTX *verify_ctx = NULL; | ||
| 966 | int ret = 0; | ||
| 967 | |||
| 968 | /* Decode the token (PKCS7) or response (TS_RESP) files. */ | ||
| 969 | if (!(in_bio = BIO_new_file(in, "rb"))) goto end; | ||
| 970 | if (token_in) | ||
| 971 | { | ||
| 972 | if (!(token = d2i_PKCS7_bio(in_bio, NULL))) goto end; | ||
| 973 | } | ||
| 974 | else | ||
| 975 | { | ||
| 976 | if (!(response = d2i_TS_RESP_bio(in_bio, NULL))) goto end; | ||
| 977 | } | ||
| 978 | |||
| 979 | if (!(verify_ctx = create_verify_ctx(data, digest, queryfile, | ||
| 980 | ca_path, ca_file, untrusted))) | ||
| 981 | goto end; | ||
| 982 | |||
| 983 | /* Checking the token or response against the request. */ | ||
| 984 | ret = token_in ? | ||
| 985 | TS_RESP_verify_token(verify_ctx, token) : | ||
| 986 | TS_RESP_verify_response(verify_ctx, response); | ||
| 987 | |||
| 988 | end: | ||
| 989 | printf("Verification: "); | ||
| 990 | if (ret) | ||
| 991 | printf("OK\n"); | ||
| 992 | else | ||
| 993 | { | ||
| 994 | printf("FAILED\n"); | ||
| 995 | /* Print errors, if there are any. */ | ||
| 996 | ERR_print_errors(bio_err); | ||
| 997 | } | ||
| 998 | |||
| 999 | /* Clean up. */ | ||
| 1000 | BIO_free_all(in_bio); | ||
| 1001 | PKCS7_free(token); | ||
| 1002 | TS_RESP_free(response); | ||
| 1003 | TS_VERIFY_CTX_free(verify_ctx); | ||
| 1004 | return ret; | ||
| 1005 | } | ||
| 1006 | |||
| 1007 | static TS_VERIFY_CTX *create_verify_ctx(char *data, char *digest, | ||
| 1008 | char *queryfile, | ||
| 1009 | char *ca_path, char *ca_file, | ||
| 1010 | char *untrusted) | ||
| 1011 | { | ||
| 1012 | TS_VERIFY_CTX *ctx = NULL; | ||
| 1013 | BIO *input = NULL; | ||
| 1014 | TS_REQ *request = NULL; | ||
| 1015 | int ret = 0; | ||
| 1016 | |||
| 1017 | if (data != NULL || digest != NULL) | ||
| 1018 | { | ||
| 1019 | if (!(ctx = TS_VERIFY_CTX_new())) goto err; | ||
| 1020 | ctx->flags = TS_VFY_VERSION | TS_VFY_SIGNER; | ||
| 1021 | if (data != NULL) | ||
| 1022 | { | ||
| 1023 | ctx->flags |= TS_VFY_DATA; | ||
| 1024 | if (!(ctx->data = BIO_new_file(data, "rb"))) goto err; | ||
| 1025 | } | ||
| 1026 | else if (digest != NULL) | ||
| 1027 | { | ||
| 1028 | long imprint_len; | ||
| 1029 | ctx->flags |= TS_VFY_IMPRINT; | ||
| 1030 | if (!(ctx->imprint = string_to_hex(digest, | ||
| 1031 | &imprint_len))) | ||
| 1032 | { | ||
| 1033 | BIO_printf(bio_err, "invalid digest string\n"); | ||
| 1034 | goto err; | ||
| 1035 | } | ||
| 1036 | ctx->imprint_len = imprint_len; | ||
| 1037 | } | ||
| 1038 | |||
| 1039 | } | ||
| 1040 | else if (queryfile != NULL) | ||
| 1041 | { | ||
| 1042 | /* The request has just to be read, decoded and converted to | ||
| 1043 | a verify context object. */ | ||
| 1044 | if (!(input = BIO_new_file(queryfile, "rb"))) goto err; | ||
| 1045 | if (!(request = d2i_TS_REQ_bio(input, NULL))) goto err; | ||
| 1046 | if (!(ctx = TS_REQ_to_TS_VERIFY_CTX(request, NULL))) goto err; | ||
| 1047 | } | ||
| 1048 | else | ||
| 1049 | return NULL; | ||
| 1050 | |||
| 1051 | /* Add the signature verification flag and arguments. */ | ||
| 1052 | ctx->flags |= TS_VFY_SIGNATURE; | ||
| 1053 | |||
| 1054 | /* Initialising the X509_STORE object. */ | ||
| 1055 | if (!(ctx->store = create_cert_store(ca_path, ca_file))) goto err; | ||
| 1056 | |||
| 1057 | /* Loading untrusted certificates. */ | ||
| 1058 | if (untrusted && !(ctx->certs = TS_CONF_load_certs(untrusted))) | ||
| 1059 | goto err; | ||
| 1060 | |||
| 1061 | ret = 1; | ||
| 1062 | err: | ||
| 1063 | if (!ret) | ||
| 1064 | { | ||
| 1065 | TS_VERIFY_CTX_free(ctx); | ||
| 1066 | ctx = NULL; | ||
| 1067 | } | ||
| 1068 | BIO_free_all(input); | ||
| 1069 | TS_REQ_free(request); | ||
| 1070 | return ctx; | ||
| 1071 | } | ||
| 1072 | |||
| 1073 | static X509_STORE *create_cert_store(char *ca_path, char *ca_file) | ||
| 1074 | { | ||
| 1075 | X509_STORE *cert_ctx = NULL; | ||
| 1076 | X509_LOOKUP *lookup = NULL; | ||
| 1077 | int i; | ||
| 1078 | |||
| 1079 | /* Creating the X509_STORE object. */ | ||
| 1080 | cert_ctx = X509_STORE_new(); | ||
| 1081 | |||
| 1082 | /* Setting the callback for certificate chain verification. */ | ||
| 1083 | X509_STORE_set_verify_cb_func(cert_ctx, verify_cb); | ||
| 1084 | |||
| 1085 | /* Adding a trusted certificate directory source. */ | ||
| 1086 | if (ca_path) | ||
| 1087 | { | ||
| 1088 | lookup = X509_STORE_add_lookup(cert_ctx, | ||
| 1089 | X509_LOOKUP_hash_dir()); | ||
| 1090 | if (lookup == NULL) | ||
| 1091 | { | ||
| 1092 | BIO_printf(bio_err, "memory allocation failure\n"); | ||
| 1093 | goto err; | ||
| 1094 | } | ||
| 1095 | i = X509_LOOKUP_add_dir(lookup, ca_path, X509_FILETYPE_PEM); | ||
| 1096 | if (!i) | ||
| 1097 | { | ||
| 1098 | BIO_printf(bio_err, "Error loading directory %s\n", | ||
| 1099 | ca_path); | ||
| 1100 | goto err; | ||
| 1101 | } | ||
| 1102 | } | ||
| 1103 | |||
| 1104 | /* Adding a trusted certificate file source. */ | ||
| 1105 | if (ca_file) | ||
| 1106 | { | ||
| 1107 | lookup = X509_STORE_add_lookup(cert_ctx, X509_LOOKUP_file()); | ||
| 1108 | if (lookup == NULL) | ||
| 1109 | { | ||
| 1110 | BIO_printf(bio_err, "memory allocation failure\n"); | ||
| 1111 | goto err; | ||
| 1112 | } | ||
| 1113 | i = X509_LOOKUP_load_file(lookup, ca_file, X509_FILETYPE_PEM); | ||
| 1114 | if (!i) | ||
| 1115 | { | ||
| 1116 | BIO_printf(bio_err, "Error loading file %s\n", ca_file); | ||
| 1117 | goto err; | ||
| 1118 | } | ||
| 1119 | } | ||
| 1120 | |||
| 1121 | return cert_ctx; | ||
| 1122 | err: | ||
| 1123 | X509_STORE_free(cert_ctx); | ||
| 1124 | return NULL; | ||
| 1125 | } | ||
| 1126 | |||
| 1127 | static int MS_CALLBACK verify_cb(int ok, X509_STORE_CTX *ctx) | ||
| 1128 | { | ||
| 1129 | /* | ||
| 1130 | char buf[256]; | ||
| 1131 | |||
| 1132 | if (!ok) | ||
| 1133 | { | ||
| 1134 | X509_NAME_oneline(X509_get_subject_name(ctx->current_cert), | ||
| 1135 | buf, sizeof(buf)); | ||
| 1136 | printf("%s\n", buf); | ||
| 1137 | printf("error %d at %d depth lookup: %s\n", | ||
| 1138 | ctx->error, ctx->error_depth, | ||
| 1139 | X509_verify_cert_error_string(ctx->error)); | ||
| 1140 | } | ||
| 1141 | */ | ||
| 1142 | |||
| 1143 | return ok; | ||
| 1144 | } | ||
diff --git a/src/lib/libssl/src/apps/tsget b/src/lib/libssl/src/apps/tsget new file mode 100644 index 0000000000..258d0bc348 --- /dev/null +++ b/src/lib/libssl/src/apps/tsget | |||
| @@ -0,0 +1,195 @@ | |||
| 1 | #!/usr/bin/perl -w | ||
| 2 | # Written by Zoltan Glozik <zglozik@stones.com>. | ||
| 3 | # Copyright (c) 2002 The OpenTSA Project. All rights reserved. | ||
| 4 | $::version = '$Id: tsget,v 1.1.1.1 2009/04/06 06:30:00 djm Exp $'; | ||
| 5 | |||
| 6 | use strict; | ||
| 7 | use IO::Handle; | ||
| 8 | use Getopt::Std; | ||
| 9 | use File::Basename; | ||
| 10 | use WWW::Curl::easy; | ||
| 11 | |||
| 12 | use vars qw(%options); | ||
| 13 | |||
| 14 | # Callback for reading the body. | ||
| 15 | sub read_body { | ||
| 16 | my ($maxlength, $state) = @_; | ||
| 17 | my $return_data = ""; | ||
| 18 | my $data_len = length ${$state->{data}}; | ||
| 19 | if ($state->{bytes} < $data_len) { | ||
| 20 | $data_len = $data_len - $state->{bytes}; | ||
| 21 | $data_len = $maxlength if $data_len > $maxlength; | ||
| 22 | $return_data = substr ${$state->{data}}, $state->{bytes}, $data_len; | ||
| 23 | $state->{bytes} += $data_len; | ||
| 24 | } | ||
| 25 | return $return_data; | ||
| 26 | } | ||
| 27 | |||
| 28 | # Callback for writing the body into a variable. | ||
| 29 | sub write_body { | ||
| 30 | my ($data, $pointer) = @_; | ||
| 31 | ${$pointer} .= $data; | ||
| 32 | return length($data); | ||
| 33 | } | ||
| 34 | |||
| 35 | # Initialise a new Curl object. | ||
| 36 | sub create_curl { | ||
| 37 | my $url = shift; | ||
| 38 | |||
| 39 | # Create Curl object. | ||
| 40 | my $curl = WWW::Curl::easy::new(); | ||
| 41 | |||
| 42 | # Error-handling related options. | ||
| 43 | $curl->setopt(CURLOPT_VERBOSE, 1) if $options{d}; | ||
| 44 | $curl->setopt(CURLOPT_FAILONERROR, 1); | ||
| 45 | $curl->setopt(CURLOPT_USERAGENT, "OpenTSA tsget.pl/" . (split / /, $::version)[2]); | ||
| 46 | |||
| 47 | # Options for POST method. | ||
| 48 | $curl->setopt(CURLOPT_UPLOAD, 1); | ||
| 49 | $curl->setopt(CURLOPT_CUSTOMREQUEST, "POST"); | ||
| 50 | $curl->setopt(CURLOPT_HTTPHEADER, | ||
| 51 | ["Content-Type: application/timestamp-query", | ||
| 52 | "Accept: application/timestamp-reply"]); | ||
| 53 | $curl->setopt(CURLOPT_READFUNCTION, \&read_body); | ||
| 54 | $curl->setopt(CURLOPT_HEADERFUNCTION, sub { return length($_[0]); }); | ||
| 55 | |||
| 56 | # Options for getting the result. | ||
| 57 | $curl->setopt(CURLOPT_WRITEFUNCTION, \&write_body); | ||
| 58 | |||
| 59 | # SSL related options. | ||
| 60 | $curl->setopt(CURLOPT_SSLKEYTYPE, "PEM"); | ||
| 61 | $curl->setopt(CURLOPT_SSL_VERIFYPEER, 1); # Verify server's certificate. | ||
| 62 | $curl->setopt(CURLOPT_SSL_VERIFYHOST, 2); # Check server's CN. | ||
| 63 | $curl->setopt(CURLOPT_SSLKEY, $options{k}) if defined($options{k}); | ||
| 64 | $curl->setopt(CURLOPT_SSLKEYPASSWD, $options{p}) if defined($options{p}); | ||
| 65 | $curl->setopt(CURLOPT_SSLCERT, $options{c}) if defined($options{c}); | ||
| 66 | $curl->setopt(CURLOPT_CAINFO, $options{C}) if defined($options{C}); | ||
| 67 | $curl->setopt(CURLOPT_CAPATH, $options{P}) if defined($options{P}); | ||
| 68 | $curl->setopt(CURLOPT_RANDOM_FILE, $options{r}) if defined($options{r}); | ||
| 69 | $curl->setopt(CURLOPT_EGDSOCKET, $options{g}) if defined($options{g}); | ||
| 70 | |||
| 71 | # Setting destination. | ||
| 72 | $curl->setopt(CURLOPT_URL, $url); | ||
| 73 | |||
| 74 | return $curl; | ||
| 75 | } | ||
| 76 | |||
| 77 | # Send a request and returns the body back. | ||
| 78 | sub get_timestamp { | ||
| 79 | my $curl = shift; | ||
| 80 | my $body = shift; | ||
| 81 | my $ts_body; | ||
| 82 | local $::error_buf; | ||
| 83 | |||
| 84 | # Error-handling related options. | ||
| 85 | $curl->setopt(CURLOPT_ERRORBUFFER, "::error_buf"); | ||
| 86 | |||
| 87 | # Options for POST method. | ||
| 88 | $curl->setopt(CURLOPT_INFILE, {data => $body, bytes => 0}); | ||
| 89 | $curl->setopt(CURLOPT_INFILESIZE, length(${$body})); | ||
| 90 | |||
| 91 | # Options for getting the result. | ||
| 92 | $curl->setopt(CURLOPT_FILE, \$ts_body); | ||
| 93 | |||
| 94 | # Send the request... | ||
| 95 | my $error_code = $curl->perform(); | ||
| 96 | my $error_string; | ||
| 97 | if ($error_code != 0) { | ||
| 98 | my $http_code = $curl->getinfo(CURLINFO_HTTP_CODE); | ||
| 99 | $error_string = "could not get timestamp"; | ||
| 100 | $error_string .= ", http code: $http_code" unless $http_code == 0; | ||
| 101 | $error_string .= ", curl code: $error_code"; | ||
| 102 | $error_string .= " ($::error_buf)" if defined($::error_buf); | ||
| 103 | } else { | ||
| 104 | my $ct = $curl->getinfo(CURLINFO_CONTENT_TYPE); | ||
| 105 | if (lc($ct) ne "application/timestamp-reply") { | ||
| 106 | $error_string = "unexpected content type returned: $ct"; | ||
| 107 | } | ||
| 108 | } | ||
| 109 | return ($ts_body, $error_string); | ||
| 110 | |||
| 111 | } | ||
| 112 | |||
| 113 | # Print usage information and exists. | ||
| 114 | sub usage { | ||
| 115 | |||
| 116 | print STDERR "usage: $0 -h <server_url> [-e <extension>] [-o <output>] "; | ||
| 117 | print STDERR "[-v] [-d] [-k <private_key.pem>] [-p <key_password>] "; | ||
| 118 | print STDERR "[-c <client_cert.pem>] [-C <CA_certs.pem>] [-P <CA_path>] "; | ||
| 119 | print STDERR "[-r <file:file...>] [-g <EGD_socket>] [<request>]...\n"; | ||
| 120 | exit 1; | ||
| 121 | } | ||
| 122 | |||
| 123 | # ---------------------------------------------------------------------- | ||
| 124 | # Main program | ||
| 125 | # ---------------------------------------------------------------------- | ||
| 126 | |||
| 127 | # Getting command-line options (default comes from TSGET environment variable). | ||
| 128 | my $getopt_arg = "h:e:o:vdk:p:c:C:P:r:g:"; | ||
| 129 | if (exists $ENV{TSGET}) { | ||
| 130 | my @old_argv = @ARGV; | ||
| 131 | @ARGV = split /\s+/, $ENV{TSGET}; | ||
| 132 | getopts($getopt_arg, \%options) or usage; | ||
| 133 | @ARGV = @old_argv; | ||
| 134 | } | ||
| 135 | getopts($getopt_arg, \%options) or usage; | ||
| 136 | |||
| 137 | # Checking argument consistency. | ||
| 138 | if (!exists($options{h}) || (@ARGV == 0 && !exists($options{o})) | ||
| 139 | || (@ARGV > 1 && exists($options{o}))) { | ||
| 140 | print STDERR "Inconsistent command line options.\n"; | ||
| 141 | usage; | ||
| 142 | } | ||
| 143 | # Setting defaults. | ||
| 144 | @ARGV = ("-") unless @ARGV != 0; | ||
| 145 | $options{e} = ".tsr" unless defined($options{e}); | ||
| 146 | |||
| 147 | # Processing requests. | ||
| 148 | my $curl = create_curl $options{h}; | ||
| 149 | undef $/; # For reading whole files. | ||
| 150 | REQUEST: foreach (@ARGV) { | ||
| 151 | my $input = $_; | ||
| 152 | my ($base, $path) = fileparse($input, '\.[^.]*'); | ||
| 153 | my $output_base = $base . $options{e}; | ||
| 154 | my $output = defined($options{o}) ? $options{o} : $path . $output_base; | ||
| 155 | |||
| 156 | STDERR->printflush("$input: ") if $options{v}; | ||
| 157 | # Read request. | ||
| 158 | my $body; | ||
| 159 | if ($input eq "-") { | ||
| 160 | # Read the request from STDIN; | ||
| 161 | $body = <STDIN>; | ||
| 162 | } else { | ||
| 163 | # Read the request from file. | ||
| 164 | open INPUT, "<" . $input | ||
| 165 | or warn("$input: could not open input file: $!\n"), next REQUEST; | ||
| 166 | $body = <INPUT>; | ||
| 167 | close INPUT | ||
| 168 | or warn("$input: could not close input file: $!\n"), next REQUEST; | ||
| 169 | } | ||
| 170 | |||
| 171 | # Send request. | ||
| 172 | STDERR->printflush("sending request") if $options{v}; | ||
| 173 | |||
| 174 | my ($ts_body, $error) = get_timestamp $curl, \$body; | ||
| 175 | if (defined($error)) { | ||
| 176 | die "$input: fatal error: $error\n"; | ||
| 177 | } | ||
| 178 | STDERR->printflush(", reply received") if $options{v}; | ||
| 179 | |||
| 180 | # Write response. | ||
| 181 | if ($output eq "-") { | ||
| 182 | # Write to STDOUT. | ||
| 183 | print $ts_body; | ||
| 184 | } else { | ||
| 185 | # Write to file. | ||
| 186 | open OUTPUT, ">", $output | ||
| 187 | or warn("$output: could not open output file: $!\n"), next REQUEST; | ||
| 188 | print OUTPUT $ts_body; | ||
| 189 | close OUTPUT | ||
| 190 | or warn("$output: could not close output file: $!\n"), next REQUEST; | ||
| 191 | } | ||
| 192 | STDERR->printflush(", $output written.\n") if $options{v}; | ||
| 193 | } | ||
| 194 | $curl->cleanup(); | ||
| 195 | WWW::Curl::easy::global_cleanup(); | ||
diff --git a/src/lib/libssl/src/crypto/aes/aes_x86core.c b/src/lib/libssl/src/crypto/aes/aes_x86core.c new file mode 100644 index 0000000000..d323e265c0 --- /dev/null +++ b/src/lib/libssl/src/crypto/aes/aes_x86core.c | |||
| @@ -0,0 +1,1063 @@ | |||
| 1 | /* crypto/aes/aes_core.c -*- mode:C; c-file-style: "eay" -*- */ | ||
| 2 | /** | ||
| 3 | * rijndael-alg-fst.c | ||
| 4 | * | ||
| 5 | * @version 3.0 (December 2000) | ||
| 6 | * | ||
| 7 | * Optimised ANSI C code for the Rijndael cipher (now AES) | ||
| 8 | * | ||
| 9 | * @author Vincent Rijmen <vincent.rijmen@esat.kuleuven.ac.be> | ||
| 10 | * @author Antoon Bosselaers <antoon.bosselaers@esat.kuleuven.ac.be> | ||
| 11 | * @author Paulo Barreto <paulo.barreto@terra.com.br> | ||
| 12 | * | ||
| 13 | * This code is hereby placed in the public domain. | ||
| 14 | * | ||
| 15 | * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ''AS IS'' AND ANY EXPRESS | ||
| 16 | * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
| 17 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 18 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE | ||
| 19 | * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR | ||
| 20 | * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF | ||
| 21 | * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR | ||
| 22 | * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, | ||
| 23 | * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE | ||
| 24 | * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, | ||
| 25 | * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
| 26 | */ | ||
| 27 | |||
| 28 | /* | ||
| 29 | * This is experimental x86[_64] derivative. It assumes little-endian | ||
| 30 | * byte order and expects CPU to sustain unaligned memory references. | ||
| 31 | * It is used as playground for cache-time attack mitigations and | ||
| 32 | * serves as reference C implementation for x86[_64] assembler. | ||
| 33 | * | ||
| 34 | * <appro@fy.chalmers.se> | ||
| 35 | */ | ||
| 36 | |||
| 37 | |||
| 38 | #ifndef AES_DEBUG | ||
| 39 | # ifndef NDEBUG | ||
| 40 | # define NDEBUG | ||
| 41 | # endif | ||
| 42 | #endif | ||
| 43 | #include <assert.h> | ||
| 44 | |||
| 45 | #include <stdlib.h> | ||
| 46 | #include <openssl/aes.h> | ||
| 47 | #include "aes_locl.h" | ||
| 48 | |||
| 49 | /* | ||
| 50 | * These two parameters control which table, 256-byte or 2KB, is | ||
| 51 | * referenced in outer and respectively inner rounds. | ||
| 52 | */ | ||
| 53 | #define AES_COMPACT_IN_OUTER_ROUNDS | ||
| 54 | #ifdef AES_COMPACT_IN_OUTER_ROUNDS | ||
| 55 | /* AES_COMPACT_IN_OUTER_ROUNDS costs ~30% in performance, while | ||
| 56 | * adding AES_COMPACT_IN_INNER_ROUNDS reduces benchmark *further* | ||
| 57 | * by factor of ~2. */ | ||
| 58 | # undef AES_COMPACT_IN_INNER_ROUNDS | ||
| 59 | #endif | ||
| 60 | |||
| 61 | #if 1 | ||
| 62 | static void prefetch256(const void *table) | ||
| 63 | { | ||
| 64 | volatile unsigned long *t=(void *)table,ret; | ||
| 65 | unsigned long sum; | ||
| 66 | int i; | ||
| 67 | |||
| 68 | /* 32 is common least cache-line size */ | ||
| 69 | for (sum=0,i=0;i<256/sizeof(t[0]);i+=32/sizeof(t[0])) sum ^= t[i]; | ||
| 70 | |||
| 71 | ret = sum; | ||
| 72 | } | ||
| 73 | #else | ||
| 74 | # define prefetch256(t) | ||
| 75 | #endif | ||
| 76 | |||
| 77 | #undef GETU32 | ||
| 78 | #define GETU32(p) (*((u32*)(p))) | ||
| 79 | |||
| 80 | #if (defined(_WIN32) || defined(_WIN64)) && !defined(__MINGW32__) | ||
| 81 | typedef unsigned __int64 u64; | ||
| 82 | #define U64(C) C##UI64 | ||
| 83 | #elif defined(__arch64__) | ||
| 84 | typedef unsigned long u64; | ||
| 85 | #define U64(C) C##UL | ||
| 86 | #else | ||
| 87 | typedef unsigned long long u64; | ||
| 88 | #define U64(C) C##ULL | ||
| 89 | #endif | ||
| 90 | |||
| 91 | #undef ROTATE | ||
| 92 | #if defined(_MSC_VER) || defined(__ICC) | ||
| 93 | # define ROTATE(a,n) _lrotl(a,n) | ||
| 94 | #elif defined(__GNUC__) && __GNUC__>=2 | ||
| 95 | # if defined(__i386) || defined(__i386__) || defined(__x86_64) || defined(__x86_64__) | ||
| 96 | # define ROTATE(a,n) ({ register unsigned int ret; \ | ||
| 97 | asm ( \ | ||
| 98 | "roll %1,%0" \ | ||
| 99 | : "=r"(ret) \ | ||
| 100 | : "I"(n), "0"(a) \ | ||
| 101 | : "cc"); \ | ||
| 102 | ret; \ | ||
| 103 | }) | ||
| 104 | # endif | ||
| 105 | #endif | ||
| 106 | /* | ||
| 107 | Te [x] = S [x].[02, 01, 01, 03, 02, 01, 01, 03]; | ||
| 108 | Te0[x] = S [x].[02, 01, 01, 03]; | ||
| 109 | Te1[x] = S [x].[03, 02, 01, 01]; | ||
| 110 | Te2[x] = S [x].[01, 03, 02, 01]; | ||
| 111 | Te3[x] = S [x].[01, 01, 03, 02]; | ||
| 112 | */ | ||
| 113 | #define Te0 (u32)((u64*)((u8*)Te+0)) | ||
| 114 | #define Te1 (u32)((u64*)((u8*)Te+3)) | ||
| 115 | #define Te2 (u32)((u64*)((u8*)Te+2)) | ||
| 116 | #define Te3 (u32)((u64*)((u8*)Te+1)) | ||
| 117 | /* | ||
| 118 | Td [x] = Si[x].[0e, 09, 0d, 0b, 0e, 09, 0d, 0b]; | ||
| 119 | Td0[x] = Si[x].[0e, 09, 0d, 0b]; | ||
| 120 | Td1[x] = Si[x].[0b, 0e, 09, 0d]; | ||
| 121 | Td2[x] = Si[x].[0d, 0b, 0e, 09]; | ||
| 122 | Td3[x] = Si[x].[09, 0d, 0b, 0e]; | ||
| 123 | Td4[x] = Si[x].[01]; | ||
| 124 | */ | ||
| 125 | #define Td0 (u32)((u64*)((u8*)Td+0)) | ||
| 126 | #define Td1 (u32)((u64*)((u8*)Td+3)) | ||
| 127 | #define Td2 (u32)((u64*)((u8*)Td+2)) | ||
| 128 | #define Td3 (u32)((u64*)((u8*)Td+1)) | ||
| 129 | |||
| 130 | static const u64 Te[256] = { | ||
| 131 | U64(0xa56363c6a56363c6), U64(0x847c7cf8847c7cf8), | ||
| 132 | U64(0x997777ee997777ee), U64(0x8d7b7bf68d7b7bf6), | ||
| 133 | U64(0x0df2f2ff0df2f2ff), U64(0xbd6b6bd6bd6b6bd6), | ||
| 134 | U64(0xb16f6fdeb16f6fde), U64(0x54c5c59154c5c591), | ||
| 135 | U64(0x5030306050303060), U64(0x0301010203010102), | ||
| 136 | U64(0xa96767cea96767ce), U64(0x7d2b2b567d2b2b56), | ||
| 137 | U64(0x19fefee719fefee7), U64(0x62d7d7b562d7d7b5), | ||
| 138 | U64(0xe6abab4de6abab4d), U64(0x9a7676ec9a7676ec), | ||
| 139 | U64(0x45caca8f45caca8f), U64(0x9d82821f9d82821f), | ||
| 140 | U64(0x40c9c98940c9c989), U64(0x877d7dfa877d7dfa), | ||
| 141 | U64(0x15fafaef15fafaef), U64(0xeb5959b2eb5959b2), | ||
| 142 | U64(0xc947478ec947478e), U64(0x0bf0f0fb0bf0f0fb), | ||
| 143 | U64(0xecadad41ecadad41), U64(0x67d4d4b367d4d4b3), | ||
| 144 | U64(0xfda2a25ffda2a25f), U64(0xeaafaf45eaafaf45), | ||
| 145 | U64(0xbf9c9c23bf9c9c23), U64(0xf7a4a453f7a4a453), | ||
| 146 | U64(0x967272e4967272e4), U64(0x5bc0c09b5bc0c09b), | ||
| 147 | U64(0xc2b7b775c2b7b775), U64(0x1cfdfde11cfdfde1), | ||
| 148 | U64(0xae93933dae93933d), U64(0x6a26264c6a26264c), | ||
| 149 | U64(0x5a36366c5a36366c), U64(0x413f3f7e413f3f7e), | ||
| 150 | U64(0x02f7f7f502f7f7f5), U64(0x4fcccc834fcccc83), | ||
| 151 | U64(0x5c3434685c343468), U64(0xf4a5a551f4a5a551), | ||
| 152 | U64(0x34e5e5d134e5e5d1), U64(0x08f1f1f908f1f1f9), | ||
| 153 | U64(0x937171e2937171e2), U64(0x73d8d8ab73d8d8ab), | ||
| 154 | U64(0x5331316253313162), U64(0x3f15152a3f15152a), | ||
| 155 | U64(0x0c0404080c040408), U64(0x52c7c79552c7c795), | ||
| 156 | U64(0x6523234665232346), U64(0x5ec3c39d5ec3c39d), | ||
| 157 | U64(0x2818183028181830), U64(0xa1969637a1969637), | ||
| 158 | U64(0x0f05050a0f05050a), U64(0xb59a9a2fb59a9a2f), | ||
| 159 | U64(0x0907070e0907070e), U64(0x3612122436121224), | ||
| 160 | U64(0x9b80801b9b80801b), U64(0x3de2e2df3de2e2df), | ||
| 161 | U64(0x26ebebcd26ebebcd), U64(0x6927274e6927274e), | ||
| 162 | U64(0xcdb2b27fcdb2b27f), U64(0x9f7575ea9f7575ea), | ||
| 163 | U64(0x1b0909121b090912), U64(0x9e83831d9e83831d), | ||
| 164 | U64(0x742c2c58742c2c58), U64(0x2e1a1a342e1a1a34), | ||
| 165 | U64(0x2d1b1b362d1b1b36), U64(0xb26e6edcb26e6edc), | ||
| 166 | U64(0xee5a5ab4ee5a5ab4), U64(0xfba0a05bfba0a05b), | ||
| 167 | U64(0xf65252a4f65252a4), U64(0x4d3b3b764d3b3b76), | ||
| 168 | U64(0x61d6d6b761d6d6b7), U64(0xceb3b37dceb3b37d), | ||
| 169 | U64(0x7b2929527b292952), U64(0x3ee3e3dd3ee3e3dd), | ||
| 170 | U64(0x712f2f5e712f2f5e), U64(0x9784841397848413), | ||
| 171 | U64(0xf55353a6f55353a6), U64(0x68d1d1b968d1d1b9), | ||
| 172 | U64(0x0000000000000000), U64(0x2cededc12cededc1), | ||
| 173 | U64(0x6020204060202040), U64(0x1ffcfce31ffcfce3), | ||
| 174 | U64(0xc8b1b179c8b1b179), U64(0xed5b5bb6ed5b5bb6), | ||
| 175 | U64(0xbe6a6ad4be6a6ad4), U64(0x46cbcb8d46cbcb8d), | ||
| 176 | U64(0xd9bebe67d9bebe67), U64(0x4b3939724b393972), | ||
| 177 | U64(0xde4a4a94de4a4a94), U64(0xd44c4c98d44c4c98), | ||
| 178 | U64(0xe85858b0e85858b0), U64(0x4acfcf854acfcf85), | ||
| 179 | U64(0x6bd0d0bb6bd0d0bb), U64(0x2aefefc52aefefc5), | ||
| 180 | U64(0xe5aaaa4fe5aaaa4f), U64(0x16fbfbed16fbfbed), | ||
| 181 | U64(0xc5434386c5434386), U64(0xd74d4d9ad74d4d9a), | ||
| 182 | U64(0x5533336655333366), U64(0x9485851194858511), | ||
| 183 | U64(0xcf45458acf45458a), U64(0x10f9f9e910f9f9e9), | ||
| 184 | U64(0x0602020406020204), U64(0x817f7ffe817f7ffe), | ||
| 185 | U64(0xf05050a0f05050a0), U64(0x443c3c78443c3c78), | ||
| 186 | U64(0xba9f9f25ba9f9f25), U64(0xe3a8a84be3a8a84b), | ||
| 187 | U64(0xf35151a2f35151a2), U64(0xfea3a35dfea3a35d), | ||
| 188 | U64(0xc0404080c0404080), U64(0x8a8f8f058a8f8f05), | ||
| 189 | U64(0xad92923fad92923f), U64(0xbc9d9d21bc9d9d21), | ||
| 190 | U64(0x4838387048383870), U64(0x04f5f5f104f5f5f1), | ||
| 191 | U64(0xdfbcbc63dfbcbc63), U64(0xc1b6b677c1b6b677), | ||
| 192 | U64(0x75dadaaf75dadaaf), U64(0x6321214263212142), | ||
| 193 | U64(0x3010102030101020), U64(0x1affffe51affffe5), | ||
| 194 | U64(0x0ef3f3fd0ef3f3fd), U64(0x6dd2d2bf6dd2d2bf), | ||
| 195 | U64(0x4ccdcd814ccdcd81), U64(0x140c0c18140c0c18), | ||
| 196 | U64(0x3513132635131326), U64(0x2fececc32fececc3), | ||
| 197 | U64(0xe15f5fbee15f5fbe), U64(0xa2979735a2979735), | ||
| 198 | U64(0xcc444488cc444488), U64(0x3917172e3917172e), | ||
| 199 | U64(0x57c4c49357c4c493), U64(0xf2a7a755f2a7a755), | ||
| 200 | U64(0x827e7efc827e7efc), U64(0x473d3d7a473d3d7a), | ||
| 201 | U64(0xac6464c8ac6464c8), U64(0xe75d5dbae75d5dba), | ||
| 202 | U64(0x2b1919322b191932), U64(0x957373e6957373e6), | ||
| 203 | U64(0xa06060c0a06060c0), U64(0x9881811998818119), | ||
| 204 | U64(0xd14f4f9ed14f4f9e), U64(0x7fdcdca37fdcdca3), | ||
| 205 | U64(0x6622224466222244), U64(0x7e2a2a547e2a2a54), | ||
| 206 | U64(0xab90903bab90903b), U64(0x8388880b8388880b), | ||
| 207 | U64(0xca46468cca46468c), U64(0x29eeeec729eeeec7), | ||
| 208 | U64(0xd3b8b86bd3b8b86b), U64(0x3c1414283c141428), | ||
| 209 | U64(0x79dedea779dedea7), U64(0xe25e5ebce25e5ebc), | ||
| 210 | U64(0x1d0b0b161d0b0b16), U64(0x76dbdbad76dbdbad), | ||
| 211 | U64(0x3be0e0db3be0e0db), U64(0x5632326456323264), | ||
| 212 | U64(0x4e3a3a744e3a3a74), U64(0x1e0a0a141e0a0a14), | ||
| 213 | U64(0xdb494992db494992), U64(0x0a06060c0a06060c), | ||
| 214 | U64(0x6c2424486c242448), U64(0xe45c5cb8e45c5cb8), | ||
| 215 | U64(0x5dc2c29f5dc2c29f), U64(0x6ed3d3bd6ed3d3bd), | ||
| 216 | U64(0xefacac43efacac43), U64(0xa66262c4a66262c4), | ||
| 217 | U64(0xa8919139a8919139), U64(0xa4959531a4959531), | ||
| 218 | U64(0x37e4e4d337e4e4d3), U64(0x8b7979f28b7979f2), | ||
| 219 | U64(0x32e7e7d532e7e7d5), U64(0x43c8c88b43c8c88b), | ||
| 220 | U64(0x5937376e5937376e), U64(0xb76d6ddab76d6dda), | ||
| 221 | U64(0x8c8d8d018c8d8d01), U64(0x64d5d5b164d5d5b1), | ||
| 222 | U64(0xd24e4e9cd24e4e9c), U64(0xe0a9a949e0a9a949), | ||
| 223 | U64(0xb46c6cd8b46c6cd8), U64(0xfa5656acfa5656ac), | ||
| 224 | U64(0x07f4f4f307f4f4f3), U64(0x25eaeacf25eaeacf), | ||
| 225 | U64(0xaf6565caaf6565ca), U64(0x8e7a7af48e7a7af4), | ||
| 226 | U64(0xe9aeae47e9aeae47), U64(0x1808081018080810), | ||
| 227 | U64(0xd5baba6fd5baba6f), U64(0x887878f0887878f0), | ||
| 228 | U64(0x6f25254a6f25254a), U64(0x722e2e5c722e2e5c), | ||
| 229 | U64(0x241c1c38241c1c38), U64(0xf1a6a657f1a6a657), | ||
| 230 | U64(0xc7b4b473c7b4b473), U64(0x51c6c69751c6c697), | ||
| 231 | U64(0x23e8e8cb23e8e8cb), U64(0x7cdddda17cdddda1), | ||
| 232 | U64(0x9c7474e89c7474e8), U64(0x211f1f3e211f1f3e), | ||
| 233 | U64(0xdd4b4b96dd4b4b96), U64(0xdcbdbd61dcbdbd61), | ||
| 234 | U64(0x868b8b0d868b8b0d), U64(0x858a8a0f858a8a0f), | ||
| 235 | U64(0x907070e0907070e0), U64(0x423e3e7c423e3e7c), | ||
| 236 | U64(0xc4b5b571c4b5b571), U64(0xaa6666ccaa6666cc), | ||
| 237 | U64(0xd8484890d8484890), U64(0x0503030605030306), | ||
| 238 | U64(0x01f6f6f701f6f6f7), U64(0x120e0e1c120e0e1c), | ||
| 239 | U64(0xa36161c2a36161c2), U64(0x5f35356a5f35356a), | ||
| 240 | U64(0xf95757aef95757ae), U64(0xd0b9b969d0b9b969), | ||
| 241 | U64(0x9186861791868617), U64(0x58c1c19958c1c199), | ||
| 242 | U64(0x271d1d3a271d1d3a), U64(0xb99e9e27b99e9e27), | ||
| 243 | U64(0x38e1e1d938e1e1d9), U64(0x13f8f8eb13f8f8eb), | ||
| 244 | U64(0xb398982bb398982b), U64(0x3311112233111122), | ||
| 245 | U64(0xbb6969d2bb6969d2), U64(0x70d9d9a970d9d9a9), | ||
| 246 | U64(0x898e8e07898e8e07), U64(0xa7949433a7949433), | ||
| 247 | U64(0xb69b9b2db69b9b2d), U64(0x221e1e3c221e1e3c), | ||
| 248 | U64(0x9287871592878715), U64(0x20e9e9c920e9e9c9), | ||
| 249 | U64(0x49cece8749cece87), U64(0xff5555aaff5555aa), | ||
| 250 | U64(0x7828285078282850), U64(0x7adfdfa57adfdfa5), | ||
| 251 | U64(0x8f8c8c038f8c8c03), U64(0xf8a1a159f8a1a159), | ||
| 252 | U64(0x8089890980898909), U64(0x170d0d1a170d0d1a), | ||
| 253 | U64(0xdabfbf65dabfbf65), U64(0x31e6e6d731e6e6d7), | ||
| 254 | U64(0xc6424284c6424284), U64(0xb86868d0b86868d0), | ||
| 255 | U64(0xc3414182c3414182), U64(0xb0999929b0999929), | ||
| 256 | U64(0x772d2d5a772d2d5a), U64(0x110f0f1e110f0f1e), | ||
| 257 | U64(0xcbb0b07bcbb0b07b), U64(0xfc5454a8fc5454a8), | ||
| 258 | U64(0xd6bbbb6dd6bbbb6d), U64(0x3a16162c3a16162c) | ||
| 259 | }; | ||
| 260 | |||
| 261 | static const u8 Te4[256] = { | ||
| 262 | 0x63U, 0x7cU, 0x77U, 0x7bU, 0xf2U, 0x6bU, 0x6fU, 0xc5U, | ||
| 263 | 0x30U, 0x01U, 0x67U, 0x2bU, 0xfeU, 0xd7U, 0xabU, 0x76U, | ||
| 264 | 0xcaU, 0x82U, 0xc9U, 0x7dU, 0xfaU, 0x59U, 0x47U, 0xf0U, | ||
| 265 | 0xadU, 0xd4U, 0xa2U, 0xafU, 0x9cU, 0xa4U, 0x72U, 0xc0U, | ||
| 266 | 0xb7U, 0xfdU, 0x93U, 0x26U, 0x36U, 0x3fU, 0xf7U, 0xccU, | ||
| 267 | 0x34U, 0xa5U, 0xe5U, 0xf1U, 0x71U, 0xd8U, 0x31U, 0x15U, | ||
| 268 | 0x04U, 0xc7U, 0x23U, 0xc3U, 0x18U, 0x96U, 0x05U, 0x9aU, | ||
| 269 | 0x07U, 0x12U, 0x80U, 0xe2U, 0xebU, 0x27U, 0xb2U, 0x75U, | ||
| 270 | 0x09U, 0x83U, 0x2cU, 0x1aU, 0x1bU, 0x6eU, 0x5aU, 0xa0U, | ||
| 271 | 0x52U, 0x3bU, 0xd6U, 0xb3U, 0x29U, 0xe3U, 0x2fU, 0x84U, | ||
| 272 | 0x53U, 0xd1U, 0x00U, 0xedU, 0x20U, 0xfcU, 0xb1U, 0x5bU, | ||
| 273 | 0x6aU, 0xcbU, 0xbeU, 0x39U, 0x4aU, 0x4cU, 0x58U, 0xcfU, | ||
| 274 | 0xd0U, 0xefU, 0xaaU, 0xfbU, 0x43U, 0x4dU, 0x33U, 0x85U, | ||
| 275 | 0x45U, 0xf9U, 0x02U, 0x7fU, 0x50U, 0x3cU, 0x9fU, 0xa8U, | ||
| 276 | 0x51U, 0xa3U, 0x40U, 0x8fU, 0x92U, 0x9dU, 0x38U, 0xf5U, | ||
| 277 | 0xbcU, 0xb6U, 0xdaU, 0x21U, 0x10U, 0xffU, 0xf3U, 0xd2U, | ||
| 278 | 0xcdU, 0x0cU, 0x13U, 0xecU, 0x5fU, 0x97U, 0x44U, 0x17U, | ||
| 279 | 0xc4U, 0xa7U, 0x7eU, 0x3dU, 0x64U, 0x5dU, 0x19U, 0x73U, | ||
| 280 | 0x60U, 0x81U, 0x4fU, 0xdcU, 0x22U, 0x2aU, 0x90U, 0x88U, | ||
| 281 | 0x46U, 0xeeU, 0xb8U, 0x14U, 0xdeU, 0x5eU, 0x0bU, 0xdbU, | ||
| 282 | 0xe0U, 0x32U, 0x3aU, 0x0aU, 0x49U, 0x06U, 0x24U, 0x5cU, | ||
| 283 | 0xc2U, 0xd3U, 0xacU, 0x62U, 0x91U, 0x95U, 0xe4U, 0x79U, | ||
| 284 | 0xe7U, 0xc8U, 0x37U, 0x6dU, 0x8dU, 0xd5U, 0x4eU, 0xa9U, | ||
| 285 | 0x6cU, 0x56U, 0xf4U, 0xeaU, 0x65U, 0x7aU, 0xaeU, 0x08U, | ||
| 286 | 0xbaU, 0x78U, 0x25U, 0x2eU, 0x1cU, 0xa6U, 0xb4U, 0xc6U, | ||
| 287 | 0xe8U, 0xddU, 0x74U, 0x1fU, 0x4bU, 0xbdU, 0x8bU, 0x8aU, | ||
| 288 | 0x70U, 0x3eU, 0xb5U, 0x66U, 0x48U, 0x03U, 0xf6U, 0x0eU, | ||
| 289 | 0x61U, 0x35U, 0x57U, 0xb9U, 0x86U, 0xc1U, 0x1dU, 0x9eU, | ||
| 290 | 0xe1U, 0xf8U, 0x98U, 0x11U, 0x69U, 0xd9U, 0x8eU, 0x94U, | ||
| 291 | 0x9bU, 0x1eU, 0x87U, 0xe9U, 0xceU, 0x55U, 0x28U, 0xdfU, | ||
| 292 | 0x8cU, 0xa1U, 0x89U, 0x0dU, 0xbfU, 0xe6U, 0x42U, 0x68U, | ||
| 293 | 0x41U, 0x99U, 0x2dU, 0x0fU, 0xb0U, 0x54U, 0xbbU, 0x16U | ||
| 294 | }; | ||
| 295 | |||
| 296 | static const u64 Td[256] = { | ||
| 297 | U64(0x50a7f45150a7f451), U64(0x5365417e5365417e), | ||
| 298 | U64(0xc3a4171ac3a4171a), U64(0x965e273a965e273a), | ||
| 299 | U64(0xcb6bab3bcb6bab3b), U64(0xf1459d1ff1459d1f), | ||
| 300 | U64(0xab58faacab58faac), U64(0x9303e34b9303e34b), | ||
| 301 | U64(0x55fa302055fa3020), U64(0xf66d76adf66d76ad), | ||
| 302 | U64(0x9176cc889176cc88), U64(0x254c02f5254c02f5), | ||
| 303 | U64(0xfcd7e54ffcd7e54f), U64(0xd7cb2ac5d7cb2ac5), | ||
| 304 | U64(0x8044352680443526), U64(0x8fa362b58fa362b5), | ||
| 305 | U64(0x495ab1de495ab1de), U64(0x671bba25671bba25), | ||
| 306 | U64(0x980eea45980eea45), U64(0xe1c0fe5de1c0fe5d), | ||
| 307 | U64(0x02752fc302752fc3), U64(0x12f04c8112f04c81), | ||
| 308 | U64(0xa397468da397468d), U64(0xc6f9d36bc6f9d36b), | ||
| 309 | U64(0xe75f8f03e75f8f03), U64(0x959c9215959c9215), | ||
| 310 | U64(0xeb7a6dbfeb7a6dbf), U64(0xda595295da595295), | ||
| 311 | U64(0x2d83bed42d83bed4), U64(0xd3217458d3217458), | ||
| 312 | U64(0x2969e0492969e049), U64(0x44c8c98e44c8c98e), | ||
| 313 | U64(0x6a89c2756a89c275), U64(0x78798ef478798ef4), | ||
| 314 | U64(0x6b3e58996b3e5899), U64(0xdd71b927dd71b927), | ||
| 315 | U64(0xb64fe1beb64fe1be), U64(0x17ad88f017ad88f0), | ||
| 316 | U64(0x66ac20c966ac20c9), U64(0xb43ace7db43ace7d), | ||
| 317 | U64(0x184adf63184adf63), U64(0x82311ae582311ae5), | ||
| 318 | U64(0x6033519760335197), U64(0x457f5362457f5362), | ||
| 319 | U64(0xe07764b1e07764b1), U64(0x84ae6bbb84ae6bbb), | ||
| 320 | U64(0x1ca081fe1ca081fe), U64(0x942b08f9942b08f9), | ||
| 321 | U64(0x5868487058684870), U64(0x19fd458f19fd458f), | ||
| 322 | U64(0x876cde94876cde94), U64(0xb7f87b52b7f87b52), | ||
| 323 | U64(0x23d373ab23d373ab), U64(0xe2024b72e2024b72), | ||
| 324 | U64(0x578f1fe3578f1fe3), U64(0x2aab55662aab5566), | ||
| 325 | U64(0x0728ebb20728ebb2), U64(0x03c2b52f03c2b52f), | ||
| 326 | U64(0x9a7bc5869a7bc586), U64(0xa50837d3a50837d3), | ||
| 327 | U64(0xf2872830f2872830), U64(0xb2a5bf23b2a5bf23), | ||
| 328 | U64(0xba6a0302ba6a0302), U64(0x5c8216ed5c8216ed), | ||
| 329 | U64(0x2b1ccf8a2b1ccf8a), U64(0x92b479a792b479a7), | ||
| 330 | U64(0xf0f207f3f0f207f3), U64(0xa1e2694ea1e2694e), | ||
| 331 | U64(0xcdf4da65cdf4da65), U64(0xd5be0506d5be0506), | ||
| 332 | U64(0x1f6234d11f6234d1), U64(0x8afea6c48afea6c4), | ||
| 333 | U64(0x9d532e349d532e34), U64(0xa055f3a2a055f3a2), | ||
| 334 | U64(0x32e18a0532e18a05), U64(0x75ebf6a475ebf6a4), | ||
| 335 | U64(0x39ec830b39ec830b), U64(0xaaef6040aaef6040), | ||
| 336 | U64(0x069f715e069f715e), U64(0x51106ebd51106ebd), | ||
| 337 | U64(0xf98a213ef98a213e), U64(0x3d06dd963d06dd96), | ||
| 338 | U64(0xae053eddae053edd), U64(0x46bde64d46bde64d), | ||
| 339 | U64(0xb58d5491b58d5491), U64(0x055dc471055dc471), | ||
| 340 | U64(0x6fd406046fd40604), U64(0xff155060ff155060), | ||
| 341 | U64(0x24fb981924fb9819), U64(0x97e9bdd697e9bdd6), | ||
| 342 | U64(0xcc434089cc434089), U64(0x779ed967779ed967), | ||
| 343 | U64(0xbd42e8b0bd42e8b0), U64(0x888b8907888b8907), | ||
| 344 | U64(0x385b19e7385b19e7), U64(0xdbeec879dbeec879), | ||
| 345 | U64(0x470a7ca1470a7ca1), U64(0xe90f427ce90f427c), | ||
| 346 | U64(0xc91e84f8c91e84f8), U64(0x0000000000000000), | ||
| 347 | U64(0x8386800983868009), U64(0x48ed2b3248ed2b32), | ||
| 348 | U64(0xac70111eac70111e), U64(0x4e725a6c4e725a6c), | ||
| 349 | U64(0xfbff0efdfbff0efd), U64(0x5638850f5638850f), | ||
| 350 | U64(0x1ed5ae3d1ed5ae3d), U64(0x27392d3627392d36), | ||
| 351 | U64(0x64d90f0a64d90f0a), U64(0x21a65c6821a65c68), | ||
| 352 | U64(0xd1545b9bd1545b9b), U64(0x3a2e36243a2e3624), | ||
| 353 | U64(0xb1670a0cb1670a0c), U64(0x0fe757930fe75793), | ||
| 354 | U64(0xd296eeb4d296eeb4), U64(0x9e919b1b9e919b1b), | ||
| 355 | U64(0x4fc5c0804fc5c080), U64(0xa220dc61a220dc61), | ||
| 356 | U64(0x694b775a694b775a), U64(0x161a121c161a121c), | ||
| 357 | U64(0x0aba93e20aba93e2), U64(0xe52aa0c0e52aa0c0), | ||
| 358 | U64(0x43e0223c43e0223c), U64(0x1d171b121d171b12), | ||
| 359 | U64(0x0b0d090e0b0d090e), U64(0xadc78bf2adc78bf2), | ||
| 360 | U64(0xb9a8b62db9a8b62d), U64(0xc8a91e14c8a91e14), | ||
| 361 | U64(0x8519f1578519f157), U64(0x4c0775af4c0775af), | ||
| 362 | U64(0xbbdd99eebbdd99ee), U64(0xfd607fa3fd607fa3), | ||
| 363 | U64(0x9f2601f79f2601f7), U64(0xbcf5725cbcf5725c), | ||
| 364 | U64(0xc53b6644c53b6644), U64(0x347efb5b347efb5b), | ||
| 365 | U64(0x7629438b7629438b), U64(0xdcc623cbdcc623cb), | ||
| 366 | U64(0x68fcedb668fcedb6), U64(0x63f1e4b863f1e4b8), | ||
| 367 | U64(0xcadc31d7cadc31d7), U64(0x1085634210856342), | ||
| 368 | U64(0x4022971340229713), U64(0x2011c6842011c684), | ||
| 369 | U64(0x7d244a857d244a85), U64(0xf83dbbd2f83dbbd2), | ||
| 370 | U64(0x1132f9ae1132f9ae), U64(0x6da129c76da129c7), | ||
| 371 | U64(0x4b2f9e1d4b2f9e1d), U64(0xf330b2dcf330b2dc), | ||
| 372 | U64(0xec52860dec52860d), U64(0xd0e3c177d0e3c177), | ||
| 373 | U64(0x6c16b32b6c16b32b), U64(0x99b970a999b970a9), | ||
| 374 | U64(0xfa489411fa489411), U64(0x2264e9472264e947), | ||
| 375 | U64(0xc48cfca8c48cfca8), U64(0x1a3ff0a01a3ff0a0), | ||
| 376 | U64(0xd82c7d56d82c7d56), U64(0xef903322ef903322), | ||
| 377 | U64(0xc74e4987c74e4987), U64(0xc1d138d9c1d138d9), | ||
| 378 | U64(0xfea2ca8cfea2ca8c), U64(0x360bd498360bd498), | ||
| 379 | U64(0xcf81f5a6cf81f5a6), U64(0x28de7aa528de7aa5), | ||
| 380 | U64(0x268eb7da268eb7da), U64(0xa4bfad3fa4bfad3f), | ||
| 381 | U64(0xe49d3a2ce49d3a2c), U64(0x0d9278500d927850), | ||
| 382 | U64(0x9bcc5f6a9bcc5f6a), U64(0x62467e5462467e54), | ||
| 383 | U64(0xc2138df6c2138df6), U64(0xe8b8d890e8b8d890), | ||
| 384 | U64(0x5ef7392e5ef7392e), U64(0xf5afc382f5afc382), | ||
| 385 | U64(0xbe805d9fbe805d9f), U64(0x7c93d0697c93d069), | ||
| 386 | U64(0xa92dd56fa92dd56f), U64(0xb31225cfb31225cf), | ||
| 387 | U64(0x3b99acc83b99acc8), U64(0xa77d1810a77d1810), | ||
| 388 | U64(0x6e639ce86e639ce8), U64(0x7bbb3bdb7bbb3bdb), | ||
| 389 | U64(0x097826cd097826cd), U64(0xf418596ef418596e), | ||
| 390 | U64(0x01b79aec01b79aec), U64(0xa89a4f83a89a4f83), | ||
| 391 | U64(0x656e95e6656e95e6), U64(0x7ee6ffaa7ee6ffaa), | ||
| 392 | U64(0x08cfbc2108cfbc21), U64(0xe6e815efe6e815ef), | ||
| 393 | U64(0xd99be7bad99be7ba), U64(0xce366f4ace366f4a), | ||
| 394 | U64(0xd4099fead4099fea), U64(0xd67cb029d67cb029), | ||
| 395 | U64(0xafb2a431afb2a431), U64(0x31233f2a31233f2a), | ||
| 396 | U64(0x3094a5c63094a5c6), U64(0xc066a235c066a235), | ||
| 397 | U64(0x37bc4e7437bc4e74), U64(0xa6ca82fca6ca82fc), | ||
| 398 | U64(0xb0d090e0b0d090e0), U64(0x15d8a73315d8a733), | ||
| 399 | U64(0x4a9804f14a9804f1), U64(0xf7daec41f7daec41), | ||
| 400 | U64(0x0e50cd7f0e50cd7f), U64(0x2ff691172ff69117), | ||
| 401 | U64(0x8dd64d768dd64d76), U64(0x4db0ef434db0ef43), | ||
| 402 | U64(0x544daacc544daacc), U64(0xdf0496e4df0496e4), | ||
| 403 | U64(0xe3b5d19ee3b5d19e), U64(0x1b886a4c1b886a4c), | ||
| 404 | U64(0xb81f2cc1b81f2cc1), U64(0x7f5165467f516546), | ||
| 405 | U64(0x04ea5e9d04ea5e9d), U64(0x5d358c015d358c01), | ||
| 406 | U64(0x737487fa737487fa), U64(0x2e410bfb2e410bfb), | ||
| 407 | U64(0x5a1d67b35a1d67b3), U64(0x52d2db9252d2db92), | ||
| 408 | U64(0x335610e9335610e9), U64(0x1347d66d1347d66d), | ||
| 409 | U64(0x8c61d79a8c61d79a), U64(0x7a0ca1377a0ca137), | ||
| 410 | U64(0x8e14f8598e14f859), U64(0x893c13eb893c13eb), | ||
| 411 | U64(0xee27a9ceee27a9ce), U64(0x35c961b735c961b7), | ||
| 412 | U64(0xede51ce1ede51ce1), U64(0x3cb1477a3cb1477a), | ||
| 413 | U64(0x59dfd29c59dfd29c), U64(0x3f73f2553f73f255), | ||
| 414 | U64(0x79ce141879ce1418), U64(0xbf37c773bf37c773), | ||
| 415 | U64(0xeacdf753eacdf753), U64(0x5baafd5f5baafd5f), | ||
| 416 | U64(0x146f3ddf146f3ddf), U64(0x86db447886db4478), | ||
| 417 | U64(0x81f3afca81f3afca), U64(0x3ec468b93ec468b9), | ||
| 418 | U64(0x2c3424382c342438), U64(0x5f40a3c25f40a3c2), | ||
| 419 | U64(0x72c31d1672c31d16), U64(0x0c25e2bc0c25e2bc), | ||
| 420 | U64(0x8b493c288b493c28), U64(0x41950dff41950dff), | ||
| 421 | U64(0x7101a8397101a839), U64(0xdeb30c08deb30c08), | ||
| 422 | U64(0x9ce4b4d89ce4b4d8), U64(0x90c1566490c15664), | ||
| 423 | U64(0x6184cb7b6184cb7b), U64(0x70b632d570b632d5), | ||
| 424 | U64(0x745c6c48745c6c48), U64(0x4257b8d04257b8d0) | ||
| 425 | }; | ||
| 426 | static const u8 Td4[256] = { | ||
| 427 | 0x52U, 0x09U, 0x6aU, 0xd5U, 0x30U, 0x36U, 0xa5U, 0x38U, | ||
| 428 | 0xbfU, 0x40U, 0xa3U, 0x9eU, 0x81U, 0xf3U, 0xd7U, 0xfbU, | ||
| 429 | 0x7cU, 0xe3U, 0x39U, 0x82U, 0x9bU, 0x2fU, 0xffU, 0x87U, | ||
| 430 | 0x34U, 0x8eU, 0x43U, 0x44U, 0xc4U, 0xdeU, 0xe9U, 0xcbU, | ||
| 431 | 0x54U, 0x7bU, 0x94U, 0x32U, 0xa6U, 0xc2U, 0x23U, 0x3dU, | ||
| 432 | 0xeeU, 0x4cU, 0x95U, 0x0bU, 0x42U, 0xfaU, 0xc3U, 0x4eU, | ||
| 433 | 0x08U, 0x2eU, 0xa1U, 0x66U, 0x28U, 0xd9U, 0x24U, 0xb2U, | ||
| 434 | 0x76U, 0x5bU, 0xa2U, 0x49U, 0x6dU, 0x8bU, 0xd1U, 0x25U, | ||
| 435 | 0x72U, 0xf8U, 0xf6U, 0x64U, 0x86U, 0x68U, 0x98U, 0x16U, | ||
| 436 | 0xd4U, 0xa4U, 0x5cU, 0xccU, 0x5dU, 0x65U, 0xb6U, 0x92U, | ||
| 437 | 0x6cU, 0x70U, 0x48U, 0x50U, 0xfdU, 0xedU, 0xb9U, 0xdaU, | ||
| 438 | 0x5eU, 0x15U, 0x46U, 0x57U, 0xa7U, 0x8dU, 0x9dU, 0x84U, | ||
| 439 | 0x90U, 0xd8U, 0xabU, 0x00U, 0x8cU, 0xbcU, 0xd3U, 0x0aU, | ||
| 440 | 0xf7U, 0xe4U, 0x58U, 0x05U, 0xb8U, 0xb3U, 0x45U, 0x06U, | ||
| 441 | 0xd0U, 0x2cU, 0x1eU, 0x8fU, 0xcaU, 0x3fU, 0x0fU, 0x02U, | ||
| 442 | 0xc1U, 0xafU, 0xbdU, 0x03U, 0x01U, 0x13U, 0x8aU, 0x6bU, | ||
| 443 | 0x3aU, 0x91U, 0x11U, 0x41U, 0x4fU, 0x67U, 0xdcU, 0xeaU, | ||
| 444 | 0x97U, 0xf2U, 0xcfU, 0xceU, 0xf0U, 0xb4U, 0xe6U, 0x73U, | ||
| 445 | 0x96U, 0xacU, 0x74U, 0x22U, 0xe7U, 0xadU, 0x35U, 0x85U, | ||
| 446 | 0xe2U, 0xf9U, 0x37U, 0xe8U, 0x1cU, 0x75U, 0xdfU, 0x6eU, | ||
| 447 | 0x47U, 0xf1U, 0x1aU, 0x71U, 0x1dU, 0x29U, 0xc5U, 0x89U, | ||
| 448 | 0x6fU, 0xb7U, 0x62U, 0x0eU, 0xaaU, 0x18U, 0xbeU, 0x1bU, | ||
| 449 | 0xfcU, 0x56U, 0x3eU, 0x4bU, 0xc6U, 0xd2U, 0x79U, 0x20U, | ||
| 450 | 0x9aU, 0xdbU, 0xc0U, 0xfeU, 0x78U, 0xcdU, 0x5aU, 0xf4U, | ||
| 451 | 0x1fU, 0xddU, 0xa8U, 0x33U, 0x88U, 0x07U, 0xc7U, 0x31U, | ||
| 452 | 0xb1U, 0x12U, 0x10U, 0x59U, 0x27U, 0x80U, 0xecU, 0x5fU, | ||
| 453 | 0x60U, 0x51U, 0x7fU, 0xa9U, 0x19U, 0xb5U, 0x4aU, 0x0dU, | ||
| 454 | 0x2dU, 0xe5U, 0x7aU, 0x9fU, 0x93U, 0xc9U, 0x9cU, 0xefU, | ||
| 455 | 0xa0U, 0xe0U, 0x3bU, 0x4dU, 0xaeU, 0x2aU, 0xf5U, 0xb0U, | ||
| 456 | 0xc8U, 0xebU, 0xbbU, 0x3cU, 0x83U, 0x53U, 0x99U, 0x61U, | ||
| 457 | 0x17U, 0x2bU, 0x04U, 0x7eU, 0xbaU, 0x77U, 0xd6U, 0x26U, | ||
| 458 | 0xe1U, 0x69U, 0x14U, 0x63U, 0x55U, 0x21U, 0x0cU, 0x7dU | ||
| 459 | }; | ||
| 460 | |||
| 461 | static const u32 rcon[] = { | ||
| 462 | 0x00000001U, 0x00000002U, 0x00000004U, 0x00000008U, | ||
| 463 | 0x00000010U, 0x00000020U, 0x00000040U, 0x00000080U, | ||
| 464 | 0x0000001bU, 0x00000036U, /* for 128-bit blocks, Rijndael never uses more than 10 rcon values */ | ||
| 465 | }; | ||
| 466 | |||
| 467 | /** | ||
| 468 | * Expand the cipher key into the encryption key schedule. | ||
| 469 | */ | ||
| 470 | int AES_set_encrypt_key(const unsigned char *userKey, const int bits, | ||
| 471 | AES_KEY *key) { | ||
| 472 | |||
| 473 | u32 *rk; | ||
| 474 | int i = 0; | ||
| 475 | u32 temp; | ||
| 476 | |||
| 477 | if (!userKey || !key) | ||
| 478 | return -1; | ||
| 479 | if (bits != 128 && bits != 192 && bits != 256) | ||
| 480 | return -2; | ||
| 481 | |||
| 482 | rk = key->rd_key; | ||
| 483 | |||
| 484 | if (bits==128) | ||
| 485 | key->rounds = 10; | ||
| 486 | else if (bits==192) | ||
| 487 | key->rounds = 12; | ||
| 488 | else | ||
| 489 | key->rounds = 14; | ||
| 490 | |||
| 491 | rk[0] = GETU32(userKey ); | ||
| 492 | rk[1] = GETU32(userKey + 4); | ||
| 493 | rk[2] = GETU32(userKey + 8); | ||
| 494 | rk[3] = GETU32(userKey + 12); | ||
| 495 | if (bits == 128) { | ||
| 496 | while (1) { | ||
| 497 | temp = rk[3]; | ||
| 498 | rk[4] = rk[0] ^ | ||
| 499 | (Te4[(temp >> 8) & 0xff] ) ^ | ||
| 500 | (Te4[(temp >> 16) & 0xff] << 8) ^ | ||
| 501 | (Te4[(temp >> 24) ] << 16) ^ | ||
| 502 | (Te4[(temp ) & 0xff] << 24) ^ | ||
| 503 | rcon[i]; | ||
| 504 | rk[5] = rk[1] ^ rk[4]; | ||
| 505 | rk[6] = rk[2] ^ rk[5]; | ||
| 506 | rk[7] = rk[3] ^ rk[6]; | ||
| 507 | if (++i == 10) { | ||
| 508 | return 0; | ||
| 509 | } | ||
| 510 | rk += 4; | ||
| 511 | } | ||
| 512 | } | ||
| 513 | rk[4] = GETU32(userKey + 16); | ||
| 514 | rk[5] = GETU32(userKey + 20); | ||
| 515 | if (bits == 192) { | ||
| 516 | while (1) { | ||
| 517 | temp = rk[ 5]; | ||
| 518 | rk[ 6] = rk[ 0] ^ | ||
| 519 | (Te4[(temp >> 8) & 0xff] ) ^ | ||
| 520 | (Te4[(temp >> 16) & 0xff] << 8) ^ | ||
| 521 | (Te4[(temp >> 24) ] << 16) ^ | ||
| 522 | (Te4[(temp ) & 0xff] << 24) ^ | ||
| 523 | rcon[i]; | ||
| 524 | rk[ 7] = rk[ 1] ^ rk[ 6]; | ||
| 525 | rk[ 8] = rk[ 2] ^ rk[ 7]; | ||
| 526 | rk[ 9] = rk[ 3] ^ rk[ 8]; | ||
| 527 | if (++i == 8) { | ||
| 528 | return 0; | ||
| 529 | } | ||
| 530 | rk[10] = rk[ 4] ^ rk[ 9]; | ||
| 531 | rk[11] = rk[ 5] ^ rk[10]; | ||
| 532 | rk += 6; | ||
| 533 | } | ||
| 534 | } | ||
| 535 | rk[6] = GETU32(userKey + 24); | ||
| 536 | rk[7] = GETU32(userKey + 28); | ||
| 537 | if (bits == 256) { | ||
| 538 | while (1) { | ||
| 539 | temp = rk[ 7]; | ||
| 540 | rk[ 8] = rk[ 0] ^ | ||
| 541 | (Te4[(temp >> 8) & 0xff] ) ^ | ||
| 542 | (Te4[(temp >> 16) & 0xff] << 8) ^ | ||
| 543 | (Te4[(temp >> 24) ] << 16) ^ | ||
| 544 | (Te4[(temp ) & 0xff] << 24) ^ | ||
| 545 | rcon[i]; | ||
| 546 | rk[ 9] = rk[ 1] ^ rk[ 8]; | ||
| 547 | rk[10] = rk[ 2] ^ rk[ 9]; | ||
| 548 | rk[11] = rk[ 3] ^ rk[10]; | ||
| 549 | if (++i == 7) { | ||
| 550 | return 0; | ||
| 551 | } | ||
| 552 | temp = rk[11]; | ||
| 553 | rk[12] = rk[ 4] ^ | ||
| 554 | (Te4[(temp ) & 0xff] ) ^ | ||
| 555 | (Te4[(temp >> 8) & 0xff] << 8) ^ | ||
| 556 | (Te4[(temp >> 16) & 0xff] << 16) ^ | ||
| 557 | (Te4[(temp >> 24) ] << 24); | ||
| 558 | rk[13] = rk[ 5] ^ rk[12]; | ||
| 559 | rk[14] = rk[ 6] ^ rk[13]; | ||
| 560 | rk[15] = rk[ 7] ^ rk[14]; | ||
| 561 | |||
| 562 | rk += 8; | ||
| 563 | } | ||
| 564 | } | ||
| 565 | return 0; | ||
| 566 | } | ||
| 567 | |||
| 568 | /** | ||
| 569 | * Expand the cipher key into the decryption key schedule. | ||
| 570 | */ | ||
| 571 | int AES_set_decrypt_key(const unsigned char *userKey, const int bits, | ||
| 572 | AES_KEY *key) { | ||
| 573 | |||
| 574 | u32 *rk; | ||
| 575 | int i, j, status; | ||
| 576 | u32 temp; | ||
| 577 | |||
| 578 | /* first, start with an encryption schedule */ | ||
| 579 | status = AES_set_encrypt_key(userKey, bits, key); | ||
| 580 | if (status < 0) | ||
| 581 | return status; | ||
| 582 | |||
| 583 | rk = key->rd_key; | ||
| 584 | |||
| 585 | /* invert the order of the round keys: */ | ||
| 586 | for (i = 0, j = 4*(key->rounds); i < j; i += 4, j -= 4) { | ||
| 587 | temp = rk[i ]; rk[i ] = rk[j ]; rk[j ] = temp; | ||
| 588 | temp = rk[i + 1]; rk[i + 1] = rk[j + 1]; rk[j + 1] = temp; | ||
| 589 | temp = rk[i + 2]; rk[i + 2] = rk[j + 2]; rk[j + 2] = temp; | ||
| 590 | temp = rk[i + 3]; rk[i + 3] = rk[j + 3]; rk[j + 3] = temp; | ||
| 591 | } | ||
| 592 | /* apply the inverse MixColumn transform to all round keys but the first and the last: */ | ||
| 593 | for (i = 1; i < (key->rounds); i++) { | ||
| 594 | rk += 4; | ||
| 595 | #if 1 | ||
| 596 | for (j = 0; j < 4; j++) { | ||
| 597 | u32 tp1, tp2, tp4, tp8, tp9, tpb, tpd, tpe, m; | ||
| 598 | |||
| 599 | tp1 = rk[j]; | ||
| 600 | m = tp1 & 0x80808080; | ||
| 601 | tp2 = ((tp1 & 0x7f7f7f7f) << 1) ^ | ||
| 602 | ((m - (m >> 7)) & 0x1b1b1b1b); | ||
| 603 | m = tp2 & 0x80808080; | ||
| 604 | tp4 = ((tp2 & 0x7f7f7f7f) << 1) ^ | ||
| 605 | ((m - (m >> 7)) & 0x1b1b1b1b); | ||
| 606 | m = tp4 & 0x80808080; | ||
| 607 | tp8 = ((tp4 & 0x7f7f7f7f) << 1) ^ | ||
| 608 | ((m - (m >> 7)) & 0x1b1b1b1b); | ||
| 609 | tp9 = tp8 ^ tp1; | ||
| 610 | tpb = tp9 ^ tp2; | ||
| 611 | tpd = tp9 ^ tp4; | ||
| 612 | tpe = tp8 ^ tp4 ^ tp2; | ||
| 613 | #if defined(ROTATE) | ||
| 614 | rk[j] = tpe ^ ROTATE(tpd,16) ^ | ||
| 615 | ROTATE(tp9,8) ^ ROTATE(tpb,24); | ||
| 616 | #else | ||
| 617 | rk[j] = tpe ^ (tpd >> 16) ^ (tpd << 16) ^ | ||
| 618 | (tp9 >> 24) ^ (tp9 << 8) ^ | ||
| 619 | (tpb >> 8) ^ (tpb << 24); | ||
| 620 | #endif | ||
| 621 | } | ||
| 622 | #else | ||
| 623 | rk[0] = | ||
| 624 | Td0[Te2[(rk[0] ) & 0xff] & 0xff] ^ | ||
| 625 | Td1[Te2[(rk[0] >> 8) & 0xff] & 0xff] ^ | ||
| 626 | Td2[Te2[(rk[0] >> 16) & 0xff] & 0xff] ^ | ||
| 627 | Td3[Te2[(rk[0] >> 24) ] & 0xff]; | ||
| 628 | rk[1] = | ||
| 629 | Td0[Te2[(rk[1] ) & 0xff] & 0xff] ^ | ||
| 630 | Td1[Te2[(rk[1] >> 8) & 0xff] & 0xff] ^ | ||
| 631 | Td2[Te2[(rk[1] >> 16) & 0xff] & 0xff] ^ | ||
| 632 | Td3[Te2[(rk[1] >> 24) ] & 0xff]; | ||
| 633 | rk[2] = | ||
| 634 | Td0[Te2[(rk[2] ) & 0xff] & 0xff] ^ | ||
| 635 | Td1[Te2[(rk[2] >> 8) & 0xff] & 0xff] ^ | ||
| 636 | Td2[Te2[(rk[2] >> 16) & 0xff] & 0xff] ^ | ||
| 637 | Td3[Te2[(rk[2] >> 24) ] & 0xff]; | ||
| 638 | rk[3] = | ||
| 639 | Td0[Te2[(rk[3] ) & 0xff] & 0xff] ^ | ||
| 640 | Td1[Te2[(rk[3] >> 8) & 0xff] & 0xff] ^ | ||
| 641 | Td2[Te2[(rk[3] >> 16) & 0xff] & 0xff] ^ | ||
| 642 | Td3[Te2[(rk[3] >> 24) ] & 0xff]; | ||
| 643 | #endif | ||
| 644 | } | ||
| 645 | return 0; | ||
| 646 | } | ||
| 647 | |||
| 648 | /* | ||
| 649 | * Encrypt a single block | ||
| 650 | * in and out can overlap | ||
| 651 | */ | ||
| 652 | void AES_encrypt(const unsigned char *in, unsigned char *out, | ||
| 653 | const AES_KEY *key) { | ||
| 654 | |||
| 655 | const u32 *rk; | ||
| 656 | u32 s0, s1, s2, s3, t[4]; | ||
| 657 | int r; | ||
| 658 | |||
| 659 | assert(in && out && key); | ||
| 660 | rk = key->rd_key; | ||
| 661 | |||
| 662 | /* | ||
| 663 | * map byte array block to cipher state | ||
| 664 | * and add initial round key: | ||
| 665 | */ | ||
| 666 | s0 = GETU32(in ) ^ rk[0]; | ||
| 667 | s1 = GETU32(in + 4) ^ rk[1]; | ||
| 668 | s2 = GETU32(in + 8) ^ rk[2]; | ||
| 669 | s3 = GETU32(in + 12) ^ rk[3]; | ||
| 670 | |||
| 671 | #if defined(AES_COMPACT_IN_OUTER_ROUNDS) | ||
| 672 | prefetch256(Te4); | ||
| 673 | |||
| 674 | t[0] = Te4[(s0 ) & 0xff] ^ | ||
| 675 | Te4[(s1 >> 8) & 0xff] << 8 ^ | ||
| 676 | Te4[(s2 >> 16) & 0xff] << 16 ^ | ||
| 677 | Te4[(s3 >> 24) ] << 24; | ||
| 678 | t[1] = Te4[(s1 ) & 0xff] ^ | ||
| 679 | Te4[(s2 >> 8) & 0xff] << 8 ^ | ||
| 680 | Te4[(s3 >> 16) & 0xff] << 16 ^ | ||
| 681 | Te4[(s0 >> 24) ] << 24; | ||
| 682 | t[2] = Te4[(s2 ) & 0xff] ^ | ||
| 683 | Te4[(s3 >> 8) & 0xff] << 8 ^ | ||
| 684 | Te4[(s0 >> 16) & 0xff] << 16 ^ | ||
| 685 | Te4[(s1 >> 24) ] << 24; | ||
| 686 | t[3] = Te4[(s3 ) & 0xff] ^ | ||
| 687 | Te4[(s0 >> 8) & 0xff] << 8 ^ | ||
| 688 | Te4[(s1 >> 16) & 0xff] << 16 ^ | ||
| 689 | Te4[(s2 >> 24) ] << 24; | ||
| 690 | |||
| 691 | /* now do the linear transform using words */ | ||
| 692 | { int i; | ||
| 693 | u32 r0, r1, r2; | ||
| 694 | |||
| 695 | for (i = 0; i < 4; i++) { | ||
| 696 | r0 = t[i]; | ||
| 697 | r1 = r0 & 0x80808080; | ||
| 698 | r2 = ((r0 & 0x7f7f7f7f) << 1) ^ | ||
| 699 | ((r1 - (r1 >> 7)) & 0x1b1b1b1b); | ||
| 700 | #if defined(ROTATE) | ||
| 701 | t[i] = r2 ^ ROTATE(r2,24) ^ ROTATE(r0,24) ^ | ||
| 702 | ROTATE(r0,16) ^ ROTATE(r0,8); | ||
| 703 | #else | ||
| 704 | t[i] = r2 ^ ((r2 ^ r0) << 24) ^ ((r2 ^ r0) >> 8) ^ | ||
| 705 | (r0 << 16) ^ (r0 >> 16) ^ | ||
| 706 | (r0 << 8) ^ (r0 >> 24); | ||
| 707 | #endif | ||
| 708 | t[i] ^= rk[4+i]; | ||
| 709 | } | ||
| 710 | } | ||
| 711 | #else | ||
| 712 | t[0] = Te0[(s0 ) & 0xff] ^ | ||
| 713 | Te1[(s1 >> 8) & 0xff] ^ | ||
| 714 | Te2[(s2 >> 16) & 0xff] ^ | ||
| 715 | Te3[(s3 >> 24) ] ^ | ||
| 716 | rk[4]; | ||
| 717 | t[1] = Te0[(s1 ) & 0xff] ^ | ||
| 718 | Te1[(s2 >> 8) & 0xff] ^ | ||
| 719 | Te2[(s3 >> 16) & 0xff] ^ | ||
| 720 | Te3[(s0 >> 24) ] ^ | ||
| 721 | rk[5]; | ||
| 722 | t[2] = Te0[(s2 ) & 0xff] ^ | ||
| 723 | Te1[(s3 >> 8) & 0xff] ^ | ||
| 724 | Te2[(s0 >> 16) & 0xff] ^ | ||
| 725 | Te3[(s1 >> 24) ] ^ | ||
| 726 | rk[6]; | ||
| 727 | t[3] = Te0[(s3 ) & 0xff] ^ | ||
| 728 | Te1[(s0 >> 8) & 0xff] ^ | ||
| 729 | Te2[(s1 >> 16) & 0xff] ^ | ||
| 730 | Te3[(s2 >> 24) ] ^ | ||
| 731 | rk[7]; | ||
| 732 | #endif | ||
| 733 | s0 = t[0]; s1 = t[1]; s2 = t[2]; s3 = t[3]; | ||
| 734 | |||
| 735 | /* | ||
| 736 | * Nr - 2 full rounds: | ||
| 737 | */ | ||
| 738 | for (rk+=8,r=key->rounds-2; r>0; rk+=4,r--) { | ||
| 739 | #if defined(AES_COMPACT_IN_INNER_ROUNDS) | ||
| 740 | t[0] = Te4[(s0 ) & 0xff] ^ | ||
| 741 | Te4[(s1 >> 8) & 0xff] << 8 ^ | ||
| 742 | Te4[(s2 >> 16) & 0xff] << 16 ^ | ||
| 743 | Te4[(s3 >> 24) ] << 24; | ||
| 744 | t[1] = Te4[(s1 ) & 0xff] ^ | ||
| 745 | Te4[(s2 >> 8) & 0xff] << 8 ^ | ||
| 746 | Te4[(s3 >> 16) & 0xff] << 16 ^ | ||
| 747 | Te4[(s0 >> 24) ] << 24; | ||
| 748 | t[2] = Te4[(s2 ) & 0xff] ^ | ||
| 749 | Te4[(s3 >> 8) & 0xff] << 8 ^ | ||
| 750 | Te4[(s0 >> 16) & 0xff] << 16 ^ | ||
| 751 | Te4[(s1 >> 24) ] << 24; | ||
| 752 | t[3] = Te4[(s3 ) & 0xff] ^ | ||
| 753 | Te4[(s0 >> 8) & 0xff] << 8 ^ | ||
| 754 | Te4[(s1 >> 16) & 0xff] << 16 ^ | ||
| 755 | Te4[(s2 >> 24) ] << 24; | ||
| 756 | |||
| 757 | /* now do the linear transform using words */ | ||
| 758 | { int i; | ||
| 759 | u32 r0, r1, r2; | ||
| 760 | |||
| 761 | for (i = 0; i < 4; i++) { | ||
| 762 | r0 = t[i]; | ||
| 763 | r1 = r0 & 0x80808080; | ||
| 764 | r2 = ((r0 & 0x7f7f7f7f) << 1) ^ | ||
| 765 | ((r1 - (r1 >> 7)) & 0x1b1b1b1b); | ||
| 766 | #if defined(ROTATE) | ||
| 767 | t[i] = r2 ^ ROTATE(r2,24) ^ ROTATE(r0,24) ^ | ||
| 768 | ROTATE(r0,16) ^ ROTATE(r0,8); | ||
| 769 | #else | ||
| 770 | t[i] = r2 ^ ((r2 ^ r0) << 24) ^ ((r2 ^ r0) >> 8) ^ | ||
| 771 | (r0 << 16) ^ (r0 >> 16) ^ | ||
| 772 | (r0 << 8) ^ (r0 >> 24); | ||
| 773 | #endif | ||
| 774 | t[i] ^= rk[i]; | ||
| 775 | } | ||
| 776 | } | ||
| 777 | #else | ||
| 778 | t[0] = Te0[(s0 ) & 0xff] ^ | ||
| 779 | Te1[(s1 >> 8) & 0xff] ^ | ||
| 780 | Te2[(s2 >> 16) & 0xff] ^ | ||
| 781 | Te3[(s3 >> 24) ] ^ | ||
| 782 | rk[0]; | ||
| 783 | t[1] = Te0[(s1 ) & 0xff] ^ | ||
| 784 | Te1[(s2 >> 8) & 0xff] ^ | ||
| 785 | Te2[(s3 >> 16) & 0xff] ^ | ||
| 786 | Te3[(s0 >> 24) ] ^ | ||
| 787 | rk[1]; | ||
| 788 | t[2] = Te0[(s2 ) & 0xff] ^ | ||
| 789 | Te1[(s3 >> 8) & 0xff] ^ | ||
| 790 | Te2[(s0 >> 16) & 0xff] ^ | ||
| 791 | Te3[(s1 >> 24) ] ^ | ||
| 792 | rk[2]; | ||
| 793 | t[3] = Te0[(s3 ) & 0xff] ^ | ||
| 794 | Te1[(s0 >> 8) & 0xff] ^ | ||
| 795 | Te2[(s1 >> 16) & 0xff] ^ | ||
| 796 | Te3[(s2 >> 24) ] ^ | ||
| 797 | rk[3]; | ||
| 798 | #endif | ||
| 799 | s0 = t[0]; s1 = t[1]; s2 = t[2]; s3 = t[3]; | ||
| 800 | } | ||
| 801 | /* | ||
| 802 | * apply last round and | ||
| 803 | * map cipher state to byte array block: | ||
| 804 | */ | ||
| 805 | #if defined(AES_COMPACT_IN_OUTER_ROUNDS) | ||
| 806 | prefetch256(Te4); | ||
| 807 | |||
| 808 | *(u32*)(out+0) = | ||
| 809 | Te4[(s0 ) & 0xff] ^ | ||
| 810 | Te4[(s1 >> 8) & 0xff] << 8 ^ | ||
| 811 | Te4[(s2 >> 16) & 0xff] << 16 ^ | ||
| 812 | Te4[(s3 >> 24) ] << 24 ^ | ||
| 813 | rk[0]; | ||
| 814 | *(u32*)(out+4) = | ||
| 815 | Te4[(s1 ) & 0xff] ^ | ||
| 816 | Te4[(s2 >> 8) & 0xff] << 8 ^ | ||
| 817 | Te4[(s3 >> 16) & 0xff] << 16 ^ | ||
| 818 | Te4[(s0 >> 24) ] << 24 ^ | ||
| 819 | rk[1]; | ||
| 820 | *(u32*)(out+8) = | ||
| 821 | Te4[(s2 ) & 0xff] ^ | ||
| 822 | Te4[(s3 >> 8) & 0xff] << 8 ^ | ||
| 823 | Te4[(s0 >> 16) & 0xff] << 16 ^ | ||
| 824 | Te4[(s1 >> 24) ] << 24 ^ | ||
| 825 | rk[2]; | ||
| 826 | *(u32*)(out+12) = | ||
| 827 | Te4[(s3 ) & 0xff] ^ | ||
| 828 | Te4[(s0 >> 8) & 0xff] << 8 ^ | ||
| 829 | Te4[(s1 >> 16) & 0xff] << 16 ^ | ||
| 830 | Te4[(s2 >> 24) ] << 24 ^ | ||
| 831 | rk[3]; | ||
| 832 | #else | ||
| 833 | *(u32*)(out+0) = | ||
| 834 | (Te2[(s0 ) & 0xff] & 0x000000ffU) ^ | ||
| 835 | (Te3[(s1 >> 8) & 0xff] & 0x0000ff00U) ^ | ||
| 836 | (Te0[(s2 >> 16) & 0xff] & 0x00ff0000U) ^ | ||
| 837 | (Te1[(s3 >> 24) ] & 0xff000000U) ^ | ||
| 838 | rk[0]; | ||
| 839 | *(u32*)(out+4) = | ||
| 840 | (Te2[(s1 ) & 0xff] & 0x000000ffU) ^ | ||
| 841 | (Te3[(s2 >> 8) & 0xff] & 0x0000ff00U) ^ | ||
| 842 | (Te0[(s3 >> 16) & 0xff] & 0x00ff0000U) ^ | ||
| 843 | (Te1[(s0 >> 24) ] & 0xff000000U) ^ | ||
| 844 | rk[1]; | ||
| 845 | *(u32*)(out+8) = | ||
| 846 | (Te2[(s2 ) & 0xff] & 0x000000ffU) ^ | ||
| 847 | (Te3[(s3 >> 8) & 0xff] & 0x0000ff00U) ^ | ||
| 848 | (Te0[(s0 >> 16) & 0xff] & 0x00ff0000U) ^ | ||
| 849 | (Te1[(s1 >> 24) ] & 0xff000000U) ^ | ||
| 850 | rk[2]; | ||
| 851 | *(u32*)(out+12) = | ||
| 852 | (Te2[(s3 ) & 0xff] & 0x000000ffU) ^ | ||
| 853 | (Te3[(s0 >> 8) & 0xff] & 0x0000ff00U) ^ | ||
| 854 | (Te0[(s1 >> 16) & 0xff] & 0x00ff0000U) ^ | ||
| 855 | (Te1[(s2 >> 24) ] & 0xff000000U) ^ | ||
| 856 | rk[3]; | ||
| 857 | #endif | ||
| 858 | } | ||
| 859 | |||
| 860 | /* | ||
| 861 | * Decrypt a single block | ||
| 862 | * in and out can overlap | ||
| 863 | */ | ||
| 864 | void AES_decrypt(const unsigned char *in, unsigned char *out, | ||
| 865 | const AES_KEY *key) { | ||
| 866 | |||
| 867 | const u32 *rk; | ||
| 868 | u32 s0, s1, s2, s3, t[4]; | ||
| 869 | int r; | ||
| 870 | |||
| 871 | assert(in && out && key); | ||
| 872 | rk = key->rd_key; | ||
| 873 | |||
| 874 | /* | ||
| 875 | * map byte array block to cipher state | ||
| 876 | * and add initial round key: | ||
| 877 | */ | ||
| 878 | s0 = GETU32(in ) ^ rk[0]; | ||
| 879 | s1 = GETU32(in + 4) ^ rk[1]; | ||
| 880 | s2 = GETU32(in + 8) ^ rk[2]; | ||
| 881 | s3 = GETU32(in + 12) ^ rk[3]; | ||
| 882 | |||
| 883 | #if defined(AES_COMPACT_IN_OUTER_ROUNDS) | ||
| 884 | prefetch256(Td4); | ||
| 885 | |||
| 886 | t[0] = Td4[(s0 ) & 0xff] ^ | ||
| 887 | Td4[(s3 >> 8) & 0xff] << 8 ^ | ||
| 888 | Td4[(s2 >> 16) & 0xff] << 16 ^ | ||
| 889 | Td4[(s1 >> 24) ] << 24; | ||
| 890 | t[1] = Td4[(s1 ) & 0xff] ^ | ||
| 891 | Td4[(s0 >> 8) & 0xff] << 8 ^ | ||
| 892 | Td4[(s3 >> 16) & 0xff] << 16 ^ | ||
| 893 | Td4[(s2 >> 24) ] << 24; | ||
| 894 | t[2] = Td4[(s2 ) & 0xff] ^ | ||
| 895 | Td4[(s1 >> 8) & 0xff] << 8 ^ | ||
| 896 | Td4[(s0 >> 16) & 0xff] << 16 ^ | ||
| 897 | Td4[(s3 >> 24) ] << 24; | ||
| 898 | t[3] = Td4[(s3 ) & 0xff] ^ | ||
| 899 | Td4[(s2 >> 8) & 0xff] << 8 ^ | ||
| 900 | Td4[(s1 >> 16) & 0xff] << 16 ^ | ||
| 901 | Td4[(s0 >> 24) ] << 24; | ||
| 902 | |||
| 903 | /* now do the linear transform using words */ | ||
| 904 | { int i; | ||
| 905 | u32 tp1, tp2, tp4, tp8, tp9, tpb, tpd, tpe, m; | ||
| 906 | |||
| 907 | for (i = 0; i < 4; i++) { | ||
| 908 | tp1 = t[i]; | ||
| 909 | m = tp1 & 0x80808080; | ||
| 910 | tp2 = ((tp1 & 0x7f7f7f7f) << 1) ^ | ||
| 911 | ((m - (m >> 7)) & 0x1b1b1b1b); | ||
| 912 | m = tp2 & 0x80808080; | ||
| 913 | tp4 = ((tp2 & 0x7f7f7f7f) << 1) ^ | ||
| 914 | ((m - (m >> 7)) & 0x1b1b1b1b); | ||
| 915 | m = tp4 & 0x80808080; | ||
| 916 | tp8 = ((tp4 & 0x7f7f7f7f) << 1) ^ | ||
| 917 | ((m - (m >> 7)) & 0x1b1b1b1b); | ||
| 918 | tp9 = tp8 ^ tp1; | ||
| 919 | tpb = tp9 ^ tp2; | ||
| 920 | tpd = tp9 ^ tp4; | ||
| 921 | tpe = tp8 ^ tp4 ^ tp2; | ||
| 922 | #if defined(ROTATE) | ||
| 923 | t[i] = tpe ^ ROTATE(tpd,16) ^ | ||
| 924 | ROTATE(tp9,8) ^ ROTATE(tpb,24); | ||
| 925 | #else | ||
| 926 | t[i] = tpe ^ (tpd >> 16) ^ (tpd << 16) ^ | ||
| 927 | (tp9 >> 24) ^ (tp9 << 8) ^ | ||
| 928 | (tpb >> 8) ^ (tpb << 24); | ||
| 929 | #endif | ||
| 930 | t[i] ^= rk[4+i]; | ||
| 931 | } | ||
| 932 | } | ||
| 933 | #else | ||
| 934 | t[0] = Td0[(s0 ) & 0xff] ^ | ||
| 935 | Td1[(s3 >> 8) & 0xff] ^ | ||
| 936 | Td2[(s2 >> 16) & 0xff] ^ | ||
| 937 | Td3[(s1 >> 24) ] ^ | ||
| 938 | rk[4]; | ||
| 939 | t[1] = Td0[(s1 ) & 0xff] ^ | ||
| 940 | Td1[(s0 >> 8) & 0xff] ^ | ||
| 941 | Td2[(s3 >> 16) & 0xff] ^ | ||
| 942 | Td3[(s2 >> 24) ] ^ | ||
| 943 | rk[5]; | ||
| 944 | t[2] = Td0[(s2 ) & 0xff] ^ | ||
| 945 | Td1[(s1 >> 8) & 0xff] ^ | ||
| 946 | Td2[(s0 >> 16) & 0xff] ^ | ||
| 947 | Td3[(s3 >> 24) ] ^ | ||
| 948 | rk[6]; | ||
| 949 | t[3] = Td0[(s3 ) & 0xff] ^ | ||
| 950 | Td1[(s2 >> 8) & 0xff] ^ | ||
| 951 | Td2[(s1 >> 16) & 0xff] ^ | ||
| 952 | Td3[(s0 >> 24) ] ^ | ||
| 953 | rk[7]; | ||
| 954 | #endif | ||
| 955 | s0 = t[0]; s1 = t[1]; s2 = t[2]; s3 = t[3]; | ||
| 956 | |||
| 957 | /* | ||
| 958 | * Nr - 2 full rounds: | ||
| 959 | */ | ||
| 960 | for (rk+=8,r=key->rounds-2; r>0; rk+=4,r--) { | ||
| 961 | #if defined(AES_COMPACT_IN_INNER_ROUNDS) | ||
| 962 | t[0] = Td4[(s0 ) & 0xff] ^ | ||
| 963 | Td4[(s3 >> 8) & 0xff] << 8 ^ | ||
| 964 | Td4[(s2 >> 16) & 0xff] << 16 ^ | ||
| 965 | Td4[(s1 >> 24) ] << 24; | ||
| 966 | t[1] = Td4[(s1 ) & 0xff] ^ | ||
| 967 | Td4[(s0 >> 8) & 0xff] << 8 ^ | ||
| 968 | Td4[(s3 >> 16) & 0xff] << 16 ^ | ||
| 969 | Td4[(s2 >> 24) ] << 24; | ||
| 970 | t[2] = Td4[(s2 ) & 0xff] ^ | ||
| 971 | Td4[(s1 >> 8) & 0xff] << 8 ^ | ||
| 972 | Td4[(s0 >> 16) & 0xff] << 16 ^ | ||
| 973 | Td4[(s3 >> 24) ] << 24; | ||
| 974 | t[3] = Td4[(s3 ) & 0xff] ^ | ||
| 975 | Td4[(s2 >> 8) & 0xff] << 8 ^ | ||
| 976 | Td4[(s1 >> 16) & 0xff] << 16 ^ | ||
| 977 | Td4[(s0 >> 24) ] << 24; | ||
| 978 | |||
| 979 | /* now do the linear transform using words */ | ||
| 980 | { int i; | ||
| 981 | u32 tp1, tp2, tp4, tp8, tp9, tpb, tpd, tpe, m; | ||
| 982 | |||
| 983 | for (i = 0; i < 4; i++) { | ||
| 984 | tp1 = t[i]; | ||
| 985 | m = tp1 & 0x80808080; | ||
| 986 | tp2 = ((tp1 & 0x7f7f7f7f) << 1) ^ | ||
| 987 | ((m - (m >> 7)) & 0x1b1b1b1b); | ||
| 988 | m = tp2 & 0x80808080; | ||
| 989 | tp4 = ((tp2 & 0x7f7f7f7f) << 1) ^ | ||
| 990 | ((m - (m >> 7)) & 0x1b1b1b1b); | ||
| 991 | m = tp4 & 0x80808080; | ||
| 992 | tp8 = ((tp4 & 0x7f7f7f7f) << 1) ^ | ||
| 993 | ((m - (m >> 7)) & 0x1b1b1b1b); | ||
| 994 | tp9 = tp8 ^ tp1; | ||
| 995 | tpb = tp9 ^ tp2; | ||
| 996 | tpd = tp9 ^ tp4; | ||
| 997 | tpe = tp8 ^ tp4 ^ tp2; | ||
| 998 | #if defined(ROTATE) | ||
| 999 | t[i] = tpe ^ ROTATE(tpd,16) ^ | ||
| 1000 | ROTATE(tp9,8) ^ ROTATE(tpb,24); | ||
| 1001 | #else | ||
| 1002 | t[i] = tpe ^ (tpd >> 16) ^ (tpd << 16) ^ | ||
| 1003 | (tp9 >> 24) ^ (tp9 << 8) ^ | ||
| 1004 | (tpb >> 8) ^ (tpb << 24); | ||
| 1005 | #endif | ||
| 1006 | t[i] ^= rk[i]; | ||
| 1007 | } | ||
| 1008 | } | ||
| 1009 | #else | ||
| 1010 | t[0] = Td0[(s0 ) & 0xff] ^ | ||
| 1011 | Td1[(s3 >> 8) & 0xff] ^ | ||
| 1012 | Td2[(s2 >> 16) & 0xff] ^ | ||
| 1013 | Td3[(s1 >> 24) ] ^ | ||
| 1014 | rk[0]; | ||
| 1015 | t[1] = Td0[(s1 ) & 0xff] ^ | ||
| 1016 | Td1[(s0 >> 8) & 0xff] ^ | ||
| 1017 | Td2[(s3 >> 16) & 0xff] ^ | ||
| 1018 | Td3[(s2 >> 24) ] ^ | ||
| 1019 | rk[1]; | ||
| 1020 | t[2] = Td0[(s2 ) & 0xff] ^ | ||
| 1021 | Td1[(s1 >> 8) & 0xff] ^ | ||
| 1022 | Td2[(s0 >> 16) & 0xff] ^ | ||
| 1023 | Td3[(s3 >> 24) ] ^ | ||
| 1024 | rk[2]; | ||
| 1025 | t[3] = Td0[(s3 ) & 0xff] ^ | ||
| 1026 | Td1[(s2 >> 8) & 0xff] ^ | ||
| 1027 | Td2[(s1 >> 16) & 0xff] ^ | ||
| 1028 | Td3[(s0 >> 24) ] ^ | ||
| 1029 | rk[3]; | ||
| 1030 | #endif | ||
| 1031 | s0 = t[0]; s1 = t[1]; s2 = t[2]; s3 = t[3]; | ||
| 1032 | } | ||
| 1033 | /* | ||
| 1034 | * apply last round and | ||
| 1035 | * map cipher state to byte array block: | ||
| 1036 | */ | ||
| 1037 | prefetch256(Td4); | ||
| 1038 | |||
| 1039 | *(u32*)(out+0) = | ||
| 1040 | (Td4[(s0 ) & 0xff]) ^ | ||
| 1041 | (Td4[(s3 >> 8) & 0xff] << 8) ^ | ||
| 1042 | (Td4[(s2 >> 16) & 0xff] << 16) ^ | ||
| 1043 | (Td4[(s1 >> 24) ] << 24) ^ | ||
| 1044 | rk[0]; | ||
| 1045 | *(u32*)(out+4) = | ||
| 1046 | (Td4[(s1 ) & 0xff]) ^ | ||
| 1047 | (Td4[(s0 >> 8) & 0xff] << 8) ^ | ||
| 1048 | (Td4[(s3 >> 16) & 0xff] << 16) ^ | ||
| 1049 | (Td4[(s2 >> 24) ] << 24) ^ | ||
| 1050 | rk[1]; | ||
| 1051 | *(u32*)(out+8) = | ||
| 1052 | (Td4[(s2 ) & 0xff]) ^ | ||
| 1053 | (Td4[(s1 >> 8) & 0xff] << 8) ^ | ||
| 1054 | (Td4[(s0 >> 16) & 0xff] << 16) ^ | ||
| 1055 | (Td4[(s3 >> 24) ] << 24) ^ | ||
| 1056 | rk[2]; | ||
| 1057 | *(u32*)(out+12) = | ||
| 1058 | (Td4[(s3 ) & 0xff]) ^ | ||
| 1059 | (Td4[(s2 >> 8) & 0xff] << 8) ^ | ||
| 1060 | (Td4[(s1 >> 16) & 0xff] << 16) ^ | ||
| 1061 | (Td4[(s0 >> 24) ] << 24) ^ | ||
| 1062 | rk[3]; | ||
| 1063 | } | ||
diff --git a/src/lib/libssl/src/crypto/aes/asm/aes-armv4.pl b/src/lib/libssl/src/crypto/aes/asm/aes-armv4.pl new file mode 100644 index 0000000000..15742c1ec5 --- /dev/null +++ b/src/lib/libssl/src/crypto/aes/asm/aes-armv4.pl | |||
| @@ -0,0 +1,1030 @@ | |||
| 1 | #!/usr/bin/env perl | ||
| 2 | |||
| 3 | # ==================================================================== | ||
| 4 | # Written by Andy Polyakov <appro@fy.chalmers.se> for the OpenSSL | ||
| 5 | # project. The module is, however, dual licensed under OpenSSL and | ||
| 6 | # CRYPTOGAMS licenses depending on where you obtain it. For further | ||
| 7 | # details see http://www.openssl.org/~appro/cryptogams/. | ||
| 8 | # ==================================================================== | ||
| 9 | |||
| 10 | # AES for ARMv4 | ||
| 11 | |||
| 12 | # January 2007. | ||
| 13 | # | ||
| 14 | # Code uses single 1K S-box and is >2 times faster than code generated | ||
| 15 | # by gcc-3.4.1. This is thanks to unique feature of ARMv4 ISA, which | ||
| 16 | # allows to merge logical or arithmetic operation with shift or rotate | ||
| 17 | # in one instruction and emit combined result every cycle. The module | ||
| 18 | # is endian-neutral. The performance is ~42 cycles/byte for 128-bit | ||
| 19 | # key. | ||
| 20 | |||
| 21 | # May 2007. | ||
| 22 | # | ||
| 23 | # AES_set_[en|de]crypt_key is added. | ||
| 24 | |||
| 25 | $s0="r0"; | ||
| 26 | $s1="r1"; | ||
| 27 | $s2="r2"; | ||
| 28 | $s3="r3"; | ||
| 29 | $t1="r4"; | ||
| 30 | $t2="r5"; | ||
| 31 | $t3="r6"; | ||
| 32 | $i1="r7"; | ||
| 33 | $i2="r8"; | ||
| 34 | $i3="r9"; | ||
| 35 | |||
| 36 | $tbl="r10"; | ||
| 37 | $key="r11"; | ||
| 38 | $rounds="r12"; | ||
| 39 | |||
| 40 | $code=<<___; | ||
| 41 | .text | ||
| 42 | .code 32 | ||
| 43 | |||
| 44 | .type AES_Te,%object | ||
| 45 | .align 5 | ||
| 46 | AES_Te: | ||
| 47 | .word 0xc66363a5, 0xf87c7c84, 0xee777799, 0xf67b7b8d | ||
| 48 | .word 0xfff2f20d, 0xd66b6bbd, 0xde6f6fb1, 0x91c5c554 | ||
| 49 | .word 0x60303050, 0x02010103, 0xce6767a9, 0x562b2b7d | ||
| 50 | .word 0xe7fefe19, 0xb5d7d762, 0x4dababe6, 0xec76769a | ||
| 51 | .word 0x8fcaca45, 0x1f82829d, 0x89c9c940, 0xfa7d7d87 | ||
| 52 | .word 0xeffafa15, 0xb25959eb, 0x8e4747c9, 0xfbf0f00b | ||
| 53 | .word 0x41adadec, 0xb3d4d467, 0x5fa2a2fd, 0x45afafea | ||
| 54 | .word 0x239c9cbf, 0x53a4a4f7, 0xe4727296, 0x9bc0c05b | ||
| 55 | .word 0x75b7b7c2, 0xe1fdfd1c, 0x3d9393ae, 0x4c26266a | ||
| 56 | .word 0x6c36365a, 0x7e3f3f41, 0xf5f7f702, 0x83cccc4f | ||
| 57 | .word 0x6834345c, 0x51a5a5f4, 0xd1e5e534, 0xf9f1f108 | ||
| 58 | .word 0xe2717193, 0xabd8d873, 0x62313153, 0x2a15153f | ||
| 59 | .word 0x0804040c, 0x95c7c752, 0x46232365, 0x9dc3c35e | ||
| 60 | .word 0x30181828, 0x379696a1, 0x0a05050f, 0x2f9a9ab5 | ||
| 61 | .word 0x0e070709, 0x24121236, 0x1b80809b, 0xdfe2e23d | ||
| 62 | .word 0xcdebeb26, 0x4e272769, 0x7fb2b2cd, 0xea75759f | ||
| 63 | .word 0x1209091b, 0x1d83839e, 0x582c2c74, 0x341a1a2e | ||
| 64 | .word 0x361b1b2d, 0xdc6e6eb2, 0xb45a5aee, 0x5ba0a0fb | ||
| 65 | .word 0xa45252f6, 0x763b3b4d, 0xb7d6d661, 0x7db3b3ce | ||
| 66 | .word 0x5229297b, 0xdde3e33e, 0x5e2f2f71, 0x13848497 | ||
| 67 | .word 0xa65353f5, 0xb9d1d168, 0x00000000, 0xc1eded2c | ||
| 68 | .word 0x40202060, 0xe3fcfc1f, 0x79b1b1c8, 0xb65b5bed | ||
| 69 | .word 0xd46a6abe, 0x8dcbcb46, 0x67bebed9, 0x7239394b | ||
| 70 | .word 0x944a4ade, 0x984c4cd4, 0xb05858e8, 0x85cfcf4a | ||
| 71 | .word 0xbbd0d06b, 0xc5efef2a, 0x4faaaae5, 0xedfbfb16 | ||
| 72 | .word 0x864343c5, 0x9a4d4dd7, 0x66333355, 0x11858594 | ||
| 73 | .word 0x8a4545cf, 0xe9f9f910, 0x04020206, 0xfe7f7f81 | ||
| 74 | .word 0xa05050f0, 0x783c3c44, 0x259f9fba, 0x4ba8a8e3 | ||
| 75 | .word 0xa25151f3, 0x5da3a3fe, 0x804040c0, 0x058f8f8a | ||
| 76 | .word 0x3f9292ad, 0x219d9dbc, 0x70383848, 0xf1f5f504 | ||
| 77 | .word 0x63bcbcdf, 0x77b6b6c1, 0xafdada75, 0x42212163 | ||
| 78 | .word 0x20101030, 0xe5ffff1a, 0xfdf3f30e, 0xbfd2d26d | ||
| 79 | .word 0x81cdcd4c, 0x180c0c14, 0x26131335, 0xc3ecec2f | ||
| 80 | .word 0xbe5f5fe1, 0x359797a2, 0x884444cc, 0x2e171739 | ||
| 81 | .word 0x93c4c457, 0x55a7a7f2, 0xfc7e7e82, 0x7a3d3d47 | ||
| 82 | .word 0xc86464ac, 0xba5d5de7, 0x3219192b, 0xe6737395 | ||
| 83 | .word 0xc06060a0, 0x19818198, 0x9e4f4fd1, 0xa3dcdc7f | ||
| 84 | .word 0x44222266, 0x542a2a7e, 0x3b9090ab, 0x0b888883 | ||
| 85 | .word 0x8c4646ca, 0xc7eeee29, 0x6bb8b8d3, 0x2814143c | ||
| 86 | .word 0xa7dede79, 0xbc5e5ee2, 0x160b0b1d, 0xaddbdb76 | ||
| 87 | .word 0xdbe0e03b, 0x64323256, 0x743a3a4e, 0x140a0a1e | ||
| 88 | .word 0x924949db, 0x0c06060a, 0x4824246c, 0xb85c5ce4 | ||
| 89 | .word 0x9fc2c25d, 0xbdd3d36e, 0x43acacef, 0xc46262a6 | ||
| 90 | .word 0x399191a8, 0x319595a4, 0xd3e4e437, 0xf279798b | ||
| 91 | .word 0xd5e7e732, 0x8bc8c843, 0x6e373759, 0xda6d6db7 | ||
| 92 | .word 0x018d8d8c, 0xb1d5d564, 0x9c4e4ed2, 0x49a9a9e0 | ||
| 93 | .word 0xd86c6cb4, 0xac5656fa, 0xf3f4f407, 0xcfeaea25 | ||
| 94 | .word 0xca6565af, 0xf47a7a8e, 0x47aeaee9, 0x10080818 | ||
| 95 | .word 0x6fbabad5, 0xf0787888, 0x4a25256f, 0x5c2e2e72 | ||
| 96 | .word 0x381c1c24, 0x57a6a6f1, 0x73b4b4c7, 0x97c6c651 | ||
| 97 | .word 0xcbe8e823, 0xa1dddd7c, 0xe874749c, 0x3e1f1f21 | ||
| 98 | .word 0x964b4bdd, 0x61bdbddc, 0x0d8b8b86, 0x0f8a8a85 | ||
| 99 | .word 0xe0707090, 0x7c3e3e42, 0x71b5b5c4, 0xcc6666aa | ||
| 100 | .word 0x904848d8, 0x06030305, 0xf7f6f601, 0x1c0e0e12 | ||
| 101 | .word 0xc26161a3, 0x6a35355f, 0xae5757f9, 0x69b9b9d0 | ||
| 102 | .word 0x17868691, 0x99c1c158, 0x3a1d1d27, 0x279e9eb9 | ||
| 103 | .word 0xd9e1e138, 0xebf8f813, 0x2b9898b3, 0x22111133 | ||
| 104 | .word 0xd26969bb, 0xa9d9d970, 0x078e8e89, 0x339494a7 | ||
| 105 | .word 0x2d9b9bb6, 0x3c1e1e22, 0x15878792, 0xc9e9e920 | ||
| 106 | .word 0x87cece49, 0xaa5555ff, 0x50282878, 0xa5dfdf7a | ||
| 107 | .word 0x038c8c8f, 0x59a1a1f8, 0x09898980, 0x1a0d0d17 | ||
| 108 | .word 0x65bfbfda, 0xd7e6e631, 0x844242c6, 0xd06868b8 | ||
| 109 | .word 0x824141c3, 0x299999b0, 0x5a2d2d77, 0x1e0f0f11 | ||
| 110 | .word 0x7bb0b0cb, 0xa85454fc, 0x6dbbbbd6, 0x2c16163a | ||
| 111 | @ Te4[256] | ||
| 112 | .byte 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5 | ||
| 113 | .byte 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76 | ||
| 114 | .byte 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0 | ||
| 115 | .byte 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0 | ||
| 116 | .byte 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc | ||
| 117 | .byte 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15 | ||
| 118 | .byte 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a | ||
| 119 | .byte 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75 | ||
| 120 | .byte 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0 | ||
| 121 | .byte 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84 | ||
| 122 | .byte 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b | ||
| 123 | .byte 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf | ||
| 124 | .byte 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85 | ||
| 125 | .byte 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8 | ||
| 126 | .byte 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5 | ||
| 127 | .byte 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2 | ||
| 128 | .byte 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17 | ||
| 129 | .byte 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73 | ||
| 130 | .byte 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88 | ||
| 131 | .byte 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb | ||
| 132 | .byte 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c | ||
| 133 | .byte 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79 | ||
| 134 | .byte 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9 | ||
| 135 | .byte 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08 | ||
| 136 | .byte 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6 | ||
| 137 | .byte 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a | ||
| 138 | .byte 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e | ||
| 139 | .byte 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e | ||
| 140 | .byte 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94 | ||
| 141 | .byte 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf | ||
| 142 | .byte 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68 | ||
| 143 | .byte 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 | ||
| 144 | @ rcon[] | ||
| 145 | .word 0x01000000, 0x02000000, 0x04000000, 0x08000000 | ||
| 146 | .word 0x10000000, 0x20000000, 0x40000000, 0x80000000 | ||
| 147 | .word 0x1B000000, 0x36000000, 0, 0, 0, 0, 0, 0 | ||
| 148 | .size AES_Te,.-AES_Te | ||
| 149 | |||
| 150 | @ void AES_encrypt(const unsigned char *in, unsigned char *out, | ||
| 151 | @ const AES_KEY *key) { | ||
| 152 | .global AES_encrypt | ||
| 153 | .type AES_encrypt,%function | ||
| 154 | .align 5 | ||
| 155 | AES_encrypt: | ||
| 156 | sub r3,pc,#8 @ AES_encrypt | ||
| 157 | stmdb sp!,{r1,r4-r12,lr} | ||
| 158 | mov $rounds,r0 @ inp | ||
| 159 | mov $key,r2 | ||
| 160 | sub $tbl,r3,#AES_encrypt-AES_Te @ Te | ||
| 161 | |||
| 162 | ldrb $s0,[$rounds,#3] @ load input data in endian-neutral | ||
| 163 | ldrb $t1,[$rounds,#2] @ manner... | ||
| 164 | ldrb $t2,[$rounds,#1] | ||
| 165 | ldrb $t3,[$rounds,#0] | ||
| 166 | orr $s0,$s0,$t1,lsl#8 | ||
| 167 | orr $s0,$s0,$t2,lsl#16 | ||
| 168 | orr $s0,$s0,$t3,lsl#24 | ||
| 169 | ldrb $s1,[$rounds,#7] | ||
| 170 | ldrb $t1,[$rounds,#6] | ||
| 171 | ldrb $t2,[$rounds,#5] | ||
| 172 | ldrb $t3,[$rounds,#4] | ||
| 173 | orr $s1,$s1,$t1,lsl#8 | ||
| 174 | orr $s1,$s1,$t2,lsl#16 | ||
| 175 | orr $s1,$s1,$t3,lsl#24 | ||
| 176 | ldrb $s2,[$rounds,#11] | ||
| 177 | ldrb $t1,[$rounds,#10] | ||
| 178 | ldrb $t2,[$rounds,#9] | ||
| 179 | ldrb $t3,[$rounds,#8] | ||
| 180 | orr $s2,$s2,$t1,lsl#8 | ||
| 181 | orr $s2,$s2,$t2,lsl#16 | ||
| 182 | orr $s2,$s2,$t3,lsl#24 | ||
| 183 | ldrb $s3,[$rounds,#15] | ||
| 184 | ldrb $t1,[$rounds,#14] | ||
| 185 | ldrb $t2,[$rounds,#13] | ||
| 186 | ldrb $t3,[$rounds,#12] | ||
| 187 | orr $s3,$s3,$t1,lsl#8 | ||
| 188 | orr $s3,$s3,$t2,lsl#16 | ||
| 189 | orr $s3,$s3,$t3,lsl#24 | ||
| 190 | |||
| 191 | bl _armv4_AES_encrypt | ||
| 192 | |||
| 193 | ldr $rounds,[sp],#4 @ pop out | ||
| 194 | mov $t1,$s0,lsr#24 @ write output in endian-neutral | ||
| 195 | mov $t2,$s0,lsr#16 @ manner... | ||
| 196 | mov $t3,$s0,lsr#8 | ||
| 197 | strb $t1,[$rounds,#0] | ||
| 198 | strb $t2,[$rounds,#1] | ||
| 199 | strb $t3,[$rounds,#2] | ||
| 200 | strb $s0,[$rounds,#3] | ||
| 201 | mov $t1,$s1,lsr#24 | ||
| 202 | mov $t2,$s1,lsr#16 | ||
| 203 | mov $t3,$s1,lsr#8 | ||
| 204 | strb $t1,[$rounds,#4] | ||
| 205 | strb $t2,[$rounds,#5] | ||
| 206 | strb $t3,[$rounds,#6] | ||
| 207 | strb $s1,[$rounds,#7] | ||
| 208 | mov $t1,$s2,lsr#24 | ||
| 209 | mov $t2,$s2,lsr#16 | ||
| 210 | mov $t3,$s2,lsr#8 | ||
| 211 | strb $t1,[$rounds,#8] | ||
| 212 | strb $t2,[$rounds,#9] | ||
| 213 | strb $t3,[$rounds,#10] | ||
| 214 | strb $s2,[$rounds,#11] | ||
| 215 | mov $t1,$s3,lsr#24 | ||
| 216 | mov $t2,$s3,lsr#16 | ||
| 217 | mov $t3,$s3,lsr#8 | ||
| 218 | strb $t1,[$rounds,#12] | ||
| 219 | strb $t2,[$rounds,#13] | ||
| 220 | strb $t3,[$rounds,#14] | ||
| 221 | strb $s3,[$rounds,#15] | ||
| 222 | |||
| 223 | ldmia sp!,{r4-r12,lr} | ||
| 224 | tst lr,#1 | ||
| 225 | moveq pc,lr @ be binary compatible with V4, yet | ||
| 226 | bx lr @ interoperable with Thumb ISA:-) | ||
| 227 | .size AES_encrypt,.-AES_encrypt | ||
| 228 | |||
| 229 | .type _armv4_AES_encrypt,%function | ||
| 230 | .align 2 | ||
| 231 | _armv4_AES_encrypt: | ||
| 232 | str lr,[sp,#-4]! @ push lr | ||
| 233 | ldr $t1,[$key],#16 | ||
| 234 | ldr $t2,[$key,#-12] | ||
| 235 | ldr $t3,[$key,#-8] | ||
| 236 | ldr $i1,[$key,#-4] | ||
| 237 | ldr $rounds,[$key,#240-16] | ||
| 238 | eor $s0,$s0,$t1 | ||
| 239 | eor $s1,$s1,$t2 | ||
| 240 | eor $s2,$s2,$t3 | ||
| 241 | eor $s3,$s3,$i1 | ||
| 242 | sub $rounds,$rounds,#1 | ||
| 243 | mov lr,#255 | ||
| 244 | |||
| 245 | .Lenc_loop: | ||
| 246 | and $i2,lr,$s0,lsr#8 | ||
| 247 | and $i3,lr,$s0,lsr#16 | ||
| 248 | and $i1,lr,$s0 | ||
| 249 | mov $s0,$s0,lsr#24 | ||
| 250 | ldr $t1,[$tbl,$i1,lsl#2] @ Te3[s0>>0] | ||
| 251 | ldr $s0,[$tbl,$s0,lsl#2] @ Te0[s0>>24] | ||
| 252 | ldr $t2,[$tbl,$i2,lsl#2] @ Te2[s0>>8] | ||
| 253 | ldr $t3,[$tbl,$i3,lsl#2] @ Te1[s0>>16] | ||
| 254 | |||
| 255 | and $i1,lr,$s1,lsr#16 @ i0 | ||
| 256 | and $i2,lr,$s1 | ||
| 257 | and $i3,lr,$s1,lsr#8 | ||
| 258 | mov $s1,$s1,lsr#24 | ||
| 259 | ldr $i1,[$tbl,$i1,lsl#2] @ Te1[s1>>16] | ||
| 260 | ldr $s1,[$tbl,$s1,lsl#2] @ Te0[s1>>24] | ||
| 261 | ldr $i2,[$tbl,$i2,lsl#2] @ Te3[s1>>0] | ||
| 262 | ldr $i3,[$tbl,$i3,lsl#2] @ Te2[s1>>8] | ||
| 263 | eor $s0,$s0,$i1,ror#8 | ||
| 264 | eor $s1,$s1,$t1,ror#24 | ||
| 265 | eor $t2,$t2,$i2,ror#8 | ||
| 266 | eor $t3,$t3,$i3,ror#8 | ||
| 267 | |||
| 268 | and $i1,lr,$s2,lsr#8 @ i0 | ||
| 269 | and $i2,lr,$s2,lsr#16 @ i1 | ||
| 270 | and $i3,lr,$s2 | ||
| 271 | mov $s2,$s2,lsr#24 | ||
| 272 | ldr $i1,[$tbl,$i1,lsl#2] @ Te2[s2>>8] | ||
| 273 | ldr $i2,[$tbl,$i2,lsl#2] @ Te1[s2>>16] | ||
| 274 | ldr $s2,[$tbl,$s2,lsl#2] @ Te0[s2>>24] | ||
| 275 | ldr $i3,[$tbl,$i3,lsl#2] @ Te3[s2>>0] | ||
| 276 | eor $s0,$s0,$i1,ror#16 | ||
| 277 | eor $s1,$s1,$i2,ror#8 | ||
| 278 | eor $s2,$s2,$t2,ror#16 | ||
| 279 | eor $t3,$t3,$i3,ror#16 | ||
| 280 | |||
| 281 | and $i1,lr,$s3 @ i0 | ||
| 282 | and $i2,lr,$s3,lsr#8 @ i1 | ||
| 283 | and $i3,lr,$s3,lsr#16 @ i2 | ||
| 284 | mov $s3,$s3,lsr#24 | ||
| 285 | ldr $i1,[$tbl,$i1,lsl#2] @ Te3[s3>>0] | ||
| 286 | ldr $i2,[$tbl,$i2,lsl#2] @ Te2[s3>>8] | ||
| 287 | ldr $i3,[$tbl,$i3,lsl#2] @ Te1[s3>>16] | ||
| 288 | ldr $s3,[$tbl,$s3,lsl#2] @ Te0[s3>>24] | ||
| 289 | eor $s0,$s0,$i1,ror#24 | ||
| 290 | eor $s1,$s1,$i2,ror#16 | ||
| 291 | eor $s2,$s2,$i3,ror#8 | ||
| 292 | eor $s3,$s3,$t3,ror#8 | ||
| 293 | |||
| 294 | ldr $t1,[$key],#16 | ||
| 295 | ldr $t2,[$key,#-12] | ||
| 296 | ldr $t3,[$key,#-8] | ||
| 297 | ldr $i1,[$key,#-4] | ||
| 298 | eor $s0,$s0,$t1 | ||
| 299 | eor $s1,$s1,$t2 | ||
| 300 | eor $s2,$s2,$t3 | ||
| 301 | eor $s3,$s3,$i1 | ||
| 302 | |||
| 303 | subs $rounds,$rounds,#1 | ||
| 304 | bne .Lenc_loop | ||
| 305 | |||
| 306 | add $tbl,$tbl,#2 | ||
| 307 | |||
| 308 | and $i1,lr,$s0 | ||
| 309 | and $i2,lr,$s0,lsr#8 | ||
| 310 | and $i3,lr,$s0,lsr#16 | ||
| 311 | mov $s0,$s0,lsr#24 | ||
| 312 | ldrb $t1,[$tbl,$i1,lsl#2] @ Te4[s0>>0] | ||
| 313 | ldrb $s0,[$tbl,$s0,lsl#2] @ Te4[s0>>24] | ||
| 314 | ldrb $t2,[$tbl,$i2,lsl#2] @ Te4[s0>>8] | ||
| 315 | ldrb $t3,[$tbl,$i3,lsl#2] @ Te4[s0>>16] | ||
| 316 | |||
| 317 | and $i1,lr,$s1,lsr#16 @ i0 | ||
| 318 | and $i2,lr,$s1 | ||
| 319 | and $i3,lr,$s1,lsr#8 | ||
| 320 | mov $s1,$s1,lsr#24 | ||
| 321 | ldrb $i1,[$tbl,$i1,lsl#2] @ Te4[s1>>16] | ||
| 322 | ldrb $s1,[$tbl,$s1,lsl#2] @ Te4[s1>>24] | ||
| 323 | ldrb $i2,[$tbl,$i2,lsl#2] @ Te4[s1>>0] | ||
| 324 | ldrb $i3,[$tbl,$i3,lsl#2] @ Te4[s1>>8] | ||
| 325 | eor $s0,$i1,$s0,lsl#8 | ||
| 326 | eor $s1,$t1,$s1,lsl#24 | ||
| 327 | eor $t2,$i2,$t2,lsl#8 | ||
| 328 | eor $t3,$i3,$t3,lsl#8 | ||
| 329 | |||
| 330 | and $i1,lr,$s2,lsr#8 @ i0 | ||
| 331 | and $i2,lr,$s2,lsr#16 @ i1 | ||
| 332 | and $i3,lr,$s2 | ||
| 333 | mov $s2,$s2,lsr#24 | ||
| 334 | ldrb $i1,[$tbl,$i1,lsl#2] @ Te4[s2>>8] | ||
| 335 | ldrb $i2,[$tbl,$i2,lsl#2] @ Te4[s2>>16] | ||
| 336 | ldrb $s2,[$tbl,$s2,lsl#2] @ Te4[s2>>24] | ||
| 337 | ldrb $i3,[$tbl,$i3,lsl#2] @ Te4[s2>>0] | ||
| 338 | eor $s0,$i1,$s0,lsl#8 | ||
| 339 | eor $s1,$s1,$i2,lsl#16 | ||
| 340 | eor $s2,$t2,$s2,lsl#24 | ||
| 341 | eor $t3,$i3,$t3,lsl#8 | ||
| 342 | |||
| 343 | and $i1,lr,$s3 @ i0 | ||
| 344 | and $i2,lr,$s3,lsr#8 @ i1 | ||
| 345 | and $i3,lr,$s3,lsr#16 @ i2 | ||
| 346 | mov $s3,$s3,lsr#24 | ||
| 347 | ldrb $i1,[$tbl,$i1,lsl#2] @ Te4[s3>>0] | ||
| 348 | ldrb $i2,[$tbl,$i2,lsl#2] @ Te4[s3>>8] | ||
| 349 | ldrb $i3,[$tbl,$i3,lsl#2] @ Te4[s3>>16] | ||
| 350 | ldrb $s3,[$tbl,$s3,lsl#2] @ Te4[s3>>24] | ||
| 351 | eor $s0,$i1,$s0,lsl#8 | ||
| 352 | eor $s1,$s1,$i2,lsl#8 | ||
| 353 | eor $s2,$s2,$i3,lsl#16 | ||
| 354 | eor $s3,$t3,$s3,lsl#24 | ||
| 355 | |||
| 356 | ldr lr,[sp],#4 @ pop lr | ||
| 357 | ldr $t1,[$key,#0] | ||
| 358 | ldr $t2,[$key,#4] | ||
| 359 | ldr $t3,[$key,#8] | ||
| 360 | ldr $i1,[$key,#12] | ||
| 361 | eor $s0,$s0,$t1 | ||
| 362 | eor $s1,$s1,$t2 | ||
| 363 | eor $s2,$s2,$t3 | ||
| 364 | eor $s3,$s3,$i1 | ||
| 365 | |||
| 366 | sub $tbl,$tbl,#2 | ||
| 367 | mov pc,lr @ return | ||
| 368 | .size _armv4_AES_encrypt,.-_armv4_AES_encrypt | ||
| 369 | |||
| 370 | .global AES_set_encrypt_key | ||
| 371 | .type AES_set_encrypt_key,%function | ||
| 372 | .align 5 | ||
| 373 | AES_set_encrypt_key: | ||
| 374 | sub r3,pc,#8 @ AES_set_encrypt_key | ||
| 375 | teq r0,#0 | ||
| 376 | moveq r0,#-1 | ||
| 377 | beq .Labrt | ||
| 378 | teq r2,#0 | ||
| 379 | moveq r0,#-1 | ||
| 380 | beq .Labrt | ||
| 381 | |||
| 382 | teq r1,#128 | ||
| 383 | beq .Lok | ||
| 384 | teq r1,#192 | ||
| 385 | beq .Lok | ||
| 386 | teq r1,#256 | ||
| 387 | movne r0,#-1 | ||
| 388 | bne .Labrt | ||
| 389 | |||
| 390 | .Lok: stmdb sp!,{r4-r12,lr} | ||
| 391 | sub $tbl,r3,#AES_set_encrypt_key-AES_Te-1024 @ Te4 | ||
| 392 | |||
| 393 | mov $rounds,r0 @ inp | ||
| 394 | mov lr,r1 @ bits | ||
| 395 | mov $key,r2 @ key | ||
| 396 | |||
| 397 | ldrb $s0,[$rounds,#3] @ load input data in endian-neutral | ||
| 398 | ldrb $t1,[$rounds,#2] @ manner... | ||
| 399 | ldrb $t2,[$rounds,#1] | ||
| 400 | ldrb $t3,[$rounds,#0] | ||
| 401 | orr $s0,$s0,$t1,lsl#8 | ||
| 402 | orr $s0,$s0,$t2,lsl#16 | ||
| 403 | orr $s0,$s0,$t3,lsl#24 | ||
| 404 | ldrb $s1,[$rounds,#7] | ||
| 405 | ldrb $t1,[$rounds,#6] | ||
| 406 | ldrb $t2,[$rounds,#5] | ||
| 407 | ldrb $t3,[$rounds,#4] | ||
| 408 | orr $s1,$s1,$t1,lsl#8 | ||
| 409 | orr $s1,$s1,$t2,lsl#16 | ||
| 410 | orr $s1,$s1,$t3,lsl#24 | ||
| 411 | ldrb $s2,[$rounds,#11] | ||
| 412 | ldrb $t1,[$rounds,#10] | ||
| 413 | ldrb $t2,[$rounds,#9] | ||
| 414 | ldrb $t3,[$rounds,#8] | ||
| 415 | orr $s2,$s2,$t1,lsl#8 | ||
| 416 | orr $s2,$s2,$t2,lsl#16 | ||
| 417 | orr $s2,$s2,$t3,lsl#24 | ||
| 418 | ldrb $s3,[$rounds,#15] | ||
| 419 | ldrb $t1,[$rounds,#14] | ||
| 420 | ldrb $t2,[$rounds,#13] | ||
| 421 | ldrb $t3,[$rounds,#12] | ||
| 422 | orr $s3,$s3,$t1,lsl#8 | ||
| 423 | orr $s3,$s3,$t2,lsl#16 | ||
| 424 | orr $s3,$s3,$t3,lsl#24 | ||
| 425 | str $s0,[$key],#16 | ||
| 426 | str $s1,[$key,#-12] | ||
| 427 | str $s2,[$key,#-8] | ||
| 428 | str $s3,[$key,#-4] | ||
| 429 | |||
| 430 | teq lr,#128 | ||
| 431 | bne .Lnot128 | ||
| 432 | mov $rounds,#10 | ||
| 433 | str $rounds,[$key,#240-16] | ||
| 434 | add $t3,$tbl,#256 @ rcon | ||
| 435 | mov lr,#255 | ||
| 436 | |||
| 437 | .L128_loop: | ||
| 438 | and $t2,lr,$s3,lsr#24 | ||
| 439 | and $i1,lr,$s3,lsr#16 | ||
| 440 | and $i2,lr,$s3,lsr#8 | ||
| 441 | and $i3,lr,$s3 | ||
| 442 | ldrb $t2,[$tbl,$t2] | ||
| 443 | ldrb $i1,[$tbl,$i1] | ||
| 444 | ldrb $i2,[$tbl,$i2] | ||
| 445 | ldrb $i3,[$tbl,$i3] | ||
| 446 | ldr $t1,[$t3],#4 @ rcon[i++] | ||
| 447 | orr $t2,$t2,$i1,lsl#24 | ||
| 448 | orr $t2,$t2,$i2,lsl#16 | ||
| 449 | orr $t2,$t2,$i3,lsl#8 | ||
| 450 | eor $t2,$t2,$t1 | ||
| 451 | eor $s0,$s0,$t2 @ rk[4]=rk[0]^... | ||
| 452 | eor $s1,$s1,$s0 @ rk[5]=rk[1]^rk[4] | ||
| 453 | eor $s2,$s2,$s1 @ rk[6]=rk[2]^rk[5] | ||
| 454 | eor $s3,$s3,$s2 @ rk[7]=rk[3]^rk[6] | ||
| 455 | str $s0,[$key],#16 | ||
| 456 | str $s1,[$key,#-12] | ||
| 457 | str $s2,[$key,#-8] | ||
| 458 | str $s3,[$key,#-4] | ||
| 459 | |||
| 460 | subs $rounds,$rounds,#1 | ||
| 461 | bne .L128_loop | ||
| 462 | sub r2,$key,#176 | ||
| 463 | b .Ldone | ||
| 464 | |||
| 465 | .Lnot128: | ||
| 466 | ldrb $i2,[$rounds,#19] | ||
| 467 | ldrb $t1,[$rounds,#18] | ||
| 468 | ldrb $t2,[$rounds,#17] | ||
| 469 | ldrb $t3,[$rounds,#16] | ||
| 470 | orr $i2,$i2,$t1,lsl#8 | ||
| 471 | orr $i2,$i2,$t2,lsl#16 | ||
| 472 | orr $i2,$i2,$t3,lsl#24 | ||
| 473 | ldrb $i3,[$rounds,#23] | ||
| 474 | ldrb $t1,[$rounds,#22] | ||
| 475 | ldrb $t2,[$rounds,#21] | ||
| 476 | ldrb $t3,[$rounds,#20] | ||
| 477 | orr $i3,$i3,$t1,lsl#8 | ||
| 478 | orr $i3,$i3,$t2,lsl#16 | ||
| 479 | orr $i3,$i3,$t3,lsl#24 | ||
| 480 | str $i2,[$key],#8 | ||
| 481 | str $i3,[$key,#-4] | ||
| 482 | |||
| 483 | teq lr,#192 | ||
| 484 | bne .Lnot192 | ||
| 485 | mov $rounds,#12 | ||
| 486 | str $rounds,[$key,#240-24] | ||
| 487 | add $t3,$tbl,#256 @ rcon | ||
| 488 | mov lr,#255 | ||
| 489 | mov $rounds,#8 | ||
| 490 | |||
| 491 | .L192_loop: | ||
| 492 | and $t2,lr,$i3,lsr#24 | ||
| 493 | and $i1,lr,$i3,lsr#16 | ||
| 494 | and $i2,lr,$i3,lsr#8 | ||
| 495 | and $i3,lr,$i3 | ||
| 496 | ldrb $t2,[$tbl,$t2] | ||
| 497 | ldrb $i1,[$tbl,$i1] | ||
| 498 | ldrb $i2,[$tbl,$i2] | ||
| 499 | ldrb $i3,[$tbl,$i3] | ||
| 500 | ldr $t1,[$t3],#4 @ rcon[i++] | ||
| 501 | orr $t2,$t2,$i1,lsl#24 | ||
| 502 | orr $t2,$t2,$i2,lsl#16 | ||
| 503 | orr $t2,$t2,$i3,lsl#8 | ||
| 504 | eor $i3,$t2,$t1 | ||
| 505 | eor $s0,$s0,$i3 @ rk[6]=rk[0]^... | ||
| 506 | eor $s1,$s1,$s0 @ rk[7]=rk[1]^rk[6] | ||
| 507 | eor $s2,$s2,$s1 @ rk[8]=rk[2]^rk[7] | ||
| 508 | eor $s3,$s3,$s2 @ rk[9]=rk[3]^rk[8] | ||
| 509 | str $s0,[$key],#24 | ||
| 510 | str $s1,[$key,#-20] | ||
| 511 | str $s2,[$key,#-16] | ||
| 512 | str $s3,[$key,#-12] | ||
| 513 | |||
| 514 | subs $rounds,$rounds,#1 | ||
| 515 | subeq r2,$key,#216 | ||
| 516 | beq .Ldone | ||
| 517 | |||
| 518 | ldr $i1,[$key,#-32] | ||
| 519 | ldr $i2,[$key,#-28] | ||
| 520 | eor $i1,$i1,$s3 @ rk[10]=rk[4]^rk[9] | ||
| 521 | eor $i3,$i2,$i1 @ rk[11]=rk[5]^rk[10] | ||
| 522 | str $i1,[$key,#-8] | ||
| 523 | str $i3,[$key,#-4] | ||
| 524 | b .L192_loop | ||
| 525 | |||
| 526 | .Lnot192: | ||
| 527 | ldrb $i2,[$rounds,#27] | ||
| 528 | ldrb $t1,[$rounds,#26] | ||
| 529 | ldrb $t2,[$rounds,#25] | ||
| 530 | ldrb $t3,[$rounds,#24] | ||
| 531 | orr $i2,$i2,$t1,lsl#8 | ||
| 532 | orr $i2,$i2,$t2,lsl#16 | ||
| 533 | orr $i2,$i2,$t3,lsl#24 | ||
| 534 | ldrb $i3,[$rounds,#31] | ||
| 535 | ldrb $t1,[$rounds,#30] | ||
| 536 | ldrb $t2,[$rounds,#29] | ||
| 537 | ldrb $t3,[$rounds,#28] | ||
| 538 | orr $i3,$i3,$t1,lsl#8 | ||
| 539 | orr $i3,$i3,$t2,lsl#16 | ||
| 540 | orr $i3,$i3,$t3,lsl#24 | ||
| 541 | str $i2,[$key],#8 | ||
| 542 | str $i3,[$key,#-4] | ||
| 543 | |||
| 544 | mov $rounds,#14 | ||
| 545 | str $rounds,[$key,#240-32] | ||
| 546 | add $t3,$tbl,#256 @ rcon | ||
| 547 | mov lr,#255 | ||
| 548 | mov $rounds,#7 | ||
| 549 | |||
| 550 | .L256_loop: | ||
| 551 | and $t2,lr,$i3,lsr#24 | ||
| 552 | and $i1,lr,$i3,lsr#16 | ||
| 553 | and $i2,lr,$i3,lsr#8 | ||
| 554 | and $i3,lr,$i3 | ||
| 555 | ldrb $t2,[$tbl,$t2] | ||
| 556 | ldrb $i1,[$tbl,$i1] | ||
| 557 | ldrb $i2,[$tbl,$i2] | ||
| 558 | ldrb $i3,[$tbl,$i3] | ||
| 559 | ldr $t1,[$t3],#4 @ rcon[i++] | ||
| 560 | orr $t2,$t2,$i1,lsl#24 | ||
| 561 | orr $t2,$t2,$i2,lsl#16 | ||
| 562 | orr $t2,$t2,$i3,lsl#8 | ||
| 563 | eor $i3,$t2,$t1 | ||
| 564 | eor $s0,$s0,$i3 @ rk[8]=rk[0]^... | ||
| 565 | eor $s1,$s1,$s0 @ rk[9]=rk[1]^rk[8] | ||
| 566 | eor $s2,$s2,$s1 @ rk[10]=rk[2]^rk[9] | ||
| 567 | eor $s3,$s3,$s2 @ rk[11]=rk[3]^rk[10] | ||
| 568 | str $s0,[$key],#32 | ||
| 569 | str $s1,[$key,#-28] | ||
| 570 | str $s2,[$key,#-24] | ||
| 571 | str $s3,[$key,#-20] | ||
| 572 | |||
| 573 | subs $rounds,$rounds,#1 | ||
| 574 | subeq r2,$key,#256 | ||
| 575 | beq .Ldone | ||
| 576 | |||
| 577 | and $t2,lr,$s3 | ||
| 578 | and $i1,lr,$s3,lsr#8 | ||
| 579 | and $i2,lr,$s3,lsr#16 | ||
| 580 | and $i3,lr,$s3,lsr#24 | ||
| 581 | ldrb $t2,[$tbl,$t2] | ||
| 582 | ldrb $i1,[$tbl,$i1] | ||
| 583 | ldrb $i2,[$tbl,$i2] | ||
| 584 | ldrb $i3,[$tbl,$i3] | ||
| 585 | orr $t2,$t2,$i1,lsl#8 | ||
| 586 | orr $t2,$t2,$i2,lsl#16 | ||
| 587 | orr $t2,$t2,$i3,lsl#24 | ||
| 588 | |||
| 589 | ldr $t1,[$key,#-48] | ||
| 590 | ldr $i1,[$key,#-44] | ||
| 591 | ldr $i2,[$key,#-40] | ||
| 592 | ldr $i3,[$key,#-36] | ||
| 593 | eor $t1,$t1,$t2 @ rk[12]=rk[4]^... | ||
| 594 | eor $i1,$i1,$t1 @ rk[13]=rk[5]^rk[12] | ||
| 595 | eor $i2,$i2,$i1 @ rk[14]=rk[6]^rk[13] | ||
| 596 | eor $i3,$i3,$i2 @ rk[15]=rk[7]^rk[14] | ||
| 597 | str $t1,[$key,#-16] | ||
| 598 | str $i1,[$key,#-12] | ||
| 599 | str $i2,[$key,#-8] | ||
| 600 | str $i3,[$key,#-4] | ||
| 601 | b .L256_loop | ||
| 602 | |||
| 603 | .Ldone: mov r0,#0 | ||
| 604 | ldmia sp!,{r4-r12,lr} | ||
| 605 | .Labrt: tst lr,#1 | ||
| 606 | moveq pc,lr @ be binary compatible with V4, yet | ||
| 607 | bx lr @ interoperable with Thumb ISA:-) | ||
| 608 | .size AES_set_encrypt_key,.-AES_set_encrypt_key | ||
| 609 | |||
| 610 | .global AES_set_decrypt_key | ||
| 611 | .type AES_set_decrypt_key,%function | ||
| 612 | .align 5 | ||
| 613 | AES_set_decrypt_key: | ||
| 614 | str lr,[sp,#-4]! @ push lr | ||
| 615 | bl AES_set_encrypt_key | ||
| 616 | teq r0,#0 | ||
| 617 | ldrne lr,[sp],#4 @ pop lr | ||
| 618 | bne .Labrt | ||
| 619 | |||
| 620 | stmdb sp!,{r4-r12} | ||
| 621 | |||
| 622 | ldr $rounds,[r2,#240] @ AES_set_encrypt_key preserves r2, | ||
| 623 | mov $key,r2 @ which is AES_KEY *key | ||
| 624 | mov $i1,r2 | ||
| 625 | add $i2,r2,$rounds,lsl#4 | ||
| 626 | |||
| 627 | .Linv: ldr $s0,[$i1] | ||
| 628 | ldr $s1,[$i1,#4] | ||
| 629 | ldr $s2,[$i1,#8] | ||
| 630 | ldr $s3,[$i1,#12] | ||
| 631 | ldr $t1,[$i2] | ||
| 632 | ldr $t2,[$i2,#4] | ||
| 633 | ldr $t3,[$i2,#8] | ||
| 634 | ldr $i3,[$i2,#12] | ||
| 635 | str $s0,[$i2],#-16 | ||
| 636 | str $s1,[$i2,#16+4] | ||
| 637 | str $s2,[$i2,#16+8] | ||
| 638 | str $s3,[$i2,#16+12] | ||
| 639 | str $t1,[$i1],#16 | ||
| 640 | str $t2,[$i1,#-12] | ||
| 641 | str $t3,[$i1,#-8] | ||
| 642 | str $i3,[$i1,#-4] | ||
| 643 | teq $i1,$i2 | ||
| 644 | bne .Linv | ||
| 645 | ___ | ||
| 646 | $mask80=$i1; | ||
| 647 | $mask1b=$i2; | ||
| 648 | $mask7f=$i3; | ||
| 649 | $code.=<<___; | ||
| 650 | ldr $s0,[$key,#16]! @ prefetch tp1 | ||
| 651 | mov $mask80,#0x80 | ||
| 652 | mov $mask1b,#0x1b | ||
| 653 | orr $mask80,$mask80,#0x8000 | ||
| 654 | orr $mask1b,$mask1b,#0x1b00 | ||
| 655 | orr $mask80,$mask80,$mask80,lsl#16 | ||
| 656 | orr $mask1b,$mask1b,$mask1b,lsl#16 | ||
| 657 | sub $rounds,$rounds,#1 | ||
| 658 | mvn $mask7f,$mask80 | ||
| 659 | mov $rounds,$rounds,lsl#2 @ (rounds-1)*4 | ||
| 660 | |||
| 661 | .Lmix: and $t1,$s0,$mask80 | ||
| 662 | and $s1,$s0,$mask7f | ||
| 663 | sub $t1,$t1,$t1,lsr#7 | ||
| 664 | and $t1,$t1,$mask1b | ||
| 665 | eor $s1,$t1,$s1,lsl#1 @ tp2 | ||
| 666 | |||
| 667 | and $t1,$s1,$mask80 | ||
| 668 | and $s2,$s1,$mask7f | ||
| 669 | sub $t1,$t1,$t1,lsr#7 | ||
| 670 | and $t1,$t1,$mask1b | ||
| 671 | eor $s2,$t1,$s2,lsl#1 @ tp4 | ||
| 672 | |||
| 673 | and $t1,$s2,$mask80 | ||
| 674 | and $s3,$s2,$mask7f | ||
| 675 | sub $t1,$t1,$t1,lsr#7 | ||
| 676 | and $t1,$t1,$mask1b | ||
| 677 | eor $s3,$t1,$s3,lsl#1 @ tp8 | ||
| 678 | |||
| 679 | eor $t1,$s1,$s2 | ||
| 680 | eor $t2,$s0,$s3 @ tp9 | ||
| 681 | eor $t1,$t1,$s3 @ tpe | ||
| 682 | eor $t1,$t1,$s1,ror#24 | ||
| 683 | eor $t1,$t1,$t2,ror#24 @ ^= ROTATE(tpb=tp9^tp2,8) | ||
| 684 | eor $t1,$t1,$s2,ror#16 | ||
| 685 | eor $t1,$t1,$t2,ror#16 @ ^= ROTATE(tpd=tp9^tp4,16) | ||
| 686 | eor $t1,$t1,$t2,ror#8 @ ^= ROTATE(tp9,24) | ||
| 687 | |||
| 688 | ldr $s0,[$key,#4] @ prefetch tp1 | ||
| 689 | str $t1,[$key],#4 | ||
| 690 | subs $rounds,$rounds,#1 | ||
| 691 | bne .Lmix | ||
| 692 | |||
| 693 | mov r0,#0 | ||
| 694 | ldmia sp!,{r4-r12,lr} | ||
| 695 | tst lr,#1 | ||
| 696 | moveq pc,lr @ be binary compatible with V4, yet | ||
| 697 | bx lr @ interoperable with Thumb ISA:-) | ||
| 698 | .size AES_set_decrypt_key,.-AES_set_decrypt_key | ||
| 699 | |||
| 700 | .type AES_Td,%object | ||
| 701 | .align 5 | ||
| 702 | AES_Td: | ||
| 703 | .word 0x51f4a750, 0x7e416553, 0x1a17a4c3, 0x3a275e96 | ||
| 704 | .word 0x3bab6bcb, 0x1f9d45f1, 0xacfa58ab, 0x4be30393 | ||
| 705 | .word 0x2030fa55, 0xad766df6, 0x88cc7691, 0xf5024c25 | ||
| 706 | .word 0x4fe5d7fc, 0xc52acbd7, 0x26354480, 0xb562a38f | ||
| 707 | .word 0xdeb15a49, 0x25ba1b67, 0x45ea0e98, 0x5dfec0e1 | ||
| 708 | .word 0xc32f7502, 0x814cf012, 0x8d4697a3, 0x6bd3f9c6 | ||
| 709 | .word 0x038f5fe7, 0x15929c95, 0xbf6d7aeb, 0x955259da | ||
| 710 | .word 0xd4be832d, 0x587421d3, 0x49e06929, 0x8ec9c844 | ||
| 711 | .word 0x75c2896a, 0xf48e7978, 0x99583e6b, 0x27b971dd | ||
| 712 | .word 0xbee14fb6, 0xf088ad17, 0xc920ac66, 0x7dce3ab4 | ||
| 713 | .word 0x63df4a18, 0xe51a3182, 0x97513360, 0x62537f45 | ||
| 714 | .word 0xb16477e0, 0xbb6bae84, 0xfe81a01c, 0xf9082b94 | ||
| 715 | .word 0x70486858, 0x8f45fd19, 0x94de6c87, 0x527bf8b7 | ||
| 716 | .word 0xab73d323, 0x724b02e2, 0xe31f8f57, 0x6655ab2a | ||
| 717 | .word 0xb2eb2807, 0x2fb5c203, 0x86c57b9a, 0xd33708a5 | ||
| 718 | .word 0x302887f2, 0x23bfa5b2, 0x02036aba, 0xed16825c | ||
| 719 | .word 0x8acf1c2b, 0xa779b492, 0xf307f2f0, 0x4e69e2a1 | ||
| 720 | .word 0x65daf4cd, 0x0605bed5, 0xd134621f, 0xc4a6fe8a | ||
| 721 | .word 0x342e539d, 0xa2f355a0, 0x058ae132, 0xa4f6eb75 | ||
| 722 | .word 0x0b83ec39, 0x4060efaa, 0x5e719f06, 0xbd6e1051 | ||
| 723 | .word 0x3e218af9, 0x96dd063d, 0xdd3e05ae, 0x4de6bd46 | ||
| 724 | .word 0x91548db5, 0x71c45d05, 0x0406d46f, 0x605015ff | ||
| 725 | .word 0x1998fb24, 0xd6bde997, 0x894043cc, 0x67d99e77 | ||
| 726 | .word 0xb0e842bd, 0x07898b88, 0xe7195b38, 0x79c8eedb | ||
| 727 | .word 0xa17c0a47, 0x7c420fe9, 0xf8841ec9, 0x00000000 | ||
| 728 | .word 0x09808683, 0x322bed48, 0x1e1170ac, 0x6c5a724e | ||
| 729 | .word 0xfd0efffb, 0x0f853856, 0x3daed51e, 0x362d3927 | ||
| 730 | .word 0x0a0fd964, 0x685ca621, 0x9b5b54d1, 0x24362e3a | ||
| 731 | .word 0x0c0a67b1, 0x9357e70f, 0xb4ee96d2, 0x1b9b919e | ||
| 732 | .word 0x80c0c54f, 0x61dc20a2, 0x5a774b69, 0x1c121a16 | ||
| 733 | .word 0xe293ba0a, 0xc0a02ae5, 0x3c22e043, 0x121b171d | ||
| 734 | .word 0x0e090d0b, 0xf28bc7ad, 0x2db6a8b9, 0x141ea9c8 | ||
| 735 | .word 0x57f11985, 0xaf75074c, 0xee99ddbb, 0xa37f60fd | ||
| 736 | .word 0xf701269f, 0x5c72f5bc, 0x44663bc5, 0x5bfb7e34 | ||
| 737 | .word 0x8b432976, 0xcb23c6dc, 0xb6edfc68, 0xb8e4f163 | ||
| 738 | .word 0xd731dcca, 0x42638510, 0x13972240, 0x84c61120 | ||
| 739 | .word 0x854a247d, 0xd2bb3df8, 0xaef93211, 0xc729a16d | ||
| 740 | .word 0x1d9e2f4b, 0xdcb230f3, 0x0d8652ec, 0x77c1e3d0 | ||
| 741 | .word 0x2bb3166c, 0xa970b999, 0x119448fa, 0x47e96422 | ||
| 742 | .word 0xa8fc8cc4, 0xa0f03f1a, 0x567d2cd8, 0x223390ef | ||
| 743 | .word 0x87494ec7, 0xd938d1c1, 0x8ccaa2fe, 0x98d40b36 | ||
| 744 | .word 0xa6f581cf, 0xa57ade28, 0xdab78e26, 0x3fadbfa4 | ||
| 745 | .word 0x2c3a9de4, 0x5078920d, 0x6a5fcc9b, 0x547e4662 | ||
| 746 | .word 0xf68d13c2, 0x90d8b8e8, 0x2e39f75e, 0x82c3aff5 | ||
| 747 | .word 0x9f5d80be, 0x69d0937c, 0x6fd52da9, 0xcf2512b3 | ||
| 748 | .word 0xc8ac993b, 0x10187da7, 0xe89c636e, 0xdb3bbb7b | ||
| 749 | .word 0xcd267809, 0x6e5918f4, 0xec9ab701, 0x834f9aa8 | ||
| 750 | .word 0xe6956e65, 0xaaffe67e, 0x21bccf08, 0xef15e8e6 | ||
| 751 | .word 0xbae79bd9, 0x4a6f36ce, 0xea9f09d4, 0x29b07cd6 | ||
| 752 | .word 0x31a4b2af, 0x2a3f2331, 0xc6a59430, 0x35a266c0 | ||
| 753 | .word 0x744ebc37, 0xfc82caa6, 0xe090d0b0, 0x33a7d815 | ||
| 754 | .word 0xf104984a, 0x41ecdaf7, 0x7fcd500e, 0x1791f62f | ||
| 755 | .word 0x764dd68d, 0x43efb04d, 0xccaa4d54, 0xe49604df | ||
| 756 | .word 0x9ed1b5e3, 0x4c6a881b, 0xc12c1fb8, 0x4665517f | ||
| 757 | .word 0x9d5eea04, 0x018c355d, 0xfa877473, 0xfb0b412e | ||
| 758 | .word 0xb3671d5a, 0x92dbd252, 0xe9105633, 0x6dd64713 | ||
| 759 | .word 0x9ad7618c, 0x37a10c7a, 0x59f8148e, 0xeb133c89 | ||
| 760 | .word 0xcea927ee, 0xb761c935, 0xe11ce5ed, 0x7a47b13c | ||
| 761 | .word 0x9cd2df59, 0x55f2733f, 0x1814ce79, 0x73c737bf | ||
| 762 | .word 0x53f7cdea, 0x5ffdaa5b, 0xdf3d6f14, 0x7844db86 | ||
| 763 | .word 0xcaaff381, 0xb968c43e, 0x3824342c, 0xc2a3405f | ||
| 764 | .word 0x161dc372, 0xbce2250c, 0x283c498b, 0xff0d9541 | ||
| 765 | .word 0x39a80171, 0x080cb3de, 0xd8b4e49c, 0x6456c190 | ||
| 766 | .word 0x7bcb8461, 0xd532b670, 0x486c5c74, 0xd0b85742 | ||
| 767 | @ Td4[256] | ||
| 768 | .byte 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38 | ||
| 769 | .byte 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb | ||
| 770 | .byte 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87 | ||
| 771 | .byte 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb | ||
| 772 | .byte 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d | ||
| 773 | .byte 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e | ||
| 774 | .byte 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2 | ||
| 775 | .byte 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25 | ||
| 776 | .byte 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16 | ||
| 777 | .byte 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92 | ||
| 778 | .byte 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda | ||
| 779 | .byte 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84 | ||
| 780 | .byte 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a | ||
| 781 | .byte 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06 | ||
| 782 | .byte 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02 | ||
| 783 | .byte 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b | ||
| 784 | .byte 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea | ||
| 785 | .byte 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73 | ||
| 786 | .byte 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85 | ||
| 787 | .byte 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e | ||
| 788 | .byte 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89 | ||
| 789 | .byte 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b | ||
| 790 | .byte 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20 | ||
| 791 | .byte 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4 | ||
| 792 | .byte 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31 | ||
| 793 | .byte 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f | ||
| 794 | .byte 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d | ||
| 795 | .byte 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef | ||
| 796 | .byte 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0 | ||
| 797 | .byte 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61 | ||
| 798 | .byte 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26 | ||
| 799 | .byte 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d | ||
| 800 | .size AES_Td,.-AES_Td | ||
| 801 | |||
| 802 | @ void AES_decrypt(const unsigned char *in, unsigned char *out, | ||
| 803 | @ const AES_KEY *key) { | ||
| 804 | .global AES_decrypt | ||
| 805 | .type AES_decrypt,%function | ||
| 806 | .align 5 | ||
| 807 | AES_decrypt: | ||
| 808 | sub r3,pc,#8 @ AES_decrypt | ||
| 809 | stmdb sp!,{r1,r4-r12,lr} | ||
| 810 | mov $rounds,r0 @ inp | ||
| 811 | mov $key,r2 | ||
| 812 | sub $tbl,r3,#AES_decrypt-AES_Td @ Td | ||
| 813 | |||
| 814 | ldrb $s0,[$rounds,#3] @ load input data in endian-neutral | ||
| 815 | ldrb $t1,[$rounds,#2] @ manner... | ||
| 816 | ldrb $t2,[$rounds,#1] | ||
| 817 | ldrb $t3,[$rounds,#0] | ||
| 818 | orr $s0,$s0,$t1,lsl#8 | ||
| 819 | orr $s0,$s0,$t2,lsl#16 | ||
| 820 | orr $s0,$s0,$t3,lsl#24 | ||
| 821 | ldrb $s1,[$rounds,#7] | ||
| 822 | ldrb $t1,[$rounds,#6] | ||
| 823 | ldrb $t2,[$rounds,#5] | ||
| 824 | ldrb $t3,[$rounds,#4] | ||
| 825 | orr $s1,$s1,$t1,lsl#8 | ||
| 826 | orr $s1,$s1,$t2,lsl#16 | ||
| 827 | orr $s1,$s1,$t3,lsl#24 | ||
| 828 | ldrb $s2,[$rounds,#11] | ||
| 829 | ldrb $t1,[$rounds,#10] | ||
| 830 | ldrb $t2,[$rounds,#9] | ||
| 831 | ldrb $t3,[$rounds,#8] | ||
| 832 | orr $s2,$s2,$t1,lsl#8 | ||
| 833 | orr $s2,$s2,$t2,lsl#16 | ||
| 834 | orr $s2,$s2,$t3,lsl#24 | ||
| 835 | ldrb $s3,[$rounds,#15] | ||
| 836 | ldrb $t1,[$rounds,#14] | ||
| 837 | ldrb $t2,[$rounds,#13] | ||
| 838 | ldrb $t3,[$rounds,#12] | ||
| 839 | orr $s3,$s3,$t1,lsl#8 | ||
| 840 | orr $s3,$s3,$t2,lsl#16 | ||
| 841 | orr $s3,$s3,$t3,lsl#24 | ||
| 842 | |||
| 843 | bl _armv4_AES_decrypt | ||
| 844 | |||
| 845 | ldr $rounds,[sp],#4 @ pop out | ||
| 846 | mov $t1,$s0,lsr#24 @ write output in endian-neutral | ||
| 847 | mov $t2,$s0,lsr#16 @ manner... | ||
| 848 | mov $t3,$s0,lsr#8 | ||
| 849 | strb $t1,[$rounds,#0] | ||
| 850 | strb $t2,[$rounds,#1] | ||
| 851 | strb $t3,[$rounds,#2] | ||
| 852 | strb $s0,[$rounds,#3] | ||
| 853 | mov $t1,$s1,lsr#24 | ||
| 854 | mov $t2,$s1,lsr#16 | ||
| 855 | mov $t3,$s1,lsr#8 | ||
| 856 | strb $t1,[$rounds,#4] | ||
| 857 | strb $t2,[$rounds,#5] | ||
| 858 | strb $t3,[$rounds,#6] | ||
| 859 | strb $s1,[$rounds,#7] | ||
| 860 | mov $t1,$s2,lsr#24 | ||
| 861 | mov $t2,$s2,lsr#16 | ||
| 862 | mov $t3,$s2,lsr#8 | ||
| 863 | strb $t1,[$rounds,#8] | ||
| 864 | strb $t2,[$rounds,#9] | ||
| 865 | strb $t3,[$rounds,#10] | ||
| 866 | strb $s2,[$rounds,#11] | ||
| 867 | mov $t1,$s3,lsr#24 | ||
| 868 | mov $t2,$s3,lsr#16 | ||
| 869 | mov $t3,$s3,lsr#8 | ||
| 870 | strb $t1,[$rounds,#12] | ||
| 871 | strb $t2,[$rounds,#13] | ||
| 872 | strb $t3,[$rounds,#14] | ||
| 873 | strb $s3,[$rounds,#15] | ||
| 874 | |||
| 875 | ldmia sp!,{r4-r12,lr} | ||
| 876 | tst lr,#1 | ||
| 877 | moveq pc,lr @ be binary compatible with V4, yet | ||
| 878 | bx lr @ interoperable with Thumb ISA:-) | ||
| 879 | .size AES_decrypt,.-AES_decrypt | ||
| 880 | |||
| 881 | .type _armv4_AES_decrypt,%function | ||
| 882 | .align 2 | ||
| 883 | _armv4_AES_decrypt: | ||
| 884 | str lr,[sp,#-4]! @ push lr | ||
| 885 | ldr $t1,[$key],#16 | ||
| 886 | ldr $t2,[$key,#-12] | ||
| 887 | ldr $t3,[$key,#-8] | ||
| 888 | ldr $i1,[$key,#-4] | ||
| 889 | ldr $rounds,[$key,#240-16] | ||
| 890 | eor $s0,$s0,$t1 | ||
| 891 | eor $s1,$s1,$t2 | ||
| 892 | eor $s2,$s2,$t3 | ||
| 893 | eor $s3,$s3,$i1 | ||
| 894 | sub $rounds,$rounds,#1 | ||
| 895 | mov lr,#255 | ||
| 896 | |||
| 897 | .Ldec_loop: | ||
| 898 | and $i1,lr,$s0,lsr#16 | ||
| 899 | and $i2,lr,$s0,lsr#8 | ||
| 900 | and $i3,lr,$s0 | ||
| 901 | mov $s0,$s0,lsr#24 | ||
| 902 | ldr $t1,[$tbl,$i1,lsl#2] @ Td1[s0>>16] | ||
| 903 | ldr $s0,[$tbl,$s0,lsl#2] @ Td0[s0>>24] | ||
| 904 | ldr $t2,[$tbl,$i2,lsl#2] @ Td2[s0>>8] | ||
| 905 | ldr $t3,[$tbl,$i3,lsl#2] @ Td3[s0>>0] | ||
| 906 | |||
| 907 | and $i1,lr,$s1 @ i0 | ||
| 908 | and $i2,lr,$s1,lsr#16 | ||
| 909 | and $i3,lr,$s1,lsr#8 | ||
| 910 | mov $s1,$s1,lsr#24 | ||
| 911 | ldr $i1,[$tbl,$i1,lsl#2] @ Td3[s1>>0] | ||
| 912 | ldr $s1,[$tbl,$s1,lsl#2] @ Td0[s1>>24] | ||
| 913 | ldr $i2,[$tbl,$i2,lsl#2] @ Td1[s1>>16] | ||
| 914 | ldr $i3,[$tbl,$i3,lsl#2] @ Td2[s1>>8] | ||
| 915 | eor $s0,$s0,$i1,ror#24 | ||
| 916 | eor $s1,$s1,$t1,ror#8 | ||
| 917 | eor $t2,$i2,$t2,ror#8 | ||
| 918 | eor $t3,$i3,$t3,ror#8 | ||
| 919 | |||
| 920 | and $i1,lr,$s2,lsr#8 @ i0 | ||
| 921 | and $i2,lr,$s2 @ i1 | ||
| 922 | and $i3,lr,$s2,lsr#16 | ||
| 923 | mov $s2,$s2,lsr#24 | ||
| 924 | ldr $i1,[$tbl,$i1,lsl#2] @ Td2[s2>>8] | ||
| 925 | ldr $i2,[$tbl,$i2,lsl#2] @ Td3[s2>>0] | ||
| 926 | ldr $s2,[$tbl,$s2,lsl#2] @ Td0[s2>>24] | ||
| 927 | ldr $i3,[$tbl,$i3,lsl#2] @ Td1[s2>>16] | ||
| 928 | eor $s0,$s0,$i1,ror#16 | ||
| 929 | eor $s1,$s1,$i2,ror#24 | ||
| 930 | eor $s2,$s2,$t2,ror#8 | ||
| 931 | eor $t3,$i3,$t3,ror#8 | ||
| 932 | |||
| 933 | and $i1,lr,$s3,lsr#16 @ i0 | ||
| 934 | and $i2,lr,$s3,lsr#8 @ i1 | ||
| 935 | and $i3,lr,$s3 @ i2 | ||
| 936 | mov $s3,$s3,lsr#24 | ||
| 937 | ldr $i1,[$tbl,$i1,lsl#2] @ Td1[s3>>16] | ||
| 938 | ldr $i2,[$tbl,$i2,lsl#2] @ Td2[s3>>8] | ||
| 939 | ldr $i3,[$tbl,$i3,lsl#2] @ Td3[s3>>0] | ||
| 940 | ldr $s3,[$tbl,$s3,lsl#2] @ Td0[s3>>24] | ||
| 941 | eor $s0,$s0,$i1,ror#8 | ||
| 942 | eor $s1,$s1,$i2,ror#16 | ||
| 943 | eor $s2,$s2,$i3,ror#24 | ||
| 944 | eor $s3,$s3,$t3,ror#8 | ||
| 945 | |||
| 946 | ldr $t1,[$key],#16 | ||
| 947 | ldr $t2,[$key,#-12] | ||
| 948 | ldr $t3,[$key,#-8] | ||
| 949 | ldr $i1,[$key,#-4] | ||
| 950 | eor $s0,$s0,$t1 | ||
| 951 | eor $s1,$s1,$t2 | ||
| 952 | eor $s2,$s2,$t3 | ||
| 953 | eor $s3,$s3,$i1 | ||
| 954 | |||
| 955 | subs $rounds,$rounds,#1 | ||
| 956 | bne .Ldec_loop | ||
| 957 | |||
| 958 | add $tbl,$tbl,#1024 | ||
| 959 | |||
| 960 | ldr $t1,[$tbl,#0] @ prefetch Td4 | ||
| 961 | ldr $t2,[$tbl,#32] | ||
| 962 | ldr $t3,[$tbl,#64] | ||
| 963 | ldr $i1,[$tbl,#96] | ||
| 964 | ldr $i2,[$tbl,#128] | ||
| 965 | ldr $i3,[$tbl,#160] | ||
| 966 | ldr $t1,[$tbl,#192] | ||
| 967 | ldr $t2,[$tbl,#224] | ||
| 968 | |||
| 969 | and $i1,lr,$s0,lsr#16 | ||
| 970 | and $i2,lr,$s0,lsr#8 | ||
| 971 | and $i3,lr,$s0 | ||
| 972 | ldrb $s0,[$tbl,$s0,lsr#24] @ Td4[s0>>24] | ||
| 973 | ldrb $t1,[$tbl,$i1] @ Td4[s0>>16] | ||
| 974 | ldrb $t2,[$tbl,$i2] @ Td4[s0>>8] | ||
| 975 | ldrb $t3,[$tbl,$i3] @ Td4[s0>>0] | ||
| 976 | |||
| 977 | and $i1,lr,$s1 @ i0 | ||
| 978 | and $i2,lr,$s1,lsr#16 | ||
| 979 | and $i3,lr,$s1,lsr#8 | ||
| 980 | ldrb $i1,[$tbl,$i1] @ Td4[s1>>0] | ||
| 981 | ldrb $s1,[$tbl,$s1,lsr#24] @ Td4[s1>>24] | ||
| 982 | ldrb $i2,[$tbl,$i2] @ Td4[s1>>16] | ||
| 983 | ldrb $i3,[$tbl,$i3] @ Td4[s1>>8] | ||
| 984 | eor $s0,$i1,$s0,lsl#24 | ||
| 985 | eor $s1,$t1,$s1,lsl#8 | ||
| 986 | eor $t2,$t2,$i2,lsl#8 | ||
| 987 | eor $t3,$t3,$i3,lsl#8 | ||
| 988 | |||
| 989 | and $i1,lr,$s2,lsr#8 @ i0 | ||
| 990 | and $i2,lr,$s2 @ i1 | ||
| 991 | and $i3,lr,$s2,lsr#16 | ||
| 992 | ldrb $i1,[$tbl,$i1] @ Td4[s2>>8] | ||
| 993 | ldrb $i2,[$tbl,$i2] @ Td4[s2>>0] | ||
| 994 | ldrb $s2,[$tbl,$s2,lsr#24] @ Td4[s2>>24] | ||
| 995 | ldrb $i3,[$tbl,$i3] @ Td4[s2>>16] | ||
| 996 | eor $s0,$s0,$i1,lsl#8 | ||
| 997 | eor $s1,$i2,$s1,lsl#16 | ||
| 998 | eor $s2,$t2,$s2,lsl#16 | ||
| 999 | eor $t3,$t3,$i3,lsl#16 | ||
| 1000 | |||
| 1001 | and $i1,lr,$s3,lsr#16 @ i0 | ||
| 1002 | and $i2,lr,$s3,lsr#8 @ i1 | ||
| 1003 | and $i3,lr,$s3 @ i2 | ||
| 1004 | ldrb $i1,[$tbl,$i1] @ Td4[s3>>16] | ||
| 1005 | ldrb $i2,[$tbl,$i2] @ Td4[s3>>8] | ||
| 1006 | ldrb $i3,[$tbl,$i3] @ Td4[s3>>0] | ||
| 1007 | ldrb $s3,[$tbl,$s3,lsr#24] @ Td4[s3>>24] | ||
| 1008 | eor $s0,$s0,$i1,lsl#16 | ||
| 1009 | eor $s1,$s1,$i2,lsl#8 | ||
| 1010 | eor $s2,$i3,$s2,lsl#8 | ||
| 1011 | eor $s3,$t3,$s3,lsl#24 | ||
| 1012 | |||
| 1013 | ldr lr,[sp],#4 @ pop lr | ||
| 1014 | ldr $t1,[$key,#0] | ||
| 1015 | ldr $t2,[$key,#4] | ||
| 1016 | ldr $t3,[$key,#8] | ||
| 1017 | ldr $i1,[$key,#12] | ||
| 1018 | eor $s0,$s0,$t1 | ||
| 1019 | eor $s1,$s1,$t2 | ||
| 1020 | eor $s2,$s2,$t3 | ||
| 1021 | eor $s3,$s3,$i1 | ||
| 1022 | |||
| 1023 | sub $tbl,$tbl,#1024 | ||
| 1024 | mov pc,lr @ return | ||
| 1025 | .size _armv4_AES_decrypt,.-_armv4_AES_decrypt | ||
| 1026 | .asciz "AES for ARMv4, CRYPTOGAMS by <appro\@openssl.org>" | ||
| 1027 | ___ | ||
| 1028 | |||
| 1029 | $code =~ s/\bbx\s+lr\b/.word\t0xe12fff1e/gm; # make it possible to compile with -march=armv4 | ||
| 1030 | print $code; | ||
diff --git a/src/lib/libssl/src/crypto/aes/asm/aes-ppc.pl b/src/lib/libssl/src/crypto/aes/asm/aes-ppc.pl new file mode 100644 index 0000000000..ce427655ef --- /dev/null +++ b/src/lib/libssl/src/crypto/aes/asm/aes-ppc.pl | |||
| @@ -0,0 +1,1176 @@ | |||
| 1 | #!/usr/bin/env perl | ||
| 2 | |||
| 3 | # ==================================================================== | ||
| 4 | # Written by Andy Polyakov <appro@fy.chalmers.se> for the OpenSSL | ||
| 5 | # project. The module is, however, dual licensed under OpenSSL and | ||
| 6 | # CRYPTOGAMS licenses depending on where you obtain it. For further | ||
| 7 | # details see http://www.openssl.org/~appro/cryptogams/. | ||
| 8 | # ==================================================================== | ||
| 9 | |||
| 10 | # Needs more work: key setup, page boundaries, CBC routine... | ||
| 11 | # | ||
| 12 | # ppc_AES_[en|de]crypt perform at 18 cycles per byte processed with | ||
| 13 | # 128-bit key, which is ~40% better than 64-bit code generated by gcc | ||
| 14 | # 4.0. But these are not the ones currently used! Their "compact" | ||
| 15 | # counterparts are, for security reason. ppc_AES_encrypt_compact runs | ||
| 16 | # at 1/2 of ppc_AES_encrypt speed, while ppc_AES_decrypt_compact - | ||
| 17 | # at 1/3 of ppc_AES_decrypt. | ||
| 18 | |||
| 19 | $flavour = shift; | ||
| 20 | |||
| 21 | if ($flavour =~ /64/) { | ||
| 22 | $SIZE_T =8; | ||
| 23 | $STU ="stdu"; | ||
| 24 | $POP ="ld"; | ||
| 25 | $PUSH ="std"; | ||
| 26 | } elsif ($flavour =~ /32/) { | ||
| 27 | $SIZE_T =4; | ||
| 28 | $STU ="stwu"; | ||
| 29 | $POP ="lwz"; | ||
| 30 | $PUSH ="stw"; | ||
| 31 | } else { die "nonsense $flavour"; } | ||
| 32 | |||
| 33 | $0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1; | ||
| 34 | ( $xlate="${dir}ppc-xlate.pl" and -f $xlate ) or | ||
| 35 | ( $xlate="${dir}../../perlasm/ppc-xlate.pl" and -f $xlate) or | ||
| 36 | die "can't locate ppc-xlate.pl"; | ||
| 37 | |||
| 38 | open STDOUT,"| $^X $xlate $flavour ".shift || die "can't call $xlate: $!"; | ||
| 39 | |||
| 40 | $FRAME=32*$SIZE_T; | ||
| 41 | |||
| 42 | sub _data_word() | ||
| 43 | { my $i; | ||
| 44 | while(defined($i=shift)) { $code.=sprintf"\t.long\t0x%08x,0x%08x\n",$i,$i; } | ||
| 45 | } | ||
| 46 | |||
| 47 | $sp="r1"; | ||
| 48 | $toc="r2"; | ||
| 49 | $inp="r3"; | ||
| 50 | $out="r4"; | ||
| 51 | $key="r5"; | ||
| 52 | |||
| 53 | $Tbl0="r3"; | ||
| 54 | $Tbl1="r6"; | ||
| 55 | $Tbl2="r7"; | ||
| 56 | $Tbl3="r2"; | ||
| 57 | |||
| 58 | $s0="r8"; | ||
| 59 | $s1="r9"; | ||
| 60 | $s2="r10"; | ||
| 61 | $s3="r11"; | ||
| 62 | |||
| 63 | $t0="r12"; | ||
| 64 | $t1="r13"; | ||
| 65 | $t2="r14"; | ||
| 66 | $t3="r15"; | ||
| 67 | |||
| 68 | $acc00="r16"; | ||
| 69 | $acc01="r17"; | ||
| 70 | $acc02="r18"; | ||
| 71 | $acc03="r19"; | ||
| 72 | |||
| 73 | $acc04="r20"; | ||
| 74 | $acc05="r21"; | ||
| 75 | $acc06="r22"; | ||
| 76 | $acc07="r23"; | ||
| 77 | |||
| 78 | $acc08="r24"; | ||
| 79 | $acc09="r25"; | ||
| 80 | $acc10="r26"; | ||
| 81 | $acc11="r27"; | ||
| 82 | |||
| 83 | $acc12="r28"; | ||
| 84 | $acc13="r29"; | ||
| 85 | $acc14="r30"; | ||
| 86 | $acc15="r31"; | ||
| 87 | |||
| 88 | # stay away from TLS pointer | ||
| 89 | if ($SIZE_T==8) { die if ($t1 ne "r13"); $t1="r0"; } | ||
| 90 | else { die if ($Tbl3 ne "r2"); $Tbl3=$t0; $t0="r0"; } | ||
| 91 | $mask80=$Tbl2; | ||
| 92 | $mask1b=$Tbl3; | ||
| 93 | |||
| 94 | $code.=<<___; | ||
| 95 | .machine "any" | ||
| 96 | .text | ||
| 97 | |||
| 98 | .align 7 | ||
| 99 | LAES_Te: | ||
| 100 | mflr r0 | ||
| 101 | bcl 20,31,\$+4 | ||
| 102 | mflr $Tbl0 ; vvvvv "distance" between . and 1st data entry | ||
| 103 | addi $Tbl0,$Tbl0,`128-8` | ||
| 104 | mtlr r0 | ||
| 105 | blr | ||
| 106 | .space `32-24` | ||
| 107 | LAES_Td: | ||
| 108 | mflr r0 | ||
| 109 | bcl 20,31,\$+4 | ||
| 110 | mflr $Tbl0 ; vvvvvvvv "distance" between . and 1st data entry | ||
| 111 | addi $Tbl0,$Tbl0,`128-8-32+2048+256` | ||
| 112 | mtlr r0 | ||
| 113 | blr | ||
| 114 | .space `128-32-24` | ||
| 115 | ___ | ||
| 116 | &_data_word( | ||
| 117 | 0xc66363a5, 0xf87c7c84, 0xee777799, 0xf67b7b8d, | ||
| 118 | 0xfff2f20d, 0xd66b6bbd, 0xde6f6fb1, 0x91c5c554, | ||
| 119 | 0x60303050, 0x02010103, 0xce6767a9, 0x562b2b7d, | ||
| 120 | 0xe7fefe19, 0xb5d7d762, 0x4dababe6, 0xec76769a, | ||
| 121 | 0x8fcaca45, 0x1f82829d, 0x89c9c940, 0xfa7d7d87, | ||
| 122 | 0xeffafa15, 0xb25959eb, 0x8e4747c9, 0xfbf0f00b, | ||
| 123 | 0x41adadec, 0xb3d4d467, 0x5fa2a2fd, 0x45afafea, | ||
| 124 | 0x239c9cbf, 0x53a4a4f7, 0xe4727296, 0x9bc0c05b, | ||
| 125 | 0x75b7b7c2, 0xe1fdfd1c, 0x3d9393ae, 0x4c26266a, | ||
| 126 | 0x6c36365a, 0x7e3f3f41, 0xf5f7f702, 0x83cccc4f, | ||
| 127 | 0x6834345c, 0x51a5a5f4, 0xd1e5e534, 0xf9f1f108, | ||
| 128 | 0xe2717193, 0xabd8d873, 0x62313153, 0x2a15153f, | ||
| 129 | 0x0804040c, 0x95c7c752, 0x46232365, 0x9dc3c35e, | ||
| 130 | 0x30181828, 0x379696a1, 0x0a05050f, 0x2f9a9ab5, | ||
| 131 | 0x0e070709, 0x24121236, 0x1b80809b, 0xdfe2e23d, | ||
| 132 | 0xcdebeb26, 0x4e272769, 0x7fb2b2cd, 0xea75759f, | ||
| 133 | 0x1209091b, 0x1d83839e, 0x582c2c74, 0x341a1a2e, | ||
| 134 | 0x361b1b2d, 0xdc6e6eb2, 0xb45a5aee, 0x5ba0a0fb, | ||
| 135 | 0xa45252f6, 0x763b3b4d, 0xb7d6d661, 0x7db3b3ce, | ||
| 136 | 0x5229297b, 0xdde3e33e, 0x5e2f2f71, 0x13848497, | ||
| 137 | 0xa65353f5, 0xb9d1d168, 0x00000000, 0xc1eded2c, | ||
| 138 | 0x40202060, 0xe3fcfc1f, 0x79b1b1c8, 0xb65b5bed, | ||
| 139 | 0xd46a6abe, 0x8dcbcb46, 0x67bebed9, 0x7239394b, | ||
| 140 | 0x944a4ade, 0x984c4cd4, 0xb05858e8, 0x85cfcf4a, | ||
| 141 | 0xbbd0d06b, 0xc5efef2a, 0x4faaaae5, 0xedfbfb16, | ||
| 142 | 0x864343c5, 0x9a4d4dd7, 0x66333355, 0x11858594, | ||
| 143 | 0x8a4545cf, 0xe9f9f910, 0x04020206, 0xfe7f7f81, | ||
| 144 | 0xa05050f0, 0x783c3c44, 0x259f9fba, 0x4ba8a8e3, | ||
| 145 | 0xa25151f3, 0x5da3a3fe, 0x804040c0, 0x058f8f8a, | ||
| 146 | 0x3f9292ad, 0x219d9dbc, 0x70383848, 0xf1f5f504, | ||
| 147 | 0x63bcbcdf, 0x77b6b6c1, 0xafdada75, 0x42212163, | ||
| 148 | 0x20101030, 0xe5ffff1a, 0xfdf3f30e, 0xbfd2d26d, | ||
| 149 | 0x81cdcd4c, 0x180c0c14, 0x26131335, 0xc3ecec2f, | ||
| 150 | 0xbe5f5fe1, 0x359797a2, 0x884444cc, 0x2e171739, | ||
| 151 | 0x93c4c457, 0x55a7a7f2, 0xfc7e7e82, 0x7a3d3d47, | ||
| 152 | 0xc86464ac, 0xba5d5de7, 0x3219192b, 0xe6737395, | ||
| 153 | 0xc06060a0, 0x19818198, 0x9e4f4fd1, 0xa3dcdc7f, | ||
| 154 | 0x44222266, 0x542a2a7e, 0x3b9090ab, 0x0b888883, | ||
| 155 | 0x8c4646ca, 0xc7eeee29, 0x6bb8b8d3, 0x2814143c, | ||
| 156 | 0xa7dede79, 0xbc5e5ee2, 0x160b0b1d, 0xaddbdb76, | ||
| 157 | 0xdbe0e03b, 0x64323256, 0x743a3a4e, 0x140a0a1e, | ||
| 158 | 0x924949db, 0x0c06060a, 0x4824246c, 0xb85c5ce4, | ||
| 159 | 0x9fc2c25d, 0xbdd3d36e, 0x43acacef, 0xc46262a6, | ||
| 160 | 0x399191a8, 0x319595a4, 0xd3e4e437, 0xf279798b, | ||
| 161 | 0xd5e7e732, 0x8bc8c843, 0x6e373759, 0xda6d6db7, | ||
| 162 | 0x018d8d8c, 0xb1d5d564, 0x9c4e4ed2, 0x49a9a9e0, | ||
| 163 | 0xd86c6cb4, 0xac5656fa, 0xf3f4f407, 0xcfeaea25, | ||
| 164 | 0xca6565af, 0xf47a7a8e, 0x47aeaee9, 0x10080818, | ||
| 165 | 0x6fbabad5, 0xf0787888, 0x4a25256f, 0x5c2e2e72, | ||
| 166 | 0x381c1c24, 0x57a6a6f1, 0x73b4b4c7, 0x97c6c651, | ||
| 167 | 0xcbe8e823, 0xa1dddd7c, 0xe874749c, 0x3e1f1f21, | ||
| 168 | 0x964b4bdd, 0x61bdbddc, 0x0d8b8b86, 0x0f8a8a85, | ||
| 169 | 0xe0707090, 0x7c3e3e42, 0x71b5b5c4, 0xcc6666aa, | ||
| 170 | 0x904848d8, 0x06030305, 0xf7f6f601, 0x1c0e0e12, | ||
| 171 | 0xc26161a3, 0x6a35355f, 0xae5757f9, 0x69b9b9d0, | ||
| 172 | 0x17868691, 0x99c1c158, 0x3a1d1d27, 0x279e9eb9, | ||
| 173 | 0xd9e1e138, 0xebf8f813, 0x2b9898b3, 0x22111133, | ||
| 174 | 0xd26969bb, 0xa9d9d970, 0x078e8e89, 0x339494a7, | ||
| 175 | 0x2d9b9bb6, 0x3c1e1e22, 0x15878792, 0xc9e9e920, | ||
| 176 | 0x87cece49, 0xaa5555ff, 0x50282878, 0xa5dfdf7a, | ||
| 177 | 0x038c8c8f, 0x59a1a1f8, 0x09898980, 0x1a0d0d17, | ||
| 178 | 0x65bfbfda, 0xd7e6e631, 0x844242c6, 0xd06868b8, | ||
| 179 | 0x824141c3, 0x299999b0, 0x5a2d2d77, 0x1e0f0f11, | ||
| 180 | 0x7bb0b0cb, 0xa85454fc, 0x6dbbbbd6, 0x2c16163a); | ||
| 181 | $code.=<<___; | ||
| 182 | .byte 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5 | ||
| 183 | .byte 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76 | ||
| 184 | .byte 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0 | ||
| 185 | .byte 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0 | ||
| 186 | .byte 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc | ||
| 187 | .byte 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15 | ||
| 188 | .byte 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a | ||
| 189 | .byte 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75 | ||
| 190 | .byte 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0 | ||
| 191 | .byte 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84 | ||
| 192 | .byte 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b | ||
| 193 | .byte 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf | ||
| 194 | .byte 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85 | ||
| 195 | .byte 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8 | ||
| 196 | .byte 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5 | ||
| 197 | .byte 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2 | ||
| 198 | .byte 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17 | ||
| 199 | .byte 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73 | ||
| 200 | .byte 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88 | ||
| 201 | .byte 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb | ||
| 202 | .byte 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c | ||
| 203 | .byte 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79 | ||
| 204 | .byte 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9 | ||
| 205 | .byte 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08 | ||
| 206 | .byte 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6 | ||
| 207 | .byte 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a | ||
| 208 | .byte 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e | ||
| 209 | .byte 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e | ||
| 210 | .byte 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94 | ||
| 211 | .byte 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf | ||
| 212 | .byte 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68 | ||
| 213 | .byte 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 | ||
| 214 | ___ | ||
| 215 | &_data_word( | ||
| 216 | 0x51f4a750, 0x7e416553, 0x1a17a4c3, 0x3a275e96, | ||
| 217 | 0x3bab6bcb, 0x1f9d45f1, 0xacfa58ab, 0x4be30393, | ||
| 218 | 0x2030fa55, 0xad766df6, 0x88cc7691, 0xf5024c25, | ||
| 219 | 0x4fe5d7fc, 0xc52acbd7, 0x26354480, 0xb562a38f, | ||
| 220 | 0xdeb15a49, 0x25ba1b67, 0x45ea0e98, 0x5dfec0e1, | ||
| 221 | 0xc32f7502, 0x814cf012, 0x8d4697a3, 0x6bd3f9c6, | ||
| 222 | 0x038f5fe7, 0x15929c95, 0xbf6d7aeb, 0x955259da, | ||
| 223 | 0xd4be832d, 0x587421d3, 0x49e06929, 0x8ec9c844, | ||
| 224 | 0x75c2896a, 0xf48e7978, 0x99583e6b, 0x27b971dd, | ||
| 225 | 0xbee14fb6, 0xf088ad17, 0xc920ac66, 0x7dce3ab4, | ||
| 226 | 0x63df4a18, 0xe51a3182, 0x97513360, 0x62537f45, | ||
| 227 | 0xb16477e0, 0xbb6bae84, 0xfe81a01c, 0xf9082b94, | ||
| 228 | 0x70486858, 0x8f45fd19, 0x94de6c87, 0x527bf8b7, | ||
| 229 | 0xab73d323, 0x724b02e2, 0xe31f8f57, 0x6655ab2a, | ||
| 230 | 0xb2eb2807, 0x2fb5c203, 0x86c57b9a, 0xd33708a5, | ||
| 231 | 0x302887f2, 0x23bfa5b2, 0x02036aba, 0xed16825c, | ||
| 232 | 0x8acf1c2b, 0xa779b492, 0xf307f2f0, 0x4e69e2a1, | ||
| 233 | 0x65daf4cd, 0x0605bed5, 0xd134621f, 0xc4a6fe8a, | ||
| 234 | 0x342e539d, 0xa2f355a0, 0x058ae132, 0xa4f6eb75, | ||
| 235 | 0x0b83ec39, 0x4060efaa, 0x5e719f06, 0xbd6e1051, | ||
| 236 | 0x3e218af9, 0x96dd063d, 0xdd3e05ae, 0x4de6bd46, | ||
| 237 | 0x91548db5, 0x71c45d05, 0x0406d46f, 0x605015ff, | ||
| 238 | 0x1998fb24, 0xd6bde997, 0x894043cc, 0x67d99e77, | ||
| 239 | 0xb0e842bd, 0x07898b88, 0xe7195b38, 0x79c8eedb, | ||
| 240 | 0xa17c0a47, 0x7c420fe9, 0xf8841ec9, 0x00000000, | ||
| 241 | 0x09808683, 0x322bed48, 0x1e1170ac, 0x6c5a724e, | ||
| 242 | 0xfd0efffb, 0x0f853856, 0x3daed51e, 0x362d3927, | ||
| 243 | 0x0a0fd964, 0x685ca621, 0x9b5b54d1, 0x24362e3a, | ||
| 244 | 0x0c0a67b1, 0x9357e70f, 0xb4ee96d2, 0x1b9b919e, | ||
| 245 | 0x80c0c54f, 0x61dc20a2, 0x5a774b69, 0x1c121a16, | ||
| 246 | 0xe293ba0a, 0xc0a02ae5, 0x3c22e043, 0x121b171d, | ||
| 247 | 0x0e090d0b, 0xf28bc7ad, 0x2db6a8b9, 0x141ea9c8, | ||
| 248 | 0x57f11985, 0xaf75074c, 0xee99ddbb, 0xa37f60fd, | ||
| 249 | 0xf701269f, 0x5c72f5bc, 0x44663bc5, 0x5bfb7e34, | ||
| 250 | 0x8b432976, 0xcb23c6dc, 0xb6edfc68, 0xb8e4f163, | ||
| 251 | 0xd731dcca, 0x42638510, 0x13972240, 0x84c61120, | ||
| 252 | 0x854a247d, 0xd2bb3df8, 0xaef93211, 0xc729a16d, | ||
| 253 | 0x1d9e2f4b, 0xdcb230f3, 0x0d8652ec, 0x77c1e3d0, | ||
| 254 | 0x2bb3166c, 0xa970b999, 0x119448fa, 0x47e96422, | ||
| 255 | 0xa8fc8cc4, 0xa0f03f1a, 0x567d2cd8, 0x223390ef, | ||
| 256 | 0x87494ec7, 0xd938d1c1, 0x8ccaa2fe, 0x98d40b36, | ||
| 257 | 0xa6f581cf, 0xa57ade28, 0xdab78e26, 0x3fadbfa4, | ||
| 258 | 0x2c3a9de4, 0x5078920d, 0x6a5fcc9b, 0x547e4662, | ||
| 259 | 0xf68d13c2, 0x90d8b8e8, 0x2e39f75e, 0x82c3aff5, | ||
| 260 | 0x9f5d80be, 0x69d0937c, 0x6fd52da9, 0xcf2512b3, | ||
| 261 | 0xc8ac993b, 0x10187da7, 0xe89c636e, 0xdb3bbb7b, | ||
| 262 | 0xcd267809, 0x6e5918f4, 0xec9ab701, 0x834f9aa8, | ||
| 263 | 0xe6956e65, 0xaaffe67e, 0x21bccf08, 0xef15e8e6, | ||
| 264 | 0xbae79bd9, 0x4a6f36ce, 0xea9f09d4, 0x29b07cd6, | ||
| 265 | 0x31a4b2af, 0x2a3f2331, 0xc6a59430, 0x35a266c0, | ||
| 266 | 0x744ebc37, 0xfc82caa6, 0xe090d0b0, 0x33a7d815, | ||
| 267 | 0xf104984a, 0x41ecdaf7, 0x7fcd500e, 0x1791f62f, | ||
| 268 | 0x764dd68d, 0x43efb04d, 0xccaa4d54, 0xe49604df, | ||
| 269 | 0x9ed1b5e3, 0x4c6a881b, 0xc12c1fb8, 0x4665517f, | ||
| 270 | 0x9d5eea04, 0x018c355d, 0xfa877473, 0xfb0b412e, | ||
| 271 | 0xb3671d5a, 0x92dbd252, 0xe9105633, 0x6dd64713, | ||
| 272 | 0x9ad7618c, 0x37a10c7a, 0x59f8148e, 0xeb133c89, | ||
| 273 | 0xcea927ee, 0xb761c935, 0xe11ce5ed, 0x7a47b13c, | ||
| 274 | 0x9cd2df59, 0x55f2733f, 0x1814ce79, 0x73c737bf, | ||
| 275 | 0x53f7cdea, 0x5ffdaa5b, 0xdf3d6f14, 0x7844db86, | ||
| 276 | 0xcaaff381, 0xb968c43e, 0x3824342c, 0xc2a3405f, | ||
| 277 | 0x161dc372, 0xbce2250c, 0x283c498b, 0xff0d9541, | ||
| 278 | 0x39a80171, 0x080cb3de, 0xd8b4e49c, 0x6456c190, | ||
| 279 | 0x7bcb8461, 0xd532b670, 0x486c5c74, 0xd0b85742); | ||
| 280 | $code.=<<___; | ||
| 281 | .byte 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38 | ||
| 282 | .byte 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb | ||
| 283 | .byte 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87 | ||
| 284 | .byte 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb | ||
| 285 | .byte 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d | ||
| 286 | .byte 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e | ||
| 287 | .byte 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2 | ||
| 288 | .byte 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25 | ||
| 289 | .byte 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16 | ||
| 290 | .byte 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92 | ||
| 291 | .byte 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda | ||
| 292 | .byte 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84 | ||
| 293 | .byte 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a | ||
| 294 | .byte 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06 | ||
| 295 | .byte 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02 | ||
| 296 | .byte 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b | ||
| 297 | .byte 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea | ||
| 298 | .byte 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73 | ||
| 299 | .byte 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85 | ||
| 300 | .byte 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e | ||
| 301 | .byte 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89 | ||
| 302 | .byte 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b | ||
| 303 | .byte 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20 | ||
| 304 | .byte 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4 | ||
| 305 | .byte 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31 | ||
| 306 | .byte 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f | ||
| 307 | .byte 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d | ||
| 308 | .byte 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef | ||
| 309 | .byte 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0 | ||
| 310 | .byte 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61 | ||
| 311 | .byte 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26 | ||
| 312 | .byte 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d | ||
| 313 | |||
| 314 | |||
| 315 | .globl .AES_encrypt | ||
| 316 | .align 7 | ||
| 317 | .AES_encrypt: | ||
| 318 | mflr r0 | ||
| 319 | $STU $sp,-$FRAME($sp) | ||
| 320 | |||
| 321 | $PUSH r0,`$FRAME-$SIZE_T*21`($sp) | ||
| 322 | $PUSH $toc,`$FRAME-$SIZE_T*20`($sp) | ||
| 323 | $PUSH r13,`$FRAME-$SIZE_T*19`($sp) | ||
| 324 | $PUSH r14,`$FRAME-$SIZE_T*18`($sp) | ||
| 325 | $PUSH r15,`$FRAME-$SIZE_T*17`($sp) | ||
| 326 | $PUSH r16,`$FRAME-$SIZE_T*16`($sp) | ||
| 327 | $PUSH r17,`$FRAME-$SIZE_T*15`($sp) | ||
| 328 | $PUSH r18,`$FRAME-$SIZE_T*14`($sp) | ||
| 329 | $PUSH r19,`$FRAME-$SIZE_T*13`($sp) | ||
| 330 | $PUSH r20,`$FRAME-$SIZE_T*12`($sp) | ||
| 331 | $PUSH r21,`$FRAME-$SIZE_T*11`($sp) | ||
| 332 | $PUSH r22,`$FRAME-$SIZE_T*10`($sp) | ||
| 333 | $PUSH r23,`$FRAME-$SIZE_T*9`($sp) | ||
| 334 | $PUSH r24,`$FRAME-$SIZE_T*8`($sp) | ||
| 335 | $PUSH r25,`$FRAME-$SIZE_T*7`($sp) | ||
| 336 | $PUSH r26,`$FRAME-$SIZE_T*6`($sp) | ||
| 337 | $PUSH r27,`$FRAME-$SIZE_T*5`($sp) | ||
| 338 | $PUSH r28,`$FRAME-$SIZE_T*4`($sp) | ||
| 339 | $PUSH r29,`$FRAME-$SIZE_T*3`($sp) | ||
| 340 | $PUSH r30,`$FRAME-$SIZE_T*2`($sp) | ||
| 341 | $PUSH r31,`$FRAME-$SIZE_T*1`($sp) | ||
| 342 | |||
| 343 | lwz $s0,0($inp) | ||
| 344 | lwz $s1,4($inp) | ||
| 345 | lwz $s2,8($inp) | ||
| 346 | lwz $s3,12($inp) | ||
| 347 | bl LAES_Te | ||
| 348 | bl Lppc_AES_encrypt_compact | ||
| 349 | stw $s0,0($out) | ||
| 350 | stw $s1,4($out) | ||
| 351 | stw $s2,8($out) | ||
| 352 | stw $s3,12($out) | ||
| 353 | |||
| 354 | $POP r0,`$FRAME-$SIZE_T*21`($sp) | ||
| 355 | $POP $toc,`$FRAME-$SIZE_T*20`($sp) | ||
| 356 | $POP r13,`$FRAME-$SIZE_T*19`($sp) | ||
| 357 | $POP r14,`$FRAME-$SIZE_T*18`($sp) | ||
| 358 | $POP r15,`$FRAME-$SIZE_T*17`($sp) | ||
| 359 | $POP r16,`$FRAME-$SIZE_T*16`($sp) | ||
| 360 | $POP r17,`$FRAME-$SIZE_T*15`($sp) | ||
| 361 | $POP r18,`$FRAME-$SIZE_T*14`($sp) | ||
| 362 | $POP r19,`$FRAME-$SIZE_T*13`($sp) | ||
| 363 | $POP r20,`$FRAME-$SIZE_T*12`($sp) | ||
| 364 | $POP r21,`$FRAME-$SIZE_T*11`($sp) | ||
| 365 | $POP r22,`$FRAME-$SIZE_T*10`($sp) | ||
| 366 | $POP r23,`$FRAME-$SIZE_T*9`($sp) | ||
| 367 | $POP r24,`$FRAME-$SIZE_T*8`($sp) | ||
| 368 | $POP r25,`$FRAME-$SIZE_T*7`($sp) | ||
| 369 | $POP r26,`$FRAME-$SIZE_T*6`($sp) | ||
| 370 | $POP r27,`$FRAME-$SIZE_T*5`($sp) | ||
| 371 | $POP r28,`$FRAME-$SIZE_T*4`($sp) | ||
| 372 | $POP r29,`$FRAME-$SIZE_T*3`($sp) | ||
| 373 | $POP r30,`$FRAME-$SIZE_T*2`($sp) | ||
| 374 | $POP r31,`$FRAME-$SIZE_T*1`($sp) | ||
| 375 | mtlr r0 | ||
| 376 | addi $sp,$sp,$FRAME | ||
| 377 | blr | ||
| 378 | |||
| 379 | .align 4 | ||
| 380 | Lppc_AES_encrypt: | ||
| 381 | lwz $acc00,240($key) | ||
| 382 | lwz $t0,0($key) | ||
| 383 | lwz $t1,4($key) | ||
| 384 | lwz $t2,8($key) | ||
| 385 | lwz $t3,12($key) | ||
| 386 | addi $Tbl1,$Tbl0,3 | ||
| 387 | addi $Tbl2,$Tbl0,2 | ||
| 388 | addi $Tbl3,$Tbl0,1 | ||
| 389 | addi $acc00,$acc00,-1 | ||
| 390 | addi $key,$key,16 | ||
| 391 | xor $s0,$s0,$t0 | ||
| 392 | xor $s1,$s1,$t1 | ||
| 393 | xor $s2,$s2,$t2 | ||
| 394 | xor $s3,$s3,$t3 | ||
| 395 | mtctr $acc00 | ||
| 396 | .align 4 | ||
| 397 | Lenc_loop: | ||
| 398 | rlwinm $acc00,$s0,`32-24+3`,21,28 | ||
| 399 | rlwinm $acc01,$s1,`32-24+3`,21,28 | ||
| 400 | lwz $t0,0($key) | ||
| 401 | lwz $t1,4($key) | ||
| 402 | rlwinm $acc02,$s2,`32-24+3`,21,28 | ||
| 403 | rlwinm $acc03,$s3,`32-24+3`,21,28 | ||
| 404 | lwz $t2,8($key) | ||
| 405 | lwz $t3,12($key) | ||
| 406 | rlwinm $acc04,$s1,`32-16+3`,21,28 | ||
| 407 | rlwinm $acc05,$s2,`32-16+3`,21,28 | ||
| 408 | lwzx $acc00,$Tbl0,$acc00 | ||
| 409 | lwzx $acc01,$Tbl0,$acc01 | ||
| 410 | rlwinm $acc06,$s3,`32-16+3`,21,28 | ||
| 411 | rlwinm $acc07,$s0,`32-16+3`,21,28 | ||
| 412 | lwzx $acc02,$Tbl0,$acc02 | ||
| 413 | lwzx $acc03,$Tbl0,$acc03 | ||
| 414 | rlwinm $acc08,$s2,`32-8+3`,21,28 | ||
| 415 | rlwinm $acc09,$s3,`32-8+3`,21,28 | ||
| 416 | lwzx $acc04,$Tbl1,$acc04 | ||
| 417 | lwzx $acc05,$Tbl1,$acc05 | ||
| 418 | rlwinm $acc10,$s0,`32-8+3`,21,28 | ||
| 419 | rlwinm $acc11,$s1,`32-8+3`,21,28 | ||
| 420 | lwzx $acc06,$Tbl1,$acc06 | ||
| 421 | lwzx $acc07,$Tbl1,$acc07 | ||
| 422 | rlwinm $acc12,$s3,`0+3`,21,28 | ||
| 423 | rlwinm $acc13,$s0,`0+3`,21,28 | ||
| 424 | lwzx $acc08,$Tbl2,$acc08 | ||
| 425 | lwzx $acc09,$Tbl2,$acc09 | ||
| 426 | rlwinm $acc14,$s1,`0+3`,21,28 | ||
| 427 | rlwinm $acc15,$s2,`0+3`,21,28 | ||
| 428 | lwzx $acc10,$Tbl2,$acc10 | ||
| 429 | lwzx $acc11,$Tbl2,$acc11 | ||
| 430 | xor $t0,$t0,$acc00 | ||
| 431 | xor $t1,$t1,$acc01 | ||
| 432 | lwzx $acc12,$Tbl3,$acc12 | ||
| 433 | lwzx $acc13,$Tbl3,$acc13 | ||
| 434 | xor $t2,$t2,$acc02 | ||
| 435 | xor $t3,$t3,$acc03 | ||
| 436 | lwzx $acc14,$Tbl3,$acc14 | ||
| 437 | lwzx $acc15,$Tbl3,$acc15 | ||
| 438 | xor $t0,$t0,$acc04 | ||
| 439 | xor $t1,$t1,$acc05 | ||
| 440 | xor $t2,$t2,$acc06 | ||
| 441 | xor $t3,$t3,$acc07 | ||
| 442 | xor $t0,$t0,$acc08 | ||
| 443 | xor $t1,$t1,$acc09 | ||
| 444 | xor $t2,$t2,$acc10 | ||
| 445 | xor $t3,$t3,$acc11 | ||
| 446 | xor $s0,$t0,$acc12 | ||
| 447 | xor $s1,$t1,$acc13 | ||
| 448 | xor $s2,$t2,$acc14 | ||
| 449 | xor $s3,$t3,$acc15 | ||
| 450 | addi $key,$key,16 | ||
| 451 | bdnz- Lenc_loop | ||
| 452 | |||
| 453 | addi $Tbl2,$Tbl0,2048 | ||
| 454 | nop | ||
| 455 | lwz $acc08,`2048+0`($Tbl0) ! prefetch Te4 | ||
| 456 | lwz $acc09,`2048+32`($Tbl0) | ||
| 457 | lwz $acc10,`2048+64`($Tbl0) | ||
| 458 | lwz $acc11,`2048+96`($Tbl0) | ||
| 459 | lwz $acc08,`2048+128`($Tbl0) | ||
| 460 | lwz $acc09,`2048+160`($Tbl0) | ||
| 461 | lwz $acc10,`2048+192`($Tbl0) | ||
| 462 | lwz $acc11,`2048+224`($Tbl0) | ||
| 463 | rlwinm $acc00,$s0,`32-24`,24,31 | ||
| 464 | rlwinm $acc01,$s1,`32-24`,24,31 | ||
| 465 | lwz $t0,0($key) | ||
| 466 | lwz $t1,4($key) | ||
| 467 | rlwinm $acc02,$s2,`32-24`,24,31 | ||
| 468 | rlwinm $acc03,$s3,`32-24`,24,31 | ||
| 469 | lwz $t2,8($key) | ||
| 470 | lwz $t3,12($key) | ||
| 471 | rlwinm $acc04,$s1,`32-16`,24,31 | ||
| 472 | rlwinm $acc05,$s2,`32-16`,24,31 | ||
| 473 | lbzx $acc00,$Tbl2,$acc00 | ||
| 474 | lbzx $acc01,$Tbl2,$acc01 | ||
| 475 | rlwinm $acc06,$s3,`32-16`,24,31 | ||
| 476 | rlwinm $acc07,$s0,`32-16`,24,31 | ||
| 477 | lbzx $acc02,$Tbl2,$acc02 | ||
| 478 | lbzx $acc03,$Tbl2,$acc03 | ||
| 479 | rlwinm $acc08,$s2,`32-8`,24,31 | ||
| 480 | rlwinm $acc09,$s3,`32-8`,24,31 | ||
| 481 | lbzx $acc04,$Tbl2,$acc04 | ||
| 482 | lbzx $acc05,$Tbl2,$acc05 | ||
| 483 | rlwinm $acc10,$s0,`32-8`,24,31 | ||
| 484 | rlwinm $acc11,$s1,`32-8`,24,31 | ||
| 485 | lbzx $acc06,$Tbl2,$acc06 | ||
| 486 | lbzx $acc07,$Tbl2,$acc07 | ||
| 487 | rlwinm $acc12,$s3,`0`,24,31 | ||
| 488 | rlwinm $acc13,$s0,`0`,24,31 | ||
| 489 | lbzx $acc08,$Tbl2,$acc08 | ||
| 490 | lbzx $acc09,$Tbl2,$acc09 | ||
| 491 | rlwinm $acc14,$s1,`0`,24,31 | ||
| 492 | rlwinm $acc15,$s2,`0`,24,31 | ||
| 493 | lbzx $acc10,$Tbl2,$acc10 | ||
| 494 | lbzx $acc11,$Tbl2,$acc11 | ||
| 495 | rlwinm $s0,$acc00,24,0,7 | ||
| 496 | rlwinm $s1,$acc01,24,0,7 | ||
| 497 | lbzx $acc12,$Tbl2,$acc12 | ||
| 498 | lbzx $acc13,$Tbl2,$acc13 | ||
| 499 | rlwinm $s2,$acc02,24,0,7 | ||
| 500 | rlwinm $s3,$acc03,24,0,7 | ||
| 501 | lbzx $acc14,$Tbl2,$acc14 | ||
| 502 | lbzx $acc15,$Tbl2,$acc15 | ||
| 503 | rlwimi $s0,$acc04,16,8,15 | ||
| 504 | rlwimi $s1,$acc05,16,8,15 | ||
| 505 | rlwimi $s2,$acc06,16,8,15 | ||
| 506 | rlwimi $s3,$acc07,16,8,15 | ||
| 507 | rlwimi $s0,$acc08,8,16,23 | ||
| 508 | rlwimi $s1,$acc09,8,16,23 | ||
| 509 | rlwimi $s2,$acc10,8,16,23 | ||
| 510 | rlwimi $s3,$acc11,8,16,23 | ||
| 511 | or $s0,$s0,$acc12 | ||
| 512 | or $s1,$s1,$acc13 | ||
| 513 | or $s2,$s2,$acc14 | ||
| 514 | or $s3,$s3,$acc15 | ||
| 515 | xor $s0,$s0,$t0 | ||
| 516 | xor $s1,$s1,$t1 | ||
| 517 | xor $s2,$s2,$t2 | ||
| 518 | xor $s3,$s3,$t3 | ||
| 519 | blr | ||
| 520 | |||
| 521 | .align 4 | ||
| 522 | Lppc_AES_encrypt_compact: | ||
| 523 | lwz $acc00,240($key) | ||
| 524 | lwz $t0,0($key) | ||
| 525 | lwz $t1,4($key) | ||
| 526 | lwz $t2,8($key) | ||
| 527 | lwz $t3,12($key) | ||
| 528 | addi $Tbl1,$Tbl0,2048 | ||
| 529 | lis $mask80,0x8080 | ||
| 530 | lis $mask1b,0x1b1b | ||
| 531 | addi $key,$key,16 | ||
| 532 | ori $mask80,$mask80,0x8080 | ||
| 533 | ori $mask1b,$mask1b,0x1b1b | ||
| 534 | mtctr $acc00 | ||
| 535 | .align 4 | ||
| 536 | Lenc_compact_loop: | ||
| 537 | xor $s0,$s0,$t0 | ||
| 538 | xor $s1,$s1,$t1 | ||
| 539 | xor $s2,$s2,$t2 | ||
| 540 | xor $s3,$s3,$t3 | ||
| 541 | rlwinm $acc00,$s0,`32-24`,24,31 | ||
| 542 | rlwinm $acc01,$s1,`32-24`,24,31 | ||
| 543 | rlwinm $acc02,$s2,`32-24`,24,31 | ||
| 544 | rlwinm $acc03,$s3,`32-24`,24,31 | ||
| 545 | lbzx $acc00,$Tbl1,$acc00 | ||
| 546 | lbzx $acc01,$Tbl1,$acc01 | ||
| 547 | rlwinm $acc04,$s1,`32-16`,24,31 | ||
| 548 | rlwinm $acc05,$s2,`32-16`,24,31 | ||
| 549 | lbzx $acc02,$Tbl1,$acc02 | ||
| 550 | lbzx $acc03,$Tbl1,$acc03 | ||
| 551 | rlwinm $acc06,$s3,`32-16`,24,31 | ||
| 552 | rlwinm $acc07,$s0,`32-16`,24,31 | ||
| 553 | lbzx $acc04,$Tbl1,$acc04 | ||
| 554 | lbzx $acc05,$Tbl1,$acc05 | ||
| 555 | rlwinm $acc08,$s2,`32-8`,24,31 | ||
| 556 | rlwinm $acc09,$s3,`32-8`,24,31 | ||
| 557 | lbzx $acc06,$Tbl1,$acc06 | ||
| 558 | lbzx $acc07,$Tbl1,$acc07 | ||
| 559 | rlwinm $acc10,$s0,`32-8`,24,31 | ||
| 560 | rlwinm $acc11,$s1,`32-8`,24,31 | ||
| 561 | lbzx $acc08,$Tbl1,$acc08 | ||
| 562 | lbzx $acc09,$Tbl1,$acc09 | ||
| 563 | rlwinm $acc12,$s3,`0`,24,31 | ||
| 564 | rlwinm $acc13,$s0,`0`,24,31 | ||
| 565 | lbzx $acc10,$Tbl1,$acc10 | ||
| 566 | lbzx $acc11,$Tbl1,$acc11 | ||
| 567 | rlwinm $acc14,$s1,`0`,24,31 | ||
| 568 | rlwinm $acc15,$s2,`0`,24,31 | ||
| 569 | lbzx $acc12,$Tbl1,$acc12 | ||
| 570 | lbzx $acc13,$Tbl1,$acc13 | ||
| 571 | rlwinm $s0,$acc00,24,0,7 | ||
| 572 | rlwinm $s1,$acc01,24,0,7 | ||
| 573 | lbzx $acc14,$Tbl1,$acc14 | ||
| 574 | lbzx $acc15,$Tbl1,$acc15 | ||
| 575 | rlwinm $s2,$acc02,24,0,7 | ||
| 576 | rlwinm $s3,$acc03,24,0,7 | ||
| 577 | rlwimi $s0,$acc04,16,8,15 | ||
| 578 | rlwimi $s1,$acc05,16,8,15 | ||
| 579 | rlwimi $s2,$acc06,16,8,15 | ||
| 580 | rlwimi $s3,$acc07,16,8,15 | ||
| 581 | rlwimi $s0,$acc08,8,16,23 | ||
| 582 | rlwimi $s1,$acc09,8,16,23 | ||
| 583 | rlwimi $s2,$acc10,8,16,23 | ||
| 584 | rlwimi $s3,$acc11,8,16,23 | ||
| 585 | lwz $t0,0($key) | ||
| 586 | lwz $t1,4($key) | ||
| 587 | or $s0,$s0,$acc12 | ||
| 588 | or $s1,$s1,$acc13 | ||
| 589 | lwz $t2,8($key) | ||
| 590 | lwz $t3,12($key) | ||
| 591 | or $s2,$s2,$acc14 | ||
| 592 | or $s3,$s3,$acc15 | ||
| 593 | |||
| 594 | addi $key,$key,16 | ||
| 595 | bdz Lenc_compact_done | ||
| 596 | |||
| 597 | and $acc00,$s0,$mask80 # r1=r0&0x80808080 | ||
| 598 | and $acc01,$s1,$mask80 | ||
| 599 | and $acc02,$s2,$mask80 | ||
| 600 | and $acc03,$s3,$mask80 | ||
| 601 | srwi $acc04,$acc00,7 # r1>>7 | ||
| 602 | srwi $acc05,$acc01,7 | ||
| 603 | srwi $acc06,$acc02,7 | ||
| 604 | srwi $acc07,$acc03,7 | ||
| 605 | andc $acc08,$s0,$mask80 # r0&0x7f7f7f7f | ||
| 606 | andc $acc09,$s1,$mask80 | ||
| 607 | andc $acc10,$s2,$mask80 | ||
| 608 | andc $acc11,$s3,$mask80 | ||
| 609 | sub $acc00,$acc00,$acc04 # r1-(r1>>7) | ||
| 610 | sub $acc01,$acc01,$acc05 | ||
| 611 | sub $acc02,$acc02,$acc06 | ||
| 612 | sub $acc03,$acc03,$acc07 | ||
| 613 | add $acc08,$acc08,$acc08 # (r0&0x7f7f7f7f)<<1 | ||
| 614 | add $acc09,$acc09,$acc09 | ||
| 615 | add $acc10,$acc10,$acc10 | ||
| 616 | add $acc11,$acc11,$acc11 | ||
| 617 | and $acc00,$acc00,$mask1b # (r1-(r1>>7))&0x1b1b1b1b | ||
| 618 | and $acc01,$acc01,$mask1b | ||
| 619 | and $acc02,$acc02,$mask1b | ||
| 620 | and $acc03,$acc03,$mask1b | ||
| 621 | xor $acc00,$acc00,$acc08 # r2 | ||
| 622 | xor $acc01,$acc01,$acc09 | ||
| 623 | xor $acc02,$acc02,$acc10 | ||
| 624 | xor $acc03,$acc03,$acc11 | ||
| 625 | |||
| 626 | rotlwi $acc12,$s0,16 # ROTATE(r0,16) | ||
| 627 | rotlwi $acc13,$s1,16 | ||
| 628 | rotlwi $acc14,$s2,16 | ||
| 629 | rotlwi $acc15,$s3,16 | ||
| 630 | xor $s0,$s0,$acc00 # r0^r2 | ||
| 631 | xor $s1,$s1,$acc01 | ||
| 632 | xor $s2,$s2,$acc02 | ||
| 633 | xor $s3,$s3,$acc03 | ||
| 634 | rotrwi $s0,$s0,24 # ROTATE(r2^r0,24) | ||
| 635 | rotrwi $s1,$s1,24 | ||
| 636 | rotrwi $s2,$s2,24 | ||
| 637 | rotrwi $s3,$s3,24 | ||
| 638 | xor $s0,$s0,$acc00 # ROTATE(r2^r0,24)^r2 | ||
| 639 | xor $s1,$s1,$acc01 | ||
| 640 | xor $s2,$s2,$acc02 | ||
| 641 | xor $s3,$s3,$acc03 | ||
| 642 | rotlwi $acc08,$acc12,8 # ROTATE(r0,24) | ||
| 643 | rotlwi $acc09,$acc13,8 | ||
| 644 | rotlwi $acc10,$acc14,8 | ||
| 645 | rotlwi $acc11,$acc15,8 | ||
| 646 | xor $s0,$s0,$acc12 # | ||
| 647 | xor $s1,$s1,$acc13 | ||
| 648 | xor $s2,$s2,$acc14 | ||
| 649 | xor $s3,$s3,$acc15 | ||
| 650 | xor $s0,$s0,$acc08 # | ||
| 651 | xor $s1,$s1,$acc09 | ||
| 652 | xor $s2,$s2,$acc10 | ||
| 653 | xor $s3,$s3,$acc11 | ||
| 654 | |||
| 655 | b Lenc_compact_loop | ||
| 656 | .align 4 | ||
| 657 | Lenc_compact_done: | ||
| 658 | xor $s0,$s0,$t0 | ||
| 659 | xor $s1,$s1,$t1 | ||
| 660 | xor $s2,$s2,$t2 | ||
| 661 | xor $s3,$s3,$t3 | ||
| 662 | blr | ||
| 663 | |||
| 664 | .globl .AES_decrypt | ||
| 665 | .align 7 | ||
| 666 | .AES_decrypt: | ||
| 667 | mflr r0 | ||
| 668 | $STU $sp,-$FRAME($sp) | ||
| 669 | |||
| 670 | $PUSH r0,`$FRAME-$SIZE_T*21`($sp) | ||
| 671 | $PUSH $toc,`$FRAME-$SIZE_T*20`($sp) | ||
| 672 | $PUSH r13,`$FRAME-$SIZE_T*19`($sp) | ||
| 673 | $PUSH r14,`$FRAME-$SIZE_T*18`($sp) | ||
| 674 | $PUSH r15,`$FRAME-$SIZE_T*17`($sp) | ||
| 675 | $PUSH r16,`$FRAME-$SIZE_T*16`($sp) | ||
| 676 | $PUSH r17,`$FRAME-$SIZE_T*15`($sp) | ||
| 677 | $PUSH r18,`$FRAME-$SIZE_T*14`($sp) | ||
| 678 | $PUSH r19,`$FRAME-$SIZE_T*13`($sp) | ||
| 679 | $PUSH r20,`$FRAME-$SIZE_T*12`($sp) | ||
| 680 | $PUSH r21,`$FRAME-$SIZE_T*11`($sp) | ||
| 681 | $PUSH r22,`$FRAME-$SIZE_T*10`($sp) | ||
| 682 | $PUSH r23,`$FRAME-$SIZE_T*9`($sp) | ||
| 683 | $PUSH r24,`$FRAME-$SIZE_T*8`($sp) | ||
| 684 | $PUSH r25,`$FRAME-$SIZE_T*7`($sp) | ||
| 685 | $PUSH r26,`$FRAME-$SIZE_T*6`($sp) | ||
| 686 | $PUSH r27,`$FRAME-$SIZE_T*5`($sp) | ||
| 687 | $PUSH r28,`$FRAME-$SIZE_T*4`($sp) | ||
| 688 | $PUSH r29,`$FRAME-$SIZE_T*3`($sp) | ||
| 689 | $PUSH r30,`$FRAME-$SIZE_T*2`($sp) | ||
| 690 | $PUSH r31,`$FRAME-$SIZE_T*1`($sp) | ||
| 691 | |||
| 692 | lwz $s0,0($inp) | ||
| 693 | lwz $s1,4($inp) | ||
| 694 | lwz $s2,8($inp) | ||
| 695 | lwz $s3,12($inp) | ||
| 696 | bl LAES_Td | ||
| 697 | bl Lppc_AES_decrypt_compact | ||
| 698 | stw $s0,0($out) | ||
| 699 | stw $s1,4($out) | ||
| 700 | stw $s2,8($out) | ||
| 701 | stw $s3,12($out) | ||
| 702 | |||
| 703 | $POP r0,`$FRAME-$SIZE_T*21`($sp) | ||
| 704 | $POP $toc,`$FRAME-$SIZE_T*20`($sp) | ||
| 705 | $POP r13,`$FRAME-$SIZE_T*19`($sp) | ||
| 706 | $POP r14,`$FRAME-$SIZE_T*18`($sp) | ||
| 707 | $POP r15,`$FRAME-$SIZE_T*17`($sp) | ||
| 708 | $POP r16,`$FRAME-$SIZE_T*16`($sp) | ||
| 709 | $POP r17,`$FRAME-$SIZE_T*15`($sp) | ||
| 710 | $POP r18,`$FRAME-$SIZE_T*14`($sp) | ||
| 711 | $POP r19,`$FRAME-$SIZE_T*13`($sp) | ||
| 712 | $POP r20,`$FRAME-$SIZE_T*12`($sp) | ||
| 713 | $POP r21,`$FRAME-$SIZE_T*11`($sp) | ||
| 714 | $POP r22,`$FRAME-$SIZE_T*10`($sp) | ||
| 715 | $POP r23,`$FRAME-$SIZE_T*9`($sp) | ||
| 716 | $POP r24,`$FRAME-$SIZE_T*8`($sp) | ||
| 717 | $POP r25,`$FRAME-$SIZE_T*7`($sp) | ||
| 718 | $POP r26,`$FRAME-$SIZE_T*6`($sp) | ||
| 719 | $POP r27,`$FRAME-$SIZE_T*5`($sp) | ||
| 720 | $POP r28,`$FRAME-$SIZE_T*4`($sp) | ||
| 721 | $POP r29,`$FRAME-$SIZE_T*3`($sp) | ||
| 722 | $POP r30,`$FRAME-$SIZE_T*2`($sp) | ||
| 723 | $POP r31,`$FRAME-$SIZE_T*1`($sp) | ||
| 724 | mtlr r0 | ||
| 725 | addi $sp,$sp,$FRAME | ||
| 726 | blr | ||
| 727 | |||
| 728 | .align 4 | ||
| 729 | Lppc_AES_decrypt: | ||
| 730 | lwz $acc00,240($key) | ||
| 731 | lwz $t0,0($key) | ||
| 732 | lwz $t1,4($key) | ||
| 733 | lwz $t2,8($key) | ||
| 734 | lwz $t3,12($key) | ||
| 735 | addi $Tbl1,$Tbl0,3 | ||
| 736 | addi $Tbl2,$Tbl0,2 | ||
| 737 | addi $Tbl3,$Tbl0,1 | ||
| 738 | addi $acc00,$acc00,-1 | ||
| 739 | addi $key,$key,16 | ||
| 740 | xor $s0,$s0,$t0 | ||
| 741 | xor $s1,$s1,$t1 | ||
| 742 | xor $s2,$s2,$t2 | ||
| 743 | xor $s3,$s3,$t3 | ||
| 744 | mtctr $acc00 | ||
| 745 | .align 4 | ||
| 746 | Ldec_loop: | ||
| 747 | rlwinm $acc00,$s0,`32-24+3`,21,28 | ||
| 748 | rlwinm $acc01,$s1,`32-24+3`,21,28 | ||
| 749 | lwz $t0,0($key) | ||
| 750 | lwz $t1,4($key) | ||
| 751 | rlwinm $acc02,$s2,`32-24+3`,21,28 | ||
| 752 | rlwinm $acc03,$s3,`32-24+3`,21,28 | ||
| 753 | lwz $t2,8($key) | ||
| 754 | lwz $t3,12($key) | ||
| 755 | rlwinm $acc04,$s3,`32-16+3`,21,28 | ||
| 756 | rlwinm $acc05,$s0,`32-16+3`,21,28 | ||
| 757 | lwzx $acc00,$Tbl0,$acc00 | ||
| 758 | lwzx $acc01,$Tbl0,$acc01 | ||
| 759 | rlwinm $acc06,$s1,`32-16+3`,21,28 | ||
| 760 | rlwinm $acc07,$s2,`32-16+3`,21,28 | ||
| 761 | lwzx $acc02,$Tbl0,$acc02 | ||
| 762 | lwzx $acc03,$Tbl0,$acc03 | ||
| 763 | rlwinm $acc08,$s2,`32-8+3`,21,28 | ||
| 764 | rlwinm $acc09,$s3,`32-8+3`,21,28 | ||
| 765 | lwzx $acc04,$Tbl1,$acc04 | ||
| 766 | lwzx $acc05,$Tbl1,$acc05 | ||
| 767 | rlwinm $acc10,$s0,`32-8+3`,21,28 | ||
| 768 | rlwinm $acc11,$s1,`32-8+3`,21,28 | ||
| 769 | lwzx $acc06,$Tbl1,$acc06 | ||
| 770 | lwzx $acc07,$Tbl1,$acc07 | ||
| 771 | rlwinm $acc12,$s1,`0+3`,21,28 | ||
| 772 | rlwinm $acc13,$s2,`0+3`,21,28 | ||
| 773 | lwzx $acc08,$Tbl2,$acc08 | ||
| 774 | lwzx $acc09,$Tbl2,$acc09 | ||
| 775 | rlwinm $acc14,$s3,`0+3`,21,28 | ||
| 776 | rlwinm $acc15,$s0,`0+3`,21,28 | ||
| 777 | lwzx $acc10,$Tbl2,$acc10 | ||
| 778 | lwzx $acc11,$Tbl2,$acc11 | ||
| 779 | xor $t0,$t0,$acc00 | ||
| 780 | xor $t1,$t1,$acc01 | ||
| 781 | lwzx $acc12,$Tbl3,$acc12 | ||
| 782 | lwzx $acc13,$Tbl3,$acc13 | ||
| 783 | xor $t2,$t2,$acc02 | ||
| 784 | xor $t3,$t3,$acc03 | ||
| 785 | lwzx $acc14,$Tbl3,$acc14 | ||
| 786 | lwzx $acc15,$Tbl3,$acc15 | ||
| 787 | xor $t0,$t0,$acc04 | ||
| 788 | xor $t1,$t1,$acc05 | ||
| 789 | xor $t2,$t2,$acc06 | ||
| 790 | xor $t3,$t3,$acc07 | ||
| 791 | xor $t0,$t0,$acc08 | ||
| 792 | xor $t1,$t1,$acc09 | ||
| 793 | xor $t2,$t2,$acc10 | ||
| 794 | xor $t3,$t3,$acc11 | ||
| 795 | xor $s0,$t0,$acc12 | ||
| 796 | xor $s1,$t1,$acc13 | ||
| 797 | xor $s2,$t2,$acc14 | ||
| 798 | xor $s3,$t3,$acc15 | ||
| 799 | addi $key,$key,16 | ||
| 800 | bdnz- Ldec_loop | ||
| 801 | |||
| 802 | addi $Tbl2,$Tbl0,2048 | ||
| 803 | nop | ||
| 804 | lwz $acc08,`2048+0`($Tbl0) ! prefetch Td4 | ||
| 805 | lwz $acc09,`2048+32`($Tbl0) | ||
| 806 | lwz $acc10,`2048+64`($Tbl0) | ||
| 807 | lwz $acc11,`2048+96`($Tbl0) | ||
| 808 | lwz $acc08,`2048+128`($Tbl0) | ||
| 809 | lwz $acc09,`2048+160`($Tbl0) | ||
| 810 | lwz $acc10,`2048+192`($Tbl0) | ||
| 811 | lwz $acc11,`2048+224`($Tbl0) | ||
| 812 | rlwinm $acc00,$s0,`32-24`,24,31 | ||
| 813 | rlwinm $acc01,$s1,`32-24`,24,31 | ||
| 814 | lwz $t0,0($key) | ||
| 815 | lwz $t1,4($key) | ||
| 816 | rlwinm $acc02,$s2,`32-24`,24,31 | ||
| 817 | rlwinm $acc03,$s3,`32-24`,24,31 | ||
| 818 | lwz $t2,8($key) | ||
| 819 | lwz $t3,12($key) | ||
| 820 | rlwinm $acc04,$s3,`32-16`,24,31 | ||
| 821 | rlwinm $acc05,$s0,`32-16`,24,31 | ||
| 822 | lbzx $acc00,$Tbl2,$acc00 | ||
| 823 | lbzx $acc01,$Tbl2,$acc01 | ||
| 824 | rlwinm $acc06,$s1,`32-16`,24,31 | ||
| 825 | rlwinm $acc07,$s2,`32-16`,24,31 | ||
| 826 | lbzx $acc02,$Tbl2,$acc02 | ||
| 827 | lbzx $acc03,$Tbl2,$acc03 | ||
| 828 | rlwinm $acc08,$s2,`32-8`,24,31 | ||
| 829 | rlwinm $acc09,$s3,`32-8`,24,31 | ||
| 830 | lbzx $acc04,$Tbl2,$acc04 | ||
| 831 | lbzx $acc05,$Tbl2,$acc05 | ||
| 832 | rlwinm $acc10,$s0,`32-8`,24,31 | ||
| 833 | rlwinm $acc11,$s1,`32-8`,24,31 | ||
| 834 | lbzx $acc06,$Tbl2,$acc06 | ||
| 835 | lbzx $acc07,$Tbl2,$acc07 | ||
| 836 | rlwinm $acc12,$s1,`0`,24,31 | ||
| 837 | rlwinm $acc13,$s2,`0`,24,31 | ||
| 838 | lbzx $acc08,$Tbl2,$acc08 | ||
| 839 | lbzx $acc09,$Tbl2,$acc09 | ||
| 840 | rlwinm $acc14,$s3,`0`,24,31 | ||
| 841 | rlwinm $acc15,$s0,`0`,24,31 | ||
| 842 | lbzx $acc10,$Tbl2,$acc10 | ||
| 843 | lbzx $acc11,$Tbl2,$acc11 | ||
| 844 | rlwinm $s0,$acc00,24,0,7 | ||
| 845 | rlwinm $s1,$acc01,24,0,7 | ||
| 846 | lbzx $acc12,$Tbl2,$acc12 | ||
| 847 | lbzx $acc13,$Tbl2,$acc13 | ||
| 848 | rlwinm $s2,$acc02,24,0,7 | ||
| 849 | rlwinm $s3,$acc03,24,0,7 | ||
| 850 | lbzx $acc14,$Tbl2,$acc14 | ||
| 851 | lbzx $acc15,$Tbl2,$acc15 | ||
| 852 | rlwimi $s0,$acc04,16,8,15 | ||
| 853 | rlwimi $s1,$acc05,16,8,15 | ||
| 854 | rlwimi $s2,$acc06,16,8,15 | ||
| 855 | rlwimi $s3,$acc07,16,8,15 | ||
| 856 | rlwimi $s0,$acc08,8,16,23 | ||
| 857 | rlwimi $s1,$acc09,8,16,23 | ||
| 858 | rlwimi $s2,$acc10,8,16,23 | ||
| 859 | rlwimi $s3,$acc11,8,16,23 | ||
| 860 | or $s0,$s0,$acc12 | ||
| 861 | or $s1,$s1,$acc13 | ||
| 862 | or $s2,$s2,$acc14 | ||
| 863 | or $s3,$s3,$acc15 | ||
| 864 | xor $s0,$s0,$t0 | ||
| 865 | xor $s1,$s1,$t1 | ||
| 866 | xor $s2,$s2,$t2 | ||
| 867 | xor $s3,$s3,$t3 | ||
| 868 | blr | ||
| 869 | |||
| 870 | .align 4 | ||
| 871 | Lppc_AES_decrypt_compact: | ||
| 872 | lwz $acc00,240($key) | ||
| 873 | lwz $t0,0($key) | ||
| 874 | lwz $t1,4($key) | ||
| 875 | lwz $t2,8($key) | ||
| 876 | lwz $t3,12($key) | ||
| 877 | addi $Tbl1,$Tbl0,2048 | ||
| 878 | lis $mask80,0x8080 | ||
| 879 | lis $mask1b,0x1b1b | ||
| 880 | addi $key,$key,16 | ||
| 881 | ori $mask80,$mask80,0x8080 | ||
| 882 | ori $mask1b,$mask1b,0x1b1b | ||
| 883 | ___ | ||
| 884 | $code.=<<___ if ($SIZE_T==8); | ||
| 885 | insrdi $mask80,$mask80,32,0 | ||
| 886 | insrdi $mask1b,$mask1b,32,0 | ||
| 887 | ___ | ||
| 888 | $code.=<<___; | ||
| 889 | mtctr $acc00 | ||
| 890 | .align 4 | ||
| 891 | Ldec_compact_loop: | ||
| 892 | xor $s0,$s0,$t0 | ||
| 893 | xor $s1,$s1,$t1 | ||
| 894 | xor $s2,$s2,$t2 | ||
| 895 | xor $s3,$s3,$t3 | ||
| 896 | rlwinm $acc00,$s0,`32-24`,24,31 | ||
| 897 | rlwinm $acc01,$s1,`32-24`,24,31 | ||
| 898 | rlwinm $acc02,$s2,`32-24`,24,31 | ||
| 899 | rlwinm $acc03,$s3,`32-24`,24,31 | ||
| 900 | lbzx $acc00,$Tbl1,$acc00 | ||
| 901 | lbzx $acc01,$Tbl1,$acc01 | ||
| 902 | rlwinm $acc04,$s3,`32-16`,24,31 | ||
| 903 | rlwinm $acc05,$s0,`32-16`,24,31 | ||
| 904 | lbzx $acc02,$Tbl1,$acc02 | ||
| 905 | lbzx $acc03,$Tbl1,$acc03 | ||
| 906 | rlwinm $acc06,$s1,`32-16`,24,31 | ||
| 907 | rlwinm $acc07,$s2,`32-16`,24,31 | ||
| 908 | lbzx $acc04,$Tbl1,$acc04 | ||
| 909 | lbzx $acc05,$Tbl1,$acc05 | ||
| 910 | rlwinm $acc08,$s2,`32-8`,24,31 | ||
| 911 | rlwinm $acc09,$s3,`32-8`,24,31 | ||
| 912 | lbzx $acc06,$Tbl1,$acc06 | ||
| 913 | lbzx $acc07,$Tbl1,$acc07 | ||
| 914 | rlwinm $acc10,$s0,`32-8`,24,31 | ||
| 915 | rlwinm $acc11,$s1,`32-8`,24,31 | ||
| 916 | lbzx $acc08,$Tbl1,$acc08 | ||
| 917 | lbzx $acc09,$Tbl1,$acc09 | ||
| 918 | rlwinm $acc12,$s1,`0`,24,31 | ||
| 919 | rlwinm $acc13,$s2,`0`,24,31 | ||
| 920 | lbzx $acc10,$Tbl1,$acc10 | ||
| 921 | lbzx $acc11,$Tbl1,$acc11 | ||
| 922 | rlwinm $acc14,$s3,`0`,24,31 | ||
| 923 | rlwinm $acc15,$s0,`0`,24,31 | ||
| 924 | lbzx $acc12,$Tbl1,$acc12 | ||
| 925 | lbzx $acc13,$Tbl1,$acc13 | ||
| 926 | rlwinm $s0,$acc00,24,0,7 | ||
| 927 | rlwinm $s1,$acc01,24,0,7 | ||
| 928 | lbzx $acc14,$Tbl1,$acc14 | ||
| 929 | lbzx $acc15,$Tbl1,$acc15 | ||
| 930 | rlwinm $s2,$acc02,24,0,7 | ||
| 931 | rlwinm $s3,$acc03,24,0,7 | ||
| 932 | rlwimi $s0,$acc04,16,8,15 | ||
| 933 | rlwimi $s1,$acc05,16,8,15 | ||
| 934 | rlwimi $s2,$acc06,16,8,15 | ||
| 935 | rlwimi $s3,$acc07,16,8,15 | ||
| 936 | rlwimi $s0,$acc08,8,16,23 | ||
| 937 | rlwimi $s1,$acc09,8,16,23 | ||
| 938 | rlwimi $s2,$acc10,8,16,23 | ||
| 939 | rlwimi $s3,$acc11,8,16,23 | ||
| 940 | lwz $t0,0($key) | ||
| 941 | lwz $t1,4($key) | ||
| 942 | or $s0,$s0,$acc12 | ||
| 943 | or $s1,$s1,$acc13 | ||
| 944 | lwz $t2,8($key) | ||
| 945 | lwz $t3,12($key) | ||
| 946 | or $s2,$s2,$acc14 | ||
| 947 | or $s3,$s3,$acc15 | ||
| 948 | |||
| 949 | addi $key,$key,16 | ||
| 950 | bdz Ldec_compact_done | ||
| 951 | ___ | ||
| 952 | $code.=<<___ if ($SIZE_T==8); | ||
| 953 | # vectorized permutation improves decrypt performance by 10% | ||
| 954 | insrdi $s0,$s1,32,0 | ||
| 955 | insrdi $s2,$s3,32,0 | ||
| 956 | |||
| 957 | and $acc00,$s0,$mask80 # r1=r0&0x80808080 | ||
| 958 | and $acc02,$s2,$mask80 | ||
| 959 | srdi $acc04,$acc00,7 # r1>>7 | ||
| 960 | srdi $acc06,$acc02,7 | ||
| 961 | andc $acc08,$s0,$mask80 # r0&0x7f7f7f7f | ||
| 962 | andc $acc10,$s2,$mask80 | ||
| 963 | sub $acc00,$acc00,$acc04 # r1-(r1>>7) | ||
| 964 | sub $acc02,$acc02,$acc06 | ||
| 965 | add $acc08,$acc08,$acc08 # (r0&0x7f7f7f7f)<<1 | ||
| 966 | add $acc10,$acc10,$acc10 | ||
| 967 | and $acc00,$acc00,$mask1b # (r1-(r1>>7))&0x1b1b1b1b | ||
| 968 | and $acc02,$acc02,$mask1b | ||
| 969 | xor $acc00,$acc00,$acc08 # r2 | ||
| 970 | xor $acc02,$acc02,$acc10 | ||
| 971 | |||
| 972 | and $acc04,$acc00,$mask80 # r1=r2&0x80808080 | ||
| 973 | and $acc06,$acc02,$mask80 | ||
| 974 | srdi $acc08,$acc04,7 # r1>>7 | ||
| 975 | srdi $acc10,$acc06,7 | ||
| 976 | andc $acc12,$acc00,$mask80 # r2&0x7f7f7f7f | ||
| 977 | andc $acc14,$acc02,$mask80 | ||
| 978 | sub $acc04,$acc04,$acc08 # r1-(r1>>7) | ||
| 979 | sub $acc06,$acc06,$acc10 | ||
| 980 | add $acc12,$acc12,$acc12 # (r2&0x7f7f7f7f)<<1 | ||
| 981 | add $acc14,$acc14,$acc14 | ||
| 982 | and $acc04,$acc04,$mask1b # (r1-(r1>>7))&0x1b1b1b1b | ||
| 983 | and $acc06,$acc06,$mask1b | ||
| 984 | xor $acc04,$acc04,$acc12 # r4 | ||
| 985 | xor $acc06,$acc06,$acc14 | ||
| 986 | |||
| 987 | and $acc08,$acc04,$mask80 # r1=r4&0x80808080 | ||
| 988 | and $acc10,$acc06,$mask80 | ||
| 989 | srdi $acc12,$acc08,7 # r1>>7 | ||
| 990 | srdi $acc14,$acc10,7 | ||
| 991 | sub $acc08,$acc08,$acc12 # r1-(r1>>7) | ||
| 992 | sub $acc10,$acc10,$acc14 | ||
| 993 | andc $acc12,$acc04,$mask80 # r4&0x7f7f7f7f | ||
| 994 | andc $acc14,$acc06,$mask80 | ||
| 995 | add $acc12,$acc12,$acc12 # (r4&0x7f7f7f7f)<<1 | ||
| 996 | add $acc14,$acc14,$acc14 | ||
| 997 | and $acc08,$acc08,$mask1b # (r1-(r1>>7))&0x1b1b1b1b | ||
| 998 | and $acc10,$acc10,$mask1b | ||
| 999 | xor $acc08,$acc08,$acc12 # r8 | ||
| 1000 | xor $acc10,$acc10,$acc14 | ||
| 1001 | |||
| 1002 | xor $acc00,$acc00,$s0 # r2^r0 | ||
| 1003 | xor $acc02,$acc02,$s2 | ||
| 1004 | xor $acc04,$acc04,$s0 # r4^r0 | ||
| 1005 | xor $acc06,$acc06,$s2 | ||
| 1006 | |||
| 1007 | extrdi $acc01,$acc00,32,0 | ||
| 1008 | extrdi $acc03,$acc02,32,0 | ||
| 1009 | extrdi $acc05,$acc04,32,0 | ||
| 1010 | extrdi $acc07,$acc06,32,0 | ||
| 1011 | extrdi $acc09,$acc08,32,0 | ||
| 1012 | extrdi $acc11,$acc10,32,0 | ||
| 1013 | ___ | ||
| 1014 | $code.=<<___ if ($SIZE_T==4); | ||
| 1015 | and $acc00,$s0,$mask80 # r1=r0&0x80808080 | ||
| 1016 | and $acc01,$s1,$mask80 | ||
| 1017 | and $acc02,$s2,$mask80 | ||
| 1018 | and $acc03,$s3,$mask80 | ||
| 1019 | srwi $acc04,$acc00,7 # r1>>7 | ||
| 1020 | srwi $acc05,$acc01,7 | ||
| 1021 | srwi $acc06,$acc02,7 | ||
| 1022 | srwi $acc07,$acc03,7 | ||
| 1023 | andc $acc08,$s0,$mask80 # r0&0x7f7f7f7f | ||
| 1024 | andc $acc09,$s1,$mask80 | ||
| 1025 | andc $acc10,$s2,$mask80 | ||
| 1026 | andc $acc11,$s3,$mask80 | ||
| 1027 | sub $acc00,$acc00,$acc04 # r1-(r1>>7) | ||
| 1028 | sub $acc01,$acc01,$acc05 | ||
| 1029 | sub $acc02,$acc02,$acc06 | ||
| 1030 | sub $acc03,$acc03,$acc07 | ||
| 1031 | add $acc08,$acc08,$acc08 # (r0&0x7f7f7f7f)<<1 | ||
| 1032 | add $acc09,$acc09,$acc09 | ||
| 1033 | add $acc10,$acc10,$acc10 | ||
| 1034 | add $acc11,$acc11,$acc11 | ||
| 1035 | and $acc00,$acc00,$mask1b # (r1-(r1>>7))&0x1b1b1b1b | ||
| 1036 | and $acc01,$acc01,$mask1b | ||
| 1037 | and $acc02,$acc02,$mask1b | ||
| 1038 | and $acc03,$acc03,$mask1b | ||
| 1039 | xor $acc00,$acc00,$acc08 # r2 | ||
| 1040 | xor $acc01,$acc01,$acc09 | ||
| 1041 | xor $acc02,$acc02,$acc10 | ||
| 1042 | xor $acc03,$acc03,$acc11 | ||
| 1043 | |||
| 1044 | and $acc04,$acc00,$mask80 # r1=r2&0x80808080 | ||
| 1045 | and $acc05,$acc01,$mask80 | ||
| 1046 | and $acc06,$acc02,$mask80 | ||
| 1047 | and $acc07,$acc03,$mask80 | ||
| 1048 | srwi $acc08,$acc04,7 # r1>>7 | ||
| 1049 | srwi $acc09,$acc05,7 | ||
| 1050 | srwi $acc10,$acc06,7 | ||
| 1051 | srwi $acc11,$acc07,7 | ||
| 1052 | andc $acc12,$acc00,$mask80 # r2&0x7f7f7f7f | ||
| 1053 | andc $acc13,$acc01,$mask80 | ||
| 1054 | andc $acc14,$acc02,$mask80 | ||
| 1055 | andc $acc15,$acc03,$mask80 | ||
| 1056 | sub $acc04,$acc04,$acc08 # r1-(r1>>7) | ||
| 1057 | sub $acc05,$acc05,$acc09 | ||
| 1058 | sub $acc06,$acc06,$acc10 | ||
| 1059 | sub $acc07,$acc07,$acc11 | ||
| 1060 | add $acc12,$acc12,$acc12 # (r2&0x7f7f7f7f)<<1 | ||
| 1061 | add $acc13,$acc13,$acc13 | ||
| 1062 | add $acc14,$acc14,$acc14 | ||
| 1063 | add $acc15,$acc15,$acc15 | ||
| 1064 | and $acc04,$acc04,$mask1b # (r1-(r1>>7))&0x1b1b1b1b | ||
| 1065 | and $acc05,$acc05,$mask1b | ||
| 1066 | and $acc06,$acc06,$mask1b | ||
| 1067 | and $acc07,$acc07,$mask1b | ||
| 1068 | xor $acc04,$acc04,$acc12 # r4 | ||
| 1069 | xor $acc05,$acc05,$acc13 | ||
| 1070 | xor $acc06,$acc06,$acc14 | ||
| 1071 | xor $acc07,$acc07,$acc15 | ||
| 1072 | |||
| 1073 | and $acc08,$acc04,$mask80 # r1=r4&0x80808080 | ||
| 1074 | and $acc09,$acc05,$mask80 | ||
| 1075 | and $acc10,$acc06,$mask80 | ||
| 1076 | and $acc11,$acc07,$mask80 | ||
| 1077 | srwi $acc12,$acc08,7 # r1>>7 | ||
| 1078 | srwi $acc13,$acc09,7 | ||
| 1079 | srwi $acc14,$acc10,7 | ||
| 1080 | srwi $acc15,$acc11,7 | ||
| 1081 | sub $acc08,$acc08,$acc12 # r1-(r1>>7) | ||
| 1082 | sub $acc09,$acc09,$acc13 | ||
| 1083 | sub $acc10,$acc10,$acc14 | ||
| 1084 | sub $acc11,$acc11,$acc15 | ||
| 1085 | andc $acc12,$acc04,$mask80 # r4&0x7f7f7f7f | ||
| 1086 | andc $acc13,$acc05,$mask80 | ||
| 1087 | andc $acc14,$acc06,$mask80 | ||
| 1088 | andc $acc15,$acc07,$mask80 | ||
| 1089 | add $acc12,$acc12,$acc12 # (r4&0x7f7f7f7f)<<1 | ||
| 1090 | add $acc13,$acc13,$acc13 | ||
| 1091 | add $acc14,$acc14,$acc14 | ||
| 1092 | add $acc15,$acc15,$acc15 | ||
| 1093 | and $acc08,$acc08,$mask1b # (r1-(r1>>7))&0x1b1b1b1b | ||
| 1094 | and $acc09,$acc09,$mask1b | ||
| 1095 | and $acc10,$acc10,$mask1b | ||
| 1096 | and $acc11,$acc11,$mask1b | ||
| 1097 | xor $acc08,$acc08,$acc12 # r8 | ||
| 1098 | xor $acc09,$acc09,$acc13 | ||
| 1099 | xor $acc10,$acc10,$acc14 | ||
| 1100 | xor $acc11,$acc11,$acc15 | ||
| 1101 | |||
| 1102 | xor $acc00,$acc00,$s0 # r2^r0 | ||
| 1103 | xor $acc01,$acc01,$s1 | ||
| 1104 | xor $acc02,$acc02,$s2 | ||
| 1105 | xor $acc03,$acc03,$s3 | ||
| 1106 | xor $acc04,$acc04,$s0 # r4^r0 | ||
| 1107 | xor $acc05,$acc05,$s1 | ||
| 1108 | xor $acc06,$acc06,$s2 | ||
| 1109 | xor $acc07,$acc07,$s3 | ||
| 1110 | ___ | ||
| 1111 | $code.=<<___; | ||
| 1112 | rotrwi $s0,$s0,8 # = ROTATE(r0,8) | ||
| 1113 | rotrwi $s1,$s1,8 | ||
| 1114 | rotrwi $s2,$s2,8 | ||
| 1115 | rotrwi $s3,$s3,8 | ||
| 1116 | xor $s0,$s0,$acc00 # ^= r2^r0 | ||
| 1117 | xor $s1,$s1,$acc01 | ||
| 1118 | xor $s2,$s2,$acc02 | ||
| 1119 | xor $s3,$s3,$acc03 | ||
| 1120 | xor $acc00,$acc00,$acc08 | ||
| 1121 | xor $acc01,$acc01,$acc09 | ||
| 1122 | xor $acc02,$acc02,$acc10 | ||
| 1123 | xor $acc03,$acc03,$acc11 | ||
| 1124 | xor $s0,$s0,$acc04 # ^= r4^r0 | ||
| 1125 | xor $s1,$s1,$acc05 | ||
| 1126 | xor $s2,$s2,$acc06 | ||
| 1127 | xor $s3,$s3,$acc07 | ||
| 1128 | rotrwi $acc00,$acc00,24 | ||
| 1129 | rotrwi $acc01,$acc01,24 | ||
| 1130 | rotrwi $acc02,$acc02,24 | ||
| 1131 | rotrwi $acc03,$acc03,24 | ||
| 1132 | xor $acc04,$acc04,$acc08 | ||
| 1133 | xor $acc05,$acc05,$acc09 | ||
| 1134 | xor $acc06,$acc06,$acc10 | ||
| 1135 | xor $acc07,$acc07,$acc11 | ||
| 1136 | xor $s0,$s0,$acc08 # ^= r8 [^((r4^r0)^(r2^r0)=r4^r2)] | ||
| 1137 | xor $s1,$s1,$acc09 | ||
| 1138 | xor $s2,$s2,$acc10 | ||
| 1139 | xor $s3,$s3,$acc11 | ||
| 1140 | rotrwi $acc04,$acc04,16 | ||
| 1141 | rotrwi $acc05,$acc05,16 | ||
| 1142 | rotrwi $acc06,$acc06,16 | ||
| 1143 | rotrwi $acc07,$acc07,16 | ||
| 1144 | xor $s0,$s0,$acc00 # ^= ROTATE(r8^r2^r0,24) | ||
| 1145 | xor $s1,$s1,$acc01 | ||
| 1146 | xor $s2,$s2,$acc02 | ||
| 1147 | xor $s3,$s3,$acc03 | ||
| 1148 | rotrwi $acc08,$acc08,8 | ||
| 1149 | rotrwi $acc09,$acc09,8 | ||
| 1150 | rotrwi $acc10,$acc10,8 | ||
| 1151 | rotrwi $acc11,$acc11,8 | ||
| 1152 | xor $s0,$s0,$acc04 # ^= ROTATE(r8^r4^r0,16) | ||
| 1153 | xor $s1,$s1,$acc05 | ||
| 1154 | xor $s2,$s2,$acc06 | ||
| 1155 | xor $s3,$s3,$acc07 | ||
| 1156 | xor $s0,$s0,$acc08 # ^= ROTATE(r8,8) | ||
| 1157 | xor $s1,$s1,$acc09 | ||
| 1158 | xor $s2,$s2,$acc10 | ||
| 1159 | xor $s3,$s3,$acc11 | ||
| 1160 | |||
| 1161 | b Ldec_compact_loop | ||
| 1162 | .align 4 | ||
| 1163 | Ldec_compact_done: | ||
| 1164 | xor $s0,$s0,$t0 | ||
| 1165 | xor $s1,$s1,$t1 | ||
| 1166 | xor $s2,$s2,$t2 | ||
| 1167 | xor $s3,$s3,$t3 | ||
| 1168 | blr | ||
| 1169 | .long 0 | ||
| 1170 | .asciz "AES for PPC, CRYPTOGAMS by <appro\@openssl.org>" | ||
| 1171 | .align 7 | ||
| 1172 | ___ | ||
| 1173 | |||
| 1174 | $code =~ s/\`([^\`]*)\`/eval $1/gem; | ||
| 1175 | print $code; | ||
| 1176 | close STDOUT; | ||
diff --git a/src/lib/libssl/src/crypto/aes/asm/aes-s390x.pl b/src/lib/libssl/src/crypto/aes/asm/aes-s390x.pl new file mode 100644 index 0000000000..4b27afd92f --- /dev/null +++ b/src/lib/libssl/src/crypto/aes/asm/aes-s390x.pl | |||
| @@ -0,0 +1,1333 @@ | |||
| 1 | #!/usr/bin/env perl | ||
| 2 | |||
| 3 | # ==================================================================== | ||
| 4 | # Written by Andy Polyakov <appro@fy.chalmers.se> for the OpenSSL | ||
| 5 | # project. The module is, however, dual licensed under OpenSSL and | ||
| 6 | # CRYPTOGAMS licenses depending on where you obtain it. For further | ||
| 7 | # details see http://www.openssl.org/~appro/cryptogams/. | ||
| 8 | # ==================================================================== | ||
| 9 | |||
| 10 | # AES for s390x. | ||
| 11 | |||
| 12 | # April 2007. | ||
| 13 | # | ||
| 14 | # Software performance improvement over gcc-generated code is ~70% and | ||
| 15 | # in absolute terms is ~73 cycles per byte processed with 128-bit key. | ||
| 16 | # You're likely to exclaim "why so slow?" Keep in mind that z-CPUs are | ||
| 17 | # *strictly* in-order execution and issued instruction [in this case | ||
| 18 | # load value from memory is critical] has to complete before execution | ||
| 19 | # flow proceeds. S-boxes are compressed to 2KB[+256B]. | ||
| 20 | # | ||
| 21 | # As for hardware acceleration support. It's basically a "teaser," as | ||
| 22 | # it can and should be improved in several ways. Most notably support | ||
| 23 | # for CBC is not utilized, nor multiple blocks are ever processed. | ||
| 24 | # Then software key schedule can be postponed till hardware support | ||
| 25 | # detection... Performance improvement over assembler is reportedly | ||
| 26 | # ~2.5x, but can reach >8x [naturally on larger chunks] if proper | ||
| 27 | # support is implemented. | ||
| 28 | |||
| 29 | # May 2007. | ||
| 30 | # | ||
| 31 | # Implement AES_set_[en|de]crypt_key. Key schedule setup is avoided | ||
| 32 | # for 128-bit keys, if hardware support is detected. | ||
| 33 | |||
| 34 | # Januray 2009. | ||
| 35 | # | ||
| 36 | # Add support for hardware AES192/256 and reschedule instructions to | ||
| 37 | # minimize/avoid Address Generation Interlock hazard and to favour | ||
| 38 | # dual-issue z10 pipeline. This gave ~25% improvement on z10 and | ||
| 39 | # almost 50% on z9. The gain is smaller on z10, because being dual- | ||
| 40 | # issue z10 makes it improssible to eliminate the interlock condition: | ||
| 41 | # critial path is not long enough. Yet it spends ~24 cycles per byte | ||
| 42 | # processed with 128-bit key. | ||
| 43 | # | ||
| 44 | # Unlike previous version hardware support detection takes place only | ||
| 45 | # at the moment of key schedule setup, which is denoted in key->rounds. | ||
| 46 | # This is done, because deferred key setup can't be made MT-safe, not | ||
| 47 | # for key lengthes longer than 128 bits. | ||
| 48 | # | ||
| 49 | # Add AES_cbc_encrypt, which gives incredible performance improvement, | ||
| 50 | # it was measured to be ~6.6x. It's less than previously mentioned 8x, | ||
| 51 | # because software implementation was optimized. | ||
| 52 | |||
| 53 | $softonly=0; # allow hardware support | ||
| 54 | |||
| 55 | $t0="%r0"; $mask="%r0"; | ||
| 56 | $t1="%r1"; | ||
| 57 | $t2="%r2"; $inp="%r2"; | ||
| 58 | $t3="%r3"; $out="%r3"; $bits="%r3"; | ||
| 59 | $key="%r4"; | ||
| 60 | $i1="%r5"; | ||
| 61 | $i2="%r6"; | ||
| 62 | $i3="%r7"; | ||
| 63 | $s0="%r8"; | ||
| 64 | $s1="%r9"; | ||
| 65 | $s2="%r10"; | ||
| 66 | $s3="%r11"; | ||
| 67 | $tbl="%r12"; | ||
| 68 | $rounds="%r13"; | ||
| 69 | $ra="%r14"; | ||
| 70 | $sp="%r15"; | ||
| 71 | |||
| 72 | sub _data_word() | ||
| 73 | { my $i; | ||
| 74 | while(defined($i=shift)) { $code.=sprintf".long\t0x%08x,0x%08x\n",$i,$i; } | ||
| 75 | } | ||
| 76 | |||
| 77 | $code=<<___; | ||
| 78 | .text | ||
| 79 | |||
| 80 | .type AES_Te,\@object | ||
| 81 | .align 256 | ||
| 82 | AES_Te: | ||
| 83 | ___ | ||
| 84 | &_data_word( | ||
| 85 | 0xc66363a5, 0xf87c7c84, 0xee777799, 0xf67b7b8d, | ||
| 86 | 0xfff2f20d, 0xd66b6bbd, 0xde6f6fb1, 0x91c5c554, | ||
| 87 | 0x60303050, 0x02010103, 0xce6767a9, 0x562b2b7d, | ||
| 88 | 0xe7fefe19, 0xb5d7d762, 0x4dababe6, 0xec76769a, | ||
| 89 | 0x8fcaca45, 0x1f82829d, 0x89c9c940, 0xfa7d7d87, | ||
| 90 | 0xeffafa15, 0xb25959eb, 0x8e4747c9, 0xfbf0f00b, | ||
| 91 | 0x41adadec, 0xb3d4d467, 0x5fa2a2fd, 0x45afafea, | ||
| 92 | 0x239c9cbf, 0x53a4a4f7, 0xe4727296, 0x9bc0c05b, | ||
| 93 | 0x75b7b7c2, 0xe1fdfd1c, 0x3d9393ae, 0x4c26266a, | ||
| 94 | 0x6c36365a, 0x7e3f3f41, 0xf5f7f702, 0x83cccc4f, | ||
| 95 | 0x6834345c, 0x51a5a5f4, 0xd1e5e534, 0xf9f1f108, | ||
| 96 | 0xe2717193, 0xabd8d873, 0x62313153, 0x2a15153f, | ||
| 97 | 0x0804040c, 0x95c7c752, 0x46232365, 0x9dc3c35e, | ||
| 98 | 0x30181828, 0x379696a1, 0x0a05050f, 0x2f9a9ab5, | ||
| 99 | 0x0e070709, 0x24121236, 0x1b80809b, 0xdfe2e23d, | ||
| 100 | 0xcdebeb26, 0x4e272769, 0x7fb2b2cd, 0xea75759f, | ||
| 101 | 0x1209091b, 0x1d83839e, 0x582c2c74, 0x341a1a2e, | ||
| 102 | 0x361b1b2d, 0xdc6e6eb2, 0xb45a5aee, 0x5ba0a0fb, | ||
| 103 | 0xa45252f6, 0x763b3b4d, 0xb7d6d661, 0x7db3b3ce, | ||
| 104 | 0x5229297b, 0xdde3e33e, 0x5e2f2f71, 0x13848497, | ||
| 105 | 0xa65353f5, 0xb9d1d168, 0x00000000, 0xc1eded2c, | ||
| 106 | 0x40202060, 0xe3fcfc1f, 0x79b1b1c8, 0xb65b5bed, | ||
| 107 | 0xd46a6abe, 0x8dcbcb46, 0x67bebed9, 0x7239394b, | ||
| 108 | 0x944a4ade, 0x984c4cd4, 0xb05858e8, 0x85cfcf4a, | ||
| 109 | 0xbbd0d06b, 0xc5efef2a, 0x4faaaae5, 0xedfbfb16, | ||
| 110 | 0x864343c5, 0x9a4d4dd7, 0x66333355, 0x11858594, | ||
| 111 | 0x8a4545cf, 0xe9f9f910, 0x04020206, 0xfe7f7f81, | ||
| 112 | 0xa05050f0, 0x783c3c44, 0x259f9fba, 0x4ba8a8e3, | ||
| 113 | 0xa25151f3, 0x5da3a3fe, 0x804040c0, 0x058f8f8a, | ||
| 114 | 0x3f9292ad, 0x219d9dbc, 0x70383848, 0xf1f5f504, | ||
| 115 | 0x63bcbcdf, 0x77b6b6c1, 0xafdada75, 0x42212163, | ||
| 116 | 0x20101030, 0xe5ffff1a, 0xfdf3f30e, 0xbfd2d26d, | ||
| 117 | 0x81cdcd4c, 0x180c0c14, 0x26131335, 0xc3ecec2f, | ||
| 118 | 0xbe5f5fe1, 0x359797a2, 0x884444cc, 0x2e171739, | ||
| 119 | 0x93c4c457, 0x55a7a7f2, 0xfc7e7e82, 0x7a3d3d47, | ||
| 120 | 0xc86464ac, 0xba5d5de7, 0x3219192b, 0xe6737395, | ||
| 121 | 0xc06060a0, 0x19818198, 0x9e4f4fd1, 0xa3dcdc7f, | ||
| 122 | 0x44222266, 0x542a2a7e, 0x3b9090ab, 0x0b888883, | ||
| 123 | 0x8c4646ca, 0xc7eeee29, 0x6bb8b8d3, 0x2814143c, | ||
| 124 | 0xa7dede79, 0xbc5e5ee2, 0x160b0b1d, 0xaddbdb76, | ||
| 125 | 0xdbe0e03b, 0x64323256, 0x743a3a4e, 0x140a0a1e, | ||
| 126 | 0x924949db, 0x0c06060a, 0x4824246c, 0xb85c5ce4, | ||
| 127 | 0x9fc2c25d, 0xbdd3d36e, 0x43acacef, 0xc46262a6, | ||
| 128 | 0x399191a8, 0x319595a4, 0xd3e4e437, 0xf279798b, | ||
| 129 | 0xd5e7e732, 0x8bc8c843, 0x6e373759, 0xda6d6db7, | ||
| 130 | 0x018d8d8c, 0xb1d5d564, 0x9c4e4ed2, 0x49a9a9e0, | ||
| 131 | 0xd86c6cb4, 0xac5656fa, 0xf3f4f407, 0xcfeaea25, | ||
| 132 | 0xca6565af, 0xf47a7a8e, 0x47aeaee9, 0x10080818, | ||
| 133 | 0x6fbabad5, 0xf0787888, 0x4a25256f, 0x5c2e2e72, | ||
| 134 | 0x381c1c24, 0x57a6a6f1, 0x73b4b4c7, 0x97c6c651, | ||
| 135 | 0xcbe8e823, 0xa1dddd7c, 0xe874749c, 0x3e1f1f21, | ||
| 136 | 0x964b4bdd, 0x61bdbddc, 0x0d8b8b86, 0x0f8a8a85, | ||
| 137 | 0xe0707090, 0x7c3e3e42, 0x71b5b5c4, 0xcc6666aa, | ||
| 138 | 0x904848d8, 0x06030305, 0xf7f6f601, 0x1c0e0e12, | ||
| 139 | 0xc26161a3, 0x6a35355f, 0xae5757f9, 0x69b9b9d0, | ||
| 140 | 0x17868691, 0x99c1c158, 0x3a1d1d27, 0x279e9eb9, | ||
| 141 | 0xd9e1e138, 0xebf8f813, 0x2b9898b3, 0x22111133, | ||
| 142 | 0xd26969bb, 0xa9d9d970, 0x078e8e89, 0x339494a7, | ||
| 143 | 0x2d9b9bb6, 0x3c1e1e22, 0x15878792, 0xc9e9e920, | ||
| 144 | 0x87cece49, 0xaa5555ff, 0x50282878, 0xa5dfdf7a, | ||
| 145 | 0x038c8c8f, 0x59a1a1f8, 0x09898980, 0x1a0d0d17, | ||
| 146 | 0x65bfbfda, 0xd7e6e631, 0x844242c6, 0xd06868b8, | ||
| 147 | 0x824141c3, 0x299999b0, 0x5a2d2d77, 0x1e0f0f11, | ||
| 148 | 0x7bb0b0cb, 0xa85454fc, 0x6dbbbbd6, 0x2c16163a); | ||
| 149 | $code.=<<___; | ||
| 150 | # Te4[256] | ||
| 151 | .byte 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5 | ||
| 152 | .byte 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76 | ||
| 153 | .byte 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0 | ||
| 154 | .byte 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0 | ||
| 155 | .byte 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc | ||
| 156 | .byte 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15 | ||
| 157 | .byte 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a | ||
| 158 | .byte 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75 | ||
| 159 | .byte 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0 | ||
| 160 | .byte 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84 | ||
| 161 | .byte 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b | ||
| 162 | .byte 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf | ||
| 163 | .byte 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85 | ||
| 164 | .byte 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8 | ||
| 165 | .byte 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5 | ||
| 166 | .byte 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2 | ||
| 167 | .byte 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17 | ||
| 168 | .byte 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73 | ||
| 169 | .byte 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88 | ||
| 170 | .byte 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb | ||
| 171 | .byte 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c | ||
| 172 | .byte 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79 | ||
| 173 | .byte 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9 | ||
| 174 | .byte 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08 | ||
| 175 | .byte 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6 | ||
| 176 | .byte 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a | ||
| 177 | .byte 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e | ||
| 178 | .byte 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e | ||
| 179 | .byte 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94 | ||
| 180 | .byte 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf | ||
| 181 | .byte 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68 | ||
| 182 | .byte 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 | ||
| 183 | # rcon[] | ||
| 184 | .long 0x01000000, 0x02000000, 0x04000000, 0x08000000 | ||
| 185 | .long 0x10000000, 0x20000000, 0x40000000, 0x80000000 | ||
| 186 | .long 0x1B000000, 0x36000000, 0, 0, 0, 0, 0, 0 | ||
| 187 | .align 256 | ||
| 188 | .size AES_Te,.-AES_Te | ||
| 189 | |||
| 190 | # void AES_encrypt(const unsigned char *inp, unsigned char *out, | ||
| 191 | # const AES_KEY *key) { | ||
| 192 | .globl AES_encrypt | ||
| 193 | .type AES_encrypt,\@function | ||
| 194 | AES_encrypt: | ||
| 195 | ___ | ||
| 196 | $code.=<<___ if (!$softonly); | ||
| 197 | l %r0,240($key) | ||
| 198 | lhi %r1,16 | ||
| 199 | clr %r0,%r1 | ||
| 200 | jl .Lesoft | ||
| 201 | |||
| 202 | la %r1,0($key) | ||
| 203 | #la %r2,0($inp) | ||
| 204 | la %r4,0($out) | ||
| 205 | lghi %r3,16 # single block length | ||
| 206 | .long 0xb92e0042 # km %r4,%r2 | ||
| 207 | brc 1,.-4 # can this happen? | ||
| 208 | br %r14 | ||
| 209 | .align 64 | ||
| 210 | .Lesoft: | ||
| 211 | ___ | ||
| 212 | $code.=<<___; | ||
| 213 | stmg %r3,$ra,24($sp) | ||
| 214 | |||
| 215 | llgf $s0,0($inp) | ||
| 216 | llgf $s1,4($inp) | ||
| 217 | llgf $s2,8($inp) | ||
| 218 | llgf $s3,12($inp) | ||
| 219 | |||
| 220 | larl $tbl,AES_Te | ||
| 221 | bras $ra,_s390x_AES_encrypt | ||
| 222 | |||
| 223 | lg $out,24($sp) | ||
| 224 | st $s0,0($out) | ||
| 225 | st $s1,4($out) | ||
| 226 | st $s2,8($out) | ||
| 227 | st $s3,12($out) | ||
| 228 | |||
| 229 | lmg %r6,$ra,48($sp) | ||
| 230 | br $ra | ||
| 231 | .size AES_encrypt,.-AES_encrypt | ||
| 232 | |||
| 233 | .type _s390x_AES_encrypt,\@function | ||
| 234 | .align 16 | ||
| 235 | _s390x_AES_encrypt: | ||
| 236 | stg $ra,152($sp) | ||
| 237 | x $s0,0($key) | ||
| 238 | x $s1,4($key) | ||
| 239 | x $s2,8($key) | ||
| 240 | x $s3,12($key) | ||
| 241 | l $rounds,240($key) | ||
| 242 | llill $mask,`0xff<<3` | ||
| 243 | aghi $rounds,-1 | ||
| 244 | j .Lenc_loop | ||
| 245 | .align 16 | ||
| 246 | .Lenc_loop: | ||
| 247 | sllg $t1,$s0,`0+3` | ||
| 248 | srlg $t2,$s0,`8-3` | ||
| 249 | srlg $t3,$s0,`16-3` | ||
| 250 | srl $s0,`24-3` | ||
| 251 | nr $s0,$mask | ||
| 252 | ngr $t1,$mask | ||
| 253 | nr $t2,$mask | ||
| 254 | nr $t3,$mask | ||
| 255 | |||
| 256 | srlg $i1,$s1,`16-3` # i0 | ||
| 257 | sllg $i2,$s1,`0+3` | ||
| 258 | srlg $i3,$s1,`8-3` | ||
| 259 | srl $s1,`24-3` | ||
| 260 | nr $i1,$mask | ||
| 261 | nr $s1,$mask | ||
| 262 | ngr $i2,$mask | ||
| 263 | nr $i3,$mask | ||
| 264 | |||
| 265 | l $s0,0($s0,$tbl) # Te0[s0>>24] | ||
| 266 | l $t1,1($t1,$tbl) # Te3[s0>>0] | ||
| 267 | l $t2,2($t2,$tbl) # Te2[s0>>8] | ||
| 268 | l $t3,3($t3,$tbl) # Te1[s0>>16] | ||
| 269 | |||
| 270 | x $s0,3($i1,$tbl) # Te1[s1>>16] | ||
| 271 | l $s1,0($s1,$tbl) # Te0[s1>>24] | ||
| 272 | x $t2,1($i2,$tbl) # Te3[s1>>0] | ||
| 273 | x $t3,2($i3,$tbl) # Te2[s1>>8] | ||
| 274 | |||
| 275 | srlg $i1,$s2,`8-3` # i0 | ||
| 276 | srlg $i2,$s2,`16-3` # i1 | ||
| 277 | nr $i1,$mask | ||
| 278 | nr $i2,$mask | ||
| 279 | sllg $i3,$s2,`0+3` | ||
| 280 | srl $s2,`24-3` | ||
| 281 | nr $s2,$mask | ||
| 282 | ngr $i3,$mask | ||
| 283 | |||
| 284 | xr $s1,$t1 | ||
| 285 | srlg $ra,$s3,`8-3` # i1 | ||
| 286 | sllg $t1,$s3,`0+3` # i0 | ||
| 287 | nr $ra,$mask | ||
| 288 | la $key,16($key) | ||
| 289 | ngr $t1,$mask | ||
| 290 | |||
| 291 | x $s0,2($i1,$tbl) # Te2[s2>>8] | ||
| 292 | x $s1,3($i2,$tbl) # Te1[s2>>16] | ||
| 293 | l $s2,0($s2,$tbl) # Te0[s2>>24] | ||
| 294 | x $t3,1($i3,$tbl) # Te3[s2>>0] | ||
| 295 | |||
| 296 | srlg $i3,$s3,`16-3` # i2 | ||
| 297 | xr $s2,$t2 | ||
| 298 | srl $s3,`24-3` | ||
| 299 | nr $i3,$mask | ||
| 300 | nr $s3,$mask | ||
| 301 | |||
| 302 | x $s0,0($key) | ||
| 303 | x $s1,4($key) | ||
| 304 | x $s2,8($key) | ||
| 305 | x $t3,12($key) | ||
| 306 | |||
| 307 | x $s0,1($t1,$tbl) # Te3[s3>>0] | ||
| 308 | x $s1,2($ra,$tbl) # Te2[s3>>8] | ||
| 309 | x $s2,3($i3,$tbl) # Te1[s3>>16] | ||
| 310 | l $s3,0($s3,$tbl) # Te0[s3>>24] | ||
| 311 | xr $s3,$t3 | ||
| 312 | |||
| 313 | brct $rounds,.Lenc_loop | ||
| 314 | .align 16 | ||
| 315 | |||
| 316 | sllg $t1,$s0,`0+3` | ||
| 317 | srlg $t2,$s0,`8-3` | ||
| 318 | ngr $t1,$mask | ||
| 319 | srlg $t3,$s0,`16-3` | ||
| 320 | srl $s0,`24-3` | ||
| 321 | nr $s0,$mask | ||
| 322 | nr $t2,$mask | ||
| 323 | nr $t3,$mask | ||
| 324 | |||
| 325 | srlg $i1,$s1,`16-3` # i0 | ||
| 326 | sllg $i2,$s1,`0+3` | ||
| 327 | ngr $i2,$mask | ||
| 328 | srlg $i3,$s1,`8-3` | ||
| 329 | srl $s1,`24-3` | ||
| 330 | nr $i1,$mask | ||
| 331 | nr $s1,$mask | ||
| 332 | nr $i3,$mask | ||
| 333 | |||
| 334 | llgc $s0,2($s0,$tbl) # Te4[s0>>24] | ||
| 335 | llgc $t1,2($t1,$tbl) # Te4[s0>>0] | ||
| 336 | sll $s0,24 | ||
| 337 | llgc $t2,2($t2,$tbl) # Te4[s0>>8] | ||
| 338 | llgc $t3,2($t3,$tbl) # Te4[s0>>16] | ||
| 339 | sll $t2,8 | ||
| 340 | sll $t3,16 | ||
| 341 | |||
| 342 | llgc $i1,2($i1,$tbl) # Te4[s1>>16] | ||
| 343 | llgc $s1,2($s1,$tbl) # Te4[s1>>24] | ||
| 344 | llgc $i2,2($i2,$tbl) # Te4[s1>>0] | ||
| 345 | llgc $i3,2($i3,$tbl) # Te4[s1>>8] | ||
| 346 | sll $i1,16 | ||
| 347 | sll $s1,24 | ||
| 348 | sll $i3,8 | ||
| 349 | or $s0,$i1 | ||
| 350 | or $s1,$t1 | ||
| 351 | or $t2,$i2 | ||
| 352 | or $t3,$i3 | ||
| 353 | |||
| 354 | srlg $i1,$s2,`8-3` # i0 | ||
| 355 | srlg $i2,$s2,`16-3` # i1 | ||
| 356 | nr $i1,$mask | ||
| 357 | nr $i2,$mask | ||
| 358 | sllg $i3,$s2,`0+3` | ||
| 359 | srl $s2,`24-3` | ||
| 360 | ngr $i3,$mask | ||
| 361 | nr $s2,$mask | ||
| 362 | |||
| 363 | sllg $t1,$s3,`0+3` # i0 | ||
| 364 | srlg $ra,$s3,`8-3` # i1 | ||
| 365 | ngr $t1,$mask | ||
| 366 | |||
| 367 | llgc $i1,2($i1,$tbl) # Te4[s2>>8] | ||
| 368 | llgc $i2,2($i2,$tbl) # Te4[s2>>16] | ||
| 369 | sll $i1,8 | ||
| 370 | llgc $s2,2($s2,$tbl) # Te4[s2>>24] | ||
| 371 | llgc $i3,2($i3,$tbl) # Te4[s2>>0] | ||
| 372 | sll $i2,16 | ||
| 373 | nr $ra,$mask | ||
| 374 | sll $s2,24 | ||
| 375 | or $s0,$i1 | ||
| 376 | or $s1,$i2 | ||
| 377 | or $s2,$t2 | ||
| 378 | or $t3,$i3 | ||
| 379 | |||
| 380 | srlg $i3,$s3,`16-3` # i2 | ||
| 381 | srl $s3,`24-3` | ||
| 382 | nr $i3,$mask | ||
| 383 | nr $s3,$mask | ||
| 384 | |||
| 385 | l $t0,16($key) | ||
| 386 | l $t2,20($key) | ||
| 387 | |||
| 388 | llgc $i1,2($t1,$tbl) # Te4[s3>>0] | ||
| 389 | llgc $i2,2($ra,$tbl) # Te4[s3>>8] | ||
| 390 | llgc $i3,2($i3,$tbl) # Te4[s3>>16] | ||
| 391 | llgc $s3,2($s3,$tbl) # Te4[s3>>24] | ||
| 392 | sll $i2,8 | ||
| 393 | sll $i3,16 | ||
| 394 | sll $s3,24 | ||
| 395 | or $s0,$i1 | ||
| 396 | or $s1,$i2 | ||
| 397 | or $s2,$i3 | ||
| 398 | or $s3,$t3 | ||
| 399 | |||
| 400 | lg $ra,152($sp) | ||
| 401 | xr $s0,$t0 | ||
| 402 | xr $s1,$t2 | ||
| 403 | x $s2,24($key) | ||
| 404 | x $s3,28($key) | ||
| 405 | |||
| 406 | br $ra | ||
| 407 | .size _s390x_AES_encrypt,.-_s390x_AES_encrypt | ||
| 408 | ___ | ||
| 409 | |||
| 410 | $code.=<<___; | ||
| 411 | .type AES_Td,\@object | ||
| 412 | .align 256 | ||
| 413 | AES_Td: | ||
| 414 | ___ | ||
| 415 | &_data_word( | ||
| 416 | 0x51f4a750, 0x7e416553, 0x1a17a4c3, 0x3a275e96, | ||
| 417 | 0x3bab6bcb, 0x1f9d45f1, 0xacfa58ab, 0x4be30393, | ||
| 418 | 0x2030fa55, 0xad766df6, 0x88cc7691, 0xf5024c25, | ||
| 419 | 0x4fe5d7fc, 0xc52acbd7, 0x26354480, 0xb562a38f, | ||
| 420 | 0xdeb15a49, 0x25ba1b67, 0x45ea0e98, 0x5dfec0e1, | ||
| 421 | 0xc32f7502, 0x814cf012, 0x8d4697a3, 0x6bd3f9c6, | ||
| 422 | 0x038f5fe7, 0x15929c95, 0xbf6d7aeb, 0x955259da, | ||
| 423 | 0xd4be832d, 0x587421d3, 0x49e06929, 0x8ec9c844, | ||
| 424 | 0x75c2896a, 0xf48e7978, 0x99583e6b, 0x27b971dd, | ||
| 425 | 0xbee14fb6, 0xf088ad17, 0xc920ac66, 0x7dce3ab4, | ||
| 426 | 0x63df4a18, 0xe51a3182, 0x97513360, 0x62537f45, | ||
| 427 | 0xb16477e0, 0xbb6bae84, 0xfe81a01c, 0xf9082b94, | ||
| 428 | 0x70486858, 0x8f45fd19, 0x94de6c87, 0x527bf8b7, | ||
| 429 | 0xab73d323, 0x724b02e2, 0xe31f8f57, 0x6655ab2a, | ||
| 430 | 0xb2eb2807, 0x2fb5c203, 0x86c57b9a, 0xd33708a5, | ||
| 431 | 0x302887f2, 0x23bfa5b2, 0x02036aba, 0xed16825c, | ||
| 432 | 0x8acf1c2b, 0xa779b492, 0xf307f2f0, 0x4e69e2a1, | ||
| 433 | 0x65daf4cd, 0x0605bed5, 0xd134621f, 0xc4a6fe8a, | ||
| 434 | 0x342e539d, 0xa2f355a0, 0x058ae132, 0xa4f6eb75, | ||
| 435 | 0x0b83ec39, 0x4060efaa, 0x5e719f06, 0xbd6e1051, | ||
| 436 | 0x3e218af9, 0x96dd063d, 0xdd3e05ae, 0x4de6bd46, | ||
| 437 | 0x91548db5, 0x71c45d05, 0x0406d46f, 0x605015ff, | ||
| 438 | 0x1998fb24, 0xd6bde997, 0x894043cc, 0x67d99e77, | ||
| 439 | 0xb0e842bd, 0x07898b88, 0xe7195b38, 0x79c8eedb, | ||
| 440 | 0xa17c0a47, 0x7c420fe9, 0xf8841ec9, 0x00000000, | ||
| 441 | 0x09808683, 0x322bed48, 0x1e1170ac, 0x6c5a724e, | ||
| 442 | 0xfd0efffb, 0x0f853856, 0x3daed51e, 0x362d3927, | ||
| 443 | 0x0a0fd964, 0x685ca621, 0x9b5b54d1, 0x24362e3a, | ||
| 444 | 0x0c0a67b1, 0x9357e70f, 0xb4ee96d2, 0x1b9b919e, | ||
| 445 | 0x80c0c54f, 0x61dc20a2, 0x5a774b69, 0x1c121a16, | ||
| 446 | 0xe293ba0a, 0xc0a02ae5, 0x3c22e043, 0x121b171d, | ||
| 447 | 0x0e090d0b, 0xf28bc7ad, 0x2db6a8b9, 0x141ea9c8, | ||
| 448 | 0x57f11985, 0xaf75074c, 0xee99ddbb, 0xa37f60fd, | ||
| 449 | 0xf701269f, 0x5c72f5bc, 0x44663bc5, 0x5bfb7e34, | ||
| 450 | 0x8b432976, 0xcb23c6dc, 0xb6edfc68, 0xb8e4f163, | ||
| 451 | 0xd731dcca, 0x42638510, 0x13972240, 0x84c61120, | ||
| 452 | 0x854a247d, 0xd2bb3df8, 0xaef93211, 0xc729a16d, | ||
| 453 | 0x1d9e2f4b, 0xdcb230f3, 0x0d8652ec, 0x77c1e3d0, | ||
| 454 | 0x2bb3166c, 0xa970b999, 0x119448fa, 0x47e96422, | ||
| 455 | 0xa8fc8cc4, 0xa0f03f1a, 0x567d2cd8, 0x223390ef, | ||
| 456 | 0x87494ec7, 0xd938d1c1, 0x8ccaa2fe, 0x98d40b36, | ||
| 457 | 0xa6f581cf, 0xa57ade28, 0xdab78e26, 0x3fadbfa4, | ||
| 458 | 0x2c3a9de4, 0x5078920d, 0x6a5fcc9b, 0x547e4662, | ||
| 459 | 0xf68d13c2, 0x90d8b8e8, 0x2e39f75e, 0x82c3aff5, | ||
| 460 | 0x9f5d80be, 0x69d0937c, 0x6fd52da9, 0xcf2512b3, | ||
| 461 | 0xc8ac993b, 0x10187da7, 0xe89c636e, 0xdb3bbb7b, | ||
| 462 | 0xcd267809, 0x6e5918f4, 0xec9ab701, 0x834f9aa8, | ||
| 463 | 0xe6956e65, 0xaaffe67e, 0x21bccf08, 0xef15e8e6, | ||
| 464 | 0xbae79bd9, 0x4a6f36ce, 0xea9f09d4, 0x29b07cd6, | ||
| 465 | 0x31a4b2af, 0x2a3f2331, 0xc6a59430, 0x35a266c0, | ||
| 466 | 0x744ebc37, 0xfc82caa6, 0xe090d0b0, 0x33a7d815, | ||
| 467 | 0xf104984a, 0x41ecdaf7, 0x7fcd500e, 0x1791f62f, | ||
| 468 | 0x764dd68d, 0x43efb04d, 0xccaa4d54, 0xe49604df, | ||
| 469 | 0x9ed1b5e3, 0x4c6a881b, 0xc12c1fb8, 0x4665517f, | ||
| 470 | 0x9d5eea04, 0x018c355d, 0xfa877473, 0xfb0b412e, | ||
| 471 | 0xb3671d5a, 0x92dbd252, 0xe9105633, 0x6dd64713, | ||
| 472 | 0x9ad7618c, 0x37a10c7a, 0x59f8148e, 0xeb133c89, | ||
| 473 | 0xcea927ee, 0xb761c935, 0xe11ce5ed, 0x7a47b13c, | ||
| 474 | 0x9cd2df59, 0x55f2733f, 0x1814ce79, 0x73c737bf, | ||
| 475 | 0x53f7cdea, 0x5ffdaa5b, 0xdf3d6f14, 0x7844db86, | ||
| 476 | 0xcaaff381, 0xb968c43e, 0x3824342c, 0xc2a3405f, | ||
| 477 | 0x161dc372, 0xbce2250c, 0x283c498b, 0xff0d9541, | ||
| 478 | 0x39a80171, 0x080cb3de, 0xd8b4e49c, 0x6456c190, | ||
| 479 | 0x7bcb8461, 0xd532b670, 0x486c5c74, 0xd0b85742); | ||
| 480 | $code.=<<___; | ||
| 481 | # Td4[256] | ||
| 482 | .byte 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38 | ||
| 483 | .byte 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb | ||
| 484 | .byte 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87 | ||
| 485 | .byte 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb | ||
| 486 | .byte 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d | ||
| 487 | .byte 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e | ||
| 488 | .byte 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2 | ||
| 489 | .byte 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25 | ||
| 490 | .byte 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16 | ||
| 491 | .byte 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92 | ||
| 492 | .byte 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda | ||
| 493 | .byte 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84 | ||
| 494 | .byte 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a | ||
| 495 | .byte 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06 | ||
| 496 | .byte 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02 | ||
| 497 | .byte 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b | ||
| 498 | .byte 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea | ||
| 499 | .byte 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73 | ||
| 500 | .byte 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85 | ||
| 501 | .byte 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e | ||
| 502 | .byte 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89 | ||
| 503 | .byte 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b | ||
| 504 | .byte 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20 | ||
| 505 | .byte 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4 | ||
| 506 | .byte 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31 | ||
| 507 | .byte 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f | ||
| 508 | .byte 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d | ||
| 509 | .byte 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef | ||
| 510 | .byte 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0 | ||
| 511 | .byte 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61 | ||
| 512 | .byte 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26 | ||
| 513 | .byte 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d | ||
| 514 | .size AES_Td,.-AES_Td | ||
| 515 | |||
| 516 | # void AES_decrypt(const unsigned char *inp, unsigned char *out, | ||
| 517 | # const AES_KEY *key) { | ||
| 518 | .globl AES_decrypt | ||
| 519 | .type AES_decrypt,\@function | ||
| 520 | AES_decrypt: | ||
| 521 | ___ | ||
| 522 | $code.=<<___ if (!$softonly); | ||
| 523 | l %r0,240($key) | ||
| 524 | lhi %r1,16 | ||
| 525 | clr %r0,%r1 | ||
| 526 | jl .Ldsoft | ||
| 527 | |||
| 528 | la %r1,0($key) | ||
| 529 | #la %r2,0($inp) | ||
| 530 | la %r4,0($out) | ||
| 531 | lghi %r3,16 # single block length | ||
| 532 | .long 0xb92e0042 # km %r4,%r2 | ||
| 533 | brc 1,.-4 # can this happen? | ||
| 534 | br %r14 | ||
| 535 | .align 64 | ||
| 536 | .Ldsoft: | ||
| 537 | ___ | ||
| 538 | $code.=<<___; | ||
| 539 | stmg %r3,$ra,24($sp) | ||
| 540 | |||
| 541 | llgf $s0,0($inp) | ||
| 542 | llgf $s1,4($inp) | ||
| 543 | llgf $s2,8($inp) | ||
| 544 | llgf $s3,12($inp) | ||
| 545 | |||
| 546 | larl $tbl,AES_Td | ||
| 547 | bras $ra,_s390x_AES_decrypt | ||
| 548 | |||
| 549 | lg $out,24($sp) | ||
| 550 | st $s0,0($out) | ||
| 551 | st $s1,4($out) | ||
| 552 | st $s2,8($out) | ||
| 553 | st $s3,12($out) | ||
| 554 | |||
| 555 | lmg %r6,$ra,48($sp) | ||
| 556 | br $ra | ||
| 557 | .size AES_decrypt,.-AES_decrypt | ||
| 558 | |||
| 559 | .type _s390x_AES_decrypt,\@function | ||
| 560 | .align 16 | ||
| 561 | _s390x_AES_decrypt: | ||
| 562 | stg $ra,152($sp) | ||
| 563 | x $s0,0($key) | ||
| 564 | x $s1,4($key) | ||
| 565 | x $s2,8($key) | ||
| 566 | x $s3,12($key) | ||
| 567 | l $rounds,240($key) | ||
| 568 | llill $mask,`0xff<<3` | ||
| 569 | aghi $rounds,-1 | ||
| 570 | j .Ldec_loop | ||
| 571 | .align 16 | ||
| 572 | .Ldec_loop: | ||
| 573 | srlg $t1,$s0,`16-3` | ||
| 574 | srlg $t2,$s0,`8-3` | ||
| 575 | sllg $t3,$s0,`0+3` | ||
| 576 | srl $s0,`24-3` | ||
| 577 | nr $s0,$mask | ||
| 578 | nr $t1,$mask | ||
| 579 | nr $t2,$mask | ||
| 580 | ngr $t3,$mask | ||
| 581 | |||
| 582 | sllg $i1,$s1,`0+3` # i0 | ||
| 583 | srlg $i2,$s1,`16-3` | ||
| 584 | srlg $i3,$s1,`8-3` | ||
| 585 | srl $s1,`24-3` | ||
| 586 | ngr $i1,$mask | ||
| 587 | nr $s1,$mask | ||
| 588 | nr $i2,$mask | ||
| 589 | nr $i3,$mask | ||
| 590 | |||
| 591 | l $s0,0($s0,$tbl) # Td0[s0>>24] | ||
| 592 | l $t1,3($t1,$tbl) # Td1[s0>>16] | ||
| 593 | l $t2,2($t2,$tbl) # Td2[s0>>8] | ||
| 594 | l $t3,1($t3,$tbl) # Td3[s0>>0] | ||
| 595 | |||
| 596 | x $s0,1($i1,$tbl) # Td3[s1>>0] | ||
| 597 | l $s1,0($s1,$tbl) # Td0[s1>>24] | ||
| 598 | x $t2,3($i2,$tbl) # Td1[s1>>16] | ||
| 599 | x $t3,2($i3,$tbl) # Td2[s1>>8] | ||
| 600 | |||
| 601 | srlg $i1,$s2,`8-3` # i0 | ||
| 602 | sllg $i2,$s2,`0+3` # i1 | ||
| 603 | srlg $i3,$s2,`16-3` | ||
| 604 | srl $s2,`24-3` | ||
| 605 | nr $i1,$mask | ||
| 606 | ngr $i2,$mask | ||
| 607 | nr $s2,$mask | ||
| 608 | nr $i3,$mask | ||
| 609 | |||
| 610 | xr $s1,$t1 | ||
| 611 | srlg $ra,$s3,`8-3` # i1 | ||
| 612 | srlg $t1,$s3,`16-3` # i0 | ||
| 613 | nr $ra,$mask | ||
| 614 | la $key,16($key) | ||
| 615 | nr $t1,$mask | ||
| 616 | |||
| 617 | x $s0,2($i1,$tbl) # Td2[s2>>8] | ||
| 618 | x $s1,1($i2,$tbl) # Td3[s2>>0] | ||
| 619 | l $s2,0($s2,$tbl) # Td0[s2>>24] | ||
| 620 | x $t3,3($i3,$tbl) # Td1[s2>>16] | ||
| 621 | |||
| 622 | sllg $i3,$s3,`0+3` # i2 | ||
| 623 | srl $s3,`24-3` | ||
| 624 | ngr $i3,$mask | ||
| 625 | nr $s3,$mask | ||
| 626 | |||
| 627 | xr $s2,$t2 | ||
| 628 | x $s0,0($key) | ||
| 629 | x $s1,4($key) | ||
| 630 | x $s2,8($key) | ||
| 631 | x $t3,12($key) | ||
| 632 | |||
| 633 | x $s0,3($t1,$tbl) # Td1[s3>>16] | ||
| 634 | x $s1,2($ra,$tbl) # Td2[s3>>8] | ||
| 635 | x $s2,1($i3,$tbl) # Td3[s3>>0] | ||
| 636 | l $s3,0($s3,$tbl) # Td0[s3>>24] | ||
| 637 | xr $s3,$t3 | ||
| 638 | |||
| 639 | brct $rounds,.Ldec_loop | ||
| 640 | .align 16 | ||
| 641 | |||
| 642 | l $t1,`2048+0`($tbl) # prefetch Td4 | ||
| 643 | l $t2,`2048+64`($tbl) | ||
| 644 | l $t3,`2048+128`($tbl) | ||
| 645 | l $i1,`2048+192`($tbl) | ||
| 646 | llill $mask,0xff | ||
| 647 | |||
| 648 | srlg $i3,$s0,24 # i0 | ||
| 649 | srlg $t1,$s0,16 | ||
| 650 | srlg $t2,$s0,8 | ||
| 651 | nr $s0,$mask # i3 | ||
| 652 | nr $t1,$mask | ||
| 653 | |||
| 654 | srlg $i1,$s1,24 | ||
| 655 | nr $t2,$mask | ||
| 656 | srlg $i2,$s1,16 | ||
| 657 | srlg $ra,$s1,8 | ||
| 658 | nr $s1,$mask # i0 | ||
| 659 | nr $i2,$mask | ||
| 660 | nr $ra,$mask | ||
| 661 | |||
| 662 | llgc $i3,2048($i3,$tbl) # Td4[s0>>24] | ||
| 663 | llgc $t1,2048($t1,$tbl) # Td4[s0>>16] | ||
| 664 | llgc $t2,2048($t2,$tbl) # Td4[s0>>8] | ||
| 665 | sll $t1,16 | ||
| 666 | llgc $t3,2048($s0,$tbl) # Td4[s0>>0] | ||
| 667 | sllg $s0,$i3,24 | ||
| 668 | sll $t2,8 | ||
| 669 | |||
| 670 | llgc $s1,2048($s1,$tbl) # Td4[s1>>0] | ||
| 671 | llgc $i1,2048($i1,$tbl) # Td4[s1>>24] | ||
| 672 | llgc $i2,2048($i2,$tbl) # Td4[s1>>16] | ||
| 673 | sll $i1,24 | ||
| 674 | llgc $i3,2048($ra,$tbl) # Td4[s1>>8] | ||
| 675 | sll $i2,16 | ||
| 676 | sll $i3,8 | ||
| 677 | or $s0,$s1 | ||
| 678 | or $t1,$i1 | ||
| 679 | or $t2,$i2 | ||
| 680 | or $t3,$i3 | ||
| 681 | |||
| 682 | srlg $i1,$s2,8 # i0 | ||
| 683 | srlg $i2,$s2,24 | ||
| 684 | srlg $i3,$s2,16 | ||
| 685 | nr $s2,$mask # i1 | ||
| 686 | nr $i1,$mask | ||
| 687 | nr $i3,$mask | ||
| 688 | llgc $i1,2048($i1,$tbl) # Td4[s2>>8] | ||
| 689 | llgc $s1,2048($s2,$tbl) # Td4[s2>>0] | ||
| 690 | llgc $i2,2048($i2,$tbl) # Td4[s2>>24] | ||
| 691 | llgc $i3,2048($i3,$tbl) # Td4[s2>>16] | ||
| 692 | sll $i1,8 | ||
| 693 | sll $i2,24 | ||
| 694 | or $s0,$i1 | ||
| 695 | sll $i3,16 | ||
| 696 | or $t2,$i2 | ||
| 697 | or $t3,$i3 | ||
| 698 | |||
| 699 | srlg $i1,$s3,16 # i0 | ||
| 700 | srlg $i2,$s3,8 # i1 | ||
| 701 | srlg $i3,$s3,24 | ||
| 702 | nr $s3,$mask # i2 | ||
| 703 | nr $i1,$mask | ||
| 704 | nr $i2,$mask | ||
| 705 | |||
| 706 | lg $ra,152($sp) | ||
| 707 | or $s1,$t1 | ||
| 708 | l $t0,16($key) | ||
| 709 | l $t1,20($key) | ||
| 710 | |||
| 711 | llgc $i1,2048($i1,$tbl) # Td4[s3>>16] | ||
| 712 | llgc $i2,2048($i2,$tbl) # Td4[s3>>8] | ||
| 713 | sll $i1,16 | ||
| 714 | llgc $s2,2048($s3,$tbl) # Td4[s3>>0] | ||
| 715 | llgc $s3,2048($i3,$tbl) # Td4[s3>>24] | ||
| 716 | sll $i2,8 | ||
| 717 | sll $s3,24 | ||
| 718 | or $s0,$i1 | ||
| 719 | or $s1,$i2 | ||
| 720 | or $s2,$t2 | ||
| 721 | or $s3,$t3 | ||
| 722 | |||
| 723 | xr $s0,$t0 | ||
| 724 | xr $s1,$t1 | ||
| 725 | x $s2,24($key) | ||
| 726 | x $s3,28($key) | ||
| 727 | |||
| 728 | br $ra | ||
| 729 | .size _s390x_AES_decrypt,.-_s390x_AES_decrypt | ||
| 730 | ___ | ||
| 731 | |||
| 732 | $code.=<<___; | ||
| 733 | # void AES_set_encrypt_key(const unsigned char *in, int bits, | ||
| 734 | # AES_KEY *key) { | ||
| 735 | .globl AES_set_encrypt_key | ||
| 736 | .type AES_set_encrypt_key,\@function | ||
| 737 | .align 16 | ||
| 738 | AES_set_encrypt_key: | ||
| 739 | lghi $t0,0 | ||
| 740 | clgr $inp,$t0 | ||
| 741 | je .Lminus1 | ||
| 742 | clgr $key,$t0 | ||
| 743 | je .Lminus1 | ||
| 744 | |||
| 745 | lghi $t0,128 | ||
| 746 | clr $bits,$t0 | ||
| 747 | je .Lproceed | ||
| 748 | lghi $t0,192 | ||
| 749 | clr $bits,$t0 | ||
| 750 | je .Lproceed | ||
| 751 | lghi $t0,256 | ||
| 752 | clr $bits,$t0 | ||
| 753 | je .Lproceed | ||
| 754 | lghi %r2,-2 | ||
| 755 | br %r14 | ||
| 756 | |||
| 757 | .align 16 | ||
| 758 | .Lproceed: | ||
| 759 | ___ | ||
| 760 | $code.=<<___ if (!$softonly); | ||
| 761 | # convert bits to km code, [128,192,256]->[18,19,20] | ||
| 762 | lhi %r5,-128 | ||
| 763 | lhi %r0,18 | ||
| 764 | ar %r5,$bits | ||
| 765 | srl %r5,6 | ||
| 766 | ar %r5,%r0 | ||
| 767 | |||
| 768 | lghi %r0,0 # query capability vector | ||
| 769 | la %r1,16($sp) | ||
| 770 | .long 0xb92f0042 # kmc %r4,%r2 | ||
| 771 | |||
| 772 | llihh %r1,0x8000 | ||
| 773 | srlg %r1,%r1,0(%r5) | ||
| 774 | ng %r1,16($sp) | ||
| 775 | jz .Lekey_internal | ||
| 776 | |||
| 777 | lmg %r0,%r1,0($inp) # just copy 128 bits... | ||
| 778 | stmg %r0,%r1,0($key) | ||
| 779 | lhi %r0,192 | ||
| 780 | cr $bits,%r0 | ||
| 781 | jl 1f | ||
| 782 | lg %r1,16($inp) | ||
| 783 | stg %r1,16($key) | ||
| 784 | je 1f | ||
| 785 | lg %r1,24($inp) | ||
| 786 | stg %r1,24($key) | ||
| 787 | 1: st $bits,236($key) # save bits | ||
| 788 | st %r5,240($key) # save km code | ||
| 789 | lghi %r2,0 | ||
| 790 | br %r14 | ||
| 791 | ___ | ||
| 792 | $code.=<<___; | ||
| 793 | .align 16 | ||
| 794 | .Lekey_internal: | ||
| 795 | stmg %r6,%r13,48($sp) # all non-volatile regs | ||
| 796 | |||
| 797 | larl $tbl,AES_Te+2048 | ||
| 798 | |||
| 799 | llgf $s0,0($inp) | ||
| 800 | llgf $s1,4($inp) | ||
| 801 | llgf $s2,8($inp) | ||
| 802 | llgf $s3,12($inp) | ||
| 803 | st $s0,0($key) | ||
| 804 | st $s1,4($key) | ||
| 805 | st $s2,8($key) | ||
| 806 | st $s3,12($key) | ||
| 807 | lghi $t0,128 | ||
| 808 | cr $bits,$t0 | ||
| 809 | jne .Lnot128 | ||
| 810 | |||
| 811 | llill $mask,0xff | ||
| 812 | lghi $t3,0 # i=0 | ||
| 813 | lghi $rounds,10 | ||
| 814 | st $rounds,240($key) | ||
| 815 | |||
| 816 | llgfr $t2,$s3 # temp=rk[3] | ||
| 817 | srlg $i1,$s3,8 | ||
| 818 | srlg $i2,$s3,16 | ||
| 819 | srlg $i3,$s3,24 | ||
| 820 | nr $t2,$mask | ||
| 821 | nr $i1,$mask | ||
| 822 | nr $i2,$mask | ||
| 823 | |||
| 824 | .align 16 | ||
| 825 | .L128_loop: | ||
| 826 | la $t2,0($t2,$tbl) | ||
| 827 | la $i1,0($i1,$tbl) | ||
| 828 | la $i2,0($i2,$tbl) | ||
| 829 | la $i3,0($i3,$tbl) | ||
| 830 | icm $t2,2,0($t2) # Te4[rk[3]>>0]<<8 | ||
| 831 | icm $t2,4,0($i1) # Te4[rk[3]>>8]<<16 | ||
| 832 | icm $t2,8,0($i2) # Te4[rk[3]>>16]<<24 | ||
| 833 | icm $t2,1,0($i3) # Te4[rk[3]>>24] | ||
| 834 | x $t2,256($t3,$tbl) # rcon[i] | ||
| 835 | xr $s0,$t2 # rk[4]=rk[0]^... | ||
| 836 | xr $s1,$s0 # rk[5]=rk[1]^rk[4] | ||
| 837 | xr $s2,$s1 # rk[6]=rk[2]^rk[5] | ||
| 838 | xr $s3,$s2 # rk[7]=rk[3]^rk[6] | ||
| 839 | |||
| 840 | llgfr $t2,$s3 # temp=rk[3] | ||
| 841 | srlg $i1,$s3,8 | ||
| 842 | srlg $i2,$s3,16 | ||
| 843 | nr $t2,$mask | ||
| 844 | nr $i1,$mask | ||
| 845 | srlg $i3,$s3,24 | ||
| 846 | nr $i2,$mask | ||
| 847 | |||
| 848 | st $s0,16($key) | ||
| 849 | st $s1,20($key) | ||
| 850 | st $s2,24($key) | ||
| 851 | st $s3,28($key) | ||
| 852 | la $key,16($key) # key+=4 | ||
| 853 | la $t3,4($t3) # i++ | ||
| 854 | brct $rounds,.L128_loop | ||
| 855 | lghi %r2,0 | ||
| 856 | lmg %r6,%r13,48($sp) | ||
| 857 | br $ra | ||
| 858 | |||
| 859 | .align 16 | ||
| 860 | .Lnot128: | ||
| 861 | llgf $t0,16($inp) | ||
| 862 | llgf $t1,20($inp) | ||
| 863 | st $t0,16($key) | ||
| 864 | st $t1,20($key) | ||
| 865 | lghi $t0,192 | ||
| 866 | cr $bits,$t0 | ||
| 867 | jne .Lnot192 | ||
| 868 | |||
| 869 | llill $mask,0xff | ||
| 870 | lghi $t3,0 # i=0 | ||
| 871 | lghi $rounds,12 | ||
| 872 | st $rounds,240($key) | ||
| 873 | lghi $rounds,8 | ||
| 874 | |||
| 875 | srlg $i1,$t1,8 | ||
| 876 | srlg $i2,$t1,16 | ||
| 877 | srlg $i3,$t1,24 | ||
| 878 | nr $t1,$mask | ||
| 879 | nr $i1,$mask | ||
| 880 | nr $i2,$mask | ||
| 881 | |||
| 882 | .align 16 | ||
| 883 | .L192_loop: | ||
| 884 | la $t1,0($t1,$tbl) | ||
| 885 | la $i1,0($i1,$tbl) | ||
| 886 | la $i2,0($i2,$tbl) | ||
| 887 | la $i3,0($i3,$tbl) | ||
| 888 | icm $t1,2,0($t1) # Te4[rk[5]>>0]<<8 | ||
| 889 | icm $t1,4,0($i1) # Te4[rk[5]>>8]<<16 | ||
| 890 | icm $t1,8,0($i2) # Te4[rk[5]>>16]<<24 | ||
| 891 | icm $t1,1,0($i3) # Te4[rk[5]>>24] | ||
| 892 | x $t1,256($t3,$tbl) # rcon[i] | ||
| 893 | xr $s0,$t1 # rk[6]=rk[0]^... | ||
| 894 | xr $s1,$s0 # rk[7]=rk[1]^rk[6] | ||
| 895 | xr $s2,$s1 # rk[8]=rk[2]^rk[7] | ||
| 896 | xr $s3,$s2 # rk[9]=rk[3]^rk[8] | ||
| 897 | |||
| 898 | st $s0,24($key) | ||
| 899 | st $s1,28($key) | ||
| 900 | st $s2,32($key) | ||
| 901 | st $s3,36($key) | ||
| 902 | brct $rounds,.L192_continue | ||
| 903 | lghi %r2,0 | ||
| 904 | lmg %r6,%r13,48($sp) | ||
| 905 | br $ra | ||
| 906 | |||
| 907 | .align 16 | ||
| 908 | .L192_continue: | ||
| 909 | lgr $t1,$s3 | ||
| 910 | x $t1,16($key) # rk[10]=rk[4]^rk[9] | ||
| 911 | st $t1,40($key) | ||
| 912 | x $t1,20($key) # rk[11]=rk[5]^rk[10] | ||
| 913 | st $t1,44($key) | ||
| 914 | |||
| 915 | srlg $i1,$t1,8 | ||
| 916 | srlg $i2,$t1,16 | ||
| 917 | srlg $i3,$t1,24 | ||
| 918 | nr $t1,$mask | ||
| 919 | nr $i1,$mask | ||
| 920 | nr $i2,$mask | ||
| 921 | |||
| 922 | la $key,24($key) # key+=6 | ||
| 923 | la $t3,4($t3) # i++ | ||
| 924 | j .L192_loop | ||
| 925 | |||
| 926 | .align 16 | ||
| 927 | .Lnot192: | ||
| 928 | llgf $t0,24($inp) | ||
| 929 | llgf $t1,28($inp) | ||
| 930 | st $t0,24($key) | ||
| 931 | st $t1,28($key) | ||
| 932 | llill $mask,0xff | ||
| 933 | lghi $t3,0 # i=0 | ||
| 934 | lghi $rounds,14 | ||
| 935 | st $rounds,240($key) | ||
| 936 | lghi $rounds,7 | ||
| 937 | |||
| 938 | srlg $i1,$t1,8 | ||
| 939 | srlg $i2,$t1,16 | ||
| 940 | srlg $i3,$t1,24 | ||
| 941 | nr $t1,$mask | ||
| 942 | nr $i1,$mask | ||
| 943 | nr $i2,$mask | ||
| 944 | |||
| 945 | .align 16 | ||
| 946 | .L256_loop: | ||
| 947 | la $t1,0($t1,$tbl) | ||
| 948 | la $i1,0($i1,$tbl) | ||
| 949 | la $i2,0($i2,$tbl) | ||
| 950 | la $i3,0($i3,$tbl) | ||
| 951 | icm $t1,2,0($t1) # Te4[rk[7]>>0]<<8 | ||
| 952 | icm $t1,4,0($i1) # Te4[rk[7]>>8]<<16 | ||
| 953 | icm $t1,8,0($i2) # Te4[rk[7]>>16]<<24 | ||
| 954 | icm $t1,1,0($i3) # Te4[rk[7]>>24] | ||
| 955 | x $t1,256($t3,$tbl) # rcon[i] | ||
| 956 | xr $s0,$t1 # rk[8]=rk[0]^... | ||
| 957 | xr $s1,$s0 # rk[9]=rk[1]^rk[8] | ||
| 958 | xr $s2,$s1 # rk[10]=rk[2]^rk[9] | ||
| 959 | xr $s3,$s2 # rk[11]=rk[3]^rk[10] | ||
| 960 | st $s0,32($key) | ||
| 961 | st $s1,36($key) | ||
| 962 | st $s2,40($key) | ||
| 963 | st $s3,44($key) | ||
| 964 | brct $rounds,.L256_continue | ||
| 965 | lghi %r2,0 | ||
| 966 | lmg %r6,%r13,48($sp) | ||
| 967 | br $ra | ||
| 968 | |||
| 969 | .align 16 | ||
| 970 | .L256_continue: | ||
| 971 | lgr $t1,$s3 # temp=rk[11] | ||
| 972 | srlg $i1,$s3,8 | ||
| 973 | srlg $i2,$s3,16 | ||
| 974 | srlg $i3,$s3,24 | ||
| 975 | nr $t1,$mask | ||
| 976 | nr $i1,$mask | ||
| 977 | nr $i2,$mask | ||
| 978 | la $t1,0($t1,$tbl) | ||
| 979 | la $i1,0($i1,$tbl) | ||
| 980 | la $i2,0($i2,$tbl) | ||
| 981 | la $i3,0($i3,$tbl) | ||
| 982 | llgc $t1,0($t1) # Te4[rk[11]>>0] | ||
| 983 | icm $t1,2,0($i1) # Te4[rk[11]>>8]<<8 | ||
| 984 | icm $t1,4,0($i2) # Te4[rk[11]>>16]<<16 | ||
| 985 | icm $t1,8,0($i3) # Te4[rk[11]>>24]<<24 | ||
| 986 | x $t1,16($key) # rk[12]=rk[4]^... | ||
| 987 | st $t1,48($key) | ||
| 988 | x $t1,20($key) # rk[13]=rk[5]^rk[12] | ||
| 989 | st $t1,52($key) | ||
| 990 | x $t1,24($key) # rk[14]=rk[6]^rk[13] | ||
| 991 | st $t1,56($key) | ||
| 992 | x $t1,28($key) # rk[15]=rk[7]^rk[14] | ||
| 993 | st $t1,60($key) | ||
| 994 | |||
| 995 | srlg $i1,$t1,8 | ||
| 996 | srlg $i2,$t1,16 | ||
| 997 | srlg $i3,$t1,24 | ||
| 998 | nr $t1,$mask | ||
| 999 | nr $i1,$mask | ||
| 1000 | nr $i2,$mask | ||
| 1001 | |||
| 1002 | la $key,32($key) # key+=8 | ||
| 1003 | la $t3,4($t3) # i++ | ||
| 1004 | j .L256_loop | ||
| 1005 | |||
| 1006 | .Lminus1: | ||
| 1007 | lghi %r2,-1 | ||
| 1008 | br $ra | ||
| 1009 | .size AES_set_encrypt_key,.-AES_set_encrypt_key | ||
| 1010 | |||
| 1011 | # void AES_set_decrypt_key(const unsigned char *in, int bits, | ||
| 1012 | # AES_KEY *key) { | ||
| 1013 | .globl AES_set_decrypt_key | ||
| 1014 | .type AES_set_decrypt_key,\@function | ||
| 1015 | .align 16 | ||
| 1016 | AES_set_decrypt_key: | ||
| 1017 | stg $key,32($sp) # I rely on AES_set_encrypt_key to | ||
| 1018 | stg $ra,112($sp) # save non-volatile registers! | ||
| 1019 | bras $ra,AES_set_encrypt_key | ||
| 1020 | lg $key,32($sp) | ||
| 1021 | lg $ra,112($sp) | ||
| 1022 | ltgr %r2,%r2 | ||
| 1023 | bnzr $ra | ||
| 1024 | ___ | ||
| 1025 | $code.=<<___ if (!$softonly); | ||
| 1026 | l $t0,240($key) | ||
| 1027 | lhi $t1,16 | ||
| 1028 | cr $t0,$t1 | ||
| 1029 | jl .Lgo | ||
| 1030 | oill $t0,0x80 # set "decrypt" bit | ||
| 1031 | st $t0,240($key) | ||
| 1032 | br $ra | ||
| 1033 | |||
| 1034 | .align 16 | ||
| 1035 | .Ldkey_internal: | ||
| 1036 | stg $key,32($sp) | ||
| 1037 | stg $ra,40($sp) | ||
| 1038 | bras $ra,.Lekey_internal | ||
| 1039 | lg $key,32($sp) | ||
| 1040 | lg $ra,40($sp) | ||
| 1041 | ___ | ||
| 1042 | $code.=<<___; | ||
| 1043 | |||
| 1044 | .Lgo: llgf $rounds,240($key) | ||
| 1045 | la $i1,0($key) | ||
| 1046 | sllg $i2,$rounds,4 | ||
| 1047 | la $i2,0($i2,$key) | ||
| 1048 | srl $rounds,1 | ||
| 1049 | lghi $t1,-16 | ||
| 1050 | |||
| 1051 | .align 16 | ||
| 1052 | .Linv: lmg $s0,$s1,0($i1) | ||
| 1053 | lmg $s2,$s3,0($i2) | ||
| 1054 | stmg $s0,$s1,0($i2) | ||
| 1055 | stmg $s2,$s3,0($i1) | ||
| 1056 | la $i1,16($i1) | ||
| 1057 | la $i2,0($t1,$i2) | ||
| 1058 | brct $rounds,.Linv | ||
| 1059 | ___ | ||
| 1060 | $mask80=$i1; | ||
| 1061 | $mask1b=$i2; | ||
| 1062 | $maskfe=$i3; | ||
| 1063 | $code.=<<___; | ||
| 1064 | llgf $rounds,240($key) | ||
| 1065 | aghi $rounds,-1 | ||
| 1066 | sll $rounds,2 # (rounds-1)*4 | ||
| 1067 | llilh $mask80,0x8080 | ||
| 1068 | llilh $mask1b,0x1b1b | ||
| 1069 | llilh $maskfe,0xfefe | ||
| 1070 | oill $mask80,0x8080 | ||
| 1071 | oill $mask1b,0x1b1b | ||
| 1072 | oill $maskfe,0xfefe | ||
| 1073 | |||
| 1074 | .align 16 | ||
| 1075 | .Lmix: l $s0,16($key) # tp1 | ||
| 1076 | lr $s1,$s0 | ||
| 1077 | ngr $s1,$mask80 | ||
| 1078 | srlg $t1,$s1,7 | ||
| 1079 | slr $s1,$t1 | ||
| 1080 | nr $s1,$mask1b | ||
| 1081 | sllg $t1,$s0,1 | ||
| 1082 | nr $t1,$maskfe | ||
| 1083 | xr $s1,$t1 # tp2 | ||
| 1084 | |||
| 1085 | lr $s2,$s1 | ||
| 1086 | ngr $s2,$mask80 | ||
| 1087 | srlg $t1,$s2,7 | ||
| 1088 | slr $s2,$t1 | ||
| 1089 | nr $s2,$mask1b | ||
| 1090 | sllg $t1,$s1,1 | ||
| 1091 | nr $t1,$maskfe | ||
| 1092 | xr $s2,$t1 # tp4 | ||
| 1093 | |||
| 1094 | lr $s3,$s2 | ||
| 1095 | ngr $s3,$mask80 | ||
| 1096 | srlg $t1,$s3,7 | ||
| 1097 | slr $s3,$t1 | ||
| 1098 | nr $s3,$mask1b | ||
| 1099 | sllg $t1,$s2,1 | ||
| 1100 | nr $t1,$maskfe | ||
| 1101 | xr $s3,$t1 # tp8 | ||
| 1102 | |||
| 1103 | xr $s1,$s0 # tp2^tp1 | ||
| 1104 | xr $s2,$s0 # tp4^tp1 | ||
| 1105 | rll $s0,$s0,24 # = ROTATE(tp1,8) | ||
| 1106 | xr $s2,$s3 # ^=tp8 | ||
| 1107 | xr $s0,$s1 # ^=tp2^tp1 | ||
| 1108 | xr $s1,$s3 # tp2^tp1^tp8 | ||
| 1109 | xr $s0,$s2 # ^=tp4^tp1^tp8 | ||
| 1110 | rll $s1,$s1,8 | ||
| 1111 | rll $s2,$s2,16 | ||
| 1112 | xr $s0,$s1 # ^= ROTATE(tp8^tp2^tp1,24) | ||
| 1113 | rll $s3,$s3,24 | ||
| 1114 | xr $s0,$s2 # ^= ROTATE(tp8^tp4^tp1,16) | ||
| 1115 | xr $s0,$s3 # ^= ROTATE(tp8,8) | ||
| 1116 | |||
| 1117 | st $s0,16($key) | ||
| 1118 | la $key,4($key) | ||
| 1119 | brct $rounds,.Lmix | ||
| 1120 | |||
| 1121 | lmg %r6,%r13,48($sp)# as was saved by AES_set_encrypt_key! | ||
| 1122 | lghi %r2,0 | ||
| 1123 | br $ra | ||
| 1124 | .size AES_set_decrypt_key,.-AES_set_decrypt_key | ||
| 1125 | ___ | ||
| 1126 | |||
| 1127 | #void AES_cbc_encrypt(const unsigned char *in, unsigned char *out, | ||
| 1128 | # size_t length, const AES_KEY *key, | ||
| 1129 | # unsigned char *ivec, const int enc) | ||
| 1130 | { | ||
| 1131 | my $inp="%r2"; | ||
| 1132 | my $out="%r4"; # length and out are swapped | ||
| 1133 | my $len="%r3"; | ||
| 1134 | my $key="%r5"; | ||
| 1135 | my $ivp="%r6"; | ||
| 1136 | |||
| 1137 | $code.=<<___; | ||
| 1138 | .globl AES_cbc_encrypt | ||
| 1139 | .type AES_cbc_encrypt,\@function | ||
| 1140 | .align 16 | ||
| 1141 | AES_cbc_encrypt: | ||
| 1142 | xgr %r3,%r4 # flip %r3 and %r4, out and len | ||
| 1143 | xgr %r4,%r3 | ||
| 1144 | xgr %r3,%r4 | ||
| 1145 | ___ | ||
| 1146 | $code.=<<___ if (!$softonly); | ||
| 1147 | lhi %r0,16 | ||
| 1148 | cl %r0,240($key) | ||
| 1149 | jh .Lcbc_software | ||
| 1150 | |||
| 1151 | lg %r0,0($ivp) # copy ivec | ||
| 1152 | lg %r1,8($ivp) | ||
| 1153 | stmg %r0,%r1,16($sp) | ||
| 1154 | lmg %r0,%r1,0($key) # copy key, cover 256 bit | ||
| 1155 | stmg %r0,%r1,32($sp) | ||
| 1156 | lmg %r0,%r1,16($key) | ||
| 1157 | stmg %r0,%r1,48($sp) | ||
| 1158 | l %r0,240($key) # load kmc code | ||
| 1159 | lghi $key,15 # res=len%16, len-=res; | ||
| 1160 | ngr $key,$len | ||
| 1161 | slgr $len,$key | ||
| 1162 | la %r1,16($sp) # parameter block - ivec || key | ||
| 1163 | jz .Lkmc_truncated | ||
| 1164 | .long 0xb92f0042 # kmc %r4,%r2 | ||
| 1165 | brc 1,.-4 # pay attention to "partial completion" | ||
| 1166 | ltr $key,$key | ||
| 1167 | jnz .Lkmc_truncated | ||
| 1168 | .Lkmc_done: | ||
| 1169 | lmg %r0,%r1,16($sp) # copy ivec to caller | ||
| 1170 | stg %r0,0($ivp) | ||
| 1171 | stg %r1,8($ivp) | ||
| 1172 | br $ra | ||
| 1173 | .align 16 | ||
| 1174 | .Lkmc_truncated: | ||
| 1175 | ahi $key,-1 # it's the way it's encoded in mvc | ||
| 1176 | tmll %r0,0x80 | ||
| 1177 | jnz .Lkmc_truncated_dec | ||
| 1178 | lghi %r1,0 | ||
| 1179 | stg %r1,128($sp) | ||
| 1180 | stg %r1,136($sp) | ||
| 1181 | bras %r1,1f | ||
| 1182 | mvc 128(1,$sp),0($inp) | ||
| 1183 | 1: ex $key,0(%r1) | ||
| 1184 | la %r1,16($sp) # restore parameter block | ||
| 1185 | la $inp,128($sp) | ||
| 1186 | lghi $len,16 | ||
| 1187 | .long 0xb92f0042 # kmc %r4,%r2 | ||
| 1188 | j .Lkmc_done | ||
| 1189 | .align 16 | ||
| 1190 | .Lkmc_truncated_dec: | ||
| 1191 | stg $out,64($sp) | ||
| 1192 | la $out,128($sp) | ||
| 1193 | lghi $len,16 | ||
| 1194 | .long 0xb92f0042 # kmc %r4,%r2 | ||
| 1195 | lg $out,64($sp) | ||
| 1196 | bras %r1,2f | ||
| 1197 | mvc 0(1,$out),128($sp) | ||
| 1198 | 2: ex $key,0(%r1) | ||
| 1199 | j .Lkmc_done | ||
| 1200 | .align 16 | ||
| 1201 | .Lcbc_software: | ||
| 1202 | ___ | ||
| 1203 | $code.=<<___; | ||
| 1204 | stmg $key,$ra,40($sp) | ||
| 1205 | lhi %r0,0 | ||
| 1206 | cl %r0,164($sp) | ||
| 1207 | je .Lcbc_decrypt | ||
| 1208 | |||
| 1209 | larl $tbl,AES_Te | ||
| 1210 | |||
| 1211 | llgf $s0,0($ivp) | ||
| 1212 | llgf $s1,4($ivp) | ||
| 1213 | llgf $s2,8($ivp) | ||
| 1214 | llgf $s3,12($ivp) | ||
| 1215 | |||
| 1216 | lghi $t0,16 | ||
| 1217 | slgr $len,$t0 | ||
| 1218 | brc 4,.Lcbc_enc_tail # if borrow | ||
| 1219 | .Lcbc_enc_loop: | ||
| 1220 | stmg $inp,$out,16($sp) | ||
| 1221 | x $s0,0($inp) | ||
| 1222 | x $s1,4($inp) | ||
| 1223 | x $s2,8($inp) | ||
| 1224 | x $s3,12($inp) | ||
| 1225 | lgr %r4,$key | ||
| 1226 | |||
| 1227 | bras $ra,_s390x_AES_encrypt | ||
| 1228 | |||
| 1229 | lmg $inp,$key,16($sp) | ||
| 1230 | st $s0,0($out) | ||
| 1231 | st $s1,4($out) | ||
| 1232 | st $s2,8($out) | ||
| 1233 | st $s3,12($out) | ||
| 1234 | |||
| 1235 | la $inp,16($inp) | ||
| 1236 | la $out,16($out) | ||
| 1237 | lghi $t0,16 | ||
| 1238 | ltgr $len,$len | ||
| 1239 | jz .Lcbc_enc_done | ||
| 1240 | slgr $len,$t0 | ||
| 1241 | brc 4,.Lcbc_enc_tail # if borrow | ||
| 1242 | j .Lcbc_enc_loop | ||
| 1243 | .align 16 | ||
| 1244 | .Lcbc_enc_done: | ||
| 1245 | lg $ivp,48($sp) | ||
| 1246 | st $s0,0($ivp) | ||
| 1247 | st $s1,4($ivp) | ||
| 1248 | st $s2,8($ivp) | ||
| 1249 | st $s3,12($ivp) | ||
| 1250 | |||
| 1251 | lmg %r7,$ra,56($sp) | ||
| 1252 | br $ra | ||
| 1253 | |||
| 1254 | .align 16 | ||
| 1255 | .Lcbc_enc_tail: | ||
| 1256 | aghi $len,15 | ||
| 1257 | lghi $t0,0 | ||
| 1258 | stg $t0,128($sp) | ||
| 1259 | stg $t0,136($sp) | ||
| 1260 | bras $t1,3f | ||
| 1261 | mvc 128(1,$sp),0($inp) | ||
| 1262 | 3: ex $len,0($t1) | ||
| 1263 | lghi $len,0 | ||
| 1264 | la $inp,128($sp) | ||
| 1265 | j .Lcbc_enc_loop | ||
| 1266 | |||
| 1267 | .align 16 | ||
| 1268 | .Lcbc_decrypt: | ||
| 1269 | larl $tbl,AES_Td | ||
| 1270 | |||
| 1271 | lg $t0,0($ivp) | ||
| 1272 | lg $t1,8($ivp) | ||
| 1273 | stmg $t0,$t1,128($sp) | ||
| 1274 | |||
| 1275 | .Lcbc_dec_loop: | ||
| 1276 | stmg $inp,$out,16($sp) | ||
| 1277 | llgf $s0,0($inp) | ||
| 1278 | llgf $s1,4($inp) | ||
| 1279 | llgf $s2,8($inp) | ||
| 1280 | llgf $s3,12($inp) | ||
| 1281 | lgr %r4,$key | ||
| 1282 | |||
| 1283 | bras $ra,_s390x_AES_decrypt | ||
| 1284 | |||
| 1285 | lmg $inp,$key,16($sp) | ||
| 1286 | sllg $s0,$s0,32 | ||
| 1287 | sllg $s2,$s2,32 | ||
| 1288 | lr $s0,$s1 | ||
| 1289 | lr $s2,$s3 | ||
| 1290 | |||
| 1291 | lg $t0,0($inp) | ||
| 1292 | lg $t1,8($inp) | ||
| 1293 | xg $s0,128($sp) | ||
| 1294 | xg $s2,136($sp) | ||
| 1295 | lghi $s1,16 | ||
| 1296 | slgr $len,$s1 | ||
| 1297 | brc 4,.Lcbc_dec_tail # if borrow | ||
| 1298 | brc 2,.Lcbc_dec_done # if zero | ||
| 1299 | stg $s0,0($out) | ||
| 1300 | stg $s2,8($out) | ||
| 1301 | stmg $t0,$t1,128($sp) | ||
| 1302 | |||
| 1303 | la $inp,16($inp) | ||
| 1304 | la $out,16($out) | ||
| 1305 | j .Lcbc_dec_loop | ||
| 1306 | |||
| 1307 | .Lcbc_dec_done: | ||
| 1308 | stg $s0,0($out) | ||
| 1309 | stg $s2,8($out) | ||
| 1310 | .Lcbc_dec_exit: | ||
| 1311 | lmg $ivp,$ra,48($sp) | ||
| 1312 | stmg $t0,$t1,0($ivp) | ||
| 1313 | |||
| 1314 | br $ra | ||
| 1315 | |||
| 1316 | .align 16 | ||
| 1317 | .Lcbc_dec_tail: | ||
| 1318 | aghi $len,15 | ||
| 1319 | stg $s0,128($sp) | ||
| 1320 | stg $s2,136($sp) | ||
| 1321 | bras $s1,4f | ||
| 1322 | mvc 0(1,$out),128($sp) | ||
| 1323 | 4: ex $len,0($s1) | ||
| 1324 | j .Lcbc_dec_exit | ||
| 1325 | .size AES_cbc_encrypt,.-AES_cbc_encrypt | ||
| 1326 | ___ | ||
| 1327 | } | ||
| 1328 | $code.=<<___; | ||
| 1329 | .string "AES for s390x, CRYPTOGAMS by <appro\@openssl.org>" | ||
| 1330 | ___ | ||
| 1331 | |||
| 1332 | $code =~ s/\`([^\`]*)\`/eval $1/gem; | ||
| 1333 | print $code; | ||
diff --git a/src/lib/libssl/src/crypto/aes/asm/aes-sparcv9.pl b/src/lib/libssl/src/crypto/aes/asm/aes-sparcv9.pl new file mode 100755 index 0000000000..c57b3a2d6d --- /dev/null +++ b/src/lib/libssl/src/crypto/aes/asm/aes-sparcv9.pl | |||
| @@ -0,0 +1,1181 @@ | |||
| 1 | #!/usr/bin/env perl | ||
| 2 | # | ||
| 3 | # ==================================================================== | ||
| 4 | # Written by Andy Polyakov <appro@fy.chalmers.se> for the OpenSSL | ||
| 5 | # project. Rights for redistribution and usage in source and binary | ||
| 6 | # forms are granted according to the OpenSSL license. | ||
| 7 | # ==================================================================== | ||
| 8 | # | ||
| 9 | # Version 1.1 | ||
| 10 | # | ||
| 11 | # The major reason for undertaken effort was to mitigate the hazard of | ||
| 12 | # cache-timing attack. This is [currently and initially!] addressed in | ||
| 13 | # two ways. 1. S-boxes are compressed from 5KB to 2KB+256B size each. | ||
| 14 | # 2. References to them are scheduled for L2 cache latency, meaning | ||
| 15 | # that the tables don't have to reside in L1 cache. Once again, this | ||
| 16 | # is an initial draft and one should expect more countermeasures to | ||
| 17 | # be implemented... | ||
| 18 | # | ||
| 19 | # Version 1.1 prefetches T[ed]4 in order to mitigate attack on last | ||
| 20 | # round. | ||
| 21 | # | ||
| 22 | # Even though performance was not the primary goal [on the contrary, | ||
| 23 | # extra shifts "induced" by compressed S-box and longer loop epilogue | ||
| 24 | # "induced" by scheduling for L2 have negative effect on performance], | ||
| 25 | # the code turned out to run in ~23 cycles per processed byte en-/ | ||
| 26 | # decrypted with 128-bit key. This is pretty good result for code | ||
| 27 | # with mentioned qualities and UltraSPARC core. Compared to Sun C | ||
| 28 | # generated code my encrypt procedure runs just few percents faster, | ||
| 29 | # while decrypt one - whole 50% faster [yes, Sun C failed to generate | ||
| 30 | # optimal decrypt procedure]. Compared to GNU C generated code both | ||
| 31 | # procedures are more than 60% faster:-) | ||
| 32 | |||
| 33 | $bits=32; | ||
| 34 | for (@ARGV) { $bits=64 if (/\-m64/ || /\-xarch\=v9/); } | ||
| 35 | if ($bits==64) { $bias=2047; $frame=192; } | ||
| 36 | else { $bias=0; $frame=112; } | ||
| 37 | $locals=16; | ||
| 38 | |||
| 39 | $acc0="%l0"; | ||
| 40 | $acc1="%o0"; | ||
| 41 | $acc2="%o1"; | ||
| 42 | $acc3="%o2"; | ||
| 43 | |||
| 44 | $acc4="%l1"; | ||
| 45 | $acc5="%o3"; | ||
| 46 | $acc6="%o4"; | ||
| 47 | $acc7="%o5"; | ||
| 48 | |||
| 49 | $acc8="%l2"; | ||
| 50 | $acc9="%o7"; | ||
| 51 | $acc10="%g1"; | ||
| 52 | $acc11="%g2"; | ||
| 53 | |||
| 54 | $acc12="%l3"; | ||
| 55 | $acc13="%g3"; | ||
| 56 | $acc14="%g4"; | ||
| 57 | $acc15="%g5"; | ||
| 58 | |||
| 59 | $t0="%l4"; | ||
| 60 | $t1="%l5"; | ||
| 61 | $t2="%l6"; | ||
| 62 | $t3="%l7"; | ||
| 63 | |||
| 64 | $s0="%i0"; | ||
| 65 | $s1="%i1"; | ||
| 66 | $s2="%i2"; | ||
| 67 | $s3="%i3"; | ||
| 68 | $tbl="%i4"; | ||
| 69 | $key="%i5"; | ||
| 70 | $rounds="%i7"; # aliases with return address, which is off-loaded to stack | ||
| 71 | |||
| 72 | sub _data_word() | ||
| 73 | { my $i; | ||
| 74 | while(defined($i=shift)) { $code.=sprintf"\t.long\t0x%08x,0x%08x\n",$i,$i; } | ||
| 75 | } | ||
| 76 | |||
| 77 | $code.=<<___ if ($bits==64); | ||
| 78 | .register %g2,#scratch | ||
| 79 | .register %g3,#scratch | ||
| 80 | ___ | ||
| 81 | $code.=<<___; | ||
| 82 | .section ".text",#alloc,#execinstr | ||
| 83 | |||
| 84 | .align 256 | ||
| 85 | AES_Te: | ||
| 86 | ___ | ||
| 87 | &_data_word( | ||
| 88 | 0xc66363a5, 0xf87c7c84, 0xee777799, 0xf67b7b8d, | ||
| 89 | 0xfff2f20d, 0xd66b6bbd, 0xde6f6fb1, 0x91c5c554, | ||
| 90 | 0x60303050, 0x02010103, 0xce6767a9, 0x562b2b7d, | ||
| 91 | 0xe7fefe19, 0xb5d7d762, 0x4dababe6, 0xec76769a, | ||
| 92 | 0x8fcaca45, 0x1f82829d, 0x89c9c940, 0xfa7d7d87, | ||
| 93 | 0xeffafa15, 0xb25959eb, 0x8e4747c9, 0xfbf0f00b, | ||
| 94 | 0x41adadec, 0xb3d4d467, 0x5fa2a2fd, 0x45afafea, | ||
| 95 | 0x239c9cbf, 0x53a4a4f7, 0xe4727296, 0x9bc0c05b, | ||
| 96 | 0x75b7b7c2, 0xe1fdfd1c, 0x3d9393ae, 0x4c26266a, | ||
| 97 | 0x6c36365a, 0x7e3f3f41, 0xf5f7f702, 0x83cccc4f, | ||
| 98 | 0x6834345c, 0x51a5a5f4, 0xd1e5e534, 0xf9f1f108, | ||
| 99 | 0xe2717193, 0xabd8d873, 0x62313153, 0x2a15153f, | ||
| 100 | 0x0804040c, 0x95c7c752, 0x46232365, 0x9dc3c35e, | ||
| 101 | 0x30181828, 0x379696a1, 0x0a05050f, 0x2f9a9ab5, | ||
| 102 | 0x0e070709, 0x24121236, 0x1b80809b, 0xdfe2e23d, | ||
| 103 | 0xcdebeb26, 0x4e272769, 0x7fb2b2cd, 0xea75759f, | ||
| 104 | 0x1209091b, 0x1d83839e, 0x582c2c74, 0x341a1a2e, | ||
| 105 | 0x361b1b2d, 0xdc6e6eb2, 0xb45a5aee, 0x5ba0a0fb, | ||
| 106 | 0xa45252f6, 0x763b3b4d, 0xb7d6d661, 0x7db3b3ce, | ||
| 107 | 0x5229297b, 0xdde3e33e, 0x5e2f2f71, 0x13848497, | ||
| 108 | 0xa65353f5, 0xb9d1d168, 0x00000000, 0xc1eded2c, | ||
| 109 | 0x40202060, 0xe3fcfc1f, 0x79b1b1c8, 0xb65b5bed, | ||
| 110 | 0xd46a6abe, 0x8dcbcb46, 0x67bebed9, 0x7239394b, | ||
| 111 | 0x944a4ade, 0x984c4cd4, 0xb05858e8, 0x85cfcf4a, | ||
| 112 | 0xbbd0d06b, 0xc5efef2a, 0x4faaaae5, 0xedfbfb16, | ||
| 113 | 0x864343c5, 0x9a4d4dd7, 0x66333355, 0x11858594, | ||
| 114 | 0x8a4545cf, 0xe9f9f910, 0x04020206, 0xfe7f7f81, | ||
| 115 | 0xa05050f0, 0x783c3c44, 0x259f9fba, 0x4ba8a8e3, | ||
| 116 | 0xa25151f3, 0x5da3a3fe, 0x804040c0, 0x058f8f8a, | ||
| 117 | 0x3f9292ad, 0x219d9dbc, 0x70383848, 0xf1f5f504, | ||
| 118 | 0x63bcbcdf, 0x77b6b6c1, 0xafdada75, 0x42212163, | ||
| 119 | 0x20101030, 0xe5ffff1a, 0xfdf3f30e, 0xbfd2d26d, | ||
| 120 | 0x81cdcd4c, 0x180c0c14, 0x26131335, 0xc3ecec2f, | ||
| 121 | 0xbe5f5fe1, 0x359797a2, 0x884444cc, 0x2e171739, | ||
| 122 | 0x93c4c457, 0x55a7a7f2, 0xfc7e7e82, 0x7a3d3d47, | ||
| 123 | 0xc86464ac, 0xba5d5de7, 0x3219192b, 0xe6737395, | ||
| 124 | 0xc06060a0, 0x19818198, 0x9e4f4fd1, 0xa3dcdc7f, | ||
| 125 | 0x44222266, 0x542a2a7e, 0x3b9090ab, 0x0b888883, | ||
| 126 | 0x8c4646ca, 0xc7eeee29, 0x6bb8b8d3, 0x2814143c, | ||
| 127 | 0xa7dede79, 0xbc5e5ee2, 0x160b0b1d, 0xaddbdb76, | ||
| 128 | 0xdbe0e03b, 0x64323256, 0x743a3a4e, 0x140a0a1e, | ||
| 129 | 0x924949db, 0x0c06060a, 0x4824246c, 0xb85c5ce4, | ||
| 130 | 0x9fc2c25d, 0xbdd3d36e, 0x43acacef, 0xc46262a6, | ||
| 131 | 0x399191a8, 0x319595a4, 0xd3e4e437, 0xf279798b, | ||
| 132 | 0xd5e7e732, 0x8bc8c843, 0x6e373759, 0xda6d6db7, | ||
| 133 | 0x018d8d8c, 0xb1d5d564, 0x9c4e4ed2, 0x49a9a9e0, | ||
| 134 | 0xd86c6cb4, 0xac5656fa, 0xf3f4f407, 0xcfeaea25, | ||
| 135 | 0xca6565af, 0xf47a7a8e, 0x47aeaee9, 0x10080818, | ||
| 136 | 0x6fbabad5, 0xf0787888, 0x4a25256f, 0x5c2e2e72, | ||
| 137 | 0x381c1c24, 0x57a6a6f1, 0x73b4b4c7, 0x97c6c651, | ||
| 138 | 0xcbe8e823, 0xa1dddd7c, 0xe874749c, 0x3e1f1f21, | ||
| 139 | 0x964b4bdd, 0x61bdbddc, 0x0d8b8b86, 0x0f8a8a85, | ||
| 140 | 0xe0707090, 0x7c3e3e42, 0x71b5b5c4, 0xcc6666aa, | ||
| 141 | 0x904848d8, 0x06030305, 0xf7f6f601, 0x1c0e0e12, | ||
| 142 | 0xc26161a3, 0x6a35355f, 0xae5757f9, 0x69b9b9d0, | ||
| 143 | 0x17868691, 0x99c1c158, 0x3a1d1d27, 0x279e9eb9, | ||
| 144 | 0xd9e1e138, 0xebf8f813, 0x2b9898b3, 0x22111133, | ||
| 145 | 0xd26969bb, 0xa9d9d970, 0x078e8e89, 0x339494a7, | ||
| 146 | 0x2d9b9bb6, 0x3c1e1e22, 0x15878792, 0xc9e9e920, | ||
| 147 | 0x87cece49, 0xaa5555ff, 0x50282878, 0xa5dfdf7a, | ||
| 148 | 0x038c8c8f, 0x59a1a1f8, 0x09898980, 0x1a0d0d17, | ||
| 149 | 0x65bfbfda, 0xd7e6e631, 0x844242c6, 0xd06868b8, | ||
| 150 | 0x824141c3, 0x299999b0, 0x5a2d2d77, 0x1e0f0f11, | ||
| 151 | 0x7bb0b0cb, 0xa85454fc, 0x6dbbbbd6, 0x2c16163a); | ||
| 152 | $code.=<<___; | ||
| 153 | .byte 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5 | ||
| 154 | .byte 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76 | ||
| 155 | .byte 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0 | ||
| 156 | .byte 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0 | ||
| 157 | .byte 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc | ||
| 158 | .byte 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15 | ||
| 159 | .byte 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a | ||
| 160 | .byte 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75 | ||
| 161 | .byte 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0 | ||
| 162 | .byte 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84 | ||
| 163 | .byte 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b | ||
| 164 | .byte 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf | ||
| 165 | .byte 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85 | ||
| 166 | .byte 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8 | ||
| 167 | .byte 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5 | ||
| 168 | .byte 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2 | ||
| 169 | .byte 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17 | ||
| 170 | .byte 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73 | ||
| 171 | .byte 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88 | ||
| 172 | .byte 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb | ||
| 173 | .byte 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c | ||
| 174 | .byte 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79 | ||
| 175 | .byte 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9 | ||
| 176 | .byte 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08 | ||
| 177 | .byte 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6 | ||
| 178 | .byte 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a | ||
| 179 | .byte 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e | ||
| 180 | .byte 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e | ||
| 181 | .byte 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94 | ||
| 182 | .byte 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf | ||
| 183 | .byte 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68 | ||
| 184 | .byte 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 | ||
| 185 | .type AES_Te,#object | ||
| 186 | .size AES_Te,(.-AES_Te) | ||
| 187 | |||
| 188 | .align 64 | ||
| 189 | .skip 16 | ||
| 190 | _sparcv9_AES_encrypt: | ||
| 191 | save %sp,-$frame-$locals,%sp | ||
| 192 | stx %i7,[%sp+$bias+$frame+0] ! off-load return address | ||
| 193 | ld [$key+240],$rounds | ||
| 194 | ld [$key+0],$t0 | ||
| 195 | ld [$key+4],$t1 ! | ||
| 196 | ld [$key+8],$t2 | ||
| 197 | srl $rounds,1,$rounds | ||
| 198 | xor $t0,$s0,$s0 | ||
| 199 | ld [$key+12],$t3 | ||
| 200 | srl $s0,21,$acc0 | ||
| 201 | xor $t1,$s1,$s1 | ||
| 202 | ld [$key+16],$t0 | ||
| 203 | srl $s1,13,$acc1 ! | ||
| 204 | xor $t2,$s2,$s2 | ||
| 205 | ld [$key+20],$t1 | ||
| 206 | xor $t3,$s3,$s3 | ||
| 207 | ld [$key+24],$t2 | ||
| 208 | and $acc0,2040,$acc0 | ||
| 209 | ld [$key+28],$t3 | ||
| 210 | nop | ||
| 211 | .Lenc_loop: | ||
| 212 | srl $s2,5,$acc2 ! | ||
| 213 | and $acc1,2040,$acc1 | ||
| 214 | ldx [$tbl+$acc0],$acc0 | ||
| 215 | sll $s3,3,$acc3 | ||
| 216 | and $acc2,2040,$acc2 | ||
| 217 | ldx [$tbl+$acc1],$acc1 | ||
| 218 | srl $s1,21,$acc4 | ||
| 219 | and $acc3,2040,$acc3 | ||
| 220 | ldx [$tbl+$acc2],$acc2 ! | ||
| 221 | srl $s2,13,$acc5 | ||
| 222 | and $acc4,2040,$acc4 | ||
| 223 | ldx [$tbl+$acc3],$acc3 | ||
| 224 | srl $s3,5,$acc6 | ||
| 225 | and $acc5,2040,$acc5 | ||
| 226 | ldx [$tbl+$acc4],$acc4 | ||
| 227 | fmovs %f0,%f0 | ||
| 228 | sll $s0,3,$acc7 ! | ||
| 229 | and $acc6,2040,$acc6 | ||
| 230 | ldx [$tbl+$acc5],$acc5 | ||
| 231 | srl $s2,21,$acc8 | ||
| 232 | and $acc7,2040,$acc7 | ||
| 233 | ldx [$tbl+$acc6],$acc6 | ||
| 234 | srl $s3,13,$acc9 | ||
| 235 | and $acc8,2040,$acc8 | ||
| 236 | ldx [$tbl+$acc7],$acc7 ! | ||
| 237 | srl $s0,5,$acc10 | ||
| 238 | and $acc9,2040,$acc9 | ||
| 239 | ldx [$tbl+$acc8],$acc8 | ||
| 240 | sll $s1,3,$acc11 | ||
| 241 | and $acc10,2040,$acc10 | ||
| 242 | ldx [$tbl+$acc9],$acc9 | ||
| 243 | fmovs %f0,%f0 | ||
| 244 | srl $s3,21,$acc12 ! | ||
| 245 | and $acc11,2040,$acc11 | ||
| 246 | ldx [$tbl+$acc10],$acc10 | ||
| 247 | srl $s0,13,$acc13 | ||
| 248 | and $acc12,2040,$acc12 | ||
| 249 | ldx [$tbl+$acc11],$acc11 | ||
| 250 | srl $s1,5,$acc14 | ||
| 251 | and $acc13,2040,$acc13 | ||
| 252 | ldx [$tbl+$acc12],$acc12 ! | ||
| 253 | sll $s2,3,$acc15 | ||
| 254 | and $acc14,2040,$acc14 | ||
| 255 | ldx [$tbl+$acc13],$acc13 | ||
| 256 | and $acc15,2040,$acc15 | ||
| 257 | add $key,32,$key | ||
| 258 | ldx [$tbl+$acc14],$acc14 | ||
| 259 | fmovs %f0,%f0 | ||
| 260 | subcc $rounds,1,$rounds ! | ||
| 261 | ldx [$tbl+$acc15],$acc15 | ||
| 262 | bz,a,pn %icc,.Lenc_last | ||
| 263 | add $tbl,2048,$rounds | ||
| 264 | |||
| 265 | srlx $acc1,8,$acc1 | ||
| 266 | xor $acc0,$t0,$t0 | ||
| 267 | ld [$key+0],$s0 | ||
| 268 | fmovs %f0,%f0 | ||
| 269 | srlx $acc2,16,$acc2 ! | ||
| 270 | xor $acc1,$t0,$t0 | ||
| 271 | ld [$key+4],$s1 | ||
| 272 | srlx $acc3,24,$acc3 | ||
| 273 | xor $acc2,$t0,$t0 | ||
| 274 | ld [$key+8],$s2 | ||
| 275 | srlx $acc5,8,$acc5 | ||
| 276 | xor $acc3,$t0,$t0 | ||
| 277 | ld [$key+12],$s3 ! | ||
| 278 | srlx $acc6,16,$acc6 | ||
| 279 | xor $acc4,$t1,$t1 | ||
| 280 | fmovs %f0,%f0 | ||
| 281 | srlx $acc7,24,$acc7 | ||
| 282 | xor $acc5,$t1,$t1 | ||
| 283 | srlx $acc9,8,$acc9 | ||
| 284 | xor $acc6,$t1,$t1 | ||
| 285 | srlx $acc10,16,$acc10 ! | ||
| 286 | xor $acc7,$t1,$t1 | ||
| 287 | srlx $acc11,24,$acc11 | ||
| 288 | xor $acc8,$t2,$t2 | ||
| 289 | srlx $acc13,8,$acc13 | ||
| 290 | xor $acc9,$t2,$t2 | ||
| 291 | srlx $acc14,16,$acc14 | ||
| 292 | xor $acc10,$t2,$t2 | ||
| 293 | srlx $acc15,24,$acc15 ! | ||
| 294 | xor $acc11,$t2,$t2 | ||
| 295 | xor $acc12,$acc14,$acc14 | ||
| 296 | xor $acc13,$t3,$t3 | ||
| 297 | srl $t0,21,$acc0 | ||
| 298 | xor $acc14,$t3,$t3 | ||
| 299 | srl $t1,13,$acc1 | ||
| 300 | xor $acc15,$t3,$t3 | ||
| 301 | |||
| 302 | and $acc0,2040,$acc0 ! | ||
| 303 | srl $t2,5,$acc2 | ||
| 304 | and $acc1,2040,$acc1 | ||
| 305 | ldx [$tbl+$acc0],$acc0 | ||
| 306 | sll $t3,3,$acc3 | ||
| 307 | and $acc2,2040,$acc2 | ||
| 308 | ldx [$tbl+$acc1],$acc1 | ||
| 309 | fmovs %f0,%f0 | ||
| 310 | srl $t1,21,$acc4 ! | ||
| 311 | and $acc3,2040,$acc3 | ||
| 312 | ldx [$tbl+$acc2],$acc2 | ||
| 313 | srl $t2,13,$acc5 | ||
| 314 | and $acc4,2040,$acc4 | ||
| 315 | ldx [$tbl+$acc3],$acc3 | ||
| 316 | srl $t3,5,$acc6 | ||
| 317 | and $acc5,2040,$acc5 | ||
| 318 | ldx [$tbl+$acc4],$acc4 ! | ||
| 319 | sll $t0,3,$acc7 | ||
| 320 | and $acc6,2040,$acc6 | ||
| 321 | ldx [$tbl+$acc5],$acc5 | ||
| 322 | srl $t2,21,$acc8 | ||
| 323 | and $acc7,2040,$acc7 | ||
| 324 | ldx [$tbl+$acc6],$acc6 | ||
| 325 | fmovs %f0,%f0 | ||
| 326 | srl $t3,13,$acc9 ! | ||
| 327 | and $acc8,2040,$acc8 | ||
| 328 | ldx [$tbl+$acc7],$acc7 | ||
| 329 | srl $t0,5,$acc10 | ||
| 330 | and $acc9,2040,$acc9 | ||
| 331 | ldx [$tbl+$acc8],$acc8 | ||
| 332 | sll $t1,3,$acc11 | ||
| 333 | and $acc10,2040,$acc10 | ||
| 334 | ldx [$tbl+$acc9],$acc9 ! | ||
| 335 | srl $t3,21,$acc12 | ||
| 336 | and $acc11,2040,$acc11 | ||
| 337 | ldx [$tbl+$acc10],$acc10 | ||
| 338 | srl $t0,13,$acc13 | ||
| 339 | and $acc12,2040,$acc12 | ||
| 340 | ldx [$tbl+$acc11],$acc11 | ||
| 341 | fmovs %f0,%f0 | ||
| 342 | srl $t1,5,$acc14 ! | ||
| 343 | and $acc13,2040,$acc13 | ||
| 344 | ldx [$tbl+$acc12],$acc12 | ||
| 345 | sll $t2,3,$acc15 | ||
| 346 | and $acc14,2040,$acc14 | ||
| 347 | ldx [$tbl+$acc13],$acc13 | ||
| 348 | srlx $acc1,8,$acc1 | ||
| 349 | and $acc15,2040,$acc15 | ||
| 350 | ldx [$tbl+$acc14],$acc14 ! | ||
| 351 | |||
| 352 | srlx $acc2,16,$acc2 | ||
| 353 | xor $acc0,$s0,$s0 | ||
| 354 | ldx [$tbl+$acc15],$acc15 | ||
| 355 | srlx $acc3,24,$acc3 | ||
| 356 | xor $acc1,$s0,$s0 | ||
| 357 | ld [$key+16],$t0 | ||
| 358 | fmovs %f0,%f0 | ||
| 359 | srlx $acc5,8,$acc5 ! | ||
| 360 | xor $acc2,$s0,$s0 | ||
| 361 | ld [$key+20],$t1 | ||
| 362 | srlx $acc6,16,$acc6 | ||
| 363 | xor $acc3,$s0,$s0 | ||
| 364 | ld [$key+24],$t2 | ||
| 365 | srlx $acc7,24,$acc7 | ||
| 366 | xor $acc4,$s1,$s1 | ||
| 367 | ld [$key+28],$t3 ! | ||
| 368 | srlx $acc9,8,$acc9 | ||
| 369 | xor $acc5,$s1,$s1 | ||
| 370 | ldx [$tbl+2048+0],%g0 ! prefetch te4 | ||
| 371 | srlx $acc10,16,$acc10 | ||
| 372 | xor $acc6,$s1,$s1 | ||
| 373 | ldx [$tbl+2048+32],%g0 ! prefetch te4 | ||
| 374 | srlx $acc11,24,$acc11 | ||
| 375 | xor $acc7,$s1,$s1 | ||
| 376 | ldx [$tbl+2048+64],%g0 ! prefetch te4 | ||
| 377 | srlx $acc13,8,$acc13 | ||
| 378 | xor $acc8,$s2,$s2 | ||
| 379 | ldx [$tbl+2048+96],%g0 ! prefetch te4 | ||
| 380 | srlx $acc14,16,$acc14 ! | ||
| 381 | xor $acc9,$s2,$s2 | ||
| 382 | ldx [$tbl+2048+128],%g0 ! prefetch te4 | ||
| 383 | srlx $acc15,24,$acc15 | ||
| 384 | xor $acc10,$s2,$s2 | ||
| 385 | ldx [$tbl+2048+160],%g0 ! prefetch te4 | ||
| 386 | srl $s0,21,$acc0 | ||
| 387 | xor $acc11,$s2,$s2 | ||
| 388 | ldx [$tbl+2048+192],%g0 ! prefetch te4 | ||
| 389 | xor $acc12,$acc14,$acc14 | ||
| 390 | xor $acc13,$s3,$s3 | ||
| 391 | ldx [$tbl+2048+224],%g0 ! prefetch te4 | ||
| 392 | srl $s1,13,$acc1 ! | ||
| 393 | xor $acc14,$s3,$s3 | ||
| 394 | xor $acc15,$s3,$s3 | ||
| 395 | ba .Lenc_loop | ||
| 396 | and $acc0,2040,$acc0 | ||
| 397 | |||
| 398 | .align 32 | ||
| 399 | .Lenc_last: | ||
| 400 | srlx $acc1,8,$acc1 ! | ||
| 401 | xor $acc0,$t0,$t0 | ||
| 402 | ld [$key+0],$s0 | ||
| 403 | srlx $acc2,16,$acc2 | ||
| 404 | xor $acc1,$t0,$t0 | ||
| 405 | ld [$key+4],$s1 | ||
| 406 | srlx $acc3,24,$acc3 | ||
| 407 | xor $acc2,$t0,$t0 | ||
| 408 | ld [$key+8],$s2 ! | ||
| 409 | srlx $acc5,8,$acc5 | ||
| 410 | xor $acc3,$t0,$t0 | ||
| 411 | ld [$key+12],$s3 | ||
| 412 | srlx $acc6,16,$acc6 | ||
| 413 | xor $acc4,$t1,$t1 | ||
| 414 | srlx $acc7,24,$acc7 | ||
| 415 | xor $acc5,$t1,$t1 | ||
| 416 | srlx $acc9,8,$acc9 ! | ||
| 417 | xor $acc6,$t1,$t1 | ||
| 418 | srlx $acc10,16,$acc10 | ||
| 419 | xor $acc7,$t1,$t1 | ||
| 420 | srlx $acc11,24,$acc11 | ||
| 421 | xor $acc8,$t2,$t2 | ||
| 422 | srlx $acc13,8,$acc13 | ||
| 423 | xor $acc9,$t2,$t2 | ||
| 424 | srlx $acc14,16,$acc14 ! | ||
| 425 | xor $acc10,$t2,$t2 | ||
| 426 | srlx $acc15,24,$acc15 | ||
| 427 | xor $acc11,$t2,$t2 | ||
| 428 | xor $acc12,$acc14,$acc14 | ||
| 429 | xor $acc13,$t3,$t3 | ||
| 430 | srl $t0,24,$acc0 | ||
| 431 | xor $acc14,$t3,$t3 | ||
| 432 | srl $t1,16,$acc1 ! | ||
| 433 | xor $acc15,$t3,$t3 | ||
| 434 | |||
| 435 | srl $t2,8,$acc2 | ||
| 436 | and $acc1,255,$acc1 | ||
| 437 | ldub [$rounds+$acc0],$acc0 | ||
| 438 | srl $t1,24,$acc4 | ||
| 439 | and $acc2,255,$acc2 | ||
| 440 | ldub [$rounds+$acc1],$acc1 | ||
| 441 | srl $t2,16,$acc5 ! | ||
| 442 | and $t3,255,$acc3 | ||
| 443 | ldub [$rounds+$acc2],$acc2 | ||
| 444 | ldub [$rounds+$acc3],$acc3 | ||
| 445 | srl $t3,8,$acc6 | ||
| 446 | and $acc5,255,$acc5 | ||
| 447 | ldub [$rounds+$acc4],$acc4 | ||
| 448 | fmovs %f0,%f0 | ||
| 449 | srl $t2,24,$acc8 ! | ||
| 450 | and $acc6,255,$acc6 | ||
| 451 | ldub [$rounds+$acc5],$acc5 | ||
| 452 | srl $t3,16,$acc9 | ||
| 453 | and $t0,255,$acc7 | ||
| 454 | ldub [$rounds+$acc6],$acc6 | ||
| 455 | ldub [$rounds+$acc7],$acc7 | ||
| 456 | fmovs %f0,%f0 | ||
| 457 | srl $t0,8,$acc10 ! | ||
| 458 | and $acc9,255,$acc9 | ||
| 459 | ldub [$rounds+$acc8],$acc8 | ||
| 460 | srl $t3,24,$acc12 | ||
| 461 | and $acc10,255,$acc10 | ||
| 462 | ldub [$rounds+$acc9],$acc9 | ||
| 463 | srl $t0,16,$acc13 | ||
| 464 | and $t1,255,$acc11 | ||
| 465 | ldub [$rounds+$acc10],$acc10 ! | ||
| 466 | srl $t1,8,$acc14 | ||
| 467 | and $acc13,255,$acc13 | ||
| 468 | ldub [$rounds+$acc11],$acc11 | ||
| 469 | ldub [$rounds+$acc12],$acc12 | ||
| 470 | and $acc14,255,$acc14 | ||
| 471 | ldub [$rounds+$acc13],$acc13 | ||
| 472 | and $t2,255,$acc15 | ||
| 473 | ldub [$rounds+$acc14],$acc14 ! | ||
| 474 | |||
| 475 | sll $acc0,24,$acc0 | ||
| 476 | xor $acc3,$s0,$s0 | ||
| 477 | ldub [$rounds+$acc15],$acc15 | ||
| 478 | sll $acc1,16,$acc1 | ||
| 479 | xor $acc0,$s0,$s0 | ||
| 480 | ldx [%sp+$bias+$frame+0],%i7 ! restore return address | ||
| 481 | fmovs %f0,%f0 | ||
| 482 | sll $acc2,8,$acc2 ! | ||
| 483 | xor $acc1,$s0,$s0 | ||
| 484 | sll $acc4,24,$acc4 | ||
| 485 | xor $acc2,$s0,$s0 | ||
| 486 | sll $acc5,16,$acc5 | ||
| 487 | xor $acc7,$s1,$s1 | ||
| 488 | sll $acc6,8,$acc6 | ||
| 489 | xor $acc4,$s1,$s1 | ||
| 490 | sll $acc8,24,$acc8 ! | ||
| 491 | xor $acc5,$s1,$s1 | ||
| 492 | sll $acc9,16,$acc9 | ||
| 493 | xor $acc11,$s2,$s2 | ||
| 494 | sll $acc10,8,$acc10 | ||
| 495 | xor $acc6,$s1,$s1 | ||
| 496 | sll $acc12,24,$acc12 | ||
| 497 | xor $acc8,$s2,$s2 | ||
| 498 | sll $acc13,16,$acc13 ! | ||
| 499 | xor $acc9,$s2,$s2 | ||
| 500 | sll $acc14,8,$acc14 | ||
| 501 | xor $acc10,$s2,$s2 | ||
| 502 | xor $acc12,$acc14,$acc14 | ||
| 503 | xor $acc13,$s3,$s3 | ||
| 504 | xor $acc14,$s3,$s3 | ||
| 505 | xor $acc15,$s3,$s3 | ||
| 506 | |||
| 507 | ret | ||
| 508 | restore | ||
| 509 | .type _sparcv9_AES_encrypt,#function | ||
| 510 | .size _sparcv9_AES_encrypt,(.-_sparcv9_AES_encrypt) | ||
| 511 | |||
| 512 | .align 32 | ||
| 513 | .globl AES_encrypt | ||
| 514 | AES_encrypt: | ||
| 515 | or %o0,%o1,%g1 | ||
| 516 | andcc %g1,3,%g0 | ||
| 517 | bnz,pn %xcc,.Lunaligned_enc | ||
| 518 | save %sp,-$frame,%sp | ||
| 519 | |||
| 520 | ld [%i0+0],%o0 | ||
| 521 | ld [%i0+4],%o1 | ||
| 522 | ld [%i0+8],%o2 | ||
| 523 | ld [%i0+12],%o3 | ||
| 524 | |||
| 525 | 1: call .+8 | ||
| 526 | add %o7,AES_Te-1b,%o4 | ||
| 527 | call _sparcv9_AES_encrypt | ||
| 528 | mov %i2,%o5 | ||
| 529 | |||
| 530 | st %o0,[%i1+0] | ||
| 531 | st %o1,[%i1+4] | ||
| 532 | st %o2,[%i1+8] | ||
| 533 | st %o3,[%i1+12] | ||
| 534 | |||
| 535 | ret | ||
| 536 | restore | ||
| 537 | |||
| 538 | .align 32 | ||
| 539 | .Lunaligned_enc: | ||
| 540 | ldub [%i0+0],%l0 | ||
| 541 | ldub [%i0+1],%l1 | ||
| 542 | ldub [%i0+2],%l2 | ||
| 543 | |||
| 544 | sll %l0,24,%l0 | ||
| 545 | ldub [%i0+3],%l3 | ||
| 546 | sll %l1,16,%l1 | ||
| 547 | ldub [%i0+4],%l4 | ||
| 548 | sll %l2,8,%l2 | ||
| 549 | or %l1,%l0,%l0 | ||
| 550 | ldub [%i0+5],%l5 | ||
| 551 | sll %l4,24,%l4 | ||
| 552 | or %l3,%l2,%l2 | ||
| 553 | ldub [%i0+6],%l6 | ||
| 554 | sll %l5,16,%l5 | ||
| 555 | or %l0,%l2,%o0 | ||
| 556 | ldub [%i0+7],%l7 | ||
| 557 | |||
| 558 | sll %l6,8,%l6 | ||
| 559 | or %l5,%l4,%l4 | ||
| 560 | ldub [%i0+8],%l0 | ||
| 561 | or %l7,%l6,%l6 | ||
| 562 | ldub [%i0+9],%l1 | ||
| 563 | or %l4,%l6,%o1 | ||
| 564 | ldub [%i0+10],%l2 | ||
| 565 | |||
| 566 | sll %l0,24,%l0 | ||
| 567 | ldub [%i0+11],%l3 | ||
| 568 | sll %l1,16,%l1 | ||
| 569 | ldub [%i0+12],%l4 | ||
| 570 | sll %l2,8,%l2 | ||
| 571 | or %l1,%l0,%l0 | ||
| 572 | ldub [%i0+13],%l5 | ||
| 573 | sll %l4,24,%l4 | ||
| 574 | or %l3,%l2,%l2 | ||
| 575 | ldub [%i0+14],%l6 | ||
| 576 | sll %l5,16,%l5 | ||
| 577 | or %l0,%l2,%o2 | ||
| 578 | ldub [%i0+15],%l7 | ||
| 579 | |||
| 580 | sll %l6,8,%l6 | ||
| 581 | or %l5,%l4,%l4 | ||
| 582 | or %l7,%l6,%l6 | ||
| 583 | or %l4,%l6,%o3 | ||
| 584 | |||
| 585 | 1: call .+8 | ||
| 586 | add %o7,AES_Te-1b,%o4 | ||
| 587 | call _sparcv9_AES_encrypt | ||
| 588 | mov %i2,%o5 | ||
| 589 | |||
| 590 | srl %o0,24,%l0 | ||
| 591 | srl %o0,16,%l1 | ||
| 592 | stb %l0,[%i1+0] | ||
| 593 | srl %o0,8,%l2 | ||
| 594 | stb %l1,[%i1+1] | ||
| 595 | stb %l2,[%i1+2] | ||
| 596 | srl %o1,24,%l4 | ||
| 597 | stb %o0,[%i1+3] | ||
| 598 | |||
| 599 | srl %o1,16,%l5 | ||
| 600 | stb %l4,[%i1+4] | ||
| 601 | srl %o1,8,%l6 | ||
| 602 | stb %l5,[%i1+5] | ||
| 603 | stb %l6,[%i1+6] | ||
| 604 | srl %o2,24,%l0 | ||
| 605 | stb %o1,[%i1+7] | ||
| 606 | |||
| 607 | srl %o2,16,%l1 | ||
| 608 | stb %l0,[%i1+8] | ||
| 609 | srl %o2,8,%l2 | ||
| 610 | stb %l1,[%i1+9] | ||
| 611 | stb %l2,[%i1+10] | ||
| 612 | srl %o3,24,%l4 | ||
| 613 | stb %o2,[%i1+11] | ||
| 614 | |||
| 615 | srl %o3,16,%l5 | ||
| 616 | stb %l4,[%i1+12] | ||
| 617 | srl %o3,8,%l6 | ||
| 618 | stb %l5,[%i1+13] | ||
| 619 | stb %l6,[%i1+14] | ||
| 620 | stb %o3,[%i1+15] | ||
| 621 | |||
| 622 | ret | ||
| 623 | restore | ||
| 624 | .type AES_encrypt,#function | ||
| 625 | .size AES_encrypt,(.-AES_encrypt) | ||
| 626 | |||
| 627 | ___ | ||
| 628 | |||
| 629 | $code.=<<___; | ||
| 630 | .align 256 | ||
| 631 | AES_Td: | ||
| 632 | ___ | ||
| 633 | &_data_word( | ||
| 634 | 0x51f4a750, 0x7e416553, 0x1a17a4c3, 0x3a275e96, | ||
| 635 | 0x3bab6bcb, 0x1f9d45f1, 0xacfa58ab, 0x4be30393, | ||
| 636 | 0x2030fa55, 0xad766df6, 0x88cc7691, 0xf5024c25, | ||
| 637 | 0x4fe5d7fc, 0xc52acbd7, 0x26354480, 0xb562a38f, | ||
| 638 | 0xdeb15a49, 0x25ba1b67, 0x45ea0e98, 0x5dfec0e1, | ||
| 639 | 0xc32f7502, 0x814cf012, 0x8d4697a3, 0x6bd3f9c6, | ||
| 640 | 0x038f5fe7, 0x15929c95, 0xbf6d7aeb, 0x955259da, | ||
| 641 | 0xd4be832d, 0x587421d3, 0x49e06929, 0x8ec9c844, | ||
| 642 | 0x75c2896a, 0xf48e7978, 0x99583e6b, 0x27b971dd, | ||
| 643 | 0xbee14fb6, 0xf088ad17, 0xc920ac66, 0x7dce3ab4, | ||
| 644 | 0x63df4a18, 0xe51a3182, 0x97513360, 0x62537f45, | ||
| 645 | 0xb16477e0, 0xbb6bae84, 0xfe81a01c, 0xf9082b94, | ||
| 646 | 0x70486858, 0x8f45fd19, 0x94de6c87, 0x527bf8b7, | ||
| 647 | 0xab73d323, 0x724b02e2, 0xe31f8f57, 0x6655ab2a, | ||
| 648 | 0xb2eb2807, 0x2fb5c203, 0x86c57b9a, 0xd33708a5, | ||
| 649 | 0x302887f2, 0x23bfa5b2, 0x02036aba, 0xed16825c, | ||
| 650 | 0x8acf1c2b, 0xa779b492, 0xf307f2f0, 0x4e69e2a1, | ||
| 651 | 0x65daf4cd, 0x0605bed5, 0xd134621f, 0xc4a6fe8a, | ||
| 652 | 0x342e539d, 0xa2f355a0, 0x058ae132, 0xa4f6eb75, | ||
| 653 | 0x0b83ec39, 0x4060efaa, 0x5e719f06, 0xbd6e1051, | ||
| 654 | 0x3e218af9, 0x96dd063d, 0xdd3e05ae, 0x4de6bd46, | ||
| 655 | 0x91548db5, 0x71c45d05, 0x0406d46f, 0x605015ff, | ||
| 656 | 0x1998fb24, 0xd6bde997, 0x894043cc, 0x67d99e77, | ||
| 657 | 0xb0e842bd, 0x07898b88, 0xe7195b38, 0x79c8eedb, | ||
| 658 | 0xa17c0a47, 0x7c420fe9, 0xf8841ec9, 0x00000000, | ||
| 659 | 0x09808683, 0x322bed48, 0x1e1170ac, 0x6c5a724e, | ||
| 660 | 0xfd0efffb, 0x0f853856, 0x3daed51e, 0x362d3927, | ||
| 661 | 0x0a0fd964, 0x685ca621, 0x9b5b54d1, 0x24362e3a, | ||
| 662 | 0x0c0a67b1, 0x9357e70f, 0xb4ee96d2, 0x1b9b919e, | ||
| 663 | 0x80c0c54f, 0x61dc20a2, 0x5a774b69, 0x1c121a16, | ||
| 664 | 0xe293ba0a, 0xc0a02ae5, 0x3c22e043, 0x121b171d, | ||
| 665 | 0x0e090d0b, 0xf28bc7ad, 0x2db6a8b9, 0x141ea9c8, | ||
| 666 | 0x57f11985, 0xaf75074c, 0xee99ddbb, 0xa37f60fd, | ||
| 667 | 0xf701269f, 0x5c72f5bc, 0x44663bc5, 0x5bfb7e34, | ||
| 668 | 0x8b432976, 0xcb23c6dc, 0xb6edfc68, 0xb8e4f163, | ||
| 669 | 0xd731dcca, 0x42638510, 0x13972240, 0x84c61120, | ||
| 670 | 0x854a247d, 0xd2bb3df8, 0xaef93211, 0xc729a16d, | ||
| 671 | 0x1d9e2f4b, 0xdcb230f3, 0x0d8652ec, 0x77c1e3d0, | ||
| 672 | 0x2bb3166c, 0xa970b999, 0x119448fa, 0x47e96422, | ||
| 673 | 0xa8fc8cc4, 0xa0f03f1a, 0x567d2cd8, 0x223390ef, | ||
| 674 | 0x87494ec7, 0xd938d1c1, 0x8ccaa2fe, 0x98d40b36, | ||
| 675 | 0xa6f581cf, 0xa57ade28, 0xdab78e26, 0x3fadbfa4, | ||
| 676 | 0x2c3a9de4, 0x5078920d, 0x6a5fcc9b, 0x547e4662, | ||
| 677 | 0xf68d13c2, 0x90d8b8e8, 0x2e39f75e, 0x82c3aff5, | ||
| 678 | 0x9f5d80be, 0x69d0937c, 0x6fd52da9, 0xcf2512b3, | ||
| 679 | 0xc8ac993b, 0x10187da7, 0xe89c636e, 0xdb3bbb7b, | ||
| 680 | 0xcd267809, 0x6e5918f4, 0xec9ab701, 0x834f9aa8, | ||
| 681 | 0xe6956e65, 0xaaffe67e, 0x21bccf08, 0xef15e8e6, | ||
| 682 | 0xbae79bd9, 0x4a6f36ce, 0xea9f09d4, 0x29b07cd6, | ||
| 683 | 0x31a4b2af, 0x2a3f2331, 0xc6a59430, 0x35a266c0, | ||
| 684 | 0x744ebc37, 0xfc82caa6, 0xe090d0b0, 0x33a7d815, | ||
| 685 | 0xf104984a, 0x41ecdaf7, 0x7fcd500e, 0x1791f62f, | ||
| 686 | 0x764dd68d, 0x43efb04d, 0xccaa4d54, 0xe49604df, | ||
| 687 | 0x9ed1b5e3, 0x4c6a881b, 0xc12c1fb8, 0x4665517f, | ||
| 688 | 0x9d5eea04, 0x018c355d, 0xfa877473, 0xfb0b412e, | ||
| 689 | 0xb3671d5a, 0x92dbd252, 0xe9105633, 0x6dd64713, | ||
| 690 | 0x9ad7618c, 0x37a10c7a, 0x59f8148e, 0xeb133c89, | ||
| 691 | 0xcea927ee, 0xb761c935, 0xe11ce5ed, 0x7a47b13c, | ||
| 692 | 0x9cd2df59, 0x55f2733f, 0x1814ce79, 0x73c737bf, | ||
| 693 | 0x53f7cdea, 0x5ffdaa5b, 0xdf3d6f14, 0x7844db86, | ||
| 694 | 0xcaaff381, 0xb968c43e, 0x3824342c, 0xc2a3405f, | ||
| 695 | 0x161dc372, 0xbce2250c, 0x283c498b, 0xff0d9541, | ||
| 696 | 0x39a80171, 0x080cb3de, 0xd8b4e49c, 0x6456c190, | ||
| 697 | 0x7bcb8461, 0xd532b670, 0x486c5c74, 0xd0b85742); | ||
| 698 | $code.=<<___; | ||
| 699 | .byte 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38 | ||
| 700 | .byte 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb | ||
| 701 | .byte 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87 | ||
| 702 | .byte 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb | ||
| 703 | .byte 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d | ||
| 704 | .byte 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e | ||
| 705 | .byte 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2 | ||
| 706 | .byte 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25 | ||
| 707 | .byte 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16 | ||
| 708 | .byte 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92 | ||
| 709 | .byte 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda | ||
| 710 | .byte 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84 | ||
| 711 | .byte 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a | ||
| 712 | .byte 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06 | ||
| 713 | .byte 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02 | ||
| 714 | .byte 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b | ||
| 715 | .byte 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea | ||
| 716 | .byte 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73 | ||
| 717 | .byte 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85 | ||
| 718 | .byte 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e | ||
| 719 | .byte 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89 | ||
| 720 | .byte 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b | ||
| 721 | .byte 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20 | ||
| 722 | .byte 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4 | ||
| 723 | .byte 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31 | ||
| 724 | .byte 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f | ||
| 725 | .byte 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d | ||
| 726 | .byte 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef | ||
| 727 | .byte 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0 | ||
| 728 | .byte 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61 | ||
| 729 | .byte 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26 | ||
| 730 | .byte 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d | ||
| 731 | .type AES_Td,#object | ||
| 732 | .size AES_Td,(.-AES_Td) | ||
| 733 | |||
| 734 | .align 64 | ||
| 735 | .skip 16 | ||
| 736 | _sparcv9_AES_decrypt: | ||
| 737 | save %sp,-$frame-$locals,%sp | ||
| 738 | stx %i7,[%sp+$bias+$frame+0] ! off-load return address | ||
| 739 | ld [$key+240],$rounds | ||
| 740 | ld [$key+0],$t0 | ||
| 741 | ld [$key+4],$t1 ! | ||
| 742 | ld [$key+8],$t2 | ||
| 743 | ld [$key+12],$t3 | ||
| 744 | srl $rounds,1,$rounds | ||
| 745 | xor $t0,$s0,$s0 | ||
| 746 | ld [$key+16],$t0 | ||
| 747 | xor $t1,$s1,$s1 | ||
| 748 | ld [$key+20],$t1 | ||
| 749 | srl $s0,21,$acc0 ! | ||
| 750 | xor $t2,$s2,$s2 | ||
| 751 | ld [$key+24],$t2 | ||
| 752 | xor $t3,$s3,$s3 | ||
| 753 | and $acc0,2040,$acc0 | ||
| 754 | ld [$key+28],$t3 | ||
| 755 | srl $s3,13,$acc1 | ||
| 756 | nop | ||
| 757 | .Ldec_loop: | ||
| 758 | srl $s2,5,$acc2 ! | ||
| 759 | and $acc1,2040,$acc1 | ||
| 760 | ldx [$tbl+$acc0],$acc0 | ||
| 761 | sll $s1,3,$acc3 | ||
| 762 | and $acc2,2040,$acc2 | ||
| 763 | ldx [$tbl+$acc1],$acc1 | ||
| 764 | srl $s1,21,$acc4 | ||
| 765 | and $acc3,2040,$acc3 | ||
| 766 | ldx [$tbl+$acc2],$acc2 ! | ||
| 767 | srl $s0,13,$acc5 | ||
| 768 | and $acc4,2040,$acc4 | ||
| 769 | ldx [$tbl+$acc3],$acc3 | ||
| 770 | srl $s3,5,$acc6 | ||
| 771 | and $acc5,2040,$acc5 | ||
| 772 | ldx [$tbl+$acc4],$acc4 | ||
| 773 | fmovs %f0,%f0 | ||
| 774 | sll $s2,3,$acc7 ! | ||
| 775 | and $acc6,2040,$acc6 | ||
| 776 | ldx [$tbl+$acc5],$acc5 | ||
| 777 | srl $s2,21,$acc8 | ||
| 778 | and $acc7,2040,$acc7 | ||
| 779 | ldx [$tbl+$acc6],$acc6 | ||
| 780 | srl $s1,13,$acc9 | ||
| 781 | and $acc8,2040,$acc8 | ||
| 782 | ldx [$tbl+$acc7],$acc7 ! | ||
| 783 | srl $s0,5,$acc10 | ||
| 784 | and $acc9,2040,$acc9 | ||
| 785 | ldx [$tbl+$acc8],$acc8 | ||
| 786 | sll $s3,3,$acc11 | ||
| 787 | and $acc10,2040,$acc10 | ||
| 788 | ldx [$tbl+$acc9],$acc9 | ||
| 789 | fmovs %f0,%f0 | ||
| 790 | srl $s3,21,$acc12 ! | ||
| 791 | and $acc11,2040,$acc11 | ||
| 792 | ldx [$tbl+$acc10],$acc10 | ||
| 793 | srl $s2,13,$acc13 | ||
| 794 | and $acc12,2040,$acc12 | ||
| 795 | ldx [$tbl+$acc11],$acc11 | ||
| 796 | srl $s1,5,$acc14 | ||
| 797 | and $acc13,2040,$acc13 | ||
| 798 | ldx [$tbl+$acc12],$acc12 ! | ||
| 799 | sll $s0,3,$acc15 | ||
| 800 | and $acc14,2040,$acc14 | ||
| 801 | ldx [$tbl+$acc13],$acc13 | ||
| 802 | and $acc15,2040,$acc15 | ||
| 803 | add $key,32,$key | ||
| 804 | ldx [$tbl+$acc14],$acc14 | ||
| 805 | fmovs %f0,%f0 | ||
| 806 | subcc $rounds,1,$rounds ! | ||
| 807 | ldx [$tbl+$acc15],$acc15 | ||
| 808 | bz,a,pn %icc,.Ldec_last | ||
| 809 | add $tbl,2048,$rounds | ||
| 810 | |||
| 811 | srlx $acc1,8,$acc1 | ||
| 812 | xor $acc0,$t0,$t0 | ||
| 813 | ld [$key+0],$s0 | ||
| 814 | fmovs %f0,%f0 | ||
| 815 | srlx $acc2,16,$acc2 ! | ||
| 816 | xor $acc1,$t0,$t0 | ||
| 817 | ld [$key+4],$s1 | ||
| 818 | srlx $acc3,24,$acc3 | ||
| 819 | xor $acc2,$t0,$t0 | ||
| 820 | ld [$key+8],$s2 | ||
| 821 | srlx $acc5,8,$acc5 | ||
| 822 | xor $acc3,$t0,$t0 | ||
| 823 | ld [$key+12],$s3 ! | ||
| 824 | srlx $acc6,16,$acc6 | ||
| 825 | xor $acc4,$t1,$t1 | ||
| 826 | fmovs %f0,%f0 | ||
| 827 | srlx $acc7,24,$acc7 | ||
| 828 | xor $acc5,$t1,$t1 | ||
| 829 | srlx $acc9,8,$acc9 | ||
| 830 | xor $acc6,$t1,$t1 | ||
| 831 | srlx $acc10,16,$acc10 ! | ||
| 832 | xor $acc7,$t1,$t1 | ||
| 833 | srlx $acc11,24,$acc11 | ||
| 834 | xor $acc8,$t2,$t2 | ||
| 835 | srlx $acc13,8,$acc13 | ||
| 836 | xor $acc9,$t2,$t2 | ||
| 837 | srlx $acc14,16,$acc14 | ||
| 838 | xor $acc10,$t2,$t2 | ||
| 839 | srlx $acc15,24,$acc15 ! | ||
| 840 | xor $acc11,$t2,$t2 | ||
| 841 | xor $acc12,$acc14,$acc14 | ||
| 842 | xor $acc13,$t3,$t3 | ||
| 843 | srl $t0,21,$acc0 | ||
| 844 | xor $acc14,$t3,$t3 | ||
| 845 | xor $acc15,$t3,$t3 | ||
| 846 | srl $t3,13,$acc1 | ||
| 847 | |||
| 848 | and $acc0,2040,$acc0 ! | ||
| 849 | srl $t2,5,$acc2 | ||
| 850 | and $acc1,2040,$acc1 | ||
| 851 | ldx [$tbl+$acc0],$acc0 | ||
| 852 | sll $t1,3,$acc3 | ||
| 853 | and $acc2,2040,$acc2 | ||
| 854 | ldx [$tbl+$acc1],$acc1 | ||
| 855 | fmovs %f0,%f0 | ||
| 856 | srl $t1,21,$acc4 ! | ||
| 857 | and $acc3,2040,$acc3 | ||
| 858 | ldx [$tbl+$acc2],$acc2 | ||
| 859 | srl $t0,13,$acc5 | ||
| 860 | and $acc4,2040,$acc4 | ||
| 861 | ldx [$tbl+$acc3],$acc3 | ||
| 862 | srl $t3,5,$acc6 | ||
| 863 | and $acc5,2040,$acc5 | ||
| 864 | ldx [$tbl+$acc4],$acc4 ! | ||
| 865 | sll $t2,3,$acc7 | ||
| 866 | and $acc6,2040,$acc6 | ||
| 867 | ldx [$tbl+$acc5],$acc5 | ||
| 868 | srl $t2,21,$acc8 | ||
| 869 | and $acc7,2040,$acc7 | ||
| 870 | ldx [$tbl+$acc6],$acc6 | ||
| 871 | fmovs %f0,%f0 | ||
| 872 | srl $t1,13,$acc9 ! | ||
| 873 | and $acc8,2040,$acc8 | ||
| 874 | ldx [$tbl+$acc7],$acc7 | ||
| 875 | srl $t0,5,$acc10 | ||
| 876 | and $acc9,2040,$acc9 | ||
| 877 | ldx [$tbl+$acc8],$acc8 | ||
| 878 | sll $t3,3,$acc11 | ||
| 879 | and $acc10,2040,$acc10 | ||
| 880 | ldx [$tbl+$acc9],$acc9 ! | ||
| 881 | srl $t3,21,$acc12 | ||
| 882 | and $acc11,2040,$acc11 | ||
| 883 | ldx [$tbl+$acc10],$acc10 | ||
| 884 | srl $t2,13,$acc13 | ||
| 885 | and $acc12,2040,$acc12 | ||
| 886 | ldx [$tbl+$acc11],$acc11 | ||
| 887 | fmovs %f0,%f0 | ||
| 888 | srl $t1,5,$acc14 ! | ||
| 889 | and $acc13,2040,$acc13 | ||
| 890 | ldx [$tbl+$acc12],$acc12 | ||
| 891 | sll $t0,3,$acc15 | ||
| 892 | and $acc14,2040,$acc14 | ||
| 893 | ldx [$tbl+$acc13],$acc13 | ||
| 894 | srlx $acc1,8,$acc1 | ||
| 895 | and $acc15,2040,$acc15 | ||
| 896 | ldx [$tbl+$acc14],$acc14 ! | ||
| 897 | |||
| 898 | srlx $acc2,16,$acc2 | ||
| 899 | xor $acc0,$s0,$s0 | ||
| 900 | ldx [$tbl+$acc15],$acc15 | ||
| 901 | srlx $acc3,24,$acc3 | ||
| 902 | xor $acc1,$s0,$s0 | ||
| 903 | ld [$key+16],$t0 | ||
| 904 | fmovs %f0,%f0 | ||
| 905 | srlx $acc5,8,$acc5 ! | ||
| 906 | xor $acc2,$s0,$s0 | ||
| 907 | ld [$key+20],$t1 | ||
| 908 | srlx $acc6,16,$acc6 | ||
| 909 | xor $acc3,$s0,$s0 | ||
| 910 | ld [$key+24],$t2 | ||
| 911 | srlx $acc7,24,$acc7 | ||
| 912 | xor $acc4,$s1,$s1 | ||
| 913 | ld [$key+28],$t3 ! | ||
| 914 | srlx $acc9,8,$acc9 | ||
| 915 | xor $acc5,$s1,$s1 | ||
| 916 | ldx [$tbl+2048+0],%g0 ! prefetch td4 | ||
| 917 | srlx $acc10,16,$acc10 | ||
| 918 | xor $acc6,$s1,$s1 | ||
| 919 | ldx [$tbl+2048+32],%g0 ! prefetch td4 | ||
| 920 | srlx $acc11,24,$acc11 | ||
| 921 | xor $acc7,$s1,$s1 | ||
| 922 | ldx [$tbl+2048+64],%g0 ! prefetch td4 | ||
| 923 | srlx $acc13,8,$acc13 | ||
| 924 | xor $acc8,$s2,$s2 | ||
| 925 | ldx [$tbl+2048+96],%g0 ! prefetch td4 | ||
| 926 | srlx $acc14,16,$acc14 ! | ||
| 927 | xor $acc9,$s2,$s2 | ||
| 928 | ldx [$tbl+2048+128],%g0 ! prefetch td4 | ||
| 929 | srlx $acc15,24,$acc15 | ||
| 930 | xor $acc10,$s2,$s2 | ||
| 931 | ldx [$tbl+2048+160],%g0 ! prefetch td4 | ||
| 932 | srl $s0,21,$acc0 | ||
| 933 | xor $acc11,$s2,$s2 | ||
| 934 | ldx [$tbl+2048+192],%g0 ! prefetch td4 | ||
| 935 | xor $acc12,$acc14,$acc14 | ||
| 936 | xor $acc13,$s3,$s3 | ||
| 937 | ldx [$tbl+2048+224],%g0 ! prefetch td4 | ||
| 938 | and $acc0,2040,$acc0 ! | ||
| 939 | xor $acc14,$s3,$s3 | ||
| 940 | xor $acc15,$s3,$s3 | ||
| 941 | ba .Ldec_loop | ||
| 942 | srl $s3,13,$acc1 | ||
| 943 | |||
| 944 | .align 32 | ||
| 945 | .Ldec_last: | ||
| 946 | srlx $acc1,8,$acc1 ! | ||
| 947 | xor $acc0,$t0,$t0 | ||
| 948 | ld [$key+0],$s0 | ||
| 949 | srlx $acc2,16,$acc2 | ||
| 950 | xor $acc1,$t0,$t0 | ||
| 951 | ld [$key+4],$s1 | ||
| 952 | srlx $acc3,24,$acc3 | ||
| 953 | xor $acc2,$t0,$t0 | ||
| 954 | ld [$key+8],$s2 ! | ||
| 955 | srlx $acc5,8,$acc5 | ||
| 956 | xor $acc3,$t0,$t0 | ||
| 957 | ld [$key+12],$s3 | ||
| 958 | srlx $acc6,16,$acc6 | ||
| 959 | xor $acc4,$t1,$t1 | ||
| 960 | srlx $acc7,24,$acc7 | ||
| 961 | xor $acc5,$t1,$t1 | ||
| 962 | srlx $acc9,8,$acc9 ! | ||
| 963 | xor $acc6,$t1,$t1 | ||
| 964 | srlx $acc10,16,$acc10 | ||
| 965 | xor $acc7,$t1,$t1 | ||
| 966 | srlx $acc11,24,$acc11 | ||
| 967 | xor $acc8,$t2,$t2 | ||
| 968 | srlx $acc13,8,$acc13 | ||
| 969 | xor $acc9,$t2,$t2 | ||
| 970 | srlx $acc14,16,$acc14 ! | ||
| 971 | xor $acc10,$t2,$t2 | ||
| 972 | srlx $acc15,24,$acc15 | ||
| 973 | xor $acc11,$t2,$t2 | ||
| 974 | xor $acc12,$acc14,$acc14 | ||
| 975 | xor $acc13,$t3,$t3 | ||
| 976 | srl $t0,24,$acc0 | ||
| 977 | xor $acc14,$t3,$t3 | ||
| 978 | xor $acc15,$t3,$t3 ! | ||
| 979 | srl $t3,16,$acc1 | ||
| 980 | |||
| 981 | srl $t2,8,$acc2 | ||
| 982 | and $acc1,255,$acc1 | ||
| 983 | ldub [$rounds+$acc0],$acc0 | ||
| 984 | srl $t1,24,$acc4 | ||
| 985 | and $acc2,255,$acc2 | ||
| 986 | ldub [$rounds+$acc1],$acc1 | ||
| 987 | srl $t0,16,$acc5 ! | ||
| 988 | and $t1,255,$acc3 | ||
| 989 | ldub [$rounds+$acc2],$acc2 | ||
| 990 | ldub [$rounds+$acc3],$acc3 | ||
| 991 | srl $t3,8,$acc6 | ||
| 992 | and $acc5,255,$acc5 | ||
| 993 | ldub [$rounds+$acc4],$acc4 | ||
| 994 | fmovs %f0,%f0 | ||
| 995 | srl $t2,24,$acc8 ! | ||
| 996 | and $acc6,255,$acc6 | ||
| 997 | ldub [$rounds+$acc5],$acc5 | ||
| 998 | srl $t1,16,$acc9 | ||
| 999 | and $t2,255,$acc7 | ||
| 1000 | ldub [$rounds+$acc6],$acc6 | ||
| 1001 | ldub [$rounds+$acc7],$acc7 | ||
| 1002 | fmovs %f0,%f0 | ||
| 1003 | srl $t0,8,$acc10 ! | ||
| 1004 | and $acc9,255,$acc9 | ||
| 1005 | ldub [$rounds+$acc8],$acc8 | ||
| 1006 | srl $t3,24,$acc12 | ||
| 1007 | and $acc10,255,$acc10 | ||
| 1008 | ldub [$rounds+$acc9],$acc9 | ||
| 1009 | srl $t2,16,$acc13 | ||
| 1010 | and $t3,255,$acc11 | ||
| 1011 | ldub [$rounds+$acc10],$acc10 ! | ||
| 1012 | srl $t1,8,$acc14 | ||
| 1013 | and $acc13,255,$acc13 | ||
| 1014 | ldub [$rounds+$acc11],$acc11 | ||
| 1015 | ldub [$rounds+$acc12],$acc12 | ||
| 1016 | and $acc14,255,$acc14 | ||
| 1017 | ldub [$rounds+$acc13],$acc13 | ||
| 1018 | and $t0,255,$acc15 | ||
| 1019 | ldub [$rounds+$acc14],$acc14 ! | ||
| 1020 | |||
| 1021 | sll $acc0,24,$acc0 | ||
| 1022 | xor $acc3,$s0,$s0 | ||
| 1023 | ldub [$rounds+$acc15],$acc15 | ||
| 1024 | sll $acc1,16,$acc1 | ||
| 1025 | xor $acc0,$s0,$s0 | ||
| 1026 | ldx [%sp+$bias+$frame+0],%i7 ! restore return address | ||
| 1027 | fmovs %f0,%f0 | ||
| 1028 | sll $acc2,8,$acc2 ! | ||
| 1029 | xor $acc1,$s0,$s0 | ||
| 1030 | sll $acc4,24,$acc4 | ||
| 1031 | xor $acc2,$s0,$s0 | ||
| 1032 | sll $acc5,16,$acc5 | ||
| 1033 | xor $acc7,$s1,$s1 | ||
| 1034 | sll $acc6,8,$acc6 | ||
| 1035 | xor $acc4,$s1,$s1 | ||
| 1036 | sll $acc8,24,$acc8 ! | ||
| 1037 | xor $acc5,$s1,$s1 | ||
| 1038 | sll $acc9,16,$acc9 | ||
| 1039 | xor $acc11,$s2,$s2 | ||
| 1040 | sll $acc10,8,$acc10 | ||
| 1041 | xor $acc6,$s1,$s1 | ||
| 1042 | sll $acc12,24,$acc12 | ||
| 1043 | xor $acc8,$s2,$s2 | ||
| 1044 | sll $acc13,16,$acc13 ! | ||
| 1045 | xor $acc9,$s2,$s2 | ||
| 1046 | sll $acc14,8,$acc14 | ||
| 1047 | xor $acc10,$s2,$s2 | ||
| 1048 | xor $acc12,$acc14,$acc14 | ||
| 1049 | xor $acc13,$s3,$s3 | ||
| 1050 | xor $acc14,$s3,$s3 | ||
| 1051 | xor $acc15,$s3,$s3 | ||
| 1052 | |||
| 1053 | ret | ||
| 1054 | restore | ||
| 1055 | .type _sparcv9_AES_decrypt,#function | ||
| 1056 | .size _sparcv9_AES_decrypt,(.-_sparcv9_AES_decrypt) | ||
| 1057 | |||
| 1058 | .align 32 | ||
| 1059 | .globl AES_decrypt | ||
| 1060 | AES_decrypt: | ||
| 1061 | or %o0,%o1,%g1 | ||
| 1062 | andcc %g1,3,%g0 | ||
| 1063 | bnz,pn %xcc,.Lunaligned_dec | ||
| 1064 | save %sp,-$frame,%sp | ||
| 1065 | |||
| 1066 | ld [%i0+0],%o0 | ||
| 1067 | ld [%i0+4],%o1 | ||
| 1068 | ld [%i0+8],%o2 | ||
| 1069 | ld [%i0+12],%o3 | ||
| 1070 | |||
| 1071 | 1: call .+8 | ||
| 1072 | add %o7,AES_Td-1b,%o4 | ||
| 1073 | call _sparcv9_AES_decrypt | ||
| 1074 | mov %i2,%o5 | ||
| 1075 | |||
| 1076 | st %o0,[%i1+0] | ||
| 1077 | st %o1,[%i1+4] | ||
| 1078 | st %o2,[%i1+8] | ||
| 1079 | st %o3,[%i1+12] | ||
| 1080 | |||
| 1081 | ret | ||
| 1082 | restore | ||
| 1083 | |||
| 1084 | .align 32 | ||
| 1085 | .Lunaligned_dec: | ||
| 1086 | ldub [%i0+0],%l0 | ||
| 1087 | ldub [%i0+1],%l1 | ||
| 1088 | ldub [%i0+2],%l2 | ||
| 1089 | |||
| 1090 | sll %l0,24,%l0 | ||
| 1091 | ldub [%i0+3],%l3 | ||
| 1092 | sll %l1,16,%l1 | ||
| 1093 | ldub [%i0+4],%l4 | ||
| 1094 | sll %l2,8,%l2 | ||
| 1095 | or %l1,%l0,%l0 | ||
| 1096 | ldub [%i0+5],%l5 | ||
| 1097 | sll %l4,24,%l4 | ||
| 1098 | or %l3,%l2,%l2 | ||
| 1099 | ldub [%i0+6],%l6 | ||
| 1100 | sll %l5,16,%l5 | ||
| 1101 | or %l0,%l2,%o0 | ||
| 1102 | ldub [%i0+7],%l7 | ||
| 1103 | |||
| 1104 | sll %l6,8,%l6 | ||
| 1105 | or %l5,%l4,%l4 | ||
| 1106 | ldub [%i0+8],%l0 | ||
| 1107 | or %l7,%l6,%l6 | ||
| 1108 | ldub [%i0+9],%l1 | ||
| 1109 | or %l4,%l6,%o1 | ||
| 1110 | ldub [%i0+10],%l2 | ||
| 1111 | |||
| 1112 | sll %l0,24,%l0 | ||
| 1113 | ldub [%i0+11],%l3 | ||
| 1114 | sll %l1,16,%l1 | ||
| 1115 | ldub [%i0+12],%l4 | ||
| 1116 | sll %l2,8,%l2 | ||
| 1117 | or %l1,%l0,%l0 | ||
| 1118 | ldub [%i0+13],%l5 | ||
| 1119 | sll %l4,24,%l4 | ||
| 1120 | or %l3,%l2,%l2 | ||
| 1121 | ldub [%i0+14],%l6 | ||
| 1122 | sll %l5,16,%l5 | ||
| 1123 | or %l0,%l2,%o2 | ||
| 1124 | ldub [%i0+15],%l7 | ||
| 1125 | |||
| 1126 | sll %l6,8,%l6 | ||
| 1127 | or %l5,%l4,%l4 | ||
| 1128 | or %l7,%l6,%l6 | ||
| 1129 | or %l4,%l6,%o3 | ||
| 1130 | |||
| 1131 | 1: call .+8 | ||
| 1132 | add %o7,AES_Td-1b,%o4 | ||
| 1133 | call _sparcv9_AES_decrypt | ||
| 1134 | mov %i2,%o5 | ||
| 1135 | |||
| 1136 | srl %o0,24,%l0 | ||
| 1137 | srl %o0,16,%l1 | ||
| 1138 | stb %l0,[%i1+0] | ||
| 1139 | srl %o0,8,%l2 | ||
| 1140 | stb %l1,[%i1+1] | ||
| 1141 | stb %l2,[%i1+2] | ||
| 1142 | srl %o1,24,%l4 | ||
| 1143 | stb %o0,[%i1+3] | ||
| 1144 | |||
| 1145 | srl %o1,16,%l5 | ||
| 1146 | stb %l4,[%i1+4] | ||
| 1147 | srl %o1,8,%l6 | ||
| 1148 | stb %l5,[%i1+5] | ||
| 1149 | stb %l6,[%i1+6] | ||
| 1150 | srl %o2,24,%l0 | ||
| 1151 | stb %o1,[%i1+7] | ||
| 1152 | |||
| 1153 | srl %o2,16,%l1 | ||
| 1154 | stb %l0,[%i1+8] | ||
| 1155 | srl %o2,8,%l2 | ||
| 1156 | stb %l1,[%i1+9] | ||
| 1157 | stb %l2,[%i1+10] | ||
| 1158 | srl %o3,24,%l4 | ||
| 1159 | stb %o2,[%i1+11] | ||
| 1160 | |||
| 1161 | srl %o3,16,%l5 | ||
| 1162 | stb %l4,[%i1+12] | ||
| 1163 | srl %o3,8,%l6 | ||
| 1164 | stb %l5,[%i1+13] | ||
| 1165 | stb %l6,[%i1+14] | ||
| 1166 | stb %o3,[%i1+15] | ||
| 1167 | |||
| 1168 | ret | ||
| 1169 | restore | ||
| 1170 | .type AES_decrypt,#function | ||
| 1171 | .size AES_decrypt,(.-AES_decrypt) | ||
| 1172 | ___ | ||
| 1173 | |||
| 1174 | # fmovs instructions substituting for FP nops were originally added | ||
| 1175 | # to meet specific instruction alignment requirements to maximize ILP. | ||
| 1176 | # As UltraSPARC T1, a.k.a. Niagara, has shared FPU, FP nops can have | ||
| 1177 | # undesired effect, so just omit them and sacrifice some portion of | ||
| 1178 | # percent in performance... | ||
| 1179 | $code =~ s/fmovs.*$//gem; | ||
| 1180 | |||
| 1181 | print $code; | ||
diff --git a/src/lib/libssl/src/crypto/asn1/ameth_lib.c b/src/lib/libssl/src/crypto/asn1/ameth_lib.c new file mode 100644 index 0000000000..18957c669e --- /dev/null +++ b/src/lib/libssl/src/crypto/asn1/ameth_lib.c | |||
| @@ -0,0 +1,446 @@ | |||
| 1 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL | ||
| 2 | * project 2006. | ||
| 3 | */ | ||
| 4 | /* ==================================================================== | ||
| 5 | * Copyright (c) 2006 The OpenSSL Project. All rights reserved. | ||
| 6 | * | ||
| 7 | * Redistribution and use in source and binary forms, with or without | ||
| 8 | * modification, are permitted provided that the following conditions | ||
| 9 | * are met: | ||
| 10 | * | ||
| 11 | * 1. Redistributions of source code must retain the above copyright | ||
| 12 | * notice, this list of conditions and the following disclaimer. | ||
| 13 | * | ||
| 14 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 15 | * notice, this list of conditions and the following disclaimer in | ||
| 16 | * the documentation and/or other materials provided with the | ||
| 17 | * distribution. | ||
| 18 | * | ||
| 19 | * 3. All advertising materials mentioning features or use of this | ||
| 20 | * software must display the following acknowledgment: | ||
| 21 | * "This product includes software developed by the OpenSSL Project | ||
| 22 | * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" | ||
| 23 | * | ||
| 24 | * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to | ||
| 25 | * endorse or promote products derived from this software without | ||
| 26 | * prior written permission. For written permission, please contact | ||
| 27 | * licensing@OpenSSL.org. | ||
| 28 | * | ||
| 29 | * 5. Products derived from this software may not be called "OpenSSL" | ||
| 30 | * nor may "OpenSSL" appear in their names without prior written | ||
| 31 | * permission of the OpenSSL Project. | ||
| 32 | * | ||
| 33 | * 6. Redistributions of any form whatsoever must retain the following | ||
| 34 | * acknowledgment: | ||
| 35 | * "This product includes software developed by the OpenSSL Project | ||
| 36 | * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" | ||
| 37 | * | ||
| 38 | * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY | ||
| 39 | * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 40 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | ||
| 41 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR | ||
| 42 | * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | ||
| 43 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | ||
| 44 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
| 45 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 46 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | ||
| 47 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | ||
| 48 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED | ||
| 49 | * OF THE POSSIBILITY OF SUCH DAMAGE. | ||
| 50 | * ==================================================================== | ||
| 51 | * | ||
| 52 | * This product includes cryptographic software written by Eric Young | ||
| 53 | * (eay@cryptsoft.com). This product includes software written by Tim | ||
| 54 | * Hudson (tjh@cryptsoft.com). | ||
| 55 | * | ||
| 56 | */ | ||
| 57 | |||
| 58 | #include <stdio.h> | ||
| 59 | #include "cryptlib.h" | ||
| 60 | #include <openssl/asn1t.h> | ||
| 61 | #include <openssl/x509.h> | ||
| 62 | #ifndef OPENSSL_NO_ENGINE | ||
| 63 | #include <openssl/engine.h> | ||
| 64 | #endif | ||
| 65 | #include "asn1_locl.h" | ||
| 66 | |||
| 67 | extern const EVP_PKEY_ASN1_METHOD rsa_asn1_meths[]; | ||
| 68 | extern const EVP_PKEY_ASN1_METHOD dsa_asn1_meths[]; | ||
| 69 | extern const EVP_PKEY_ASN1_METHOD dh_asn1_meth; | ||
| 70 | extern const EVP_PKEY_ASN1_METHOD eckey_asn1_meth; | ||
| 71 | extern const EVP_PKEY_ASN1_METHOD hmac_asn1_meth; | ||
| 72 | |||
| 73 | /* Keep this sorted in type order !! */ | ||
| 74 | static const EVP_PKEY_ASN1_METHOD *standard_methods[] = | ||
| 75 | { | ||
| 76 | #ifndef OPENSSL_NO_RSA | ||
| 77 | &rsa_asn1_meths[0], | ||
| 78 | &rsa_asn1_meths[1], | ||
| 79 | #endif | ||
| 80 | #ifndef OPENSSL_NO_DH | ||
| 81 | &dh_asn1_meth, | ||
| 82 | #endif | ||
| 83 | #ifndef OPENSSL_NO_DSA | ||
| 84 | &dsa_asn1_meths[0], | ||
| 85 | &dsa_asn1_meths[1], | ||
| 86 | &dsa_asn1_meths[2], | ||
| 87 | &dsa_asn1_meths[3], | ||
| 88 | &dsa_asn1_meths[4], | ||
| 89 | #endif | ||
| 90 | #ifndef OPENSSL_NO_EC | ||
| 91 | &eckey_asn1_meth, | ||
| 92 | #endif | ||
| 93 | &hmac_asn1_meth | ||
| 94 | }; | ||
| 95 | |||
| 96 | typedef int sk_cmp_fn_type(const char * const *a, const char * const *b); | ||
| 97 | DECLARE_STACK_OF(EVP_PKEY_ASN1_METHOD) | ||
| 98 | static STACK_OF(EVP_PKEY_ASN1_METHOD) *app_methods = NULL; | ||
| 99 | |||
| 100 | |||
| 101 | |||
| 102 | #ifdef TEST | ||
| 103 | void main() | ||
| 104 | { | ||
| 105 | int i; | ||
| 106 | for (i = 0; | ||
| 107 | i < sizeof(standard_methods)/sizeof(EVP_PKEY_ASN1_METHOD *); | ||
| 108 | i++) | ||
| 109 | fprintf(stderr, "Number %d id=%d (%s)\n", i, | ||
| 110 | standard_methods[i]->pkey_id, | ||
| 111 | OBJ_nid2sn(standard_methods[i]->pkey_id)); | ||
| 112 | } | ||
| 113 | #endif | ||
| 114 | |||
| 115 | DECLARE_OBJ_BSEARCH_CMP_FN(const EVP_PKEY_ASN1_METHOD *, | ||
| 116 | const EVP_PKEY_ASN1_METHOD *, ameth); | ||
| 117 | |||
| 118 | static int ameth_cmp(const EVP_PKEY_ASN1_METHOD * const *a, | ||
| 119 | const EVP_PKEY_ASN1_METHOD * const *b) | ||
| 120 | { | ||
| 121 | return ((*a)->pkey_id - (*b)->pkey_id); | ||
| 122 | } | ||
| 123 | |||
| 124 | IMPLEMENT_OBJ_BSEARCH_CMP_FN(const EVP_PKEY_ASN1_METHOD *, | ||
| 125 | const EVP_PKEY_ASN1_METHOD *, ameth); | ||
| 126 | |||
| 127 | int EVP_PKEY_asn1_get_count(void) | ||
| 128 | { | ||
| 129 | int num = sizeof(standard_methods)/sizeof(EVP_PKEY_ASN1_METHOD *); | ||
| 130 | if (app_methods) | ||
| 131 | num += sk_EVP_PKEY_ASN1_METHOD_num(app_methods); | ||
| 132 | return num; | ||
| 133 | } | ||
| 134 | |||
| 135 | const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_get0(int idx) | ||
| 136 | { | ||
| 137 | int num = sizeof(standard_methods)/sizeof(EVP_PKEY_ASN1_METHOD *); | ||
| 138 | if (idx < 0) | ||
| 139 | return NULL; | ||
| 140 | if (idx < num) | ||
| 141 | return standard_methods[idx]; | ||
| 142 | idx -= num; | ||
| 143 | return sk_EVP_PKEY_ASN1_METHOD_value(app_methods, idx); | ||
| 144 | } | ||
| 145 | |||
| 146 | static const EVP_PKEY_ASN1_METHOD *pkey_asn1_find(int type) | ||
| 147 | { | ||
| 148 | EVP_PKEY_ASN1_METHOD tmp; | ||
| 149 | const EVP_PKEY_ASN1_METHOD *t = &tmp, **ret; | ||
| 150 | tmp.pkey_id = type; | ||
| 151 | if (app_methods) | ||
| 152 | { | ||
| 153 | int idx; | ||
| 154 | idx = sk_EVP_PKEY_ASN1_METHOD_find(app_methods, &tmp); | ||
| 155 | if (idx >= 0) | ||
| 156 | return sk_EVP_PKEY_ASN1_METHOD_value(app_methods, idx); | ||
| 157 | } | ||
| 158 | ret = OBJ_bsearch_ameth(&t, standard_methods, | ||
| 159 | sizeof(standard_methods) | ||
| 160 | /sizeof(EVP_PKEY_ASN1_METHOD *)); | ||
| 161 | if (!ret || !*ret) | ||
| 162 | return NULL; | ||
| 163 | return *ret; | ||
| 164 | } | ||
| 165 | |||
| 166 | /* Find an implementation of an ASN1 algorithm. If 'pe' is not NULL | ||
| 167 | * also search through engines and set *pe to a functional reference | ||
| 168 | * to the engine implementing 'type' or NULL if no engine implements | ||
| 169 | * it. | ||
| 170 | */ | ||
| 171 | |||
| 172 | const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find(ENGINE **pe, int type) | ||
| 173 | { | ||
| 174 | const EVP_PKEY_ASN1_METHOD *t; | ||
| 175 | ENGINE *e; | ||
| 176 | |||
| 177 | for (;;) | ||
| 178 | { | ||
| 179 | t = pkey_asn1_find(type); | ||
| 180 | if (!t || !(t->pkey_flags & ASN1_PKEY_ALIAS)) | ||
| 181 | break; | ||
| 182 | type = t->pkey_base_id; | ||
| 183 | } | ||
| 184 | if (pe) | ||
| 185 | { | ||
| 186 | #ifndef OPENSSL_NO_ENGINE | ||
| 187 | /* type will contain the final unaliased type */ | ||
| 188 | e = ENGINE_get_pkey_asn1_meth_engine(type); | ||
| 189 | if (e) | ||
| 190 | { | ||
| 191 | *pe = e; | ||
| 192 | return ENGINE_get_pkey_asn1_meth(e, type); | ||
| 193 | } | ||
| 194 | #endif | ||
| 195 | *pe = NULL; | ||
| 196 | } | ||
| 197 | return t; | ||
| 198 | } | ||
| 199 | |||
| 200 | const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find_str(ENGINE **pe, | ||
| 201 | const char *str, int len) | ||
| 202 | { | ||
| 203 | int i; | ||
| 204 | const EVP_PKEY_ASN1_METHOD *ameth; | ||
| 205 | if (len == -1) | ||
| 206 | len = strlen(str); | ||
| 207 | if (pe) | ||
| 208 | { | ||
| 209 | #ifndef OPENSSL_NO_ENGINE | ||
| 210 | ENGINE *e; | ||
| 211 | ameth = ENGINE_pkey_asn1_find_str(&e, str, len); | ||
| 212 | if (ameth) | ||
| 213 | { | ||
| 214 | /* Convert structural into | ||
| 215 | * functional reference | ||
| 216 | */ | ||
| 217 | if (!ENGINE_init(e)) | ||
| 218 | ameth = NULL; | ||
| 219 | ENGINE_free(e); | ||
| 220 | *pe = e; | ||
| 221 | return ameth; | ||
| 222 | } | ||
| 223 | #endif | ||
| 224 | *pe = NULL; | ||
| 225 | } | ||
| 226 | for (i = 0; i < EVP_PKEY_asn1_get_count(); i++) | ||
| 227 | { | ||
| 228 | ameth = EVP_PKEY_asn1_get0(i); | ||
| 229 | if (ameth->pkey_flags & ASN1_PKEY_ALIAS) | ||
| 230 | continue; | ||
| 231 | if (((int)strlen(ameth->pem_str) == len) && | ||
| 232 | !strncasecmp(ameth->pem_str, str, len)) | ||
| 233 | return ameth; | ||
| 234 | } | ||
| 235 | return NULL; | ||
| 236 | } | ||
| 237 | |||
| 238 | int EVP_PKEY_asn1_add0(const EVP_PKEY_ASN1_METHOD *ameth) | ||
| 239 | { | ||
| 240 | if (app_methods == NULL) | ||
| 241 | { | ||
| 242 | app_methods = sk_EVP_PKEY_ASN1_METHOD_new(ameth_cmp); | ||
| 243 | if (!app_methods) | ||
| 244 | return 0; | ||
| 245 | } | ||
| 246 | if (!sk_EVP_PKEY_ASN1_METHOD_push(app_methods, ameth)) | ||
| 247 | return 0; | ||
| 248 | sk_EVP_PKEY_ASN1_METHOD_sort(app_methods); | ||
| 249 | return 1; | ||
| 250 | } | ||
| 251 | |||
| 252 | int EVP_PKEY_asn1_add_alias(int to, int from) | ||
| 253 | { | ||
| 254 | EVP_PKEY_ASN1_METHOD *ameth; | ||
| 255 | ameth = EVP_PKEY_asn1_new(from, ASN1_PKEY_ALIAS, NULL, NULL); | ||
| 256 | if (!ameth) | ||
| 257 | return 0; | ||
| 258 | ameth->pkey_base_id = to; | ||
| 259 | return EVP_PKEY_asn1_add0(ameth); | ||
| 260 | } | ||
| 261 | |||
| 262 | int EVP_PKEY_asn1_get0_info(int *ppkey_id, int *ppkey_base_id, int *ppkey_flags, | ||
| 263 | const char **pinfo, const char **ppem_str, | ||
| 264 | const EVP_PKEY_ASN1_METHOD *ameth) | ||
| 265 | { | ||
| 266 | if (!ameth) | ||
| 267 | return 0; | ||
| 268 | if (ppkey_id) | ||
| 269 | *ppkey_id = ameth->pkey_id; | ||
| 270 | if (ppkey_base_id) | ||
| 271 | *ppkey_base_id = ameth->pkey_base_id; | ||
| 272 | if (ppkey_flags) | ||
| 273 | *ppkey_flags = ameth->pkey_flags; | ||
| 274 | if (pinfo) | ||
| 275 | *pinfo = ameth->info; | ||
| 276 | if (ppem_str) | ||
| 277 | *ppem_str = ameth->pem_str; | ||
| 278 | return 1; | ||
| 279 | } | ||
| 280 | |||
| 281 | const EVP_PKEY_ASN1_METHOD* EVP_PKEY_get0_asn1(EVP_PKEY *pkey) | ||
| 282 | { | ||
| 283 | return pkey->ameth; | ||
| 284 | } | ||
| 285 | |||
| 286 | EVP_PKEY_ASN1_METHOD* EVP_PKEY_asn1_new(int id, int flags, | ||
| 287 | const char *pem_str, const char *info) | ||
| 288 | { | ||
| 289 | EVP_PKEY_ASN1_METHOD *ameth; | ||
| 290 | ameth = OPENSSL_malloc(sizeof(EVP_PKEY_ASN1_METHOD)); | ||
| 291 | if (!ameth) | ||
| 292 | return NULL; | ||
| 293 | |||
| 294 | ameth->pkey_id = id; | ||
| 295 | ameth->pkey_base_id = id; | ||
| 296 | ameth->pkey_flags = flags | ASN1_PKEY_DYNAMIC; | ||
| 297 | |||
| 298 | if (info) | ||
| 299 | { | ||
| 300 | ameth->info = BUF_strdup(info); | ||
| 301 | if (!ameth->info) | ||
| 302 | goto err; | ||
| 303 | } | ||
| 304 | |||
| 305 | if (pem_str) | ||
| 306 | { | ||
| 307 | ameth->pem_str = BUF_strdup(pem_str); | ||
| 308 | if (!ameth->pem_str) | ||
| 309 | goto err; | ||
| 310 | } | ||
| 311 | |||
| 312 | ameth->pub_decode = 0; | ||
| 313 | ameth->pub_encode = 0; | ||
| 314 | ameth->pub_cmp = 0; | ||
| 315 | ameth->pub_print = 0; | ||
| 316 | |||
| 317 | ameth->priv_decode = 0; | ||
| 318 | ameth->priv_encode = 0; | ||
| 319 | ameth->priv_print = 0; | ||
| 320 | |||
| 321 | ameth->old_priv_encode = 0; | ||
| 322 | ameth->old_priv_decode = 0; | ||
| 323 | |||
| 324 | ameth->pkey_size = 0; | ||
| 325 | ameth->pkey_bits = 0; | ||
| 326 | |||
| 327 | ameth->param_decode = 0; | ||
| 328 | ameth->param_encode = 0; | ||
| 329 | ameth->param_missing = 0; | ||
| 330 | ameth->param_copy = 0; | ||
| 331 | ameth->param_cmp = 0; | ||
| 332 | ameth->param_print = 0; | ||
| 333 | |||
| 334 | ameth->pkey_free = 0; | ||
| 335 | ameth->pkey_ctrl = 0; | ||
| 336 | |||
| 337 | return ameth; | ||
| 338 | |||
| 339 | err: | ||
| 340 | |||
| 341 | EVP_PKEY_asn1_free(ameth); | ||
| 342 | return NULL; | ||
| 343 | |||
| 344 | } | ||
| 345 | |||
| 346 | void EVP_PKEY_asn1_copy(EVP_PKEY_ASN1_METHOD *dst, | ||
| 347 | const EVP_PKEY_ASN1_METHOD *src) | ||
| 348 | { | ||
| 349 | |||
| 350 | dst->pub_decode = src->pub_decode; | ||
| 351 | dst->pub_encode = src->pub_encode; | ||
| 352 | dst->pub_cmp = src->pub_cmp; | ||
| 353 | dst->pub_print = src->pub_print; | ||
| 354 | |||
| 355 | dst->priv_decode = src->priv_decode; | ||
| 356 | dst->priv_encode = src->priv_encode; | ||
| 357 | dst->priv_print = src->priv_print; | ||
| 358 | |||
| 359 | dst->old_priv_encode = src->old_priv_encode; | ||
| 360 | dst->old_priv_decode = src->old_priv_decode; | ||
| 361 | |||
| 362 | dst->pkey_size = src->pkey_size; | ||
| 363 | dst->pkey_bits = src->pkey_bits; | ||
| 364 | |||
| 365 | dst->param_decode = src->param_decode; | ||
| 366 | dst->param_encode = src->param_encode; | ||
| 367 | dst->param_missing = src->param_missing; | ||
| 368 | dst->param_copy = src->param_copy; | ||
| 369 | dst->param_cmp = src->param_cmp; | ||
| 370 | dst->param_print = src->param_print; | ||
| 371 | |||
| 372 | dst->pkey_free = src->pkey_free; | ||
| 373 | dst->pkey_ctrl = src->pkey_ctrl; | ||
| 374 | |||
| 375 | } | ||
| 376 | |||
| 377 | void EVP_PKEY_asn1_free(EVP_PKEY_ASN1_METHOD *ameth) | ||
| 378 | { | ||
| 379 | if (ameth && (ameth->pkey_flags & ASN1_PKEY_DYNAMIC)) | ||
| 380 | { | ||
| 381 | if (ameth->pem_str) | ||
| 382 | OPENSSL_free(ameth->pem_str); | ||
| 383 | if (ameth->info) | ||
| 384 | OPENSSL_free(ameth->info); | ||
| 385 | OPENSSL_free(ameth); | ||
| 386 | } | ||
| 387 | } | ||
| 388 | |||
| 389 | void EVP_PKEY_asn1_set_public(EVP_PKEY_ASN1_METHOD *ameth, | ||
| 390 | int (*pub_decode)(EVP_PKEY *pk, X509_PUBKEY *pub), | ||
| 391 | int (*pub_encode)(X509_PUBKEY *pub, const EVP_PKEY *pk), | ||
| 392 | int (*pub_cmp)(const EVP_PKEY *a, const EVP_PKEY *b), | ||
| 393 | int (*pub_print)(BIO *out, const EVP_PKEY *pkey, int indent, | ||
| 394 | ASN1_PCTX *pctx), | ||
| 395 | int (*pkey_size)(const EVP_PKEY *pk), | ||
| 396 | int (*pkey_bits)(const EVP_PKEY *pk)) | ||
| 397 | { | ||
| 398 | ameth->pub_decode = pub_decode; | ||
| 399 | ameth->pub_encode = pub_encode; | ||
| 400 | ameth->pub_cmp = pub_cmp; | ||
| 401 | ameth->pub_print = pub_print; | ||
| 402 | ameth->pkey_size = pkey_size; | ||
| 403 | ameth->pkey_bits = pkey_bits; | ||
| 404 | } | ||
| 405 | |||
| 406 | void EVP_PKEY_asn1_set_private(EVP_PKEY_ASN1_METHOD *ameth, | ||
| 407 | int (*priv_decode)(EVP_PKEY *pk, PKCS8_PRIV_KEY_INFO *p8inf), | ||
| 408 | int (*priv_encode)(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pk), | ||
| 409 | int (*priv_print)(BIO *out, const EVP_PKEY *pkey, int indent, | ||
| 410 | ASN1_PCTX *pctx)) | ||
| 411 | { | ||
| 412 | ameth->priv_decode = priv_decode; | ||
| 413 | ameth->priv_encode = priv_encode; | ||
| 414 | ameth->priv_print = priv_print; | ||
| 415 | } | ||
| 416 | |||
| 417 | void EVP_PKEY_asn1_set_param(EVP_PKEY_ASN1_METHOD *ameth, | ||
| 418 | int (*param_decode)(EVP_PKEY *pkey, | ||
| 419 | const unsigned char **pder, int derlen), | ||
| 420 | int (*param_encode)(const EVP_PKEY *pkey, unsigned char **pder), | ||
| 421 | int (*param_missing)(const EVP_PKEY *pk), | ||
| 422 | int (*param_copy)(EVP_PKEY *to, const EVP_PKEY *from), | ||
| 423 | int (*param_cmp)(const EVP_PKEY *a, const EVP_PKEY *b), | ||
| 424 | int (*param_print)(BIO *out, const EVP_PKEY *pkey, int indent, | ||
| 425 | ASN1_PCTX *pctx)) | ||
| 426 | { | ||
| 427 | ameth->param_decode = param_decode; | ||
| 428 | ameth->param_encode = param_encode; | ||
| 429 | ameth->param_missing = param_missing; | ||
| 430 | ameth->param_copy = param_copy; | ||
| 431 | ameth->param_cmp = param_cmp; | ||
| 432 | ameth->param_print = param_print; | ||
| 433 | } | ||
| 434 | |||
| 435 | void EVP_PKEY_asn1_set_free(EVP_PKEY_ASN1_METHOD *ameth, | ||
| 436 | void (*pkey_free)(EVP_PKEY *pkey)) | ||
| 437 | { | ||
| 438 | ameth->pkey_free = pkey_free; | ||
| 439 | } | ||
| 440 | |||
| 441 | void EVP_PKEY_asn1_set_ctrl(EVP_PKEY_ASN1_METHOD *ameth, | ||
| 442 | int (*pkey_ctrl)(EVP_PKEY *pkey, int op, | ||
| 443 | long arg1, void *arg2)) | ||
| 444 | { | ||
| 445 | ameth->pkey_ctrl = pkey_ctrl; | ||
| 446 | } | ||
diff --git a/src/lib/libssl/src/crypto/asn1/asn1_locl.h b/src/lib/libssl/src/crypto/asn1/asn1_locl.h new file mode 100644 index 0000000000..5aa65e28f5 --- /dev/null +++ b/src/lib/libssl/src/crypto/asn1/asn1_locl.h | |||
| @@ -0,0 +1,134 @@ | |||
| 1 | /* asn1t.h */ | ||
| 2 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL | ||
| 3 | * project 2006. | ||
| 4 | */ | ||
| 5 | /* ==================================================================== | ||
| 6 | * Copyright (c) 2006 The OpenSSL Project. All rights reserved. | ||
| 7 | * | ||
| 8 | * Redistribution and use in source and binary forms, with or without | ||
| 9 | * modification, are permitted provided that the following conditions | ||
| 10 | * are met: | ||
| 11 | * | ||
| 12 | * 1. Redistributions of source code must retain the above copyright | ||
| 13 | * notice, this list of conditions and the following disclaimer. | ||
| 14 | * | ||
| 15 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 16 | * notice, this list of conditions and the following disclaimer in | ||
| 17 | * the documentation and/or other materials provided with the | ||
| 18 | * distribution. | ||
| 19 | * | ||
| 20 | * 3. All advertising materials mentioning features or use of this | ||
| 21 | * software must display the following acknowledgment: | ||
| 22 | * "This product includes software developed by the OpenSSL Project | ||
| 23 | * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" | ||
| 24 | * | ||
| 25 | * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to | ||
| 26 | * endorse or promote products derived from this software without | ||
| 27 | * prior written permission. For written permission, please contact | ||
| 28 | * licensing@OpenSSL.org. | ||
| 29 | * | ||
| 30 | * 5. Products derived from this software may not be called "OpenSSL" | ||
| 31 | * nor may "OpenSSL" appear in their names without prior written | ||
| 32 | * permission of the OpenSSL Project. | ||
| 33 | * | ||
| 34 | * 6. Redistributions of any form whatsoever must retain the following | ||
| 35 | * acknowledgment: | ||
| 36 | * "This product includes software developed by the OpenSSL Project | ||
| 37 | * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" | ||
| 38 | * | ||
| 39 | * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY | ||
| 40 | * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 41 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | ||
| 42 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR | ||
| 43 | * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | ||
| 44 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | ||
| 45 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
| 46 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 47 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | ||
| 48 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | ||
| 49 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED | ||
| 50 | * OF THE POSSIBILITY OF SUCH DAMAGE. | ||
| 51 | * ==================================================================== | ||
| 52 | * | ||
| 53 | * This product includes cryptographic software written by Eric Young | ||
| 54 | * (eay@cryptsoft.com). This product includes software written by Tim | ||
| 55 | * Hudson (tjh@cryptsoft.com). | ||
| 56 | * | ||
| 57 | */ | ||
| 58 | |||
| 59 | /* Internal ASN1 structures and functions: not for application use */ | ||
| 60 | |||
| 61 | /* ASN1 print context structure */ | ||
| 62 | |||
| 63 | struct asn1_pctx_st | ||
| 64 | { | ||
| 65 | unsigned long flags; | ||
| 66 | unsigned long nm_flags; | ||
| 67 | unsigned long cert_flags; | ||
| 68 | unsigned long oid_flags; | ||
| 69 | unsigned long str_flags; | ||
| 70 | } /* ASN1_PCTX */; | ||
| 71 | |||
| 72 | /* ASN1 public key method structure */ | ||
| 73 | |||
| 74 | struct evp_pkey_asn1_method_st | ||
| 75 | { | ||
| 76 | int pkey_id; | ||
| 77 | int pkey_base_id; | ||
| 78 | unsigned long pkey_flags; | ||
| 79 | |||
| 80 | char *pem_str; | ||
| 81 | char *info; | ||
| 82 | |||
| 83 | int (*pub_decode)(EVP_PKEY *pk, X509_PUBKEY *pub); | ||
| 84 | int (*pub_encode)(X509_PUBKEY *pub, const EVP_PKEY *pk); | ||
| 85 | int (*pub_cmp)(const EVP_PKEY *a, const EVP_PKEY *b); | ||
| 86 | int (*pub_print)(BIO *out, const EVP_PKEY *pkey, int indent, | ||
| 87 | ASN1_PCTX *pctx); | ||
| 88 | |||
| 89 | int (*priv_decode)(EVP_PKEY *pk, PKCS8_PRIV_KEY_INFO *p8inf); | ||
| 90 | int (*priv_encode)(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pk); | ||
| 91 | int (*priv_print)(BIO *out, const EVP_PKEY *pkey, int indent, | ||
| 92 | ASN1_PCTX *pctx); | ||
| 93 | |||
| 94 | int (*pkey_size)(const EVP_PKEY *pk); | ||
| 95 | int (*pkey_bits)(const EVP_PKEY *pk); | ||
| 96 | |||
| 97 | int (*param_decode)(EVP_PKEY *pkey, | ||
| 98 | const unsigned char **pder, int derlen); | ||
| 99 | int (*param_encode)(const EVP_PKEY *pkey, unsigned char **pder); | ||
| 100 | int (*param_missing)(const EVP_PKEY *pk); | ||
| 101 | int (*param_copy)(EVP_PKEY *to, const EVP_PKEY *from); | ||
| 102 | int (*param_cmp)(const EVP_PKEY *a, const EVP_PKEY *b); | ||
| 103 | int (*param_print)(BIO *out, const EVP_PKEY *pkey, int indent, | ||
| 104 | ASN1_PCTX *pctx); | ||
| 105 | |||
| 106 | void (*pkey_free)(EVP_PKEY *pkey); | ||
| 107 | int (*pkey_ctrl)(EVP_PKEY *pkey, int op, long arg1, void *arg2); | ||
| 108 | |||
| 109 | /* Legacy functions for old PEM */ | ||
| 110 | |||
| 111 | int (*old_priv_decode)(EVP_PKEY *pkey, | ||
| 112 | const unsigned char **pder, int derlen); | ||
| 113 | int (*old_priv_encode)(const EVP_PKEY *pkey, unsigned char **pder); | ||
| 114 | |||
| 115 | } /* EVP_PKEY_ASN1_METHOD */; | ||
| 116 | |||
| 117 | /* Method to handle CRL access. | ||
| 118 | * In general a CRL could be very large (several Mb) and can consume large | ||
| 119 | * amounts of resources if stored in memory by multiple processes. | ||
| 120 | * This method allows general CRL operations to be redirected to more | ||
| 121 | * efficient callbacks: for example a CRL entry database. | ||
| 122 | */ | ||
| 123 | |||
| 124 | #define X509_CRL_METHOD_DYNAMIC 1 | ||
| 125 | |||
| 126 | struct x509_crl_method_st | ||
| 127 | { | ||
| 128 | int flags; | ||
| 129 | int (*crl_init)(X509_CRL *crl); | ||
| 130 | int (*crl_free)(X509_CRL *crl); | ||
| 131 | int (*crl_lookup)(X509_CRL *crl, X509_REVOKED **ret, | ||
| 132 | ASN1_INTEGER *ser, X509_NAME *issuer); | ||
| 133 | int (*crl_verify)(X509_CRL *crl, EVP_PKEY *pk); | ||
| 134 | }; | ||
diff --git a/src/lib/libssl/src/crypto/asn1/asn_mime.c b/src/lib/libssl/src/crypto/asn1/asn_mime.c index bc80b20d63..d8d9e76cc0 100644 --- a/src/lib/libssl/src/crypto/asn1/asn_mime.c +++ b/src/lib/libssl/src/crypto/asn1/asn_mime.c | |||
| @@ -152,7 +152,6 @@ static ASN1_VALUE *b64_read_asn1(BIO *bio, const ASN1_ITEM *it) | |||
| 152 | 152 | ||
| 153 | static int asn1_write_micalg(BIO *out, STACK_OF(X509_ALGOR) *mdalgs) | 153 | static int asn1_write_micalg(BIO *out, STACK_OF(X509_ALGOR) *mdalgs) |
| 154 | { | 154 | { |
| 155 | const EVP_MD *md; | ||
| 156 | int i, have_unknown = 0, write_comma, md_nid; | 155 | int i, have_unknown = 0, write_comma, md_nid; |
| 157 | have_unknown = 0; | 156 | have_unknown = 0; |
| 158 | write_comma = 0; | 157 | write_comma = 0; |
| @@ -162,7 +161,6 @@ static int asn1_write_micalg(BIO *out, STACK_OF(X509_ALGOR) *mdalgs) | |||
| 162 | BIO_write(out, ",", 1); | 161 | BIO_write(out, ",", 1); |
| 163 | write_comma = 1; | 162 | write_comma = 1; |
| 164 | md_nid = OBJ_obj2nid(sk_X509_ALGOR_value(mdalgs, i)->algorithm); | 163 | md_nid = OBJ_obj2nid(sk_X509_ALGOR_value(mdalgs, i)->algorithm); |
| 165 | md = EVP_get_digestbynid(md_nid); | ||
| 166 | switch(md_nid) | 164 | switch(md_nid) |
| 167 | { | 165 | { |
| 168 | case NID_sha1: | 166 | case NID_sha1: |
diff --git a/src/lib/libssl/src/crypto/asn1/bio_asn1.c b/src/lib/libssl/src/crypto/asn1/bio_asn1.c new file mode 100644 index 0000000000..dc7efd551c --- /dev/null +++ b/src/lib/libssl/src/crypto/asn1/bio_asn1.c | |||
| @@ -0,0 +1,495 @@ | |||
| 1 | /* bio_asn1.c */ | ||
| 2 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL | ||
| 3 | * project. | ||
| 4 | */ | ||
| 5 | /* ==================================================================== | ||
| 6 | * Copyright (c) 2006 The OpenSSL Project. All rights reserved. | ||
| 7 | * | ||
| 8 | * Redistribution and use in source and binary forms, with or without | ||
| 9 | * modification, are permitted provided that the following conditions | ||
| 10 | * are met: | ||
| 11 | * | ||
| 12 | * 1. Redistributions of source code must retain the above copyright | ||
| 13 | * notice, this list of conditions and the following disclaimer. | ||
| 14 | * | ||
| 15 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 16 | * notice, this list of conditions and the following disclaimer in | ||
| 17 | * the documentation and/or other materials provided with the | ||
| 18 | * distribution. | ||
| 19 | * | ||
| 20 | * 3. All advertising materials mentioning features or use of this | ||
| 21 | * software must display the following acknowledgment: | ||
| 22 | * "This product includes software developed by the OpenSSL Project | ||
| 23 | * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" | ||
| 24 | * | ||
| 25 | * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to | ||
| 26 | * endorse or promote products derived from this software without | ||
| 27 | * prior written permission. For written permission, please contact | ||
| 28 | * licensing@OpenSSL.org. | ||
| 29 | * | ||
| 30 | * 5. Products derived from this software may not be called "OpenSSL" | ||
| 31 | * nor may "OpenSSL" appear in their names without prior written | ||
| 32 | * permission of the OpenSSL Project. | ||
| 33 | * | ||
| 34 | * 6. Redistributions of any form whatsoever must retain the following | ||
| 35 | * acknowledgment: | ||
| 36 | * "This product includes software developed by the OpenSSL Project | ||
| 37 | * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" | ||
| 38 | * | ||
| 39 | * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY | ||
| 40 | * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 41 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | ||
| 42 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR | ||
| 43 | * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | ||
| 44 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | ||
| 45 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
| 46 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 47 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | ||
| 48 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | ||
| 49 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED | ||
| 50 | * OF THE POSSIBILITY OF SUCH DAMAGE. | ||
| 51 | * ==================================================================== | ||
| 52 | * | ||
| 53 | * This product includes cryptographic software written by Eric Young | ||
| 54 | * (eay@cryptsoft.com). This product includes software written by Tim | ||
| 55 | * Hudson (tjh@cryptsoft.com). | ||
| 56 | * | ||
| 57 | */ | ||
| 58 | |||
| 59 | /* Experimental ASN1 BIO. When written through the data is converted | ||
| 60 | * to an ASN1 string type: default is OCTET STRING. Additional functions | ||
| 61 | * can be provided to add prefix and suffix data. | ||
| 62 | */ | ||
| 63 | |||
| 64 | #include <string.h> | ||
| 65 | #include <openssl/bio.h> | ||
| 66 | #include <openssl/asn1.h> | ||
| 67 | |||
| 68 | /* Must be large enough for biggest tag+length */ | ||
| 69 | #define DEFAULT_ASN1_BUF_SIZE 20 | ||
| 70 | |||
| 71 | typedef enum | ||
| 72 | { | ||
| 73 | ASN1_STATE_START, | ||
| 74 | ASN1_STATE_PRE_COPY, | ||
| 75 | ASN1_STATE_HEADER, | ||
| 76 | ASN1_STATE_HEADER_COPY, | ||
| 77 | ASN1_STATE_DATA_COPY, | ||
| 78 | ASN1_STATE_POST_COPY, | ||
| 79 | ASN1_STATE_DONE | ||
| 80 | } asn1_bio_state_t; | ||
| 81 | |||
| 82 | typedef struct BIO_ASN1_EX_FUNCS_st | ||
| 83 | { | ||
| 84 | asn1_ps_func *ex_func; | ||
| 85 | asn1_ps_func *ex_free_func; | ||
| 86 | } BIO_ASN1_EX_FUNCS; | ||
| 87 | |||
| 88 | typedef struct BIO_ASN1_BUF_CTX_t | ||
| 89 | { | ||
| 90 | /* Internal state */ | ||
| 91 | asn1_bio_state_t state; | ||
| 92 | /* Internal buffer */ | ||
| 93 | unsigned char *buf; | ||
| 94 | /* Size of buffer */ | ||
| 95 | int bufsize; | ||
| 96 | /* Current position in buffer */ | ||
| 97 | int bufpos; | ||
| 98 | /* Current buffer length */ | ||
| 99 | int buflen; | ||
| 100 | /* Amount of data to copy */ | ||
| 101 | int copylen; | ||
| 102 | /* Class and tag to use */ | ||
| 103 | int asn1_class, asn1_tag; | ||
| 104 | asn1_ps_func *prefix, *prefix_free, *suffix, *suffix_free; | ||
| 105 | /* Extra buffer for prefix and suffix data */ | ||
| 106 | unsigned char *ex_buf; | ||
| 107 | int ex_len; | ||
| 108 | int ex_pos; | ||
| 109 | void *ex_arg; | ||
| 110 | } BIO_ASN1_BUF_CTX; | ||
| 111 | |||
| 112 | |||
| 113 | static int asn1_bio_write(BIO *h, const char *buf,int num); | ||
| 114 | static int asn1_bio_read(BIO *h, char *buf, int size); | ||
| 115 | static int asn1_bio_puts(BIO *h, const char *str); | ||
| 116 | static int asn1_bio_gets(BIO *h, char *str, int size); | ||
| 117 | static long asn1_bio_ctrl(BIO *h, int cmd, long arg1, void *arg2); | ||
| 118 | static int asn1_bio_new(BIO *h); | ||
| 119 | static int asn1_bio_free(BIO *data); | ||
| 120 | static long asn1_bio_callback_ctrl(BIO *h, int cmd, bio_info_cb *fp); | ||
| 121 | |||
| 122 | static int asn1_bio_init(BIO_ASN1_BUF_CTX *ctx, int size); | ||
| 123 | static int asn1_bio_flush_ex(BIO *b, BIO_ASN1_BUF_CTX *ctx, | ||
| 124 | asn1_ps_func *cleanup, asn1_bio_state_t next); | ||
| 125 | static int asn1_bio_setup_ex(BIO *b, BIO_ASN1_BUF_CTX *ctx, | ||
| 126 | asn1_ps_func *setup, | ||
| 127 | asn1_bio_state_t ex_state, | ||
| 128 | asn1_bio_state_t other_state); | ||
| 129 | |||
| 130 | static BIO_METHOD methods_asn1= | ||
| 131 | { | ||
| 132 | BIO_TYPE_ASN1, | ||
| 133 | "asn1", | ||
| 134 | asn1_bio_write, | ||
| 135 | asn1_bio_read, | ||
| 136 | asn1_bio_puts, | ||
| 137 | asn1_bio_gets, | ||
| 138 | asn1_bio_ctrl, | ||
| 139 | asn1_bio_new, | ||
| 140 | asn1_bio_free, | ||
| 141 | asn1_bio_callback_ctrl, | ||
| 142 | }; | ||
| 143 | |||
| 144 | BIO_METHOD *BIO_f_asn1(void) | ||
| 145 | { | ||
| 146 | return(&methods_asn1); | ||
| 147 | } | ||
| 148 | |||
| 149 | |||
| 150 | static int asn1_bio_new(BIO *b) | ||
| 151 | { | ||
| 152 | BIO_ASN1_BUF_CTX *ctx; | ||
| 153 | ctx = OPENSSL_malloc(sizeof(BIO_ASN1_BUF_CTX)); | ||
| 154 | if (!ctx) | ||
| 155 | return 0; | ||
| 156 | if (!asn1_bio_init(ctx, DEFAULT_ASN1_BUF_SIZE)) | ||
| 157 | return 0; | ||
| 158 | b->init = 1; | ||
| 159 | b->ptr = (char *)ctx; | ||
| 160 | b->flags = 0; | ||
| 161 | return 1; | ||
| 162 | } | ||
| 163 | |||
| 164 | static int asn1_bio_init(BIO_ASN1_BUF_CTX *ctx, int size) | ||
| 165 | { | ||
| 166 | ctx->buf = OPENSSL_malloc(size); | ||
| 167 | if (!ctx->buf) | ||
| 168 | return 0; | ||
| 169 | ctx->bufsize = size; | ||
| 170 | ctx->bufpos = 0; | ||
| 171 | ctx->buflen = 0; | ||
| 172 | ctx->copylen = 0; | ||
| 173 | ctx->asn1_class = V_ASN1_UNIVERSAL; | ||
| 174 | ctx->asn1_tag = V_ASN1_OCTET_STRING; | ||
| 175 | ctx->ex_buf = 0; | ||
| 176 | ctx->ex_pos = 0; | ||
| 177 | ctx->ex_len = 0; | ||
| 178 | ctx->state = ASN1_STATE_START; | ||
| 179 | return 1; | ||
| 180 | } | ||
| 181 | |||
| 182 | static int asn1_bio_free(BIO *b) | ||
| 183 | { | ||
| 184 | BIO_ASN1_BUF_CTX *ctx; | ||
| 185 | ctx = (BIO_ASN1_BUF_CTX *) b->ptr; | ||
| 186 | if (ctx == NULL) | ||
| 187 | return 0; | ||
| 188 | if (ctx->buf) | ||
| 189 | OPENSSL_free(ctx->buf); | ||
| 190 | OPENSSL_free(ctx); | ||
| 191 | b->init = 0; | ||
| 192 | b->ptr = NULL; | ||
| 193 | b->flags = 0; | ||
| 194 | return 1; | ||
| 195 | } | ||
| 196 | |||
| 197 | static int asn1_bio_write(BIO *b, const char *in , int inl) | ||
| 198 | { | ||
| 199 | BIO_ASN1_BUF_CTX *ctx; | ||
| 200 | int wrmax, wrlen, ret; | ||
| 201 | unsigned char *p; | ||
| 202 | if (!in || (inl < 0) || (b->next_bio == NULL)) | ||
| 203 | return 0; | ||
| 204 | ctx = (BIO_ASN1_BUF_CTX *) b->ptr; | ||
| 205 | if (ctx == NULL) | ||
| 206 | return 0; | ||
| 207 | |||
| 208 | wrlen = 0; | ||
| 209 | ret = -1; | ||
| 210 | |||
| 211 | for(;;) | ||
| 212 | { | ||
| 213 | switch (ctx->state) | ||
| 214 | { | ||
| 215 | |||
| 216 | /* Setup prefix data, call it */ | ||
| 217 | case ASN1_STATE_START: | ||
| 218 | if (!asn1_bio_setup_ex(b, ctx, ctx->prefix, | ||
| 219 | ASN1_STATE_PRE_COPY, ASN1_STATE_HEADER)) | ||
| 220 | return 0; | ||
| 221 | break; | ||
| 222 | |||
| 223 | /* Copy any pre data first */ | ||
| 224 | case ASN1_STATE_PRE_COPY: | ||
| 225 | |||
| 226 | ret = asn1_bio_flush_ex(b, ctx, ctx->prefix_free, | ||
| 227 | ASN1_STATE_HEADER); | ||
| 228 | |||
| 229 | if (ret <= 0) | ||
| 230 | goto done; | ||
| 231 | |||
| 232 | break; | ||
| 233 | |||
| 234 | case ASN1_STATE_HEADER: | ||
| 235 | ctx->buflen = | ||
| 236 | ASN1_object_size(0, inl, ctx->asn1_tag) - inl; | ||
| 237 | OPENSSL_assert(ctx->buflen <= ctx->bufsize); | ||
| 238 | p = ctx->buf; | ||
| 239 | ASN1_put_object(&p, 0, inl, | ||
| 240 | ctx->asn1_tag, ctx->asn1_class); | ||
| 241 | ctx->copylen = inl; | ||
| 242 | ctx->state = ASN1_STATE_HEADER_COPY; | ||
| 243 | |||
| 244 | break; | ||
| 245 | |||
| 246 | case ASN1_STATE_HEADER_COPY: | ||
| 247 | ret = BIO_write(b->next_bio, | ||
| 248 | ctx->buf + ctx->bufpos, ctx->buflen); | ||
| 249 | if (ret <= 0) | ||
| 250 | goto done; | ||
| 251 | |||
| 252 | ctx->buflen -= ret; | ||
| 253 | if (ctx->buflen) | ||
| 254 | ctx->bufpos += ret; | ||
| 255 | else | ||
| 256 | { | ||
| 257 | ctx->bufpos = 0; | ||
| 258 | ctx->state = ASN1_STATE_DATA_COPY; | ||
| 259 | } | ||
| 260 | |||
| 261 | break; | ||
| 262 | |||
| 263 | case ASN1_STATE_DATA_COPY: | ||
| 264 | |||
| 265 | if (inl > ctx->copylen) | ||
| 266 | wrmax = ctx->copylen; | ||
| 267 | else | ||
| 268 | wrmax = inl; | ||
| 269 | ret = BIO_write(b->next_bio, in, wrmax); | ||
| 270 | if (ret <= 0) | ||
| 271 | break; | ||
| 272 | wrlen += ret; | ||
| 273 | ctx->copylen -= ret; | ||
| 274 | in += ret; | ||
| 275 | inl -= ret; | ||
| 276 | |||
| 277 | if (ctx->copylen == 0) | ||
| 278 | ctx->state = ASN1_STATE_HEADER; | ||
| 279 | |||
| 280 | if (inl == 0) | ||
| 281 | goto done; | ||
| 282 | |||
| 283 | break; | ||
| 284 | |||
| 285 | default: | ||
| 286 | BIO_clear_retry_flags(b); | ||
| 287 | return 0; | ||
| 288 | |||
| 289 | } | ||
| 290 | |||
| 291 | } | ||
| 292 | |||
| 293 | done: | ||
| 294 | BIO_clear_retry_flags(b); | ||
| 295 | BIO_copy_next_retry(b); | ||
| 296 | |||
| 297 | return (wrlen > 0) ? wrlen : ret; | ||
| 298 | |||
| 299 | } | ||
| 300 | |||
| 301 | static int asn1_bio_flush_ex(BIO *b, BIO_ASN1_BUF_CTX *ctx, | ||
| 302 | asn1_ps_func *cleanup, asn1_bio_state_t next) | ||
| 303 | { | ||
| 304 | int ret; | ||
| 305 | if (ctx->ex_len <= 0) | ||
| 306 | return 1; | ||
| 307 | for(;;) | ||
| 308 | { | ||
| 309 | ret = BIO_write(b->next_bio, ctx->ex_buf + ctx->ex_pos, | ||
| 310 | ctx->ex_len); | ||
| 311 | if (ret <= 0) | ||
| 312 | break; | ||
| 313 | ctx->ex_len -= ret; | ||
| 314 | if (ctx->ex_len > 0) | ||
| 315 | ctx->ex_pos += ret; | ||
| 316 | else | ||
| 317 | { | ||
| 318 | if(cleanup) | ||
| 319 | cleanup(b, &ctx->ex_buf, &ctx->ex_len, | ||
| 320 | &ctx->ex_arg); | ||
| 321 | ctx->state = next; | ||
| 322 | ctx->ex_pos = 0; | ||
| 323 | break; | ||
| 324 | } | ||
| 325 | } | ||
| 326 | return ret; | ||
| 327 | } | ||
| 328 | |||
| 329 | static int asn1_bio_setup_ex(BIO *b, BIO_ASN1_BUF_CTX *ctx, | ||
| 330 | asn1_ps_func *setup, | ||
| 331 | asn1_bio_state_t ex_state, | ||
| 332 | asn1_bio_state_t other_state) | ||
| 333 | { | ||
| 334 | if (setup && !setup(b, &ctx->ex_buf, &ctx->ex_len, &ctx->ex_arg)) | ||
| 335 | { | ||
| 336 | BIO_clear_retry_flags(b); | ||
| 337 | return 0; | ||
| 338 | } | ||
| 339 | if (ctx->ex_len > 0) | ||
| 340 | ctx->state = ex_state; | ||
| 341 | else | ||
| 342 | ctx->state = other_state; | ||
| 343 | return 1; | ||
| 344 | } | ||
| 345 | |||
| 346 | static int asn1_bio_read(BIO *b, char *in , int inl) | ||
| 347 | { | ||
| 348 | if (!b->next_bio) | ||
| 349 | return 0; | ||
| 350 | return BIO_read(b->next_bio, in , inl); | ||
| 351 | } | ||
| 352 | |||
| 353 | static int asn1_bio_puts(BIO *b, const char *str) | ||
| 354 | { | ||
| 355 | return asn1_bio_write(b, str, strlen(str)); | ||
| 356 | } | ||
| 357 | |||
| 358 | static int asn1_bio_gets(BIO *b, char *str, int size) | ||
| 359 | { | ||
| 360 | if (!b->next_bio) | ||
| 361 | return 0; | ||
| 362 | return BIO_gets(b->next_bio, str , size); | ||
| 363 | } | ||
| 364 | |||
| 365 | static long asn1_bio_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp) | ||
| 366 | { | ||
| 367 | if (b->next_bio == NULL) return(0); | ||
| 368 | return BIO_callback_ctrl(b->next_bio,cmd,fp); | ||
| 369 | } | ||
| 370 | |||
| 371 | static long asn1_bio_ctrl(BIO *b, int cmd, long arg1, void *arg2) | ||
| 372 | { | ||
| 373 | BIO_ASN1_BUF_CTX *ctx; | ||
| 374 | BIO_ASN1_EX_FUNCS *ex_func; | ||
| 375 | long ret = 1; | ||
| 376 | ctx = (BIO_ASN1_BUF_CTX *) b->ptr; | ||
| 377 | if (ctx == NULL) | ||
| 378 | return 0; | ||
| 379 | switch(cmd) | ||
| 380 | { | ||
| 381 | |||
| 382 | case BIO_C_SET_PREFIX: | ||
| 383 | ex_func = arg2; | ||
| 384 | ctx->prefix = ex_func->ex_func; | ||
| 385 | ctx->prefix_free = ex_func->ex_free_func; | ||
| 386 | break; | ||
| 387 | |||
| 388 | case BIO_C_GET_PREFIX: | ||
| 389 | ex_func = arg2; | ||
| 390 | ex_func->ex_func = ctx->prefix; | ||
| 391 | ex_func->ex_free_func = ctx->prefix_free; | ||
| 392 | break; | ||
| 393 | |||
| 394 | case BIO_C_SET_SUFFIX: | ||
| 395 | ex_func = arg2; | ||
| 396 | ctx->suffix = ex_func->ex_func; | ||
| 397 | ctx->suffix_free = ex_func->ex_free_func; | ||
| 398 | break; | ||
| 399 | |||
| 400 | case BIO_C_GET_SUFFIX: | ||
| 401 | ex_func = arg2; | ||
| 402 | ex_func->ex_func = ctx->suffix; | ||
| 403 | ex_func->ex_free_func = ctx->suffix_free; | ||
| 404 | break; | ||
| 405 | |||
| 406 | case BIO_C_SET_EX_ARG: | ||
| 407 | ctx->ex_arg = arg2; | ||
| 408 | break; | ||
| 409 | |||
| 410 | case BIO_C_GET_EX_ARG: | ||
| 411 | *(void **)arg2 = ctx->ex_arg; | ||
| 412 | break; | ||
| 413 | |||
| 414 | case BIO_CTRL_FLUSH: | ||
| 415 | if (!b->next_bio) | ||
| 416 | return 0; | ||
| 417 | |||
| 418 | /* Call post function if possible */ | ||
| 419 | if (ctx->state == ASN1_STATE_HEADER) | ||
| 420 | { | ||
| 421 | if (!asn1_bio_setup_ex(b, ctx, ctx->suffix, | ||
| 422 | ASN1_STATE_POST_COPY, ASN1_STATE_DONE)) | ||
| 423 | return 0; | ||
| 424 | } | ||
| 425 | |||
| 426 | if (ctx->state == ASN1_STATE_POST_COPY) | ||
| 427 | { | ||
| 428 | ret = asn1_bio_flush_ex(b, ctx, ctx->suffix_free, | ||
| 429 | ASN1_STATE_DONE); | ||
| 430 | if (ret <= 0) | ||
| 431 | return ret; | ||
| 432 | } | ||
| 433 | |||
| 434 | if (ctx->state == ASN1_STATE_DONE) | ||
| 435 | return BIO_ctrl(b->next_bio, cmd, arg1, arg2); | ||
| 436 | else | ||
| 437 | { | ||
| 438 | BIO_clear_retry_flags(b); | ||
| 439 | return 0; | ||
| 440 | } | ||
| 441 | break; | ||
| 442 | |||
| 443 | |||
| 444 | default: | ||
| 445 | if (!b->next_bio) | ||
| 446 | return 0; | ||
| 447 | return BIO_ctrl(b->next_bio, cmd, arg1, arg2); | ||
| 448 | |||
| 449 | } | ||
| 450 | |||
| 451 | return ret; | ||
| 452 | } | ||
| 453 | |||
| 454 | static int asn1_bio_set_ex(BIO *b, int cmd, | ||
| 455 | asn1_ps_func *ex_func, asn1_ps_func *ex_free_func) | ||
| 456 | { | ||
| 457 | BIO_ASN1_EX_FUNCS extmp; | ||
| 458 | extmp.ex_func = ex_func; | ||
| 459 | extmp.ex_free_func = ex_free_func; | ||
| 460 | return BIO_ctrl(b, cmd, 0, &extmp); | ||
| 461 | } | ||
| 462 | |||
| 463 | static int asn1_bio_get_ex(BIO *b, int cmd, | ||
| 464 | asn1_ps_func **ex_func, asn1_ps_func **ex_free_func) | ||
| 465 | { | ||
| 466 | BIO_ASN1_EX_FUNCS extmp; | ||
| 467 | int ret; | ||
| 468 | ret = BIO_ctrl(b, cmd, 0, &extmp); | ||
| 469 | if (ret > 0) | ||
| 470 | { | ||
| 471 | *ex_func = extmp.ex_func; | ||
| 472 | *ex_free_func = extmp.ex_free_func; | ||
| 473 | } | ||
| 474 | return ret; | ||
| 475 | } | ||
| 476 | |||
| 477 | int BIO_asn1_set_prefix(BIO *b, asn1_ps_func *prefix, asn1_ps_func *prefix_free) | ||
| 478 | { | ||
| 479 | return asn1_bio_set_ex(b, BIO_C_SET_PREFIX, prefix, prefix_free); | ||
| 480 | } | ||
| 481 | |||
| 482 | int BIO_asn1_get_prefix(BIO *b, asn1_ps_func **pprefix, asn1_ps_func **pprefix_free) | ||
| 483 | { | ||
| 484 | return asn1_bio_get_ex(b, BIO_C_GET_PREFIX, pprefix, pprefix_free); | ||
| 485 | } | ||
| 486 | |||
| 487 | int BIO_asn1_set_suffix(BIO *b, asn1_ps_func *suffix, asn1_ps_func *suffix_free) | ||
| 488 | { | ||
| 489 | return asn1_bio_set_ex(b, BIO_C_SET_SUFFIX, suffix, suffix_free); | ||
| 490 | } | ||
| 491 | |||
| 492 | int BIO_asn1_get_suffix(BIO *b, asn1_ps_func **psuffix, asn1_ps_func **psuffix_free) | ||
| 493 | { | ||
| 494 | return asn1_bio_get_ex(b, BIO_C_GET_SUFFIX, psuffix, psuffix_free); | ||
| 495 | } | ||
diff --git a/src/lib/libssl/src/crypto/asn1/bio_ndef.c b/src/lib/libssl/src/crypto/asn1/bio_ndef.c new file mode 100644 index 0000000000..370389b1e6 --- /dev/null +++ b/src/lib/libssl/src/crypto/asn1/bio_ndef.c | |||
| @@ -0,0 +1,246 @@ | |||
| 1 | /* bio_ndef.c */ | ||
| 2 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL | ||
| 3 | * project. | ||
| 4 | */ | ||
| 5 | /* ==================================================================== | ||
| 6 | * Copyright (c) 2008 The OpenSSL Project. All rights reserved. | ||
| 7 | * | ||
| 8 | * Redistribution and use in source and binary forms, with or without | ||
| 9 | * modification, are permitted provided that the following conditions | ||
| 10 | * are met: | ||
| 11 | * | ||
| 12 | * 1. Redistributions of source code must retain the above copyright | ||
| 13 | * notice, this list of conditions and the following disclaimer. | ||
| 14 | * | ||
| 15 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 16 | * notice, this list of conditions and the following disclaimer in | ||
| 17 | * the documentation and/or other materials provided with the | ||
| 18 | * distribution. | ||
| 19 | * | ||
| 20 | * 3. All advertising materials mentioning features or use of this | ||
| 21 | * software must display the following acknowledgment: | ||
| 22 | * "This product includes software developed by the OpenSSL Project | ||
| 23 | * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" | ||
| 24 | * | ||
| 25 | * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to | ||
| 26 | * endorse or promote products derived from this software without | ||
| 27 | * prior written permission. For written permission, please contact | ||
| 28 | * licensing@OpenSSL.org. | ||
| 29 | * | ||
| 30 | * 5. Products derived from this software may not be called "OpenSSL" | ||
| 31 | * nor may "OpenSSL" appear in their names without prior written | ||
| 32 | * permission of the OpenSSL Project. | ||
| 33 | * | ||
| 34 | * 6. Redistributions of any form whatsoever must retain the following | ||
| 35 | * acknowledgment: | ||
| 36 | * "This product includes software developed by the OpenSSL Project | ||
| 37 | * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" | ||
| 38 | * | ||
| 39 | * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY | ||
| 40 | * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 41 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | ||
| 42 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR | ||
| 43 | * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | ||
| 44 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | ||
| 45 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
| 46 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 47 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | ||
| 48 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | ||
| 49 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED | ||
| 50 | * OF THE POSSIBILITY OF SUCH DAMAGE. | ||
| 51 | * ==================================================================== | ||
| 52 | * | ||
| 53 | */ | ||
| 54 | |||
| 55 | #include <openssl/asn1.h> | ||
| 56 | #include <openssl/asn1t.h> | ||
| 57 | #include <openssl/bio.h> | ||
| 58 | #include <openssl/err.h> | ||
| 59 | |||
| 60 | #ifndef OPENSSL_SYSNAME_NETWARE | ||
| 61 | #include <memory.h> | ||
| 62 | #endif | ||
| 63 | #include <stdio.h> | ||
| 64 | |||
| 65 | /* Experimental NDEF ASN1 BIO support routines */ | ||
| 66 | |||
| 67 | /* The usage is quite simple, initialize an ASN1 structure, | ||
| 68 | * get a BIO from it then any data written through the BIO | ||
| 69 | * will end up translated to approptiate format on the fly. | ||
| 70 | * The data is streamed out and does *not* need to be | ||
| 71 | * all held in memory at once. | ||
| 72 | * | ||
| 73 | * When the BIO is flushed the output is finalized and any | ||
| 74 | * signatures etc written out. | ||
| 75 | * | ||
| 76 | * The BIO is a 'proper' BIO and can handle non blocking I/O | ||
| 77 | * correctly. | ||
| 78 | * | ||
| 79 | * The usage is simple. The implementation is *not*... | ||
| 80 | */ | ||
| 81 | |||
| 82 | /* BIO support data stored in the ASN1 BIO ex_arg */ | ||
| 83 | |||
| 84 | typedef struct ndef_aux_st | ||
| 85 | { | ||
| 86 | /* ASN1 structure this BIO refers to */ | ||
| 87 | ASN1_VALUE *val; | ||
| 88 | const ASN1_ITEM *it; | ||
| 89 | /* Top of the BIO chain */ | ||
| 90 | BIO *ndef_bio; | ||
| 91 | /* Output BIO */ | ||
| 92 | BIO *out; | ||
| 93 | /* Boundary where content is inserted */ | ||
| 94 | unsigned char **boundary; | ||
| 95 | /* DER buffer start */ | ||
| 96 | unsigned char *derbuf; | ||
| 97 | } NDEF_SUPPORT; | ||
| 98 | |||
| 99 | static int ndef_prefix(BIO *b, unsigned char **pbuf, int *plen, void *parg); | ||
| 100 | static int ndef_prefix_free(BIO *b, unsigned char **pbuf, int *plen, void *parg); | ||
| 101 | static int ndef_suffix(BIO *b, unsigned char **pbuf, int *plen, void *parg); | ||
| 102 | static int ndef_suffix_free(BIO *b, unsigned char **pbuf, int *plen, void *parg); | ||
| 103 | |||
| 104 | BIO *BIO_new_NDEF(BIO *out, ASN1_VALUE *val, const ASN1_ITEM *it) | ||
| 105 | { | ||
| 106 | NDEF_SUPPORT *ndef_aux = NULL; | ||
| 107 | BIO *asn_bio = NULL; | ||
| 108 | const ASN1_AUX *aux = it->funcs; | ||
| 109 | ASN1_STREAM_ARG sarg; | ||
| 110 | |||
| 111 | if (!aux || !aux->asn1_cb) | ||
| 112 | { | ||
| 113 | ASN1err(ASN1_F_BIO_NEW_NDEF, ASN1_R_STREAMING_NOT_SUPPORTED); | ||
| 114 | return NULL; | ||
| 115 | } | ||
| 116 | ndef_aux = OPENSSL_malloc(sizeof(NDEF_SUPPORT)); | ||
| 117 | asn_bio = BIO_new(BIO_f_asn1()); | ||
| 118 | |||
| 119 | /* ASN1 bio needs to be next to output BIO */ | ||
| 120 | |||
| 121 | out = BIO_push(asn_bio, out); | ||
| 122 | |||
| 123 | if (!ndef_aux || !asn_bio || !out) | ||
| 124 | goto err; | ||
| 125 | |||
| 126 | BIO_asn1_set_prefix(asn_bio, ndef_prefix, ndef_prefix_free); | ||
| 127 | BIO_asn1_set_suffix(asn_bio, ndef_suffix, ndef_suffix_free); | ||
| 128 | |||
| 129 | /* Now let callback prepend any digest, cipher etc BIOs | ||
| 130 | * ASN1 structure needs. | ||
| 131 | */ | ||
| 132 | |||
| 133 | sarg.out = out; | ||
| 134 | sarg.ndef_bio = NULL; | ||
| 135 | sarg.boundary = NULL; | ||
| 136 | |||
| 137 | if (aux->asn1_cb(ASN1_OP_STREAM_PRE, &val, it, &sarg) <= 0) | ||
| 138 | goto err; | ||
| 139 | |||
| 140 | ndef_aux->val = val; | ||
| 141 | ndef_aux->it = it; | ||
| 142 | ndef_aux->ndef_bio = sarg.ndef_bio; | ||
| 143 | ndef_aux->boundary = sarg.boundary; | ||
| 144 | ndef_aux->out = out; | ||
| 145 | |||
| 146 | BIO_ctrl(asn_bio, BIO_C_SET_EX_ARG, 0, ndef_aux); | ||
| 147 | |||
| 148 | return sarg.ndef_bio; | ||
| 149 | |||
| 150 | err: | ||
| 151 | if (asn_bio) | ||
| 152 | BIO_free(asn_bio); | ||
| 153 | if (ndef_aux) | ||
| 154 | OPENSSL_free(ndef_aux); | ||
| 155 | return NULL; | ||
| 156 | } | ||
| 157 | |||
| 158 | static int ndef_prefix(BIO *b, unsigned char **pbuf, int *plen, void *parg) | ||
| 159 | { | ||
| 160 | NDEF_SUPPORT *ndef_aux; | ||
| 161 | unsigned char *p; | ||
| 162 | int derlen; | ||
| 163 | |||
| 164 | if (!parg) | ||
| 165 | return 0; | ||
| 166 | |||
| 167 | ndef_aux = *(NDEF_SUPPORT **)parg; | ||
| 168 | |||
| 169 | derlen = ASN1_item_ndef_i2d(ndef_aux->val, NULL, ndef_aux->it); | ||
| 170 | p = OPENSSL_malloc(derlen); | ||
| 171 | ndef_aux->derbuf = p; | ||
| 172 | *pbuf = p; | ||
| 173 | derlen = ASN1_item_ndef_i2d(ndef_aux->val, &p, ndef_aux->it); | ||
| 174 | |||
| 175 | if (!*ndef_aux->boundary) | ||
| 176 | return 0; | ||
| 177 | |||
| 178 | *plen = *ndef_aux->boundary - *pbuf; | ||
| 179 | |||
| 180 | return 1; | ||
| 181 | } | ||
| 182 | |||
| 183 | static int ndef_prefix_free(BIO *b, unsigned char **pbuf, int *plen, void *parg) | ||
| 184 | { | ||
| 185 | NDEF_SUPPORT *ndef_aux; | ||
| 186 | |||
| 187 | if (!parg) | ||
| 188 | return 0; | ||
| 189 | |||
| 190 | ndef_aux = *(NDEF_SUPPORT **)parg; | ||
| 191 | |||
| 192 | if (ndef_aux->derbuf) | ||
| 193 | OPENSSL_free(ndef_aux->derbuf); | ||
| 194 | |||
| 195 | ndef_aux->derbuf = NULL; | ||
| 196 | *pbuf = NULL; | ||
| 197 | *plen = 0; | ||
| 198 | return 1; | ||
| 199 | } | ||
| 200 | |||
| 201 | static int ndef_suffix_free(BIO *b, unsigned char **pbuf, int *plen, void *parg) | ||
| 202 | { | ||
| 203 | NDEF_SUPPORT **pndef_aux = (NDEF_SUPPORT **)parg; | ||
| 204 | if (!ndef_prefix_free(b, pbuf, plen, parg)) | ||
| 205 | return 0; | ||
| 206 | OPENSSL_free(*pndef_aux); | ||
| 207 | *pndef_aux = NULL; | ||
| 208 | return 1; | ||
| 209 | } | ||
| 210 | |||
| 211 | static int ndef_suffix(BIO *b, unsigned char **pbuf, int *plen, void *parg) | ||
| 212 | { | ||
| 213 | NDEF_SUPPORT *ndef_aux; | ||
| 214 | unsigned char *p; | ||
| 215 | int derlen; | ||
| 216 | const ASN1_AUX *aux; | ||
| 217 | ASN1_STREAM_ARG sarg; | ||
| 218 | |||
| 219 | if (!parg) | ||
| 220 | return 0; | ||
| 221 | |||
| 222 | ndef_aux = *(NDEF_SUPPORT **)parg; | ||
| 223 | |||
| 224 | aux = ndef_aux->it->funcs; | ||
| 225 | |||
| 226 | /* Finalize structures */ | ||
| 227 | sarg.ndef_bio = ndef_aux->ndef_bio; | ||
| 228 | sarg.out = ndef_aux->out; | ||
| 229 | sarg.boundary = ndef_aux->boundary; | ||
| 230 | if (aux->asn1_cb(ASN1_OP_STREAM_POST, | ||
| 231 | &ndef_aux->val, ndef_aux->it, &sarg) <= 0) | ||
| 232 | return 0; | ||
| 233 | |||
| 234 | derlen = ASN1_item_ndef_i2d(ndef_aux->val, NULL, ndef_aux->it); | ||
| 235 | p = OPENSSL_malloc(derlen); | ||
| 236 | ndef_aux->derbuf = p; | ||
| 237 | *pbuf = p; | ||
| 238 | derlen = ASN1_item_ndef_i2d(ndef_aux->val, &p, ndef_aux->it); | ||
| 239 | |||
| 240 | if (!*ndef_aux->boundary) | ||
| 241 | return 0; | ||
| 242 | *pbuf = *ndef_aux->boundary; | ||
| 243 | *plen = derlen - (*ndef_aux->boundary - ndef_aux->derbuf); | ||
| 244 | |||
| 245 | return 1; | ||
| 246 | } | ||
diff --git a/src/lib/libssl/src/crypto/asn1/x_nx509.c b/src/lib/libssl/src/crypto/asn1/x_nx509.c new file mode 100644 index 0000000000..fbd9a22db3 --- /dev/null +++ b/src/lib/libssl/src/crypto/asn1/x_nx509.c | |||
| @@ -0,0 +1,72 @@ | |||
| 1 | /* x_nx509.c */ | ||
| 2 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL | ||
| 3 | * project 2005. | ||
| 4 | */ | ||
| 5 | /* ==================================================================== | ||
| 6 | * Copyright (c) 2005 The OpenSSL Project. All rights reserved. | ||
| 7 | * | ||
| 8 | * Redistribution and use in source and binary forms, with or without | ||
| 9 | * modification, are permitted provided that the following conditions | ||
| 10 | * are met: | ||
| 11 | * | ||
| 12 | * 1. Redistributions of source code must retain the above copyright | ||
| 13 | * notice, this list of conditions and the following disclaimer. | ||
| 14 | * | ||
| 15 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 16 | * notice, this list of conditions and the following disclaimer in | ||
| 17 | * the documentation and/or other materials provided with the | ||
| 18 | * distribution. | ||
| 19 | * | ||
| 20 | * 3. All advertising materials mentioning features or use of this | ||
| 21 | * software must display the following acknowledgment: | ||
| 22 | * "This product includes software developed by the OpenSSL Project | ||
| 23 | * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" | ||
| 24 | * | ||
| 25 | * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to | ||
| 26 | * endorse or promote products derived from this software without | ||
| 27 | * prior written permission. For written permission, please contact | ||
| 28 | * licensing@OpenSSL.org. | ||
| 29 | * | ||
| 30 | * 5. Products derived from this software may not be called "OpenSSL" | ||
| 31 | * nor may "OpenSSL" appear in their names without prior written | ||
| 32 | * permission of the OpenSSL Project. | ||
| 33 | * | ||
| 34 | * 6. Redistributions of any form whatsoever must retain the following | ||
| 35 | * acknowledgment: | ||
| 36 | * "This product includes software developed by the OpenSSL Project | ||
| 37 | * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" | ||
| 38 | * | ||
| 39 | * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY | ||
| 40 | * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 41 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | ||
| 42 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR | ||
| 43 | * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | ||
| 44 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | ||
| 45 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
| 46 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 47 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | ||
| 48 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | ||
| 49 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED | ||
| 50 | * OF THE POSSIBILITY OF SUCH DAMAGE. | ||
| 51 | * ==================================================================== | ||
| 52 | * | ||
| 53 | * This product includes cryptographic software written by Eric Young | ||
| 54 | * (eay@cryptsoft.com). This product includes software written by Tim | ||
| 55 | * Hudson (tjh@cryptsoft.com). | ||
| 56 | * | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stddef.h> | ||
| 60 | #include <openssl/x509.h> | ||
| 61 | #include <openssl/asn1.h> | ||
| 62 | #include <openssl/asn1t.h> | ||
| 63 | |||
| 64 | /* Old netscape certificate wrapper format */ | ||
| 65 | |||
| 66 | ASN1_SEQUENCE(NETSCAPE_X509) = { | ||
| 67 | ASN1_SIMPLE(NETSCAPE_X509, header, ASN1_OCTET_STRING), | ||
| 68 | ASN1_OPT(NETSCAPE_X509, cert, X509) | ||
| 69 | } ASN1_SEQUENCE_END(NETSCAPE_X509) | ||
| 70 | |||
| 71 | IMPLEMENT_ASN1_FUNCTIONS(NETSCAPE_X509) | ||
| 72 | |||
diff --git a/src/lib/libssl/src/crypto/bn/asm/alpha-mont.pl b/src/lib/libssl/src/crypto/bn/asm/alpha-mont.pl new file mode 100644 index 0000000000..7a2cc3173b --- /dev/null +++ b/src/lib/libssl/src/crypto/bn/asm/alpha-mont.pl | |||
| @@ -0,0 +1,317 @@ | |||
| 1 | #!/usr/bin/env perl | ||
| 2 | # | ||
| 3 | # ==================================================================== | ||
| 4 | # Written by Andy Polyakov <appro@fy.chalmers.se> for the OpenSSL | ||
| 5 | # project. The module is, however, dual licensed under OpenSSL and | ||
| 6 | # CRYPTOGAMS licenses depending on where you obtain it. For further | ||
| 7 | # details see http://www.openssl.org/~appro/cryptogams/. | ||
| 8 | # ==================================================================== | ||
| 9 | # | ||
| 10 | # On 21264 RSA sign performance improves by 70/35/20/15 percent for | ||
| 11 | # 512/1024/2048/4096 bit key lengths. This is against vendor compiler | ||
| 12 | # instructed to '-tune host' code with in-line assembler. Other | ||
| 13 | # benchmarks improve by 15-20%. To anchor it to something else, the | ||
| 14 | # code provides approximately the same performance per GHz as AMD64. | ||
| 15 | # I.e. if you compare 1GHz 21264 and 2GHz Opteron, you'll observe ~2x | ||
| 16 | # difference. | ||
| 17 | |||
| 18 | # int bn_mul_mont( | ||
| 19 | $rp="a0"; # BN_ULONG *rp, | ||
| 20 | $ap="a1"; # const BN_ULONG *ap, | ||
| 21 | $bp="a2"; # const BN_ULONG *bp, | ||
| 22 | $np="a3"; # const BN_ULONG *np, | ||
| 23 | $n0="a4"; # const BN_ULONG *n0, | ||
| 24 | $num="a5"; # int num); | ||
| 25 | |||
| 26 | $lo0="t0"; | ||
| 27 | $hi0="t1"; | ||
| 28 | $lo1="t2"; | ||
| 29 | $hi1="t3"; | ||
| 30 | $aj="t4"; | ||
| 31 | $bi="t5"; | ||
| 32 | $nj="t6"; | ||
| 33 | $tp="t7"; | ||
| 34 | $alo="t8"; | ||
| 35 | $ahi="t9"; | ||
| 36 | $nlo="t10"; | ||
| 37 | $nhi="t11"; | ||
| 38 | $tj="t12"; | ||
| 39 | $i="s3"; | ||
| 40 | $j="s4"; | ||
| 41 | $m1="s5"; | ||
| 42 | |||
| 43 | $code=<<___; | ||
| 44 | #include <asm.h> | ||
| 45 | #include <regdef.h> | ||
| 46 | |||
| 47 | .text | ||
| 48 | |||
| 49 | .set noat | ||
| 50 | .set noreorder | ||
| 51 | |||
| 52 | .globl bn_mul_mont | ||
| 53 | .align 5 | ||
| 54 | .ent bn_mul_mont | ||
| 55 | bn_mul_mont: | ||
| 56 | lda sp,-40(sp) | ||
| 57 | stq ra,0(sp) | ||
| 58 | stq s3,8(sp) | ||
| 59 | stq s4,16(sp) | ||
| 60 | stq s5,24(sp) | ||
| 61 | stq fp,32(sp) | ||
| 62 | mov sp,fp | ||
| 63 | .mask 0x0400f000,-40 | ||
| 64 | .frame fp,40,ra | ||
| 65 | .prologue 0 | ||
| 66 | |||
| 67 | .align 4 | ||
| 68 | .set reorder | ||
| 69 | sextl $num,$num | ||
| 70 | mov 0,v0 | ||
| 71 | cmplt $num,4,AT | ||
| 72 | bne AT,.Lexit | ||
| 73 | |||
| 74 | ldq $hi0,0($ap) # ap[0] | ||
| 75 | s8addq $num,16,AT | ||
| 76 | ldq $aj,8($ap) | ||
| 77 | subq sp,AT,sp | ||
| 78 | ldq $bi,0($bp) # bp[0] | ||
| 79 | mov -4096,AT | ||
| 80 | ldq $n0,0($n0) | ||
| 81 | and sp,AT,sp | ||
| 82 | |||
| 83 | mulq $hi0,$bi,$lo0 | ||
| 84 | ldq $hi1,0($np) # np[0] | ||
| 85 | umulh $hi0,$bi,$hi0 | ||
| 86 | ldq $nj,8($np) | ||
| 87 | |||
| 88 | mulq $lo0,$n0,$m1 | ||
| 89 | |||
| 90 | mulq $hi1,$m1,$lo1 | ||
| 91 | umulh $hi1,$m1,$hi1 | ||
| 92 | |||
| 93 | addq $lo1,$lo0,$lo1 | ||
| 94 | cmpult $lo1,$lo0,AT | ||
| 95 | addq $hi1,AT,$hi1 | ||
| 96 | |||
| 97 | mulq $aj,$bi,$alo | ||
| 98 | mov 2,$j | ||
| 99 | umulh $aj,$bi,$ahi | ||
| 100 | mov sp,$tp | ||
| 101 | |||
| 102 | mulq $nj,$m1,$nlo | ||
| 103 | s8addq $j,$ap,$aj | ||
| 104 | umulh $nj,$m1,$nhi | ||
| 105 | s8addq $j,$np,$nj | ||
| 106 | .align 4 | ||
| 107 | .L1st: | ||
| 108 | .set noreorder | ||
| 109 | ldq $aj,($aj) | ||
| 110 | addl $j,1,$j | ||
| 111 | ldq $nj,($nj) | ||
| 112 | lda $tp,8($tp) | ||
| 113 | |||
| 114 | addq $alo,$hi0,$lo0 | ||
| 115 | mulq $aj,$bi,$alo | ||
| 116 | cmpult $lo0,$hi0,AT | ||
| 117 | addq $nlo,$hi1,$lo1 | ||
| 118 | |||
| 119 | mulq $nj,$m1,$nlo | ||
| 120 | addq $ahi,AT,$hi0 | ||
| 121 | cmpult $lo1,$hi1,v0 | ||
| 122 | cmplt $j,$num,$tj | ||
| 123 | |||
| 124 | umulh $aj,$bi,$ahi | ||
| 125 | addq $nhi,v0,$hi1 | ||
| 126 | addq $lo1,$lo0,$lo1 | ||
| 127 | s8addq $j,$ap,$aj | ||
| 128 | |||
| 129 | umulh $nj,$m1,$nhi | ||
| 130 | cmpult $lo1,$lo0,v0 | ||
| 131 | addq $hi1,v0,$hi1 | ||
| 132 | s8addq $j,$np,$nj | ||
| 133 | |||
| 134 | stq $lo1,-8($tp) | ||
| 135 | nop | ||
| 136 | unop | ||
| 137 | bne $tj,.L1st | ||
| 138 | .set reorder | ||
| 139 | |||
| 140 | addq $alo,$hi0,$lo0 | ||
| 141 | addq $nlo,$hi1,$lo1 | ||
| 142 | cmpult $lo0,$hi0,AT | ||
| 143 | cmpult $lo1,$hi1,v0 | ||
| 144 | addq $ahi,AT,$hi0 | ||
| 145 | addq $nhi,v0,$hi1 | ||
| 146 | |||
| 147 | addq $lo1,$lo0,$lo1 | ||
| 148 | cmpult $lo1,$lo0,v0 | ||
| 149 | addq $hi1,v0,$hi1 | ||
| 150 | |||
| 151 | stq $lo1,0($tp) | ||
| 152 | |||
| 153 | addq $hi1,$hi0,$hi1 | ||
| 154 | cmpult $hi1,$hi0,AT | ||
| 155 | stq $hi1,8($tp) | ||
| 156 | stq AT,16($tp) | ||
| 157 | |||
| 158 | mov 1,$i | ||
| 159 | .align 4 | ||
| 160 | .Louter: | ||
| 161 | s8addq $i,$bp,$bi | ||
| 162 | ldq $hi0,($ap) | ||
| 163 | ldq $aj,8($ap) | ||
| 164 | ldq $bi,($bi) | ||
| 165 | ldq $hi1,($np) | ||
| 166 | ldq $nj,8($np) | ||
| 167 | ldq $tj,(sp) | ||
| 168 | |||
| 169 | mulq $hi0,$bi,$lo0 | ||
| 170 | umulh $hi0,$bi,$hi0 | ||
| 171 | |||
| 172 | addq $lo0,$tj,$lo0 | ||
| 173 | cmpult $lo0,$tj,AT | ||
| 174 | addq $hi0,AT,$hi0 | ||
| 175 | |||
| 176 | mulq $lo0,$n0,$m1 | ||
| 177 | |||
| 178 | mulq $hi1,$m1,$lo1 | ||
| 179 | umulh $hi1,$m1,$hi1 | ||
| 180 | |||
| 181 | addq $lo1,$lo0,$lo1 | ||
| 182 | cmpult $lo1,$lo0,AT | ||
| 183 | mov 2,$j | ||
| 184 | addq $hi1,AT,$hi1 | ||
| 185 | |||
| 186 | mulq $aj,$bi,$alo | ||
| 187 | mov sp,$tp | ||
| 188 | umulh $aj,$bi,$ahi | ||
| 189 | |||
| 190 | mulq $nj,$m1,$nlo | ||
| 191 | s8addq $j,$ap,$aj | ||
| 192 | umulh $nj,$m1,$nhi | ||
| 193 | .align 4 | ||
| 194 | .Linner: | ||
| 195 | .set noreorder | ||
| 196 | ldq $tj,8($tp) #L0 | ||
| 197 | nop #U1 | ||
| 198 | ldq $aj,($aj) #L1 | ||
| 199 | s8addq $j,$np,$nj #U0 | ||
| 200 | |||
| 201 | ldq $nj,($nj) #L0 | ||
| 202 | nop #U1 | ||
| 203 | addq $alo,$hi0,$lo0 #L1 | ||
| 204 | lda $tp,8($tp) | ||
| 205 | |||
| 206 | mulq $aj,$bi,$alo #U1 | ||
| 207 | cmpult $lo0,$hi0,AT #L0 | ||
| 208 | addq $nlo,$hi1,$lo1 #L1 | ||
| 209 | addl $j,1,$j | ||
| 210 | |||
| 211 | mulq $nj,$m1,$nlo #U1 | ||
| 212 | addq $ahi,AT,$hi0 #L0 | ||
| 213 | addq $lo0,$tj,$lo0 #L1 | ||
| 214 | cmpult $lo1,$hi1,v0 #U0 | ||
| 215 | |||
| 216 | umulh $aj,$bi,$ahi #U1 | ||
| 217 | cmpult $lo0,$tj,AT #L0 | ||
| 218 | addq $lo1,$lo0,$lo1 #L1 | ||
| 219 | addq $nhi,v0,$hi1 #U0 | ||
| 220 | |||
| 221 | umulh $nj,$m1,$nhi #U1 | ||
| 222 | s8addq $j,$ap,$aj #L0 | ||
| 223 | cmpult $lo1,$lo0,v0 #L1 | ||
| 224 | cmplt $j,$num,$tj #U0 # borrow $tj | ||
| 225 | |||
| 226 | addq $hi0,AT,$hi0 #L0 | ||
| 227 | addq $hi1,v0,$hi1 #U1 | ||
| 228 | stq $lo1,-8($tp) #L1 | ||
| 229 | bne $tj,.Linner #U0 | ||
| 230 | .set reorder | ||
| 231 | |||
| 232 | ldq $tj,8($tp) | ||
| 233 | addq $alo,$hi0,$lo0 | ||
| 234 | addq $nlo,$hi1,$lo1 | ||
| 235 | cmpult $lo0,$hi0,AT | ||
| 236 | cmpult $lo1,$hi1,v0 | ||
| 237 | addq $ahi,AT,$hi0 | ||
| 238 | addq $nhi,v0,$hi1 | ||
| 239 | |||
| 240 | addq $lo0,$tj,$lo0 | ||
| 241 | cmpult $lo0,$tj,AT | ||
| 242 | addq $hi0,AT,$hi0 | ||
| 243 | |||
| 244 | ldq $tj,16($tp) | ||
| 245 | addq $lo1,$lo0,$j | ||
| 246 | cmpult $j,$lo0,v0 | ||
| 247 | addq $hi1,v0,$hi1 | ||
| 248 | |||
| 249 | addq $hi1,$hi0,$lo1 | ||
| 250 | stq $j,($tp) | ||
| 251 | cmpult $lo1,$hi0,$hi1 | ||
| 252 | addq $lo1,$tj,$lo1 | ||
| 253 | cmpult $lo1,$tj,AT | ||
| 254 | addl $i,1,$i | ||
| 255 | addq $hi1,AT,$hi1 | ||
| 256 | stq $lo1,8($tp) | ||
| 257 | cmplt $i,$num,$tj # borrow $tj | ||
| 258 | stq $hi1,16($tp) | ||
| 259 | bne $tj,.Louter | ||
| 260 | |||
| 261 | s8addq $num,sp,$tj # &tp[num] | ||
| 262 | mov $rp,$bp # put rp aside | ||
| 263 | mov sp,$tp | ||
| 264 | mov sp,$ap | ||
| 265 | mov 0,$hi0 # clear borrow bit | ||
| 266 | |||
| 267 | .align 4 | ||
| 268 | .Lsub: ldq $lo0,($tp) | ||
| 269 | ldq $lo1,($np) | ||
| 270 | lda $tp,8($tp) | ||
| 271 | lda $np,8($np) | ||
| 272 | subq $lo0,$lo1,$lo1 # tp[i]-np[i] | ||
| 273 | cmpult $lo0,$lo1,AT | ||
| 274 | subq $lo1,$hi0,$lo0 | ||
| 275 | cmpult $lo1,$lo0,$hi0 | ||
| 276 | or $hi0,AT,$hi0 | ||
| 277 | stq $lo0,($rp) | ||
| 278 | cmpult $tp,$tj,v0 | ||
| 279 | lda $rp,8($rp) | ||
| 280 | bne v0,.Lsub | ||
| 281 | |||
| 282 | subq $hi1,$hi0,$hi0 # handle upmost overflow bit | ||
| 283 | mov sp,$tp | ||
| 284 | mov $bp,$rp # restore rp | ||
| 285 | |||
| 286 | and sp,$hi0,$ap | ||
| 287 | bic $bp,$hi0,$bp | ||
| 288 | bis $bp,$ap,$ap # ap=borrow?tp:rp | ||
| 289 | |||
| 290 | .align 4 | ||
| 291 | .Lcopy: ldq $aj,($ap) # copy or in-place refresh | ||
| 292 | lda $tp,8($tp) | ||
| 293 | lda $rp,8($rp) | ||
| 294 | lda $ap,8($ap) | ||
| 295 | stq zero,-8($tp) # zap tp | ||
| 296 | cmpult $tp,$tj,AT | ||
| 297 | stq $aj,-8($rp) | ||
| 298 | bne AT,.Lcopy | ||
| 299 | mov 1,v0 | ||
| 300 | |||
| 301 | .Lexit: | ||
| 302 | .set noreorder | ||
| 303 | mov fp,sp | ||
| 304 | /*ldq ra,0(sp)*/ | ||
| 305 | ldq s3,8(sp) | ||
| 306 | ldq s4,16(sp) | ||
| 307 | ldq s5,24(sp) | ||
| 308 | ldq fp,32(sp) | ||
| 309 | lda sp,40(sp) | ||
| 310 | ret (ra) | ||
| 311 | .end bn_mul_mont | ||
| 312 | .rdata | ||
| 313 | .asciiz "Montgomery Multiplication for Alpha, CRYPTOGAMS by <appro\@openssl.org>" | ||
| 314 | ___ | ||
| 315 | |||
| 316 | print $code; | ||
| 317 | close STDOUT; | ||
diff --git a/src/lib/libssl/src/crypto/bn/asm/armv4-mont.pl b/src/lib/libssl/src/crypto/bn/asm/armv4-mont.pl new file mode 100644 index 0000000000..05d5dc1a48 --- /dev/null +++ b/src/lib/libssl/src/crypto/bn/asm/armv4-mont.pl | |||
| @@ -0,0 +1,200 @@ | |||
| 1 | #!/usr/bin/env perl | ||
| 2 | |||
| 3 | # ==================================================================== | ||
| 4 | # Written by Andy Polyakov <appro@fy.chalmers.se> for the OpenSSL | ||
| 5 | # project. The module is, however, dual licensed under OpenSSL and | ||
| 6 | # CRYPTOGAMS licenses depending on where you obtain it. For further | ||
| 7 | # details see http://www.openssl.org/~appro/cryptogams/. | ||
| 8 | # ==================================================================== | ||
| 9 | |||
| 10 | # January 2007. | ||
| 11 | |||
| 12 | # Montgomery multiplication for ARMv4. | ||
| 13 | # | ||
| 14 | # Performance improvement naturally varies among CPU implementations | ||
| 15 | # and compilers. The code was observed to provide +65-35% improvement | ||
| 16 | # [depending on key length, less for longer keys] on ARM920T, and | ||
| 17 | # +115-80% on Intel IXP425. This is compared to pre-bn_mul_mont code | ||
| 18 | # base and compiler generated code with in-lined umull and even umlal | ||
| 19 | # instructions. The latter means that this code didn't really have an | ||
| 20 | # "advantage" of utilizing some "secret" instruction. | ||
| 21 | # | ||
| 22 | # The code is interoperable with Thumb ISA and is rather compact, less | ||
| 23 | # than 1/2KB. Windows CE port would be trivial, as it's exclusively | ||
| 24 | # about decorations, ABI and instruction syntax are identical. | ||
| 25 | |||
| 26 | $num="r0"; # starts as num argument, but holds &tp[num-1] | ||
| 27 | $ap="r1"; | ||
| 28 | $bp="r2"; $bi="r2"; $rp="r2"; | ||
| 29 | $np="r3"; | ||
| 30 | $tp="r4"; | ||
| 31 | $aj="r5"; | ||
| 32 | $nj="r6"; | ||
| 33 | $tj="r7"; | ||
| 34 | $n0="r8"; | ||
| 35 | ########### # r9 is reserved by ELF as platform specific, e.g. TLS pointer | ||
| 36 | $alo="r10"; # sl, gcc uses it to keep @GOT | ||
| 37 | $ahi="r11"; # fp | ||
| 38 | $nlo="r12"; # ip | ||
| 39 | ########### # r13 is stack pointer | ||
| 40 | $nhi="r14"; # lr | ||
| 41 | ########### # r15 is program counter | ||
| 42 | |||
| 43 | #### argument block layout relative to &tp[num-1], a.k.a. $num | ||
| 44 | $_rp="$num,#12*4"; | ||
| 45 | # ap permanently resides in r1 | ||
| 46 | $_bp="$num,#13*4"; | ||
| 47 | # np permanently resides in r3 | ||
| 48 | $_n0="$num,#14*4"; | ||
| 49 | $_num="$num,#15*4"; $_bpend=$_num; | ||
| 50 | |||
| 51 | $code=<<___; | ||
| 52 | .text | ||
| 53 | |||
| 54 | .global bn_mul_mont | ||
| 55 | .type bn_mul_mont,%function | ||
| 56 | |||
| 57 | .align 2 | ||
| 58 | bn_mul_mont: | ||
| 59 | stmdb sp!,{r0,r2} @ sp points at argument block | ||
| 60 | ldr $num,[sp,#3*4] @ load num | ||
| 61 | cmp $num,#2 | ||
| 62 | movlt r0,#0 | ||
| 63 | addlt sp,sp,#2*4 | ||
| 64 | blt .Labrt | ||
| 65 | |||
| 66 | stmdb sp!,{r4-r12,lr} @ save 10 registers | ||
| 67 | |||
| 68 | mov $num,$num,lsl#2 @ rescale $num for byte count | ||
| 69 | sub sp,sp,$num @ alloca(4*num) | ||
| 70 | sub sp,sp,#4 @ +extra dword | ||
| 71 | sub $num,$num,#4 @ "num=num-1" | ||
| 72 | add $tp,$bp,$num @ &bp[num-1] | ||
| 73 | |||
| 74 | add $num,sp,$num @ $num to point at &tp[num-1] | ||
| 75 | ldr $n0,[$_n0] @ &n0 | ||
| 76 | ldr $bi,[$bp] @ bp[0] | ||
| 77 | ldr $aj,[$ap],#4 @ ap[0],ap++ | ||
| 78 | ldr $nj,[$np],#4 @ np[0],np++ | ||
| 79 | ldr $n0,[$n0] @ *n0 | ||
| 80 | str $tp,[$_bpend] @ save &bp[num] | ||
| 81 | |||
| 82 | umull $alo,$ahi,$aj,$bi @ ap[0]*bp[0] | ||
| 83 | str $n0,[$_n0] @ save n0 value | ||
| 84 | mul $n0,$alo,$n0 @ "tp[0]"*n0 | ||
| 85 | mov $nlo,#0 | ||
| 86 | umlal $alo,$nlo,$nj,$n0 @ np[0]*n0+"t[0]" | ||
| 87 | mov $tp,sp | ||
| 88 | |||
| 89 | .L1st: | ||
| 90 | ldr $aj,[$ap],#4 @ ap[j],ap++ | ||
| 91 | mov $alo,$ahi | ||
| 92 | mov $ahi,#0 | ||
| 93 | umlal $alo,$ahi,$aj,$bi @ ap[j]*bp[0] | ||
| 94 | ldr $nj,[$np],#4 @ np[j],np++ | ||
| 95 | mov $nhi,#0 | ||
| 96 | umlal $nlo,$nhi,$nj,$n0 @ np[j]*n0 | ||
| 97 | adds $nlo,$nlo,$alo | ||
| 98 | str $nlo,[$tp],#4 @ tp[j-1]=,tp++ | ||
| 99 | adc $nlo,$nhi,#0 | ||
| 100 | cmp $tp,$num | ||
| 101 | bne .L1st | ||
| 102 | |||
| 103 | adds $nlo,$nlo,$ahi | ||
| 104 | mov $nhi,#0 | ||
| 105 | adc $nhi,$nhi,#0 | ||
| 106 | ldr $tp,[$_bp] @ restore bp | ||
| 107 | str $nlo,[$num] @ tp[num-1]= | ||
| 108 | ldr $n0,[$_n0] @ restore n0 | ||
| 109 | str $nhi,[$num,#4] @ tp[num]= | ||
| 110 | |||
| 111 | .Louter: | ||
| 112 | sub $tj,$num,sp @ "original" $num-1 value | ||
| 113 | sub $ap,$ap,$tj @ "rewind" ap to &ap[1] | ||
| 114 | sub $np,$np,$tj @ "rewind" np to &np[1] | ||
| 115 | ldr $bi,[$tp,#4]! @ *(++bp) | ||
| 116 | ldr $aj,[$ap,#-4] @ ap[0] | ||
| 117 | ldr $nj,[$np,#-4] @ np[0] | ||
| 118 | ldr $alo,[sp] @ tp[0] | ||
| 119 | ldr $tj,[sp,#4] @ tp[1] | ||
| 120 | |||
| 121 | mov $ahi,#0 | ||
| 122 | umlal $alo,$ahi,$aj,$bi @ ap[0]*bp[i]+tp[0] | ||
| 123 | str $tp,[$_bp] @ save bp | ||
| 124 | mul $n0,$alo,$n0 | ||
| 125 | mov $nlo,#0 | ||
| 126 | umlal $alo,$nlo,$nj,$n0 @ np[0]*n0+"tp[0]" | ||
| 127 | mov $tp,sp | ||
| 128 | |||
| 129 | .Linner: | ||
| 130 | ldr $aj,[$ap],#4 @ ap[j],ap++ | ||
| 131 | adds $alo,$ahi,$tj @ +=tp[j] | ||
| 132 | mov $ahi,#0 | ||
| 133 | umlal $alo,$ahi,$aj,$bi @ ap[j]*bp[i] | ||
| 134 | ldr $nj,[$np],#4 @ np[j],np++ | ||
| 135 | mov $nhi,#0 | ||
| 136 | umlal $nlo,$nhi,$nj,$n0 @ np[j]*n0 | ||
| 137 | ldr $tj,[$tp,#8] @ tp[j+1] | ||
| 138 | adc $ahi,$ahi,#0 | ||
| 139 | adds $nlo,$nlo,$alo | ||
| 140 | str $nlo,[$tp],#4 @ tp[j-1]=,tp++ | ||
| 141 | adc $nlo,$nhi,#0 | ||
| 142 | cmp $tp,$num | ||
| 143 | bne .Linner | ||
| 144 | |||
| 145 | adds $nlo,$nlo,$ahi | ||
| 146 | mov $nhi,#0 | ||
| 147 | adc $nhi,$nhi,#0 | ||
| 148 | adds $nlo,$nlo,$tj | ||
| 149 | adc $nhi,$nhi,#0 | ||
| 150 | ldr $tp,[$_bp] @ restore bp | ||
| 151 | ldr $tj,[$_bpend] @ restore &bp[num] | ||
| 152 | str $nlo,[$num] @ tp[num-1]= | ||
| 153 | ldr $n0,[$_n0] @ restore n0 | ||
| 154 | str $nhi,[$num,#4] @ tp[num]= | ||
| 155 | |||
| 156 | cmp $tp,$tj | ||
| 157 | bne .Louter | ||
| 158 | |||
| 159 | ldr $rp,[$_rp] @ pull rp | ||
| 160 | add $num,$num,#4 @ $num to point at &tp[num] | ||
| 161 | sub $aj,$num,sp @ "original" num value | ||
| 162 | mov $tp,sp @ "rewind" $tp | ||
| 163 | mov $ap,$tp @ "borrow" $ap | ||
| 164 | sub $np,$np,$aj @ "rewind" $np to &np[0] | ||
| 165 | |||
| 166 | subs $tj,$tj,$tj @ "clear" carry flag | ||
| 167 | .Lsub: ldr $tj,[$tp],#4 | ||
| 168 | ldr $nj,[$np],#4 | ||
| 169 | sbcs $tj,$tj,$nj @ tp[j]-np[j] | ||
| 170 | str $tj,[$rp],#4 @ rp[j]= | ||
| 171 | teq $tp,$num @ preserve carry | ||
| 172 | bne .Lsub | ||
| 173 | sbcs $nhi,$nhi,#0 @ upmost carry | ||
| 174 | mov $tp,sp @ "rewind" $tp | ||
| 175 | sub $rp,$rp,$aj @ "rewind" $rp | ||
| 176 | |||
| 177 | and $ap,$tp,$nhi | ||
| 178 | bic $np,$rp,$nhi | ||
| 179 | orr $ap,$ap,$np @ ap=borrow?tp:rp | ||
| 180 | |||
| 181 | .Lcopy: ldr $tj,[$ap],#4 @ copy or in-place refresh | ||
| 182 | str sp,[$tp],#4 @ zap tp | ||
| 183 | str $tj,[$rp],#4 | ||
| 184 | cmp $tp,$num | ||
| 185 | bne .Lcopy | ||
| 186 | |||
| 187 | add sp,$num,#4 @ skip over tp[num+1] | ||
| 188 | ldmia sp!,{r4-r12,lr} @ restore registers | ||
| 189 | add sp,sp,#2*4 @ skip over {r0,r2} | ||
| 190 | mov r0,#1 | ||
| 191 | .Labrt: tst lr,#1 | ||
| 192 | moveq pc,lr @ be binary compatible with V4, yet | ||
| 193 | bx lr @ interoperable with Thumb ISA:-) | ||
| 194 | .size bn_mul_mont,.-bn_mul_mont | ||
| 195 | .asciz "Montgomery multiplication for ARMv4, CRYPTOGAMS by <appro\@openssl.org>" | ||
| 196 | ___ | ||
| 197 | |||
| 198 | $code =~ s/\bbx\s+lr\b/.word\t0xe12fff1e/gm; # make it possible to compile with -march=armv4 | ||
| 199 | print $code; | ||
| 200 | close STDOUT; | ||
diff --git a/src/lib/libssl/src/crypto/bn/asm/mips3-mont.pl b/src/lib/libssl/src/crypto/bn/asm/mips3-mont.pl new file mode 100644 index 0000000000..8f9156e02a --- /dev/null +++ b/src/lib/libssl/src/crypto/bn/asm/mips3-mont.pl | |||
| @@ -0,0 +1,327 @@ | |||
| 1 | #!/usr/bin/env perl | ||
| 2 | # | ||
| 3 | # ==================================================================== | ||
| 4 | # Written by Andy Polyakov <appro@fy.chalmers.se> for the OpenSSL | ||
| 5 | # project. The module is, however, dual licensed under OpenSSL and | ||
| 6 | # CRYPTOGAMS licenses depending on where you obtain it. For further | ||
| 7 | # details see http://www.openssl.org/~appro/cryptogams/. | ||
| 8 | # ==================================================================== | ||
| 9 | |||
| 10 | # This module doesn't present direct interest for OpenSSL, because it | ||
| 11 | # doesn't provide better performance for longer keys. While 512-bit | ||
| 12 | # RSA private key operations are 40% faster, 1024-bit ones are hardly | ||
| 13 | # faster at all, while longer key operations are slower by up to 20%. | ||
| 14 | # It might be of interest to embedded system developers though, as | ||
| 15 | # it's smaller than 1KB, yet offers ~3x improvement over compiler | ||
| 16 | # generated code. | ||
| 17 | # | ||
| 18 | # The module targets N32 and N64 MIPS ABIs and currently is a bit | ||
| 19 | # IRIX-centric, i.e. is likely to require adaptation for other OSes. | ||
| 20 | |||
| 21 | # int bn_mul_mont( | ||
| 22 | $rp="a0"; # BN_ULONG *rp, | ||
| 23 | $ap="a1"; # const BN_ULONG *ap, | ||
| 24 | $bp="a2"; # const BN_ULONG *bp, | ||
| 25 | $np="a3"; # const BN_ULONG *np, | ||
| 26 | $n0="a4"; # const BN_ULONG *n0, | ||
| 27 | $num="a5"; # int num); | ||
| 28 | |||
| 29 | $lo0="a6"; | ||
| 30 | $hi0="a7"; | ||
| 31 | $lo1="v0"; | ||
| 32 | $hi1="v1"; | ||
| 33 | $aj="t0"; | ||
| 34 | $bi="t1"; | ||
| 35 | $nj="t2"; | ||
| 36 | $tp="t3"; | ||
| 37 | $alo="s0"; | ||
| 38 | $ahi="s1"; | ||
| 39 | $nlo="s2"; | ||
| 40 | $nhi="s3"; | ||
| 41 | $tj="s4"; | ||
| 42 | $i="s5"; | ||
| 43 | $j="s6"; | ||
| 44 | $fp="t8"; | ||
| 45 | $m1="t9"; | ||
| 46 | |||
| 47 | $FRAME=8*(2+8); | ||
| 48 | |||
| 49 | $code=<<___; | ||
| 50 | #include <asm.h> | ||
| 51 | #include <regdef.h> | ||
| 52 | |||
| 53 | .text | ||
| 54 | |||
| 55 | .set noat | ||
| 56 | .set reorder | ||
| 57 | |||
| 58 | .align 5 | ||
| 59 | .globl bn_mul_mont | ||
| 60 | .ent bn_mul_mont | ||
| 61 | bn_mul_mont: | ||
| 62 | .set noreorder | ||
| 63 | PTR_SUB sp,64 | ||
| 64 | move $fp,sp | ||
| 65 | .frame $fp,64,ra | ||
| 66 | slt AT,$num,4 | ||
| 67 | li v0,0 | ||
| 68 | beqzl AT,.Lproceed | ||
| 69 | nop | ||
| 70 | jr ra | ||
| 71 | PTR_ADD sp,$fp,64 | ||
| 72 | .set reorder | ||
| 73 | .align 5 | ||
| 74 | .Lproceed: | ||
| 75 | ld $n0,0($n0) | ||
| 76 | ld $bi,0($bp) # bp[0] | ||
| 77 | ld $aj,0($ap) # ap[0] | ||
| 78 | ld $nj,0($np) # np[0] | ||
| 79 | PTR_SUB sp,16 # place for two extra words | ||
| 80 | sll $num,3 | ||
| 81 | li AT,-4096 | ||
| 82 | PTR_SUB sp,$num | ||
| 83 | and sp,AT | ||
| 84 | |||
| 85 | sd s0,0($fp) | ||
| 86 | sd s1,8($fp) | ||
| 87 | sd s2,16($fp) | ||
| 88 | sd s3,24($fp) | ||
| 89 | sd s4,32($fp) | ||
| 90 | sd s5,40($fp) | ||
| 91 | sd s6,48($fp) | ||
| 92 | sd s7,56($fp) | ||
| 93 | |||
| 94 | dmultu $aj,$bi | ||
| 95 | ld $alo,8($ap) | ||
| 96 | ld $nlo,8($np) | ||
| 97 | mflo $lo0 | ||
| 98 | mfhi $hi0 | ||
| 99 | dmultu $lo0,$n0 | ||
| 100 | mflo $m1 | ||
| 101 | |||
| 102 | dmultu $alo,$bi | ||
| 103 | mflo $alo | ||
| 104 | mfhi $ahi | ||
| 105 | |||
| 106 | dmultu $nj,$m1 | ||
| 107 | mflo $lo1 | ||
| 108 | mfhi $hi1 | ||
| 109 | dmultu $nlo,$m1 | ||
| 110 | daddu $lo1,$lo0 | ||
| 111 | sltu AT,$lo1,$lo0 | ||
| 112 | daddu $hi1,AT | ||
| 113 | mflo $nlo | ||
| 114 | mfhi $nhi | ||
| 115 | |||
| 116 | move $tp,sp | ||
| 117 | li $j,16 | ||
| 118 | .align 4 | ||
| 119 | .L1st: | ||
| 120 | .set noreorder | ||
| 121 | PTR_ADD $aj,$ap,$j | ||
| 122 | ld $aj,($aj) | ||
| 123 | PTR_ADD $nj,$np,$j | ||
| 124 | ld $nj,($nj) | ||
| 125 | |||
| 126 | dmultu $aj,$bi | ||
| 127 | daddu $lo0,$alo,$hi0 | ||
| 128 | daddu $lo1,$nlo,$hi1 | ||
| 129 | sltu AT,$lo0,$hi0 | ||
| 130 | sltu s7,$lo1,$hi1 | ||
| 131 | daddu $hi0,$ahi,AT | ||
| 132 | daddu $hi1,$nhi,s7 | ||
| 133 | mflo $alo | ||
| 134 | mfhi $ahi | ||
| 135 | |||
| 136 | daddu $lo1,$lo0 | ||
| 137 | sltu AT,$lo1,$lo0 | ||
| 138 | dmultu $nj,$m1 | ||
| 139 | daddu $hi1,AT | ||
| 140 | addu $j,8 | ||
| 141 | sd $lo1,($tp) | ||
| 142 | sltu s7,$j,$num | ||
| 143 | mflo $nlo | ||
| 144 | mfhi $nhi | ||
| 145 | |||
| 146 | bnez s7,.L1st | ||
| 147 | PTR_ADD $tp,8 | ||
| 148 | .set reorder | ||
| 149 | |||
| 150 | daddu $lo0,$alo,$hi0 | ||
| 151 | sltu AT,$lo0,$hi0 | ||
| 152 | daddu $hi0,$ahi,AT | ||
| 153 | |||
| 154 | daddu $lo1,$nlo,$hi1 | ||
| 155 | sltu s7,$lo1,$hi1 | ||
| 156 | daddu $hi1,$nhi,s7 | ||
| 157 | daddu $lo1,$lo0 | ||
| 158 | sltu AT,$lo1,$lo0 | ||
| 159 | daddu $hi1,AT | ||
| 160 | |||
| 161 | sd $lo1,($tp) | ||
| 162 | |||
| 163 | daddu $hi1,$hi0 | ||
| 164 | sltu AT,$hi1,$hi0 | ||
| 165 | sd $hi1,8($tp) | ||
| 166 | sd AT,16($tp) | ||
| 167 | |||
| 168 | li $i,8 | ||
| 169 | .align 4 | ||
| 170 | .Louter: | ||
| 171 | PTR_ADD $bi,$bp,$i | ||
| 172 | ld $bi,($bi) | ||
| 173 | ld $aj,($ap) | ||
| 174 | ld $alo,8($ap) | ||
| 175 | ld $tj,(sp) | ||
| 176 | |||
| 177 | dmultu $aj,$bi | ||
| 178 | ld $nj,($np) | ||
| 179 | ld $nlo,8($np) | ||
| 180 | mflo $lo0 | ||
| 181 | mfhi $hi0 | ||
| 182 | daddu $lo0,$tj | ||
| 183 | dmultu $lo0,$n0 | ||
| 184 | sltu AT,$lo0,$tj | ||
| 185 | daddu $hi0,AT | ||
| 186 | mflo $m1 | ||
| 187 | |||
| 188 | dmultu $alo,$bi | ||
| 189 | mflo $alo | ||
| 190 | mfhi $ahi | ||
| 191 | |||
| 192 | dmultu $nj,$m1 | ||
| 193 | mflo $lo1 | ||
| 194 | mfhi $hi1 | ||
| 195 | |||
| 196 | dmultu $nlo,$m1 | ||
| 197 | daddu $lo1,$lo0 | ||
| 198 | sltu AT,$lo1,$lo0 | ||
| 199 | daddu $hi1,AT | ||
| 200 | mflo $nlo | ||
| 201 | mfhi $nhi | ||
| 202 | |||
| 203 | move $tp,sp | ||
| 204 | li $j,16 | ||
| 205 | ld $tj,8($tp) | ||
| 206 | .align 4 | ||
| 207 | .Linner: | ||
| 208 | .set noreorder | ||
| 209 | PTR_ADD $aj,$ap,$j | ||
| 210 | ld $aj,($aj) | ||
| 211 | PTR_ADD $nj,$np,$j | ||
| 212 | ld $nj,($nj) | ||
| 213 | |||
| 214 | dmultu $aj,$bi | ||
| 215 | daddu $lo0,$alo,$hi0 | ||
| 216 | daddu $lo1,$nlo,$hi1 | ||
| 217 | sltu AT,$lo0,$hi0 | ||
| 218 | sltu s7,$lo1,$hi1 | ||
| 219 | daddu $hi0,$ahi,AT | ||
| 220 | daddu $hi1,$nhi,s7 | ||
| 221 | mflo $alo | ||
| 222 | mfhi $ahi | ||
| 223 | |||
| 224 | daddu $lo0,$tj | ||
| 225 | addu $j,8 | ||
| 226 | dmultu $nj,$m1 | ||
| 227 | sltu AT,$lo0,$tj | ||
| 228 | daddu $lo1,$lo0 | ||
| 229 | daddu $hi0,AT | ||
| 230 | sltu s7,$lo1,$lo0 | ||
| 231 | ld $tj,16($tp) | ||
| 232 | daddu $hi1,s7 | ||
| 233 | sltu AT,$j,$num | ||
| 234 | mflo $nlo | ||
| 235 | mfhi $nhi | ||
| 236 | sd $lo1,($tp) | ||
| 237 | bnez AT,.Linner | ||
| 238 | PTR_ADD $tp,8 | ||
| 239 | .set reorder | ||
| 240 | |||
| 241 | daddu $lo0,$alo,$hi0 | ||
| 242 | sltu AT,$lo0,$hi0 | ||
| 243 | daddu $hi0,$ahi,AT | ||
| 244 | daddu $lo0,$tj | ||
| 245 | sltu s7,$lo0,$tj | ||
| 246 | daddu $hi0,s7 | ||
| 247 | |||
| 248 | ld $tj,16($tp) | ||
| 249 | daddu $lo1,$nlo,$hi1 | ||
| 250 | sltu AT,$lo1,$hi1 | ||
| 251 | daddu $hi1,$nhi,AT | ||
| 252 | daddu $lo1,$lo0 | ||
| 253 | sltu s7,$lo1,$lo0 | ||
| 254 | daddu $hi1,s7 | ||
| 255 | sd $lo1,($tp) | ||
| 256 | |||
| 257 | daddu $lo1,$hi1,$hi0 | ||
| 258 | sltu $hi1,$lo1,$hi0 | ||
| 259 | daddu $lo1,$tj | ||
| 260 | sltu AT,$lo1,$tj | ||
| 261 | daddu $hi1,AT | ||
| 262 | sd $lo1,8($tp) | ||
| 263 | sd $hi1,16($tp) | ||
| 264 | |||
| 265 | addu $i,8 | ||
| 266 | sltu s7,$i,$num | ||
| 267 | bnez s7,.Louter | ||
| 268 | |||
| 269 | .set noreorder | ||
| 270 | PTR_ADD $tj,sp,$num # &tp[num] | ||
| 271 | move $tp,sp | ||
| 272 | move $ap,sp | ||
| 273 | li $hi0,0 # clear borrow bit | ||
| 274 | |||
| 275 | .align 4 | ||
| 276 | .Lsub: ld $lo0,($tp) | ||
| 277 | ld $lo1,($np) | ||
| 278 | PTR_ADD $tp,8 | ||
| 279 | PTR_ADD $np,8 | ||
| 280 | dsubu $lo1,$lo0,$lo1 # tp[i]-np[i] | ||
| 281 | sgtu AT,$lo1,$lo0 | ||
| 282 | dsubu $lo0,$lo1,$hi0 | ||
| 283 | sgtu $hi0,$lo0,$lo1 | ||
| 284 | sd $lo0,($rp) | ||
| 285 | or $hi0,AT | ||
| 286 | sltu AT,$tp,$tj | ||
| 287 | bnez AT,.Lsub | ||
| 288 | PTR_ADD $rp,8 | ||
| 289 | |||
| 290 | dsubu $hi0,$hi1,$hi0 # handle upmost overflow bit | ||
| 291 | move $tp,sp | ||
| 292 | PTR_SUB $rp,$num # restore rp | ||
| 293 | not $hi1,$hi0 | ||
| 294 | |||
| 295 | and $ap,$hi0,sp | ||
| 296 | and $bp,$hi1,$rp | ||
| 297 | or $ap,$ap,$bp # ap=borrow?tp:rp | ||
| 298 | |||
| 299 | .align 4 | ||
| 300 | .Lcopy: ld $aj,($ap) | ||
| 301 | PTR_ADD $ap,8 | ||
| 302 | PTR_ADD $tp,8 | ||
| 303 | sd zero,-8($tp) | ||
| 304 | sltu AT,$tp,$tj | ||
| 305 | sd $aj,($rp) | ||
| 306 | bnez AT,.Lcopy | ||
| 307 | PTR_ADD $rp,8 | ||
| 308 | |||
| 309 | ld s0,0($fp) | ||
| 310 | ld s1,8($fp) | ||
| 311 | ld s2,16($fp) | ||
| 312 | ld s3,24($fp) | ||
| 313 | ld s4,32($fp) | ||
| 314 | ld s5,40($fp) | ||
| 315 | ld s6,48($fp) | ||
| 316 | ld s7,56($fp) | ||
| 317 | li v0,1 | ||
| 318 | jr ra | ||
| 319 | PTR_ADD sp,$fp,64 | ||
| 320 | .set reorder | ||
| 321 | END(bn_mul_mont) | ||
| 322 | .rdata | ||
| 323 | .asciiz "Montgomery Multiplication for MIPS III/IV, CRYPTOGAMS by <appro\@openssl.org>" | ||
| 324 | ___ | ||
| 325 | |||
| 326 | print $code; | ||
| 327 | close STDOUT; | ||
diff --git a/src/lib/libssl/src/crypto/bn/asm/ppc-mont.pl b/src/lib/libssl/src/crypto/bn/asm/ppc-mont.pl new file mode 100644 index 0000000000..7849eae959 --- /dev/null +++ b/src/lib/libssl/src/crypto/bn/asm/ppc-mont.pl | |||
| @@ -0,0 +1,323 @@ | |||
| 1 | #!/usr/bin/env perl | ||
| 2 | |||
| 3 | # ==================================================================== | ||
| 4 | # Written by Andy Polyakov <appro@fy.chalmers.se> for the OpenSSL | ||
| 5 | # project. The module is, however, dual licensed under OpenSSL and | ||
| 6 | # CRYPTOGAMS licenses depending on where you obtain it. For further | ||
| 7 | # details see http://www.openssl.org/~appro/cryptogams/. | ||
| 8 | # ==================================================================== | ||
| 9 | |||
| 10 | # April 2006 | ||
| 11 | |||
| 12 | # "Teaser" Montgomery multiplication module for PowerPC. It's possible | ||
| 13 | # to gain a bit more by modulo-scheduling outer loop, then dedicated | ||
| 14 | # squaring procedure should give further 20% and code can be adapted | ||
| 15 | # for 32-bit application running on 64-bit CPU. As for the latter. | ||
| 16 | # It won't be able to achieve "native" 64-bit performance, because in | ||
| 17 | # 32-bit application context every addc instruction will have to be | ||
| 18 | # expanded as addc, twice right shift by 32 and finally adde, etc. | ||
| 19 | # So far RSA *sign* performance improvement over pre-bn_mul_mont asm | ||
| 20 | # for 64-bit application running on PPC970/G5 is: | ||
| 21 | # | ||
| 22 | # 512-bit +65% | ||
| 23 | # 1024-bit +35% | ||
| 24 | # 2048-bit +18% | ||
| 25 | # 4096-bit +4% | ||
| 26 | |||
| 27 | $flavour = shift; | ||
| 28 | |||
| 29 | if ($flavour =~ /32/) { | ||
| 30 | $BITS= 32; | ||
| 31 | $BNSZ= $BITS/8; | ||
| 32 | $SIZE_T=4; | ||
| 33 | $RZONE= 224; | ||
| 34 | $FRAME= $SIZE_T*16; | ||
| 35 | |||
| 36 | $LD= "lwz"; # load | ||
| 37 | $LDU= "lwzu"; # load and update | ||
| 38 | $LDX= "lwzx"; # load indexed | ||
| 39 | $ST= "stw"; # store | ||
| 40 | $STU= "stwu"; # store and update | ||
| 41 | $STX= "stwx"; # store indexed | ||
| 42 | $STUX= "stwux"; # store indexed and update | ||
| 43 | $UMULL= "mullw"; # unsigned multiply low | ||
| 44 | $UMULH= "mulhwu"; # unsigned multiply high | ||
| 45 | $UCMP= "cmplw"; # unsigned compare | ||
| 46 | $SHRI= "srwi"; # unsigned shift right by immediate | ||
| 47 | $PUSH= $ST; | ||
| 48 | $POP= $LD; | ||
| 49 | } elsif ($flavour =~ /64/) { | ||
| 50 | $BITS= 64; | ||
| 51 | $BNSZ= $BITS/8; | ||
| 52 | $SIZE_T=8; | ||
| 53 | $RZONE= 288; | ||
| 54 | $FRAME= $SIZE_T*16; | ||
| 55 | |||
| 56 | # same as above, but 64-bit mnemonics... | ||
| 57 | $LD= "ld"; # load | ||
| 58 | $LDU= "ldu"; # load and update | ||
| 59 | $LDX= "ldx"; # load indexed | ||
| 60 | $ST= "std"; # store | ||
| 61 | $STU= "stdu"; # store and update | ||
| 62 | $STX= "stdx"; # store indexed | ||
| 63 | $STUX= "stdux"; # store indexed and update | ||
| 64 | $UMULL= "mulld"; # unsigned multiply low | ||
| 65 | $UMULH= "mulhdu"; # unsigned multiply high | ||
| 66 | $UCMP= "cmpld"; # unsigned compare | ||
| 67 | $SHRI= "srdi"; # unsigned shift right by immediate | ||
| 68 | $PUSH= $ST; | ||
| 69 | $POP= $LD; | ||
| 70 | } else { die "nonsense $flavour"; } | ||
| 71 | |||
| 72 | $0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1; | ||
| 73 | ( $xlate="${dir}ppc-xlate.pl" and -f $xlate ) or | ||
| 74 | ( $xlate="${dir}../../perlasm/ppc-xlate.pl" and -f $xlate) or | ||
| 75 | die "can't locate ppc-xlate.pl"; | ||
| 76 | |||
| 77 | open STDOUT,"| $^X $xlate $flavour ".shift || die "can't call $xlate: $!"; | ||
| 78 | |||
| 79 | $sp="r1"; | ||
| 80 | $toc="r2"; | ||
| 81 | $rp="r3"; $ovf="r3"; | ||
| 82 | $ap="r4"; | ||
| 83 | $bp="r5"; | ||
| 84 | $np="r6"; | ||
| 85 | $n0="r7"; | ||
| 86 | $num="r8"; | ||
| 87 | $rp="r9"; # $rp is reassigned | ||
| 88 | $aj="r10"; | ||
| 89 | $nj="r11"; | ||
| 90 | $tj="r12"; | ||
| 91 | # non-volatile registers | ||
| 92 | $i="r14"; | ||
| 93 | $j="r15"; | ||
| 94 | $tp="r16"; | ||
| 95 | $m0="r17"; | ||
| 96 | $m1="r18"; | ||
| 97 | $lo0="r19"; | ||
| 98 | $hi0="r20"; | ||
| 99 | $lo1="r21"; | ||
| 100 | $hi1="r22"; | ||
| 101 | $alo="r23"; | ||
| 102 | $ahi="r24"; | ||
| 103 | $nlo="r25"; | ||
| 104 | # | ||
| 105 | $nhi="r0"; | ||
| 106 | |||
| 107 | $code=<<___; | ||
| 108 | .machine "any" | ||
| 109 | .text | ||
| 110 | |||
| 111 | .globl .bn_mul_mont | ||
| 112 | .align 4 | ||
| 113 | .bn_mul_mont: | ||
| 114 | cmpwi $num,4 | ||
| 115 | mr $rp,r3 ; $rp is reassigned | ||
| 116 | li r3,0 | ||
| 117 | bltlr | ||
| 118 | |||
| 119 | slwi $num,$num,`log($BNSZ)/log(2)` | ||
| 120 | li $tj,-4096 | ||
| 121 | addi $ovf,$num,`$FRAME+$RZONE` | ||
| 122 | subf $ovf,$ovf,$sp ; $sp-$ovf | ||
| 123 | and $ovf,$ovf,$tj ; minimize TLB usage | ||
| 124 | subf $ovf,$sp,$ovf ; $ovf-$sp | ||
| 125 | srwi $num,$num,`log($BNSZ)/log(2)` | ||
| 126 | $STUX $sp,$sp,$ovf | ||
| 127 | |||
| 128 | $PUSH r14,`4*$SIZE_T`($sp) | ||
| 129 | $PUSH r15,`5*$SIZE_T`($sp) | ||
| 130 | $PUSH r16,`6*$SIZE_T`($sp) | ||
| 131 | $PUSH r17,`7*$SIZE_T`($sp) | ||
| 132 | $PUSH r18,`8*$SIZE_T`($sp) | ||
| 133 | $PUSH r19,`9*$SIZE_T`($sp) | ||
| 134 | $PUSH r20,`10*$SIZE_T`($sp) | ||
| 135 | $PUSH r21,`11*$SIZE_T`($sp) | ||
| 136 | $PUSH r22,`12*$SIZE_T`($sp) | ||
| 137 | $PUSH r23,`13*$SIZE_T`($sp) | ||
| 138 | $PUSH r24,`14*$SIZE_T`($sp) | ||
| 139 | $PUSH r25,`15*$SIZE_T`($sp) | ||
| 140 | |||
| 141 | $LD $n0,0($n0) ; pull n0[0] value | ||
| 142 | addi $num,$num,-2 ; adjust $num for counter register | ||
| 143 | |||
| 144 | $LD $m0,0($bp) ; m0=bp[0] | ||
| 145 | $LD $aj,0($ap) ; ap[0] | ||
| 146 | addi $tp,$sp,$FRAME | ||
| 147 | $UMULL $lo0,$aj,$m0 ; ap[0]*bp[0] | ||
| 148 | $UMULH $hi0,$aj,$m0 | ||
| 149 | |||
| 150 | $LD $aj,$BNSZ($ap) ; ap[1] | ||
| 151 | $LD $nj,0($np) ; np[0] | ||
| 152 | |||
| 153 | $UMULL $m1,$lo0,$n0 ; "tp[0]"*n0 | ||
| 154 | |||
| 155 | $UMULL $alo,$aj,$m0 ; ap[1]*bp[0] | ||
| 156 | $UMULH $ahi,$aj,$m0 | ||
| 157 | |||
| 158 | $UMULL $lo1,$nj,$m1 ; np[0]*m1 | ||
| 159 | $UMULH $hi1,$nj,$m1 | ||
| 160 | $LD $nj,$BNSZ($np) ; np[1] | ||
| 161 | addc $lo1,$lo1,$lo0 | ||
| 162 | addze $hi1,$hi1 | ||
| 163 | |||
| 164 | $UMULL $nlo,$nj,$m1 ; np[1]*m1 | ||
| 165 | $UMULH $nhi,$nj,$m1 | ||
| 166 | |||
| 167 | mtctr $num | ||
| 168 | li $j,`2*$BNSZ` | ||
| 169 | .align 4 | ||
| 170 | L1st: | ||
| 171 | $LDX $aj,$ap,$j ; ap[j] | ||
| 172 | addc $lo0,$alo,$hi0 | ||
| 173 | $LDX $nj,$np,$j ; np[j] | ||
| 174 | addze $hi0,$ahi | ||
| 175 | $UMULL $alo,$aj,$m0 ; ap[j]*bp[0] | ||
| 176 | addc $lo1,$nlo,$hi1 | ||
| 177 | $UMULH $ahi,$aj,$m0 | ||
| 178 | addze $hi1,$nhi | ||
| 179 | $UMULL $nlo,$nj,$m1 ; np[j]*m1 | ||
| 180 | addc $lo1,$lo1,$lo0 ; np[j]*m1+ap[j]*bp[0] | ||
| 181 | $UMULH $nhi,$nj,$m1 | ||
| 182 | addze $hi1,$hi1 | ||
| 183 | $ST $lo1,0($tp) ; tp[j-1] | ||
| 184 | |||
| 185 | addi $j,$j,$BNSZ ; j++ | ||
| 186 | addi $tp,$tp,$BNSZ ; tp++ | ||
| 187 | bdnz- L1st | ||
| 188 | ;L1st | ||
| 189 | addc $lo0,$alo,$hi0 | ||
| 190 | addze $hi0,$ahi | ||
| 191 | |||
| 192 | addc $lo1,$nlo,$hi1 | ||
| 193 | addze $hi1,$nhi | ||
| 194 | addc $lo1,$lo1,$lo0 ; np[j]*m1+ap[j]*bp[0] | ||
| 195 | addze $hi1,$hi1 | ||
| 196 | $ST $lo1,0($tp) ; tp[j-1] | ||
| 197 | |||
| 198 | li $ovf,0 | ||
| 199 | addc $hi1,$hi1,$hi0 | ||
| 200 | addze $ovf,$ovf ; upmost overflow bit | ||
| 201 | $ST $hi1,$BNSZ($tp) | ||
| 202 | |||
| 203 | li $i,$BNSZ | ||
| 204 | .align 4 | ||
| 205 | Louter: | ||
| 206 | $LDX $m0,$bp,$i ; m0=bp[i] | ||
| 207 | $LD $aj,0($ap) ; ap[0] | ||
| 208 | addi $tp,$sp,$FRAME | ||
| 209 | $LD $tj,$FRAME($sp) ; tp[0] | ||
| 210 | $UMULL $lo0,$aj,$m0 ; ap[0]*bp[i] | ||
| 211 | $UMULH $hi0,$aj,$m0 | ||
| 212 | $LD $aj,$BNSZ($ap) ; ap[1] | ||
| 213 | $LD $nj,0($np) ; np[0] | ||
| 214 | addc $lo0,$lo0,$tj ; ap[0]*bp[i]+tp[0] | ||
| 215 | $UMULL $alo,$aj,$m0 ; ap[j]*bp[i] | ||
| 216 | addze $hi0,$hi0 | ||
| 217 | $UMULL $m1,$lo0,$n0 ; tp[0]*n0 | ||
| 218 | $UMULH $ahi,$aj,$m0 | ||
| 219 | $UMULL $lo1,$nj,$m1 ; np[0]*m1 | ||
| 220 | $UMULH $hi1,$nj,$m1 | ||
| 221 | $LD $nj,$BNSZ($np) ; np[1] | ||
| 222 | addc $lo1,$lo1,$lo0 | ||
| 223 | $UMULL $nlo,$nj,$m1 ; np[1]*m1 | ||
| 224 | addze $hi1,$hi1 | ||
| 225 | $UMULH $nhi,$nj,$m1 | ||
| 226 | |||
| 227 | mtctr $num | ||
| 228 | li $j,`2*$BNSZ` | ||
| 229 | .align 4 | ||
| 230 | Linner: | ||
| 231 | $LDX $aj,$ap,$j ; ap[j] | ||
| 232 | addc $lo0,$alo,$hi0 | ||
| 233 | $LD $tj,$BNSZ($tp) ; tp[j] | ||
| 234 | addze $hi0,$ahi | ||
| 235 | $LDX $nj,$np,$j ; np[j] | ||
| 236 | addc $lo1,$nlo,$hi1 | ||
| 237 | $UMULL $alo,$aj,$m0 ; ap[j]*bp[i] | ||
| 238 | addze $hi1,$nhi | ||
| 239 | $UMULH $ahi,$aj,$m0 | ||
| 240 | addc $lo0,$lo0,$tj ; ap[j]*bp[i]+tp[j] | ||
| 241 | $UMULL $nlo,$nj,$m1 ; np[j]*m1 | ||
| 242 | addze $hi0,$hi0 | ||
| 243 | $UMULH $nhi,$nj,$m1 | ||
| 244 | addc $lo1,$lo1,$lo0 ; np[j]*m1+ap[j]*bp[i]+tp[j] | ||
| 245 | addi $j,$j,$BNSZ ; j++ | ||
| 246 | addze $hi1,$hi1 | ||
| 247 | $ST $lo1,0($tp) ; tp[j-1] | ||
| 248 | addi $tp,$tp,$BNSZ ; tp++ | ||
| 249 | bdnz- Linner | ||
| 250 | ;Linner | ||
| 251 | $LD $tj,$BNSZ($tp) ; tp[j] | ||
| 252 | addc $lo0,$alo,$hi0 | ||
| 253 | addze $hi0,$ahi | ||
| 254 | addc $lo0,$lo0,$tj ; ap[j]*bp[i]+tp[j] | ||
| 255 | addze $hi0,$hi0 | ||
| 256 | |||
| 257 | addc $lo1,$nlo,$hi1 | ||
| 258 | addze $hi1,$nhi | ||
| 259 | addc $lo1,$lo1,$lo0 ; np[j]*m1+ap[j]*bp[i]+tp[j] | ||
| 260 | addze $hi1,$hi1 | ||
| 261 | $ST $lo1,0($tp) ; tp[j-1] | ||
| 262 | |||
| 263 | addic $ovf,$ovf,-1 ; move upmost overflow to XER[CA] | ||
| 264 | li $ovf,0 | ||
| 265 | adde $hi1,$hi1,$hi0 | ||
| 266 | addze $ovf,$ovf | ||
| 267 | $ST $hi1,$BNSZ($tp) | ||
| 268 | ; | ||
| 269 | slwi $tj,$num,`log($BNSZ)/log(2)` | ||
| 270 | $UCMP $i,$tj | ||
| 271 | addi $i,$i,$BNSZ | ||
| 272 | ble- Louter | ||
| 273 | |||
| 274 | addi $num,$num,2 ; restore $num | ||
| 275 | subfc $j,$j,$j ; j=0 and "clear" XER[CA] | ||
| 276 | addi $tp,$sp,$FRAME | ||
| 277 | mtctr $num | ||
| 278 | |||
| 279 | .align 4 | ||
| 280 | Lsub: $LDX $tj,$tp,$j | ||
| 281 | $LDX $nj,$np,$j | ||
| 282 | subfe $aj,$nj,$tj ; tp[j]-np[j] | ||
| 283 | $STX $aj,$rp,$j | ||
| 284 | addi $j,$j,$BNSZ | ||
| 285 | bdnz- Lsub | ||
| 286 | |||
| 287 | li $j,0 | ||
| 288 | mtctr $num | ||
| 289 | subfe $ovf,$j,$ovf ; handle upmost overflow bit | ||
| 290 | and $ap,$tp,$ovf | ||
| 291 | andc $np,$rp,$ovf | ||
| 292 | or $ap,$ap,$np ; ap=borrow?tp:rp | ||
| 293 | |||
| 294 | .align 4 | ||
| 295 | Lcopy: ; copy or in-place refresh | ||
| 296 | $LDX $tj,$ap,$j | ||
| 297 | $STX $tj,$rp,$j | ||
| 298 | $STX $j,$tp,$j ; zap at once | ||
| 299 | addi $j,$j,$BNSZ | ||
| 300 | bdnz- Lcopy | ||
| 301 | |||
| 302 | $POP r14,`4*$SIZE_T`($sp) | ||
| 303 | $POP r15,`5*$SIZE_T`($sp) | ||
| 304 | $POP r16,`6*$SIZE_T`($sp) | ||
| 305 | $POP r17,`7*$SIZE_T`($sp) | ||
| 306 | $POP r18,`8*$SIZE_T`($sp) | ||
| 307 | $POP r19,`9*$SIZE_T`($sp) | ||
| 308 | $POP r20,`10*$SIZE_T`($sp) | ||
| 309 | $POP r21,`11*$SIZE_T`($sp) | ||
| 310 | $POP r22,`12*$SIZE_T`($sp) | ||
| 311 | $POP r23,`13*$SIZE_T`($sp) | ||
| 312 | $POP r24,`14*$SIZE_T`($sp) | ||
| 313 | $POP r25,`15*$SIZE_T`($sp) | ||
| 314 | $POP $sp,0($sp) | ||
| 315 | li r3,1 | ||
| 316 | blr | ||
| 317 | .long 0 | ||
| 318 | .asciz "Montgomery Multiplication for PPC, CRYPTOGAMS by <appro\@fy.chalmers.se>" | ||
| 319 | ___ | ||
| 320 | |||
| 321 | $code =~ s/\`([^\`]*)\`/eval $1/gem; | ||
| 322 | print $code; | ||
| 323 | close STDOUT; | ||
diff --git a/src/lib/libssl/src/crypto/bn/asm/ppc64-mont.pl b/src/lib/libssl/src/crypto/bn/asm/ppc64-mont.pl new file mode 100644 index 0000000000..3449b35855 --- /dev/null +++ b/src/lib/libssl/src/crypto/bn/asm/ppc64-mont.pl | |||
| @@ -0,0 +1,918 @@ | |||
| 1 | #!/usr/bin/env perl | ||
| 2 | |||
| 3 | # ==================================================================== | ||
| 4 | # Written by Andy Polyakov <appro@fy.chalmers.se> for the OpenSSL | ||
| 5 | # project. The module is, however, dual licensed under OpenSSL and | ||
| 6 | # CRYPTOGAMS licenses depending on where you obtain it. For further | ||
| 7 | # details see http://www.openssl.org/~appro/cryptogams/. | ||
| 8 | # ==================================================================== | ||
| 9 | |||
| 10 | # December 2007 | ||
| 11 | |||
| 12 | # The reason for undertaken effort is basically following. Even though | ||
| 13 | # Power 6 CPU operates at incredible 4.7GHz clock frequency, its PKI | ||
| 14 | # performance was observed to be less than impressive, essentially as | ||
| 15 | # fast as 1.8GHz PPC970, or 2.6 times(!) slower than one would hope. | ||
| 16 | # Well, it's not surprising that IBM had to make some sacrifices to | ||
| 17 | # boost the clock frequency that much, but no overall improvement? | ||
| 18 | # Having observed how much difference did switching to FPU make on | ||
| 19 | # UltraSPARC, playing same stunt on Power 6 appeared appropriate... | ||
| 20 | # Unfortunately the resulting performance improvement is not as | ||
| 21 | # impressive, ~30%, and in absolute terms is still very far from what | ||
| 22 | # one would expect from 4.7GHz CPU. There is a chance that I'm doing | ||
| 23 | # something wrong, but in the lack of assembler level micro-profiling | ||
| 24 | # data or at least decent platform guide I can't tell... Or better | ||
| 25 | # results might be achieved with VMX... Anyway, this module provides | ||
| 26 | # *worse* performance on other PowerPC implementations, ~40-15% slower | ||
| 27 | # on PPC970 depending on key length and ~40% slower on Power 5 for all | ||
| 28 | # key lengths. As it's obviously inappropriate as "best all-round" | ||
| 29 | # alternative, it has to be complemented with run-time CPU family | ||
| 30 | # detection. Oh! It should also be noted that unlike other PowerPC | ||
| 31 | # implementation IALU ppc-mont.pl module performs *suboptimaly* on | ||
| 32 | # >=1024-bit key lengths on Power 6. It should also be noted that | ||
| 33 | # *everything* said so far applies to 64-bit builds! As far as 32-bit | ||
| 34 | # application executed on 64-bit CPU goes, this module is likely to | ||
| 35 | # become preferred choice, because it's easy to adapt it for such | ||
| 36 | # case and *is* faster than 32-bit ppc-mont.pl on *all* processors. | ||
| 37 | |||
| 38 | # February 2008 | ||
| 39 | |||
| 40 | # Micro-profiling assisted optimization results in ~15% improvement | ||
| 41 | # over original ppc64-mont.pl version, or overall ~50% improvement | ||
| 42 | # over ppc.pl module on Power 6. If compared to ppc-mont.pl on same | ||
| 43 | # Power 6 CPU, this module is 5-150% faster depending on key length, | ||
| 44 | # [hereafter] more for longer keys. But if compared to ppc-mont.pl | ||
| 45 | # on 1.8GHz PPC970, it's only 5-55% faster. Still far from impressive | ||
| 46 | # in absolute terms, but it's apparently the way Power 6 is... | ||
| 47 | |||
| 48 | $flavour = shift; | ||
| 49 | |||
| 50 | if ($flavour =~ /32/) { | ||
| 51 | $SIZE_T=4; | ||
| 52 | $RZONE= 224; | ||
| 53 | $FRAME= $SIZE_T*12+8*12; | ||
| 54 | $fname= "bn_mul_mont_ppc64"; | ||
| 55 | |||
| 56 | $STUX= "stwux"; # store indexed and update | ||
| 57 | $PUSH= "stw"; | ||
| 58 | $POP= "lwz"; | ||
| 59 | die "not implemented yet"; | ||
| 60 | } elsif ($flavour =~ /64/) { | ||
| 61 | $SIZE_T=8; | ||
| 62 | $RZONE= 288; | ||
| 63 | $FRAME= $SIZE_T*12+8*12; | ||
| 64 | $fname= "bn_mul_mont"; | ||
| 65 | |||
| 66 | # same as above, but 64-bit mnemonics... | ||
| 67 | $STUX= "stdux"; # store indexed and update | ||
| 68 | $PUSH= "std"; | ||
| 69 | $POP= "ld"; | ||
| 70 | } else { die "nonsense $flavour"; } | ||
| 71 | |||
| 72 | $0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1; | ||
| 73 | ( $xlate="${dir}ppc-xlate.pl" and -f $xlate ) or | ||
| 74 | ( $xlate="${dir}../../perlasm/ppc-xlate.pl" and -f $xlate) or | ||
| 75 | die "can't locate ppc-xlate.pl"; | ||
| 76 | |||
| 77 | open STDOUT,"| $^X $xlate $flavour ".shift || die "can't call $xlate: $!"; | ||
| 78 | |||
| 79 | $FRAME=($FRAME+63)&~63; | ||
| 80 | $TRANSFER=16*8; | ||
| 81 | |||
| 82 | $carry="r0"; | ||
| 83 | $sp="r1"; | ||
| 84 | $toc="r2"; | ||
| 85 | $rp="r3"; $ovf="r3"; | ||
| 86 | $ap="r4"; | ||
| 87 | $bp="r5"; | ||
| 88 | $np="r6"; | ||
| 89 | $n0="r7"; | ||
| 90 | $num="r8"; | ||
| 91 | $rp="r9"; # $rp is reassigned | ||
| 92 | $tp="r10"; | ||
| 93 | $j="r11"; | ||
| 94 | $i="r12"; | ||
| 95 | # non-volatile registers | ||
| 96 | $nap_d="r14"; # interleaved ap and np in double format | ||
| 97 | $a0="r15"; # ap[0] | ||
| 98 | $t0="r16"; # temporary registers | ||
| 99 | $t1="r17"; | ||
| 100 | $t2="r18"; | ||
| 101 | $t3="r19"; | ||
| 102 | $t4="r20"; | ||
| 103 | $t5="r21"; | ||
| 104 | $t6="r22"; | ||
| 105 | $t7="r23"; | ||
| 106 | |||
| 107 | # PPC offers enough register bank capacity to unroll inner loops twice | ||
| 108 | # | ||
| 109 | # ..A3A2A1A0 | ||
| 110 | # dcba | ||
| 111 | # ----------- | ||
| 112 | # A0a | ||
| 113 | # A0b | ||
| 114 | # A0c | ||
| 115 | # A0d | ||
| 116 | # A1a | ||
| 117 | # A1b | ||
| 118 | # A1c | ||
| 119 | # A1d | ||
| 120 | # A2a | ||
| 121 | # A2b | ||
| 122 | # A2c | ||
| 123 | # A2d | ||
| 124 | # A3a | ||
| 125 | # A3b | ||
| 126 | # A3c | ||
| 127 | # A3d | ||
| 128 | # ..a | ||
| 129 | # ..b | ||
| 130 | # | ||
| 131 | $ba="f0"; $bb="f1"; $bc="f2"; $bd="f3"; | ||
| 132 | $na="f4"; $nb="f5"; $nc="f6"; $nd="f7"; | ||
| 133 | $dota="f8"; $dotb="f9"; | ||
| 134 | $A0="f10"; $A1="f11"; $A2="f12"; $A3="f13"; | ||
| 135 | $N0="f14"; $N1="f15"; $N2="f16"; $N3="f17"; | ||
| 136 | $T0a="f18"; $T0b="f19"; | ||
| 137 | $T1a="f20"; $T1b="f21"; | ||
| 138 | $T2a="f22"; $T2b="f23"; | ||
| 139 | $T3a="f24"; $T3b="f25"; | ||
| 140 | |||
| 141 | # sp----------->+-------------------------------+ | ||
| 142 | # | saved sp | | ||
| 143 | # +-------------------------------+ | ||
| 144 | # | | | ||
| 145 | # +-------------------------------+ | ||
| 146 | # | 10 saved gpr, r14-r23 | | ||
| 147 | # . . | ||
| 148 | # . . | ||
| 149 | # +12*size_t +-------------------------------+ | ||
| 150 | # | 12 saved fpr, f14-f25 | | ||
| 151 | # . . | ||
| 152 | # . . | ||
| 153 | # +12*8 +-------------------------------+ | ||
| 154 | # | padding to 64 byte boundary | | ||
| 155 | # . . | ||
| 156 | # +X +-------------------------------+ | ||
| 157 | # | 16 gpr<->fpr transfer zone | | ||
| 158 | # . . | ||
| 159 | # . . | ||
| 160 | # +16*8 +-------------------------------+ | ||
| 161 | # | __int64 tmp[-1] | | ||
| 162 | # +-------------------------------+ | ||
| 163 | # | __int64 tmp[num] | | ||
| 164 | # . . | ||
| 165 | # . . | ||
| 166 | # . . | ||
| 167 | # +(num+1)*8 +-------------------------------+ | ||
| 168 | # | padding to 64 byte boundary | | ||
| 169 | # . . | ||
| 170 | # +X +-------------------------------+ | ||
| 171 | # | double nap_d[4*num] | | ||
| 172 | # . . | ||
| 173 | # . . | ||
| 174 | # . . | ||
| 175 | # +-------------------------------+ | ||
| 176 | |||
| 177 | $code=<<___; | ||
| 178 | .machine "any" | ||
| 179 | .text | ||
| 180 | |||
| 181 | .globl .$fname | ||
| 182 | .align 5 | ||
| 183 | .$fname: | ||
| 184 | cmpwi $num,4 | ||
| 185 | mr $rp,r3 ; $rp is reassigned | ||
| 186 | li r3,0 ; possible "not handled" return code | ||
| 187 | bltlr- | ||
| 188 | andi. r0,$num,1 ; $num has to be even | ||
| 189 | bnelr- | ||
| 190 | |||
| 191 | slwi $num,$num,3 ; num*=8 | ||
| 192 | li $i,-4096 | ||
| 193 | slwi $tp,$num,2 ; place for {an}p_{lh}[num], i.e. 4*num | ||
| 194 | add $tp,$tp,$num ; place for tp[num+1] | ||
| 195 | addi $tp,$tp,`$FRAME+$TRANSFER+8+64+$RZONE` | ||
| 196 | subf $tp,$tp,$sp ; $sp-$tp | ||
| 197 | and $tp,$tp,$i ; minimize TLB usage | ||
| 198 | subf $tp,$sp,$tp ; $tp-$sp | ||
| 199 | $STUX $sp,$sp,$tp ; alloca | ||
| 200 | |||
| 201 | $PUSH r14,`2*$SIZE_T`($sp) | ||
| 202 | $PUSH r15,`3*$SIZE_T`($sp) | ||
| 203 | $PUSH r16,`4*$SIZE_T`($sp) | ||
| 204 | $PUSH r17,`5*$SIZE_T`($sp) | ||
| 205 | $PUSH r18,`6*$SIZE_T`($sp) | ||
| 206 | $PUSH r19,`7*$SIZE_T`($sp) | ||
| 207 | $PUSH r20,`8*$SIZE_T`($sp) | ||
| 208 | $PUSH r21,`9*$SIZE_T`($sp) | ||
| 209 | $PUSH r22,`10*$SIZE_T`($sp) | ||
| 210 | $PUSH r23,`11*$SIZE_T`($sp) | ||
| 211 | stfd f14,`12*$SIZE_T+0`($sp) | ||
| 212 | stfd f15,`12*$SIZE_T+8`($sp) | ||
| 213 | stfd f16,`12*$SIZE_T+16`($sp) | ||
| 214 | stfd f17,`12*$SIZE_T+24`($sp) | ||
| 215 | stfd f18,`12*$SIZE_T+32`($sp) | ||
| 216 | stfd f19,`12*$SIZE_T+40`($sp) | ||
| 217 | stfd f20,`12*$SIZE_T+48`($sp) | ||
| 218 | stfd f21,`12*$SIZE_T+56`($sp) | ||
| 219 | stfd f22,`12*$SIZE_T+64`($sp) | ||
| 220 | stfd f23,`12*$SIZE_T+72`($sp) | ||
| 221 | stfd f24,`12*$SIZE_T+80`($sp) | ||
| 222 | stfd f25,`12*$SIZE_T+88`($sp) | ||
| 223 | |||
| 224 | ld $a0,0($ap) ; pull ap[0] value | ||
| 225 | ld $n0,0($n0) ; pull n0[0] value | ||
| 226 | ld $t3,0($bp) ; bp[0] | ||
| 227 | |||
| 228 | addi $tp,$sp,`$FRAME+$TRANSFER+8+64` | ||
| 229 | li $i,-64 | ||
| 230 | add $nap_d,$tp,$num | ||
| 231 | and $nap_d,$nap_d,$i ; align to 64 bytes | ||
| 232 | |||
| 233 | mulld $t7,$a0,$t3 ; ap[0]*bp[0] | ||
| 234 | ; nap_d is off by 1, because it's used with stfdu/lfdu | ||
| 235 | addi $nap_d,$nap_d,-8 | ||
| 236 | srwi $j,$num,`3+1` ; counter register, num/2 | ||
| 237 | mulld $t7,$t7,$n0 ; tp[0]*n0 | ||
| 238 | addi $j,$j,-1 | ||
| 239 | addi $tp,$sp,`$FRAME+$TRANSFER-8` | ||
| 240 | li $carry,0 | ||
| 241 | mtctr $j | ||
| 242 | |||
| 243 | ; transfer bp[0] to FPU as 4x16-bit values | ||
| 244 | extrdi $t0,$t3,16,48 | ||
| 245 | extrdi $t1,$t3,16,32 | ||
| 246 | extrdi $t2,$t3,16,16 | ||
| 247 | extrdi $t3,$t3,16,0 | ||
| 248 | std $t0,`$FRAME+0`($sp) | ||
| 249 | std $t1,`$FRAME+8`($sp) | ||
| 250 | std $t2,`$FRAME+16`($sp) | ||
| 251 | std $t3,`$FRAME+24`($sp) | ||
| 252 | ; transfer (ap[0]*bp[0])*n0 to FPU as 4x16-bit values | ||
| 253 | extrdi $t4,$t7,16,48 | ||
| 254 | extrdi $t5,$t7,16,32 | ||
| 255 | extrdi $t6,$t7,16,16 | ||
| 256 | extrdi $t7,$t7,16,0 | ||
| 257 | std $t4,`$FRAME+32`($sp) | ||
| 258 | std $t5,`$FRAME+40`($sp) | ||
| 259 | std $t6,`$FRAME+48`($sp) | ||
| 260 | std $t7,`$FRAME+56`($sp) | ||
| 261 | lwz $t0,4($ap) ; load a[j] as 32-bit word pair | ||
| 262 | lwz $t1,0($ap) | ||
| 263 | lwz $t2,12($ap) ; load a[j+1] as 32-bit word pair | ||
| 264 | lwz $t3,8($ap) | ||
| 265 | lwz $t4,4($np) ; load n[j] as 32-bit word pair | ||
| 266 | lwz $t5,0($np) | ||
| 267 | lwz $t6,12($np) ; load n[j+1] as 32-bit word pair | ||
| 268 | lwz $t7,8($np) | ||
| 269 | lfd $ba,`$FRAME+0`($sp) | ||
| 270 | lfd $bb,`$FRAME+8`($sp) | ||
| 271 | lfd $bc,`$FRAME+16`($sp) | ||
| 272 | lfd $bd,`$FRAME+24`($sp) | ||
| 273 | lfd $na,`$FRAME+32`($sp) | ||
| 274 | lfd $nb,`$FRAME+40`($sp) | ||
| 275 | lfd $nc,`$FRAME+48`($sp) | ||
| 276 | lfd $nd,`$FRAME+56`($sp) | ||
| 277 | std $t0,`$FRAME+64`($sp) | ||
| 278 | std $t1,`$FRAME+72`($sp) | ||
| 279 | std $t2,`$FRAME+80`($sp) | ||
| 280 | std $t3,`$FRAME+88`($sp) | ||
| 281 | std $t4,`$FRAME+96`($sp) | ||
| 282 | std $t5,`$FRAME+104`($sp) | ||
| 283 | std $t6,`$FRAME+112`($sp) | ||
| 284 | std $t7,`$FRAME+120`($sp) | ||
| 285 | fcfid $ba,$ba | ||
| 286 | fcfid $bb,$bb | ||
| 287 | fcfid $bc,$bc | ||
| 288 | fcfid $bd,$bd | ||
| 289 | fcfid $na,$na | ||
| 290 | fcfid $nb,$nb | ||
| 291 | fcfid $nc,$nc | ||
| 292 | fcfid $nd,$nd | ||
| 293 | |||
| 294 | lfd $A0,`$FRAME+64`($sp) | ||
| 295 | lfd $A1,`$FRAME+72`($sp) | ||
| 296 | lfd $A2,`$FRAME+80`($sp) | ||
| 297 | lfd $A3,`$FRAME+88`($sp) | ||
| 298 | lfd $N0,`$FRAME+96`($sp) | ||
| 299 | lfd $N1,`$FRAME+104`($sp) | ||
| 300 | lfd $N2,`$FRAME+112`($sp) | ||
| 301 | lfd $N3,`$FRAME+120`($sp) | ||
| 302 | fcfid $A0,$A0 | ||
| 303 | fcfid $A1,$A1 | ||
| 304 | fcfid $A2,$A2 | ||
| 305 | fcfid $A3,$A3 | ||
| 306 | fcfid $N0,$N0 | ||
| 307 | fcfid $N1,$N1 | ||
| 308 | fcfid $N2,$N2 | ||
| 309 | fcfid $N3,$N3 | ||
| 310 | addi $ap,$ap,16 | ||
| 311 | addi $np,$np,16 | ||
| 312 | |||
| 313 | fmul $T1a,$A1,$ba | ||
| 314 | fmul $T1b,$A1,$bb | ||
| 315 | stfd $A0,8($nap_d) ; save a[j] in double format | ||
| 316 | stfd $A1,16($nap_d) | ||
| 317 | fmul $T2a,$A2,$ba | ||
| 318 | fmul $T2b,$A2,$bb | ||
| 319 | stfd $A2,24($nap_d) ; save a[j+1] in double format | ||
| 320 | stfd $A3,32($nap_d) | ||
| 321 | fmul $T3a,$A3,$ba | ||
| 322 | fmul $T3b,$A3,$bb | ||
| 323 | stfd $N0,40($nap_d) ; save n[j] in double format | ||
| 324 | stfd $N1,48($nap_d) | ||
| 325 | fmul $T0a,$A0,$ba | ||
| 326 | fmul $T0b,$A0,$bb | ||
| 327 | stfd $N2,56($nap_d) ; save n[j+1] in double format | ||
| 328 | stfdu $N3,64($nap_d) | ||
| 329 | |||
| 330 | fmadd $T1a,$A0,$bc,$T1a | ||
| 331 | fmadd $T1b,$A0,$bd,$T1b | ||
| 332 | fmadd $T2a,$A1,$bc,$T2a | ||
| 333 | fmadd $T2b,$A1,$bd,$T2b | ||
| 334 | fmadd $T3a,$A2,$bc,$T3a | ||
| 335 | fmadd $T3b,$A2,$bd,$T3b | ||
| 336 | fmul $dota,$A3,$bc | ||
| 337 | fmul $dotb,$A3,$bd | ||
| 338 | |||
| 339 | fmadd $T1a,$N1,$na,$T1a | ||
| 340 | fmadd $T1b,$N1,$nb,$T1b | ||
| 341 | fmadd $T2a,$N2,$na,$T2a | ||
| 342 | fmadd $T2b,$N2,$nb,$T2b | ||
| 343 | fmadd $T3a,$N3,$na,$T3a | ||
| 344 | fmadd $T3b,$N3,$nb,$T3b | ||
| 345 | fmadd $T0a,$N0,$na,$T0a | ||
| 346 | fmadd $T0b,$N0,$nb,$T0b | ||
| 347 | |||
| 348 | fmadd $T1a,$N0,$nc,$T1a | ||
| 349 | fmadd $T1b,$N0,$nd,$T1b | ||
| 350 | fmadd $T2a,$N1,$nc,$T2a | ||
| 351 | fmadd $T2b,$N1,$nd,$T2b | ||
| 352 | fmadd $T3a,$N2,$nc,$T3a | ||
| 353 | fmadd $T3b,$N2,$nd,$T3b | ||
| 354 | fmadd $dota,$N3,$nc,$dota | ||
| 355 | fmadd $dotb,$N3,$nd,$dotb | ||
| 356 | |||
| 357 | fctid $T0a,$T0a | ||
| 358 | fctid $T0b,$T0b | ||
| 359 | fctid $T1a,$T1a | ||
| 360 | fctid $T1b,$T1b | ||
| 361 | fctid $T2a,$T2a | ||
| 362 | fctid $T2b,$T2b | ||
| 363 | fctid $T3a,$T3a | ||
| 364 | fctid $T3b,$T3b | ||
| 365 | |||
| 366 | stfd $T0a,`$FRAME+0`($sp) | ||
| 367 | stfd $T0b,`$FRAME+8`($sp) | ||
| 368 | stfd $T1a,`$FRAME+16`($sp) | ||
| 369 | stfd $T1b,`$FRAME+24`($sp) | ||
| 370 | stfd $T2a,`$FRAME+32`($sp) | ||
| 371 | stfd $T2b,`$FRAME+40`($sp) | ||
| 372 | stfd $T3a,`$FRAME+48`($sp) | ||
| 373 | stfd $T3b,`$FRAME+56`($sp) | ||
| 374 | |||
| 375 | .align 5 | ||
| 376 | L1st: | ||
| 377 | lwz $t0,4($ap) ; load a[j] as 32-bit word pair | ||
| 378 | lwz $t1,0($ap) | ||
| 379 | lwz $t2,12($ap) ; load a[j+1] as 32-bit word pair | ||
| 380 | lwz $t3,8($ap) | ||
| 381 | lwz $t4,4($np) ; load n[j] as 32-bit word pair | ||
| 382 | lwz $t5,0($np) | ||
| 383 | lwz $t6,12($np) ; load n[j+1] as 32-bit word pair | ||
| 384 | lwz $t7,8($np) | ||
| 385 | std $t0,`$FRAME+64`($sp) | ||
| 386 | std $t1,`$FRAME+72`($sp) | ||
| 387 | std $t2,`$FRAME+80`($sp) | ||
| 388 | std $t3,`$FRAME+88`($sp) | ||
| 389 | std $t4,`$FRAME+96`($sp) | ||
| 390 | std $t5,`$FRAME+104`($sp) | ||
| 391 | std $t6,`$FRAME+112`($sp) | ||
| 392 | std $t7,`$FRAME+120`($sp) | ||
| 393 | ld $t0,`$FRAME+0`($sp) | ||
| 394 | ld $t1,`$FRAME+8`($sp) | ||
| 395 | ld $t2,`$FRAME+16`($sp) | ||
| 396 | ld $t3,`$FRAME+24`($sp) | ||
| 397 | ld $t4,`$FRAME+32`($sp) | ||
| 398 | ld $t5,`$FRAME+40`($sp) | ||
| 399 | ld $t6,`$FRAME+48`($sp) | ||
| 400 | ld $t7,`$FRAME+56`($sp) | ||
| 401 | lfd $A0,`$FRAME+64`($sp) | ||
| 402 | lfd $A1,`$FRAME+72`($sp) | ||
| 403 | lfd $A2,`$FRAME+80`($sp) | ||
| 404 | lfd $A3,`$FRAME+88`($sp) | ||
| 405 | lfd $N0,`$FRAME+96`($sp) | ||
| 406 | lfd $N1,`$FRAME+104`($sp) | ||
| 407 | lfd $N2,`$FRAME+112`($sp) | ||
| 408 | lfd $N3,`$FRAME+120`($sp) | ||
| 409 | fcfid $A0,$A0 | ||
| 410 | fcfid $A1,$A1 | ||
| 411 | fcfid $A2,$A2 | ||
| 412 | fcfid $A3,$A3 | ||
| 413 | fcfid $N0,$N0 | ||
| 414 | fcfid $N1,$N1 | ||
| 415 | fcfid $N2,$N2 | ||
| 416 | fcfid $N3,$N3 | ||
| 417 | addi $ap,$ap,16 | ||
| 418 | addi $np,$np,16 | ||
| 419 | |||
| 420 | fmul $T1a,$A1,$ba | ||
| 421 | fmul $T1b,$A1,$bb | ||
| 422 | fmul $T2a,$A2,$ba | ||
| 423 | fmul $T2b,$A2,$bb | ||
| 424 | stfd $A0,8($nap_d) ; save a[j] in double format | ||
| 425 | stfd $A1,16($nap_d) | ||
| 426 | fmul $T3a,$A3,$ba | ||
| 427 | fmul $T3b,$A3,$bb | ||
| 428 | fmadd $T0a,$A0,$ba,$dota | ||
| 429 | fmadd $T0b,$A0,$bb,$dotb | ||
| 430 | stfd $A2,24($nap_d) ; save a[j+1] in double format | ||
| 431 | stfd $A3,32($nap_d) | ||
| 432 | |||
| 433 | fmadd $T1a,$A0,$bc,$T1a | ||
| 434 | fmadd $T1b,$A0,$bd,$T1b | ||
| 435 | fmadd $T2a,$A1,$bc,$T2a | ||
| 436 | fmadd $T2b,$A1,$bd,$T2b | ||
| 437 | stfd $N0,40($nap_d) ; save n[j] in double format | ||
| 438 | stfd $N1,48($nap_d) | ||
| 439 | fmadd $T3a,$A2,$bc,$T3a | ||
| 440 | fmadd $T3b,$A2,$bd,$T3b | ||
| 441 | add $t0,$t0,$carry ; can not overflow | ||
| 442 | fmul $dota,$A3,$bc | ||
| 443 | fmul $dotb,$A3,$bd | ||
| 444 | stfd $N2,56($nap_d) ; save n[j+1] in double format | ||
| 445 | stfdu $N3,64($nap_d) | ||
| 446 | srdi $carry,$t0,16 | ||
| 447 | add $t1,$t1,$carry | ||
| 448 | srdi $carry,$t1,16 | ||
| 449 | |||
| 450 | fmadd $T1a,$N1,$na,$T1a | ||
| 451 | fmadd $T1b,$N1,$nb,$T1b | ||
| 452 | insrdi $t0,$t1,16,32 | ||
| 453 | fmadd $T2a,$N2,$na,$T2a | ||
| 454 | fmadd $T2b,$N2,$nb,$T2b | ||
| 455 | add $t2,$t2,$carry | ||
| 456 | fmadd $T3a,$N3,$na,$T3a | ||
| 457 | fmadd $T3b,$N3,$nb,$T3b | ||
| 458 | srdi $carry,$t2,16 | ||
| 459 | fmadd $T0a,$N0,$na,$T0a | ||
| 460 | fmadd $T0b,$N0,$nb,$T0b | ||
| 461 | insrdi $t0,$t2,16,16 | ||
| 462 | add $t3,$t3,$carry | ||
| 463 | srdi $carry,$t3,16 | ||
| 464 | |||
| 465 | fmadd $T1a,$N0,$nc,$T1a | ||
| 466 | fmadd $T1b,$N0,$nd,$T1b | ||
| 467 | insrdi $t0,$t3,16,0 ; 0..63 bits | ||
| 468 | fmadd $T2a,$N1,$nc,$T2a | ||
| 469 | fmadd $T2b,$N1,$nd,$T2b | ||
| 470 | add $t4,$t4,$carry | ||
| 471 | fmadd $T3a,$N2,$nc,$T3a | ||
| 472 | fmadd $T3b,$N2,$nd,$T3b | ||
| 473 | srdi $carry,$t4,16 | ||
| 474 | fmadd $dota,$N3,$nc,$dota | ||
| 475 | fmadd $dotb,$N3,$nd,$dotb | ||
| 476 | add $t5,$t5,$carry | ||
| 477 | srdi $carry,$t5,16 | ||
| 478 | insrdi $t4,$t5,16,32 | ||
| 479 | |||
| 480 | fctid $T0a,$T0a | ||
| 481 | fctid $T0b,$T0b | ||
| 482 | add $t6,$t6,$carry | ||
| 483 | fctid $T1a,$T1a | ||
| 484 | fctid $T1b,$T1b | ||
| 485 | srdi $carry,$t6,16 | ||
| 486 | fctid $T2a,$T2a | ||
| 487 | fctid $T2b,$T2b | ||
| 488 | insrdi $t4,$t6,16,16 | ||
| 489 | fctid $T3a,$T3a | ||
| 490 | fctid $T3b,$T3b | ||
| 491 | add $t7,$t7,$carry | ||
| 492 | insrdi $t4,$t7,16,0 ; 64..127 bits | ||
| 493 | srdi $carry,$t7,16 ; upper 33 bits | ||
| 494 | |||
| 495 | stfd $T0a,`$FRAME+0`($sp) | ||
| 496 | stfd $T0b,`$FRAME+8`($sp) | ||
| 497 | stfd $T1a,`$FRAME+16`($sp) | ||
| 498 | stfd $T1b,`$FRAME+24`($sp) | ||
| 499 | stfd $T2a,`$FRAME+32`($sp) | ||
| 500 | stfd $T2b,`$FRAME+40`($sp) | ||
| 501 | stfd $T3a,`$FRAME+48`($sp) | ||
| 502 | stfd $T3b,`$FRAME+56`($sp) | ||
| 503 | std $t0,8($tp) ; tp[j-1] | ||
| 504 | stdu $t4,16($tp) ; tp[j] | ||
| 505 | bdnz- L1st | ||
| 506 | |||
| 507 | fctid $dota,$dota | ||
| 508 | fctid $dotb,$dotb | ||
| 509 | |||
| 510 | ld $t0,`$FRAME+0`($sp) | ||
| 511 | ld $t1,`$FRAME+8`($sp) | ||
| 512 | ld $t2,`$FRAME+16`($sp) | ||
| 513 | ld $t3,`$FRAME+24`($sp) | ||
| 514 | ld $t4,`$FRAME+32`($sp) | ||
| 515 | ld $t5,`$FRAME+40`($sp) | ||
| 516 | ld $t6,`$FRAME+48`($sp) | ||
| 517 | ld $t7,`$FRAME+56`($sp) | ||
| 518 | stfd $dota,`$FRAME+64`($sp) | ||
| 519 | stfd $dotb,`$FRAME+72`($sp) | ||
| 520 | |||
| 521 | add $t0,$t0,$carry ; can not overflow | ||
| 522 | srdi $carry,$t0,16 | ||
| 523 | add $t1,$t1,$carry | ||
| 524 | srdi $carry,$t1,16 | ||
| 525 | insrdi $t0,$t1,16,32 | ||
| 526 | add $t2,$t2,$carry | ||
| 527 | srdi $carry,$t2,16 | ||
| 528 | insrdi $t0,$t2,16,16 | ||
| 529 | add $t3,$t3,$carry | ||
| 530 | srdi $carry,$t3,16 | ||
| 531 | insrdi $t0,$t3,16,0 ; 0..63 bits | ||
| 532 | add $t4,$t4,$carry | ||
| 533 | srdi $carry,$t4,16 | ||
| 534 | add $t5,$t5,$carry | ||
| 535 | srdi $carry,$t5,16 | ||
| 536 | insrdi $t4,$t5,16,32 | ||
| 537 | add $t6,$t6,$carry | ||
| 538 | srdi $carry,$t6,16 | ||
| 539 | insrdi $t4,$t6,16,16 | ||
| 540 | add $t7,$t7,$carry | ||
| 541 | insrdi $t4,$t7,16,0 ; 64..127 bits | ||
| 542 | srdi $carry,$t7,16 ; upper 33 bits | ||
| 543 | ld $t6,`$FRAME+64`($sp) | ||
| 544 | ld $t7,`$FRAME+72`($sp) | ||
| 545 | |||
| 546 | std $t0,8($tp) ; tp[j-1] | ||
| 547 | stdu $t4,16($tp) ; tp[j] | ||
| 548 | |||
| 549 | add $t6,$t6,$carry ; can not overflow | ||
| 550 | srdi $carry,$t6,16 | ||
| 551 | add $t7,$t7,$carry | ||
| 552 | insrdi $t6,$t7,48,0 | ||
| 553 | srdi $ovf,$t7,48 | ||
| 554 | std $t6,8($tp) ; tp[num-1] | ||
| 555 | |||
| 556 | slwi $t7,$num,2 | ||
| 557 | subf $nap_d,$t7,$nap_d ; rewind pointer | ||
| 558 | |||
| 559 | li $i,8 ; i=1 | ||
| 560 | .align 5 | ||
| 561 | Louter: | ||
| 562 | ldx $t3,$bp,$i ; bp[i] | ||
| 563 | ld $t6,`$FRAME+$TRANSFER+8`($sp) ; tp[0] | ||
| 564 | mulld $t7,$a0,$t3 ; ap[0]*bp[i] | ||
| 565 | |||
| 566 | addi $tp,$sp,`$FRAME+$TRANSFER` | ||
| 567 | add $t7,$t7,$t6 ; ap[0]*bp[i]+tp[0] | ||
| 568 | li $carry,0 | ||
| 569 | mulld $t7,$t7,$n0 ; tp[0]*n0 | ||
| 570 | mtctr $j | ||
| 571 | |||
| 572 | ; transfer bp[i] to FPU as 4x16-bit values | ||
| 573 | extrdi $t0,$t3,16,48 | ||
| 574 | extrdi $t1,$t3,16,32 | ||
| 575 | extrdi $t2,$t3,16,16 | ||
| 576 | extrdi $t3,$t3,16,0 | ||
| 577 | std $t0,`$FRAME+0`($sp) | ||
| 578 | std $t1,`$FRAME+8`($sp) | ||
| 579 | std $t2,`$FRAME+16`($sp) | ||
| 580 | std $t3,`$FRAME+24`($sp) | ||
| 581 | ; transfer (ap[0]*bp[i]+tp[0])*n0 to FPU as 4x16-bit values | ||
| 582 | extrdi $t4,$t7,16,48 | ||
| 583 | extrdi $t5,$t7,16,32 | ||
| 584 | extrdi $t6,$t7,16,16 | ||
| 585 | extrdi $t7,$t7,16,0 | ||
| 586 | std $t4,`$FRAME+32`($sp) | ||
| 587 | std $t5,`$FRAME+40`($sp) | ||
| 588 | std $t6,`$FRAME+48`($sp) | ||
| 589 | std $t7,`$FRAME+56`($sp) | ||
| 590 | |||
| 591 | lfd $A0,8($nap_d) ; load a[j] in double format | ||
| 592 | lfd $A1,16($nap_d) | ||
| 593 | lfd $A2,24($nap_d) ; load a[j+1] in double format | ||
| 594 | lfd $A3,32($nap_d) | ||
| 595 | lfd $N0,40($nap_d) ; load n[j] in double format | ||
| 596 | lfd $N1,48($nap_d) | ||
| 597 | lfd $N2,56($nap_d) ; load n[j+1] in double format | ||
| 598 | lfdu $N3,64($nap_d) | ||
| 599 | |||
| 600 | lfd $ba,`$FRAME+0`($sp) | ||
| 601 | lfd $bb,`$FRAME+8`($sp) | ||
| 602 | lfd $bc,`$FRAME+16`($sp) | ||
| 603 | lfd $bd,`$FRAME+24`($sp) | ||
| 604 | lfd $na,`$FRAME+32`($sp) | ||
| 605 | lfd $nb,`$FRAME+40`($sp) | ||
| 606 | lfd $nc,`$FRAME+48`($sp) | ||
| 607 | lfd $nd,`$FRAME+56`($sp) | ||
| 608 | |||
| 609 | fcfid $ba,$ba | ||
| 610 | fcfid $bb,$bb | ||
| 611 | fcfid $bc,$bc | ||
| 612 | fcfid $bd,$bd | ||
| 613 | fcfid $na,$na | ||
| 614 | fcfid $nb,$nb | ||
| 615 | fcfid $nc,$nc | ||
| 616 | fcfid $nd,$nd | ||
| 617 | |||
| 618 | fmul $T1a,$A1,$ba | ||
| 619 | fmul $T1b,$A1,$bb | ||
| 620 | fmul $T2a,$A2,$ba | ||
| 621 | fmul $T2b,$A2,$bb | ||
| 622 | fmul $T3a,$A3,$ba | ||
| 623 | fmul $T3b,$A3,$bb | ||
| 624 | fmul $T0a,$A0,$ba | ||
| 625 | fmul $T0b,$A0,$bb | ||
| 626 | |||
| 627 | fmadd $T1a,$A0,$bc,$T1a | ||
| 628 | fmadd $T1b,$A0,$bd,$T1b | ||
| 629 | fmadd $T2a,$A1,$bc,$T2a | ||
| 630 | fmadd $T2b,$A1,$bd,$T2b | ||
| 631 | fmadd $T3a,$A2,$bc,$T3a | ||
| 632 | fmadd $T3b,$A2,$bd,$T3b | ||
| 633 | fmul $dota,$A3,$bc | ||
| 634 | fmul $dotb,$A3,$bd | ||
| 635 | |||
| 636 | fmadd $T1a,$N1,$na,$T1a | ||
| 637 | fmadd $T1b,$N1,$nb,$T1b | ||
| 638 | lfd $A0,8($nap_d) ; load a[j] in double format | ||
| 639 | lfd $A1,16($nap_d) | ||
| 640 | fmadd $T2a,$N2,$na,$T2a | ||
| 641 | fmadd $T2b,$N2,$nb,$T2b | ||
| 642 | lfd $A2,24($nap_d) ; load a[j+1] in double format | ||
| 643 | lfd $A3,32($nap_d) | ||
| 644 | fmadd $T3a,$N3,$na,$T3a | ||
| 645 | fmadd $T3b,$N3,$nb,$T3b | ||
| 646 | fmadd $T0a,$N0,$na,$T0a | ||
| 647 | fmadd $T0b,$N0,$nb,$T0b | ||
| 648 | |||
| 649 | fmadd $T1a,$N0,$nc,$T1a | ||
| 650 | fmadd $T1b,$N0,$nd,$T1b | ||
| 651 | fmadd $T2a,$N1,$nc,$T2a | ||
| 652 | fmadd $T2b,$N1,$nd,$T2b | ||
| 653 | fmadd $T3a,$N2,$nc,$T3a | ||
| 654 | fmadd $T3b,$N2,$nd,$T3b | ||
| 655 | fmadd $dota,$N3,$nc,$dota | ||
| 656 | fmadd $dotb,$N3,$nd,$dotb | ||
| 657 | |||
| 658 | fctid $T0a,$T0a | ||
| 659 | fctid $T0b,$T0b | ||
| 660 | fctid $T1a,$T1a | ||
| 661 | fctid $T1b,$T1b | ||
| 662 | fctid $T2a,$T2a | ||
| 663 | fctid $T2b,$T2b | ||
| 664 | fctid $T3a,$T3a | ||
| 665 | fctid $T3b,$T3b | ||
| 666 | |||
| 667 | stfd $T0a,`$FRAME+0`($sp) | ||
| 668 | stfd $T0b,`$FRAME+8`($sp) | ||
| 669 | stfd $T1a,`$FRAME+16`($sp) | ||
| 670 | stfd $T1b,`$FRAME+24`($sp) | ||
| 671 | stfd $T2a,`$FRAME+32`($sp) | ||
| 672 | stfd $T2b,`$FRAME+40`($sp) | ||
| 673 | stfd $T3a,`$FRAME+48`($sp) | ||
| 674 | stfd $T3b,`$FRAME+56`($sp) | ||
| 675 | |||
| 676 | .align 5 | ||
| 677 | Linner: | ||
| 678 | fmul $T1a,$A1,$ba | ||
| 679 | fmul $T1b,$A1,$bb | ||
| 680 | fmul $T2a,$A2,$ba | ||
| 681 | fmul $T2b,$A2,$bb | ||
| 682 | lfd $N0,40($nap_d) ; load n[j] in double format | ||
| 683 | lfd $N1,48($nap_d) | ||
| 684 | fmul $T3a,$A3,$ba | ||
| 685 | fmul $T3b,$A3,$bb | ||
| 686 | fmadd $T0a,$A0,$ba,$dota | ||
| 687 | fmadd $T0b,$A0,$bb,$dotb | ||
| 688 | lfd $N2,56($nap_d) ; load n[j+1] in double format | ||
| 689 | lfdu $N3,64($nap_d) | ||
| 690 | |||
| 691 | fmadd $T1a,$A0,$bc,$T1a | ||
| 692 | fmadd $T1b,$A0,$bd,$T1b | ||
| 693 | fmadd $T2a,$A1,$bc,$T2a | ||
| 694 | fmadd $T2b,$A1,$bd,$T2b | ||
| 695 | lfd $A0,8($nap_d) ; load a[j] in double format | ||
| 696 | lfd $A1,16($nap_d) | ||
| 697 | fmadd $T3a,$A2,$bc,$T3a | ||
| 698 | fmadd $T3b,$A2,$bd,$T3b | ||
| 699 | fmul $dota,$A3,$bc | ||
| 700 | fmul $dotb,$A3,$bd | ||
| 701 | lfd $A2,24($nap_d) ; load a[j+1] in double format | ||
| 702 | lfd $A3,32($nap_d) | ||
| 703 | |||
| 704 | fmadd $T1a,$N1,$na,$T1a | ||
| 705 | fmadd $T1b,$N1,$nb,$T1b | ||
| 706 | ld $t0,`$FRAME+0`($sp) | ||
| 707 | ld $t1,`$FRAME+8`($sp) | ||
| 708 | fmadd $T2a,$N2,$na,$T2a | ||
| 709 | fmadd $T2b,$N2,$nb,$T2b | ||
| 710 | ld $t2,`$FRAME+16`($sp) | ||
| 711 | ld $t3,`$FRAME+24`($sp) | ||
| 712 | fmadd $T3a,$N3,$na,$T3a | ||
| 713 | fmadd $T3b,$N3,$nb,$T3b | ||
| 714 | add $t0,$t0,$carry ; can not overflow | ||
| 715 | ld $t4,`$FRAME+32`($sp) | ||
| 716 | ld $t5,`$FRAME+40`($sp) | ||
| 717 | fmadd $T0a,$N0,$na,$T0a | ||
| 718 | fmadd $T0b,$N0,$nb,$T0b | ||
| 719 | srdi $carry,$t0,16 | ||
| 720 | add $t1,$t1,$carry | ||
| 721 | srdi $carry,$t1,16 | ||
| 722 | ld $t6,`$FRAME+48`($sp) | ||
| 723 | ld $t7,`$FRAME+56`($sp) | ||
| 724 | |||
| 725 | fmadd $T1a,$N0,$nc,$T1a | ||
| 726 | fmadd $T1b,$N0,$nd,$T1b | ||
| 727 | insrdi $t0,$t1,16,32 | ||
| 728 | ld $t1,8($tp) ; tp[j] | ||
| 729 | fmadd $T2a,$N1,$nc,$T2a | ||
| 730 | fmadd $T2b,$N1,$nd,$T2b | ||
| 731 | add $t2,$t2,$carry | ||
| 732 | fmadd $T3a,$N2,$nc,$T3a | ||
| 733 | fmadd $T3b,$N2,$nd,$T3b | ||
| 734 | srdi $carry,$t2,16 | ||
| 735 | insrdi $t0,$t2,16,16 | ||
| 736 | fmadd $dota,$N3,$nc,$dota | ||
| 737 | fmadd $dotb,$N3,$nd,$dotb | ||
| 738 | add $t3,$t3,$carry | ||
| 739 | ldu $t2,16($tp) ; tp[j+1] | ||
| 740 | srdi $carry,$t3,16 | ||
| 741 | insrdi $t0,$t3,16,0 ; 0..63 bits | ||
| 742 | add $t4,$t4,$carry | ||
| 743 | |||
| 744 | fctid $T0a,$T0a | ||
| 745 | fctid $T0b,$T0b | ||
| 746 | srdi $carry,$t4,16 | ||
| 747 | fctid $T1a,$T1a | ||
| 748 | fctid $T1b,$T1b | ||
| 749 | add $t5,$t5,$carry | ||
| 750 | fctid $T2a,$T2a | ||
| 751 | fctid $T2b,$T2b | ||
| 752 | srdi $carry,$t5,16 | ||
| 753 | insrdi $t4,$t5,16,32 | ||
| 754 | fctid $T3a,$T3a | ||
| 755 | fctid $T3b,$T3b | ||
| 756 | add $t6,$t6,$carry | ||
| 757 | srdi $carry,$t6,16 | ||
| 758 | insrdi $t4,$t6,16,16 | ||
| 759 | |||
| 760 | stfd $T0a,`$FRAME+0`($sp) | ||
| 761 | stfd $T0b,`$FRAME+8`($sp) | ||
| 762 | add $t7,$t7,$carry | ||
| 763 | addc $t3,$t0,$t1 | ||
| 764 | stfd $T1a,`$FRAME+16`($sp) | ||
| 765 | stfd $T1b,`$FRAME+24`($sp) | ||
| 766 | insrdi $t4,$t7,16,0 ; 64..127 bits | ||
| 767 | srdi $carry,$t7,16 ; upper 33 bits | ||
| 768 | stfd $T2a,`$FRAME+32`($sp) | ||
| 769 | stfd $T2b,`$FRAME+40`($sp) | ||
| 770 | adde $t5,$t4,$t2 | ||
| 771 | stfd $T3a,`$FRAME+48`($sp) | ||
| 772 | stfd $T3b,`$FRAME+56`($sp) | ||
| 773 | addze $carry,$carry | ||
| 774 | std $t3,-16($tp) ; tp[j-1] | ||
| 775 | std $t5,-8($tp) ; tp[j] | ||
| 776 | bdnz- Linner | ||
| 777 | |||
| 778 | fctid $dota,$dota | ||
| 779 | fctid $dotb,$dotb | ||
| 780 | ld $t0,`$FRAME+0`($sp) | ||
| 781 | ld $t1,`$FRAME+8`($sp) | ||
| 782 | ld $t2,`$FRAME+16`($sp) | ||
| 783 | ld $t3,`$FRAME+24`($sp) | ||
| 784 | ld $t4,`$FRAME+32`($sp) | ||
| 785 | ld $t5,`$FRAME+40`($sp) | ||
| 786 | ld $t6,`$FRAME+48`($sp) | ||
| 787 | ld $t7,`$FRAME+56`($sp) | ||
| 788 | stfd $dota,`$FRAME+64`($sp) | ||
| 789 | stfd $dotb,`$FRAME+72`($sp) | ||
| 790 | |||
| 791 | add $t0,$t0,$carry ; can not overflow | ||
| 792 | srdi $carry,$t0,16 | ||
| 793 | add $t1,$t1,$carry | ||
| 794 | srdi $carry,$t1,16 | ||
| 795 | insrdi $t0,$t1,16,32 | ||
| 796 | add $t2,$t2,$carry | ||
| 797 | ld $t1,8($tp) ; tp[j] | ||
| 798 | srdi $carry,$t2,16 | ||
| 799 | insrdi $t0,$t2,16,16 | ||
| 800 | add $t3,$t3,$carry | ||
| 801 | ldu $t2,16($tp) ; tp[j+1] | ||
| 802 | srdi $carry,$t3,16 | ||
| 803 | insrdi $t0,$t3,16,0 ; 0..63 bits | ||
| 804 | add $t4,$t4,$carry | ||
| 805 | srdi $carry,$t4,16 | ||
| 806 | add $t5,$t5,$carry | ||
| 807 | srdi $carry,$t5,16 | ||
| 808 | insrdi $t4,$t5,16,32 | ||
| 809 | add $t6,$t6,$carry | ||
| 810 | srdi $carry,$t6,16 | ||
| 811 | insrdi $t4,$t6,16,16 | ||
| 812 | add $t7,$t7,$carry | ||
| 813 | insrdi $t4,$t7,16,0 ; 64..127 bits | ||
| 814 | srdi $carry,$t7,16 ; upper 33 bits | ||
| 815 | ld $t6,`$FRAME+64`($sp) | ||
| 816 | ld $t7,`$FRAME+72`($sp) | ||
| 817 | |||
| 818 | addc $t3,$t0,$t1 | ||
| 819 | adde $t5,$t4,$t2 | ||
| 820 | addze $carry,$carry | ||
| 821 | |||
| 822 | std $t3,-16($tp) ; tp[j-1] | ||
| 823 | std $t5,-8($tp) ; tp[j] | ||
| 824 | |||
| 825 | add $carry,$carry,$ovf ; comsume upmost overflow | ||
| 826 | add $t6,$t6,$carry ; can not overflow | ||
| 827 | srdi $carry,$t6,16 | ||
| 828 | add $t7,$t7,$carry | ||
| 829 | insrdi $t6,$t7,48,0 | ||
| 830 | srdi $ovf,$t7,48 | ||
| 831 | std $t6,0($tp) ; tp[num-1] | ||
| 832 | |||
| 833 | slwi $t7,$num,2 | ||
| 834 | addi $i,$i,8 | ||
| 835 | subf $nap_d,$t7,$nap_d ; rewind pointer | ||
| 836 | cmpw $i,$num | ||
| 837 | blt- Louter | ||
| 838 | |||
| 839 | subf $np,$num,$np ; rewind np | ||
| 840 | addi $j,$j,1 ; restore counter | ||
| 841 | subfc $i,$i,$i ; j=0 and "clear" XER[CA] | ||
| 842 | addi $tp,$sp,`$FRAME+$TRANSFER+8` | ||
| 843 | addi $t4,$sp,`$FRAME+$TRANSFER+16` | ||
| 844 | addi $t5,$np,8 | ||
| 845 | addi $t6,$rp,8 | ||
| 846 | mtctr $j | ||
| 847 | |||
| 848 | .align 4 | ||
| 849 | Lsub: ldx $t0,$tp,$i | ||
| 850 | ldx $t1,$np,$i | ||
| 851 | ldx $t2,$t4,$i | ||
| 852 | ldx $t3,$t5,$i | ||
| 853 | subfe $t0,$t1,$t0 ; tp[j]-np[j] | ||
| 854 | subfe $t2,$t3,$t2 ; tp[j+1]-np[j+1] | ||
| 855 | stdx $t0,$rp,$i | ||
| 856 | stdx $t2,$t6,$i | ||
| 857 | addi $i,$i,16 | ||
| 858 | bdnz- Lsub | ||
| 859 | |||
| 860 | li $i,0 | ||
| 861 | subfe $ovf,$i,$ovf ; handle upmost overflow bit | ||
| 862 | and $ap,$tp,$ovf | ||
| 863 | andc $np,$rp,$ovf | ||
| 864 | or $ap,$ap,$np ; ap=borrow?tp:rp | ||
| 865 | addi $t7,$ap,8 | ||
| 866 | mtctr $j | ||
| 867 | |||
| 868 | .align 4 | ||
| 869 | Lcopy: ; copy or in-place refresh | ||
| 870 | ldx $t0,$ap,$i | ||
| 871 | ldx $t1,$t7,$i | ||
| 872 | std $i,8($nap_d) ; zap nap_d | ||
| 873 | std $i,16($nap_d) | ||
| 874 | std $i,24($nap_d) | ||
| 875 | std $i,32($nap_d) | ||
| 876 | std $i,40($nap_d) | ||
| 877 | std $i,48($nap_d) | ||
| 878 | std $i,56($nap_d) | ||
| 879 | stdu $i,64($nap_d) | ||
| 880 | stdx $t0,$rp,$i | ||
| 881 | stdx $t1,$t6,$i | ||
| 882 | stdx $i,$tp,$i ; zap tp at once | ||
| 883 | stdx $i,$t4,$i | ||
| 884 | addi $i,$i,16 | ||
| 885 | bdnz- Lcopy | ||
| 886 | |||
| 887 | $POP r14,`2*$SIZE_T`($sp) | ||
| 888 | $POP r15,`3*$SIZE_T`($sp) | ||
| 889 | $POP r16,`4*$SIZE_T`($sp) | ||
| 890 | $POP r17,`5*$SIZE_T`($sp) | ||
| 891 | $POP r18,`6*$SIZE_T`($sp) | ||
| 892 | $POP r19,`7*$SIZE_T`($sp) | ||
| 893 | $POP r20,`8*$SIZE_T`($sp) | ||
| 894 | $POP r21,`9*$SIZE_T`($sp) | ||
| 895 | $POP r22,`10*$SIZE_T`($sp) | ||
| 896 | $POP r23,`11*$SIZE_T`($sp) | ||
| 897 | lfd f14,`12*$SIZE_T+0`($sp) | ||
| 898 | lfd f15,`12*$SIZE_T+8`($sp) | ||
| 899 | lfd f16,`12*$SIZE_T+16`($sp) | ||
| 900 | lfd f17,`12*$SIZE_T+24`($sp) | ||
| 901 | lfd f18,`12*$SIZE_T+32`($sp) | ||
| 902 | lfd f19,`12*$SIZE_T+40`($sp) | ||
| 903 | lfd f20,`12*$SIZE_T+48`($sp) | ||
| 904 | lfd f21,`12*$SIZE_T+56`($sp) | ||
| 905 | lfd f22,`12*$SIZE_T+64`($sp) | ||
| 906 | lfd f23,`12*$SIZE_T+72`($sp) | ||
| 907 | lfd f24,`12*$SIZE_T+80`($sp) | ||
| 908 | lfd f25,`12*$SIZE_T+88`($sp) | ||
| 909 | $POP $sp,0($sp) | ||
| 910 | li r3,1 ; signal "handled" | ||
| 911 | blr | ||
| 912 | .long 0 | ||
| 913 | .asciz "Montgomery Multiplication for PPC64, CRYPTOGAMS by <appro\@fy.chalmers.se>" | ||
| 914 | ___ | ||
| 915 | |||
| 916 | $code =~ s/\`([^\`]*)\`/eval $1/gem; | ||
| 917 | print $code; | ||
| 918 | close STDOUT; | ||
diff --git a/src/lib/libssl/src/crypto/bn/asm/s390x-mont.pl b/src/lib/libssl/src/crypto/bn/asm/s390x-mont.pl new file mode 100644 index 0000000000..d23251033b --- /dev/null +++ b/src/lib/libssl/src/crypto/bn/asm/s390x-mont.pl | |||
| @@ -0,0 +1,225 @@ | |||
| 1 | #!/usr/bin/env perl | ||
| 2 | |||
| 3 | # ==================================================================== | ||
| 4 | # Written by Andy Polyakov <appro@fy.chalmers.se> for the OpenSSL | ||
| 5 | # project. The module is, however, dual licensed under OpenSSL and | ||
| 6 | # CRYPTOGAMS licenses depending on where you obtain it. For further | ||
| 7 | # details see http://www.openssl.org/~appro/cryptogams/. | ||
| 8 | # ==================================================================== | ||
| 9 | |||
| 10 | # April 2007. | ||
| 11 | # | ||
| 12 | # Performance improvement over vanilla C code varies from 85% to 45% | ||
| 13 | # depending on key length and benchmark. Unfortunately in this context | ||
| 14 | # these are not very impressive results [for code that utilizes "wide" | ||
| 15 | # 64x64=128-bit multiplication, which is not commonly available to C | ||
| 16 | # programmers], at least hand-coded bn_asm.c replacement is known to | ||
| 17 | # provide 30-40% better results for longest keys. Well, on a second | ||
| 18 | # thought it's not very surprising, because z-CPUs are single-issue | ||
| 19 | # and _strictly_ in-order execution, while bn_mul_mont is more or less | ||
| 20 | # dependent on CPU ability to pipe-line instructions and have several | ||
| 21 | # of them "in-flight" at the same time. I mean while other methods, | ||
| 22 | # for example Karatsuba, aim to minimize amount of multiplications at | ||
| 23 | # the cost of other operations increase, bn_mul_mont aim to neatly | ||
| 24 | # "overlap" multiplications and the other operations [and on most | ||
| 25 | # platforms even minimize the amount of the other operations, in | ||
| 26 | # particular references to memory]. But it's possible to improve this | ||
| 27 | # module performance by implementing dedicated squaring code-path and | ||
| 28 | # possibly by unrolling loops... | ||
| 29 | |||
| 30 | # January 2009. | ||
| 31 | # | ||
| 32 | # Reschedule to minimize/avoid Address Generation Interlock hazard, | ||
| 33 | # make inner loops counter-based. | ||
| 34 | |||
| 35 | $mn0="%r0"; | ||
| 36 | $num="%r1"; | ||
| 37 | |||
| 38 | # int bn_mul_mont( | ||
| 39 | $rp="%r2"; # BN_ULONG *rp, | ||
| 40 | $ap="%r3"; # const BN_ULONG *ap, | ||
| 41 | $bp="%r4"; # const BN_ULONG *bp, | ||
| 42 | $np="%r5"; # const BN_ULONG *np, | ||
| 43 | $n0="%r6"; # const BN_ULONG *n0, | ||
| 44 | #$num="160(%r15)" # int num); | ||
| 45 | |||
| 46 | $bi="%r2"; # zaps rp | ||
| 47 | $j="%r7"; | ||
| 48 | |||
| 49 | $ahi="%r8"; | ||
| 50 | $alo="%r9"; | ||
| 51 | $nhi="%r10"; | ||
| 52 | $nlo="%r11"; | ||
| 53 | $AHI="%r12"; | ||
| 54 | $NHI="%r13"; | ||
| 55 | $count="%r14"; | ||
| 56 | $sp="%r15"; | ||
| 57 | |||
| 58 | $code.=<<___; | ||
| 59 | .text | ||
| 60 | .globl bn_mul_mont | ||
| 61 | .type bn_mul_mont,\@function | ||
| 62 | bn_mul_mont: | ||
| 63 | lgf $num,164($sp) # pull $num | ||
| 64 | sla $num,3 # $num to enumerate bytes | ||
| 65 | la $bp,0($num,$bp) | ||
| 66 | |||
| 67 | stg %r2,16($sp) | ||
| 68 | |||
| 69 | cghi $num,16 # | ||
| 70 | lghi %r2,0 # | ||
| 71 | blr %r14 # if($num<16) return 0; | ||
| 72 | cghi $num,128 # | ||
| 73 | bhr %r14 # if($num>128) return 0; | ||
| 74 | |||
| 75 | stmg %r3,%r15,24($sp) | ||
| 76 | |||
| 77 | lghi $rp,-160-8 # leave room for carry bit | ||
| 78 | lcgr $j,$num # -$num | ||
| 79 | lgr %r0,$sp | ||
| 80 | la $rp,0($rp,$sp) | ||
| 81 | la $sp,0($j,$rp) # alloca | ||
| 82 | stg %r0,0($sp) # back chain | ||
| 83 | |||
| 84 | sra $num,3 # restore $num | ||
| 85 | la $bp,0($j,$bp) # restore $bp | ||
| 86 | ahi $num,-1 # adjust $num for inner loop | ||
| 87 | lg $n0,0($n0) # pull n0 | ||
| 88 | |||
| 89 | lg $bi,0($bp) | ||
| 90 | lg $alo,0($ap) | ||
| 91 | mlgr $ahi,$bi # ap[0]*bp[0] | ||
| 92 | lgr $AHI,$ahi | ||
| 93 | |||
| 94 | lgr $mn0,$alo # "tp[0]"*n0 | ||
| 95 | msgr $mn0,$n0 | ||
| 96 | |||
| 97 | lg $nlo,0($np) # | ||
| 98 | mlgr $nhi,$mn0 # np[0]*m1 | ||
| 99 | algr $nlo,$alo # +="tp[0]" | ||
| 100 | lghi $NHI,0 | ||
| 101 | alcgr $NHI,$nhi | ||
| 102 | |||
| 103 | la $j,8(%r0) # j=1 | ||
| 104 | lr $count,$num | ||
| 105 | |||
| 106 | .align 16 | ||
| 107 | .L1st: | ||
| 108 | lg $alo,0($j,$ap) | ||
| 109 | mlgr $ahi,$bi # ap[j]*bp[0] | ||
| 110 | algr $alo,$AHI | ||
| 111 | lghi $AHI,0 | ||
| 112 | alcgr $AHI,$ahi | ||
| 113 | |||
| 114 | lg $nlo,0($j,$np) | ||
| 115 | mlgr $nhi,$mn0 # np[j]*m1 | ||
| 116 | algr $nlo,$NHI | ||
| 117 | lghi $NHI,0 | ||
| 118 | alcgr $nhi,$NHI # +="tp[j]" | ||
| 119 | algr $nlo,$alo | ||
| 120 | alcgr $NHI,$nhi | ||
| 121 | |||
| 122 | stg $nlo,160-8($j,$sp) # tp[j-1]= | ||
| 123 | la $j,8($j) # j++ | ||
| 124 | brct $count,.L1st | ||
| 125 | |||
| 126 | algr $NHI,$AHI | ||
| 127 | lghi $AHI,0 | ||
| 128 | alcgr $AHI,$AHI # upmost overflow bit | ||
| 129 | stg $NHI,160-8($j,$sp) | ||
| 130 | stg $AHI,160($j,$sp) | ||
| 131 | la $bp,8($bp) # bp++ | ||
| 132 | |||
| 133 | .Louter: | ||
| 134 | lg $bi,0($bp) # bp[i] | ||
| 135 | lg $alo,0($ap) | ||
| 136 | mlgr $ahi,$bi # ap[0]*bp[i] | ||
| 137 | alg $alo,160($sp) # +=tp[0] | ||
| 138 | lghi $AHI,0 | ||
| 139 | alcgr $AHI,$ahi | ||
| 140 | |||
| 141 | lgr $mn0,$alo | ||
| 142 | msgr $mn0,$n0 # tp[0]*n0 | ||
| 143 | |||
| 144 | lg $nlo,0($np) # np[0] | ||
| 145 | mlgr $nhi,$mn0 # np[0]*m1 | ||
| 146 | algr $nlo,$alo # +="tp[0]" | ||
| 147 | lghi $NHI,0 | ||
| 148 | alcgr $NHI,$nhi | ||
| 149 | |||
| 150 | la $j,8(%r0) # j=1 | ||
| 151 | lr $count,$num | ||
| 152 | |||
| 153 | .align 16 | ||
| 154 | .Linner: | ||
| 155 | lg $alo,0($j,$ap) | ||
| 156 | mlgr $ahi,$bi # ap[j]*bp[i] | ||
| 157 | algr $alo,$AHI | ||
| 158 | lghi $AHI,0 | ||
| 159 | alcgr $ahi,$AHI | ||
| 160 | alg $alo,160($j,$sp)# +=tp[j] | ||
| 161 | alcgr $AHI,$ahi | ||
| 162 | |||
| 163 | lg $nlo,0($j,$np) | ||
| 164 | mlgr $nhi,$mn0 # np[j]*m1 | ||
| 165 | algr $nlo,$NHI | ||
| 166 | lghi $NHI,0 | ||
| 167 | alcgr $nhi,$NHI | ||
| 168 | algr $nlo,$alo # +="tp[j]" | ||
| 169 | alcgr $NHI,$nhi | ||
| 170 | |||
| 171 | stg $nlo,160-8($j,$sp) # tp[j-1]= | ||
| 172 | la $j,8($j) # j++ | ||
| 173 | brct $count,.Linner | ||
| 174 | |||
| 175 | algr $NHI,$AHI | ||
| 176 | lghi $AHI,0 | ||
| 177 | alcgr $AHI,$AHI | ||
| 178 | alg $NHI,160($j,$sp)# accumulate previous upmost overflow bit | ||
| 179 | lghi $ahi,0 | ||
| 180 | alcgr $AHI,$ahi # new upmost overflow bit | ||
| 181 | stg $NHI,160-8($j,$sp) | ||
| 182 | stg $AHI,160($j,$sp) | ||
| 183 | |||
| 184 | la $bp,8($bp) # bp++ | ||
| 185 | clg $bp,160+8+32($j,$sp) # compare to &bp[num] | ||
| 186 | jne .Louter | ||
| 187 | |||
| 188 | lg $rp,160+8+16($j,$sp) # reincarnate rp | ||
| 189 | la $ap,160($sp) | ||
| 190 | ahi $num,1 # restore $num, incidentally clears "borrow" | ||
| 191 | |||
| 192 | la $j,0(%r0) | ||
| 193 | lr $count,$num | ||
| 194 | .Lsub: lg $alo,0($j,$ap) | ||
| 195 | slbg $alo,0($j,$np) | ||
| 196 | stg $alo,0($j,$rp) | ||
| 197 | la $j,8($j) | ||
| 198 | brct $count,.Lsub | ||
| 199 | lghi $ahi,0 | ||
| 200 | slbgr $AHI,$ahi # handle upmost carry | ||
| 201 | |||
| 202 | ngr $ap,$AHI | ||
| 203 | lghi $np,-1 | ||
| 204 | xgr $np,$AHI | ||
| 205 | ngr $np,$rp | ||
| 206 | ogr $ap,$np # ap=borrow?tp:rp | ||
| 207 | |||
| 208 | la $j,0(%r0) | ||
| 209 | lgr $count,$num | ||
| 210 | .Lcopy: lg $alo,0($j,$ap) # copy or in-place refresh | ||
| 211 | stg $j,160($j,$sp) # zap tp | ||
| 212 | stg $alo,0($j,$rp) | ||
| 213 | la $j,8($j) | ||
| 214 | brct $count,.Lcopy | ||
| 215 | |||
| 216 | la %r1,160+8+48($j,$sp) | ||
| 217 | lmg %r6,%r15,0(%r1) | ||
| 218 | lghi %r2,1 # signal "processed" | ||
| 219 | br %r14 | ||
| 220 | .size bn_mul_mont,.-bn_mul_mont | ||
| 221 | .string "Montgomery Multiplication for s390x, CRYPTOGAMS by <appro\@openssl.org>" | ||
| 222 | ___ | ||
| 223 | |||
| 224 | print $code; | ||
| 225 | close STDOUT; | ||
diff --git a/src/lib/libssl/src/crypto/bn/asm/s390x.S b/src/lib/libssl/src/crypto/bn/asm/s390x.S new file mode 100755 index 0000000000..8f45f5d513 --- /dev/null +++ b/src/lib/libssl/src/crypto/bn/asm/s390x.S | |||
| @@ -0,0 +1,678 @@ | |||
| 1 | .ident "s390x.S, version 1.0" | ||
| 2 | // ==================================================================== | ||
| 3 | // Written by Andy Polyakov <appro@fy.chalmers.se> for the OpenSSL | ||
| 4 | // project. | ||
| 5 | // | ||
| 6 | // Rights for redistribution and usage in source and binary forms are | ||
| 7 | // granted according to the OpenSSL license. Warranty of any kind is | ||
| 8 | // disclaimed. | ||
| 9 | // ==================================================================== | ||
| 10 | |||
| 11 | .text | ||
| 12 | |||
| 13 | #define zero %r0 | ||
| 14 | |||
| 15 | // BN_ULONG bn_mul_add_words(BN_ULONG *r2,BN_ULONG *r3,int r4,BN_ULONG r5); | ||
| 16 | .globl bn_mul_add_words | ||
| 17 | .type bn_mul_add_words,@function | ||
| 18 | .align 4 | ||
| 19 | bn_mul_add_words: | ||
| 20 | lghi zero,0 // zero = 0 | ||
| 21 | la %r1,0(%r2) // put rp aside | ||
| 22 | lghi %r2,0 // i=0; | ||
| 23 | ltgfr %r4,%r4 | ||
| 24 | bler %r14 // if (len<=0) return 0; | ||
| 25 | |||
| 26 | stmg %r6,%r10,48(%r15) | ||
| 27 | lghi %r8,0 // carry = 0 | ||
| 28 | srag %r10,%r4,2 // cnt=len/4 | ||
| 29 | jz .Loop1_madd | ||
| 30 | |||
| 31 | .Loop4_madd: | ||
| 32 | lg %r7,0(%r2,%r3) // ap[i] | ||
| 33 | mlgr %r6,%r5 // *=w | ||
| 34 | algr %r7,%r8 // +=carry | ||
| 35 | alcgr %r6,zero | ||
| 36 | alg %r7,0(%r2,%r1) // +=rp[i] | ||
| 37 | alcgr %r6,zero | ||
| 38 | stg %r7,0(%r2,%r1) // rp[i]= | ||
| 39 | |||
| 40 | lg %r9,8(%r2,%r3) | ||
| 41 | mlgr %r8,%r5 | ||
| 42 | algr %r9,%r6 | ||
| 43 | alcgr %r8,zero | ||
| 44 | alg %r9,8(%r2,%r1) | ||
| 45 | alcgr %r8,zero | ||
| 46 | stg %r9,8(%r2,%r1) | ||
| 47 | |||
| 48 | lg %r7,16(%r2,%r3) | ||
| 49 | mlgr %r6,%r5 | ||
| 50 | algr %r7,%r8 | ||
| 51 | alcgr %r6,zero | ||
| 52 | alg %r7,16(%r2,%r1) | ||
| 53 | alcgr %r6,zero | ||
| 54 | stg %r7,16(%r2,%r1) | ||
| 55 | |||
| 56 | lg %r9,24(%r2,%r3) | ||
| 57 | mlgr %r8,%r5 | ||
| 58 | algr %r9,%r6 | ||
| 59 | alcgr %r8,zero | ||
| 60 | alg %r9,24(%r2,%r1) | ||
| 61 | alcgr %r8,zero | ||
| 62 | stg %r9,24(%r2,%r1) | ||
| 63 | |||
| 64 | la %r2,32(%r2) // i+=4 | ||
| 65 | brct %r10,.Loop4_madd | ||
| 66 | |||
| 67 | lghi %r10,3 | ||
| 68 | nr %r4,%r10 // cnt=len%4 | ||
| 69 | jz .Lend_madd | ||
| 70 | |||
| 71 | .Loop1_madd: | ||
| 72 | lg %r7,0(%r2,%r3) // ap[i] | ||
| 73 | mlgr %r6,%r5 // *=w | ||
| 74 | algr %r7,%r8 // +=carry | ||
| 75 | alcgr %r6,zero | ||
| 76 | alg %r7,0(%r2,%r1) // +=rp[i] | ||
| 77 | alcgr %r6,zero | ||
| 78 | stg %r7,0(%r2,%r1) // rp[i]= | ||
| 79 | |||
| 80 | lgr %r8,%r6 | ||
| 81 | la %r2,8(%r2) // i++ | ||
| 82 | brct %r4,.Loop1_madd | ||
| 83 | |||
| 84 | .Lend_madd: | ||
| 85 | lgr %r2,%r8 | ||
| 86 | lmg %r6,%r10,48(%r15) | ||
| 87 | br %r14 | ||
| 88 | .size bn_mul_add_words,.-bn_mul_add_words | ||
| 89 | |||
| 90 | // BN_ULONG bn_mul_words(BN_ULONG *r2,BN_ULONG *r3,int r4,BN_ULONG r5); | ||
| 91 | .globl bn_mul_words | ||
| 92 | .type bn_mul_words,@function | ||
| 93 | .align 4 | ||
| 94 | bn_mul_words: | ||
| 95 | lghi zero,0 // zero = 0 | ||
| 96 | la %r1,0(%r2) // put rp aside | ||
| 97 | lghi %r2,0 // i=0; | ||
| 98 | ltgfr %r4,%r4 | ||
| 99 | bler %r14 // if (len<=0) return 0; | ||
| 100 | |||
| 101 | stmg %r6,%r10,48(%r15) | ||
| 102 | lghi %r8,0 // carry = 0 | ||
| 103 | srag %r10,%r4,2 // cnt=len/4 | ||
| 104 | jz .Loop1_mul | ||
| 105 | |||
| 106 | .Loop4_mul: | ||
| 107 | lg %r7,0(%r2,%r3) // ap[i] | ||
| 108 | mlgr %r6,%r5 // *=w | ||
| 109 | algr %r7,%r8 // +=carry | ||
| 110 | alcgr %r6,zero | ||
| 111 | stg %r7,0(%r2,%r1) // rp[i]= | ||
| 112 | |||
| 113 | lg %r9,8(%r2,%r3) | ||
| 114 | mlgr %r8,%r5 | ||
| 115 | algr %r9,%r6 | ||
| 116 | alcgr %r8,zero | ||
| 117 | stg %r9,8(%r2,%r1) | ||
| 118 | |||
| 119 | lg %r7,16(%r2,%r3) | ||
| 120 | mlgr %r6,%r5 | ||
| 121 | algr %r7,%r8 | ||
| 122 | alcgr %r6,zero | ||
| 123 | stg %r7,16(%r2,%r1) | ||
| 124 | |||
| 125 | lg %r9,24(%r2,%r3) | ||
| 126 | mlgr %r8,%r5 | ||
| 127 | algr %r9,%r6 | ||
| 128 | alcgr %r8,zero | ||
| 129 | stg %r9,24(%r2,%r1) | ||
| 130 | |||
| 131 | la %r2,32(%r2) // i+=4 | ||
| 132 | brct %r10,.Loop4_mul | ||
| 133 | |||
| 134 | lghi %r10,3 | ||
| 135 | nr %r4,%r10 // cnt=len%4 | ||
| 136 | jz .Lend_mul | ||
| 137 | |||
| 138 | .Loop1_mul: | ||
| 139 | lg %r7,0(%r2,%r3) // ap[i] | ||
| 140 | mlgr %r6,%r5 // *=w | ||
| 141 | algr %r7,%r8 // +=carry | ||
| 142 | alcgr %r6,zero | ||
| 143 | stg %r7,0(%r2,%r1) // rp[i]= | ||
| 144 | |||
| 145 | lgr %r8,%r6 | ||
| 146 | la %r2,8(%r2) // i++ | ||
| 147 | brct %r4,.Loop1_mul | ||
| 148 | |||
| 149 | .Lend_mul: | ||
| 150 | lgr %r2,%r8 | ||
| 151 | lmg %r6,%r10,48(%r15) | ||
| 152 | br %r14 | ||
| 153 | .size bn_mul_words,.-bn_mul_words | ||
| 154 | |||
| 155 | // void bn_sqr_words(BN_ULONG *r2,BN_ULONG *r2,int r4) | ||
| 156 | .globl bn_sqr_words | ||
| 157 | .type bn_sqr_words,@function | ||
| 158 | .align 4 | ||
| 159 | bn_sqr_words: | ||
| 160 | ltgfr %r4,%r4 | ||
| 161 | bler %r14 | ||
| 162 | |||
| 163 | stmg %r6,%r7,48(%r15) | ||
| 164 | srag %r1,%r4,2 // cnt=len/4 | ||
| 165 | jz .Loop1_sqr | ||
| 166 | |||
| 167 | .Loop4_sqr: | ||
| 168 | lg %r7,0(%r3) | ||
| 169 | mlgr %r6,%r7 | ||
| 170 | stg %r7,0(%r2) | ||
| 171 | stg %r6,8(%r2) | ||
| 172 | |||
| 173 | lg %r7,8(%r3) | ||
| 174 | mlgr %r6,%r7 | ||
| 175 | stg %r7,16(%r2) | ||
| 176 | stg %r6,24(%r2) | ||
| 177 | |||
| 178 | lg %r7,16(%r3) | ||
| 179 | mlgr %r6,%r7 | ||
| 180 | stg %r7,32(%r2) | ||
| 181 | stg %r6,40(%r2) | ||
| 182 | |||
| 183 | lg %r7,24(%r3) | ||
| 184 | mlgr %r6,%r7 | ||
| 185 | stg %r7,48(%r2) | ||
| 186 | stg %r6,56(%r2) | ||
| 187 | |||
| 188 | la %r3,32(%r3) | ||
| 189 | la %r2,64(%r2) | ||
| 190 | brct %r1,.Loop4_sqr | ||
| 191 | |||
| 192 | lghi %r1,3 | ||
| 193 | nr %r4,%r1 // cnt=len%4 | ||
| 194 | jz .Lend_sqr | ||
| 195 | |||
| 196 | .Loop1_sqr: | ||
| 197 | lg %r7,0(%r3) | ||
| 198 | mlgr %r6,%r7 | ||
| 199 | stg %r7,0(%r2) | ||
| 200 | stg %r6,8(%r2) | ||
| 201 | |||
| 202 | la %r3,8(%r3) | ||
| 203 | la %r2,16(%r2) | ||
| 204 | brct %r4,.Loop1_sqr | ||
| 205 | |||
| 206 | .Lend_sqr: | ||
| 207 | lmg %r6,%r7,48(%r15) | ||
| 208 | br %r14 | ||
| 209 | .size bn_sqr_words,.-bn_sqr_words | ||
| 210 | |||
| 211 | // BN_ULONG bn_div_words(BN_ULONG h,BN_ULONG l,BN_ULONG d); | ||
| 212 | .globl bn_div_words | ||
| 213 | .type bn_div_words,@function | ||
| 214 | .align 4 | ||
| 215 | bn_div_words: | ||
| 216 | dlgr %r2,%r4 | ||
| 217 | lgr %r2,%r3 | ||
| 218 | br %r14 | ||
| 219 | .size bn_div_words,.-bn_div_words | ||
| 220 | |||
| 221 | // BN_ULONG bn_add_words(BN_ULONG *r2,BN_ULONG *r3,BN_ULONG *r4,int r5); | ||
| 222 | .globl bn_add_words | ||
| 223 | .type bn_add_words,@function | ||
| 224 | .align 4 | ||
| 225 | bn_add_words: | ||
| 226 | la %r1,0(%r2) // put rp aside | ||
| 227 | lghi %r2,0 // i=0 | ||
| 228 | ltgfr %r5,%r5 | ||
| 229 | bler %r14 // if (len<=0) return 0; | ||
| 230 | |||
| 231 | stg %r6,48(%r15) | ||
| 232 | lghi %r6,3 | ||
| 233 | nr %r6,%r5 // len%4 | ||
| 234 | sra %r5,2 // len/4, use sra because it sets condition code | ||
| 235 | jz .Loop1_add // carry is incidentally cleared if branch taken | ||
| 236 | algr %r2,%r2 // clear carry | ||
| 237 | |||
| 238 | .Loop4_add: | ||
| 239 | lg %r0,0(%r2,%r3) | ||
| 240 | alcg %r0,0(%r2,%r4) | ||
| 241 | stg %r0,0(%r2,%r1) | ||
| 242 | lg %r0,8(%r2,%r3) | ||
| 243 | alcg %r0,8(%r2,%r4) | ||
| 244 | stg %r0,8(%r2,%r1) | ||
| 245 | lg %r0,16(%r2,%r3) | ||
| 246 | alcg %r0,16(%r2,%r4) | ||
| 247 | stg %r0,16(%r2,%r1) | ||
| 248 | lg %r0,24(%r2,%r3) | ||
| 249 | alcg %r0,24(%r2,%r4) | ||
| 250 | stg %r0,24(%r2,%r1) | ||
| 251 | |||
| 252 | la %r2,32(%r2) // i+=4 | ||
| 253 | brct %r5,.Loop4_add | ||
| 254 | |||
| 255 | la %r6,1(%r6) // see if len%4 is zero ... | ||
| 256 | brct %r6,.Loop1_add // without touching condition code:-) | ||
| 257 | |||
| 258 | .Lexit_add: | ||
| 259 | lghi %r2,0 | ||
| 260 | alcgr %r2,%r2 | ||
| 261 | lg %r6,48(%r15) | ||
| 262 | br %r14 | ||
| 263 | |||
| 264 | .Loop1_add: | ||
| 265 | lg %r0,0(%r2,%r3) | ||
| 266 | alcg %r0,0(%r2,%r4) | ||
| 267 | stg %r0,0(%r2,%r1) | ||
| 268 | |||
| 269 | la %r2,8(%r2) // i++ | ||
| 270 | brct %r6,.Loop1_add | ||
| 271 | |||
| 272 | j .Lexit_add | ||
| 273 | .size bn_add_words,.-bn_add_words | ||
| 274 | |||
| 275 | // BN_ULONG bn_sub_words(BN_ULONG *r2,BN_ULONG *r3,BN_ULONG *r4,int r5); | ||
| 276 | .globl bn_sub_words | ||
| 277 | .type bn_sub_words,@function | ||
| 278 | .align 4 | ||
| 279 | bn_sub_words: | ||
| 280 | la %r1,0(%r2) // put rp aside | ||
| 281 | lghi %r2,0 // i=0 | ||
| 282 | ltgfr %r5,%r5 | ||
| 283 | bler %r14 // if (len<=0) return 0; | ||
| 284 | |||
| 285 | stg %r6,48(%r15) | ||
| 286 | lghi %r6,3 | ||
| 287 | nr %r6,%r5 // len%4 | ||
| 288 | sra %r5,2 // len/4, use sra because it sets condition code | ||
| 289 | jnz .Loop4_sub // borrow is incidentally cleared if branch taken | ||
| 290 | slgr %r2,%r2 // clear borrow | ||
| 291 | |||
| 292 | .Loop1_sub: | ||
| 293 | lg %r0,0(%r2,%r3) | ||
| 294 | slbg %r0,0(%r2,%r4) | ||
| 295 | stg %r0,0(%r2,%r1) | ||
| 296 | |||
| 297 | la %r2,8(%r2) // i++ | ||
| 298 | brct %r6,.Loop1_sub | ||
| 299 | j .Lexit_sub | ||
| 300 | |||
| 301 | .Loop4_sub: | ||
| 302 | lg %r0,0(%r2,%r3) | ||
| 303 | slbg %r0,0(%r2,%r4) | ||
| 304 | stg %r0,0(%r2,%r1) | ||
| 305 | lg %r0,8(%r2,%r3) | ||
| 306 | slbg %r0,8(%r2,%r4) | ||
| 307 | stg %r0,8(%r2,%r1) | ||
| 308 | lg %r0,16(%r2,%r3) | ||
| 309 | slbg %r0,16(%r2,%r4) | ||
| 310 | stg %r0,16(%r2,%r1) | ||
| 311 | lg %r0,24(%r2,%r3) | ||
| 312 | slbg %r0,24(%r2,%r4) | ||
| 313 | stg %r0,24(%r2,%r1) | ||
| 314 | |||
| 315 | la %r2,32(%r2) // i+=4 | ||
| 316 | brct %r5,.Loop4_sub | ||
| 317 | |||
| 318 | la %r6,1(%r6) // see if len%4 is zero ... | ||
| 319 | brct %r6,.Loop1_sub // without touching condition code:-) | ||
| 320 | |||
| 321 | .Lexit_sub: | ||
| 322 | lghi %r2,0 | ||
| 323 | slbgr %r2,%r2 | ||
| 324 | lcgr %r2,%r2 | ||
| 325 | lg %r6,48(%r15) | ||
| 326 | br %r14 | ||
| 327 | .size bn_sub_words,.-bn_sub_words | ||
| 328 | |||
| 329 | #define c1 %r1 | ||
| 330 | #define c2 %r5 | ||
| 331 | #define c3 %r8 | ||
| 332 | |||
| 333 | #define mul_add_c(ai,bi,c1,c2,c3) \ | ||
| 334 | lg %r7,ai*8(%r3); \ | ||
| 335 | mlg %r6,bi*8(%r4); \ | ||
| 336 | algr c1,%r7; \ | ||
| 337 | alcgr c2,%r6; \ | ||
| 338 | alcgr c3,zero | ||
| 339 | |||
| 340 | // void bn_mul_comba8(BN_ULONG *r2,BN_ULONG *r3,BN_ULONG *r4); | ||
| 341 | .globl bn_mul_comba8 | ||
| 342 | .type bn_mul_comba8,@function | ||
| 343 | .align 4 | ||
| 344 | bn_mul_comba8: | ||
| 345 | stmg %r6,%r8,48(%r15) | ||
| 346 | |||
| 347 | lghi c1,0 | ||
| 348 | lghi c2,0 | ||
| 349 | lghi c3,0 | ||
| 350 | lghi zero,0 | ||
| 351 | |||
| 352 | mul_add_c(0,0,c1,c2,c3); | ||
| 353 | stg c1,0*8(%r2) | ||
| 354 | lghi c1,0 | ||
| 355 | |||
| 356 | mul_add_c(0,1,c2,c3,c1); | ||
| 357 | mul_add_c(1,0,c2,c3,c1); | ||
| 358 | stg c2,1*8(%r2) | ||
| 359 | lghi c2,0 | ||
| 360 | |||
| 361 | mul_add_c(2,0,c3,c1,c2); | ||
| 362 | mul_add_c(1,1,c3,c1,c2); | ||
| 363 | mul_add_c(0,2,c3,c1,c2); | ||
| 364 | stg c3,2*8(%r2) | ||
| 365 | lghi c3,0 | ||
| 366 | |||
| 367 | mul_add_c(0,3,c1,c2,c3); | ||
| 368 | mul_add_c(1,2,c1,c2,c3); | ||
| 369 | mul_add_c(2,1,c1,c2,c3); | ||
| 370 | mul_add_c(3,0,c1,c2,c3); | ||
| 371 | stg c1,3*8(%r2) | ||
| 372 | lghi c1,0 | ||
| 373 | |||
| 374 | mul_add_c(4,0,c2,c3,c1); | ||
| 375 | mul_add_c(3,1,c2,c3,c1); | ||
| 376 | mul_add_c(2,2,c2,c3,c1); | ||
| 377 | mul_add_c(1,3,c2,c3,c1); | ||
| 378 | mul_add_c(0,4,c2,c3,c1); | ||
| 379 | stg c2,4*8(%r2) | ||
| 380 | lghi c2,0 | ||
| 381 | |||
| 382 | mul_add_c(0,5,c3,c1,c2); | ||
| 383 | mul_add_c(1,4,c3,c1,c2); | ||
| 384 | mul_add_c(2,3,c3,c1,c2); | ||
| 385 | mul_add_c(3,2,c3,c1,c2); | ||
| 386 | mul_add_c(4,1,c3,c1,c2); | ||
| 387 | mul_add_c(5,0,c3,c1,c2); | ||
| 388 | stg c3,5*8(%r2) | ||
| 389 | lghi c3,0 | ||
| 390 | |||
| 391 | mul_add_c(6,0,c1,c2,c3); | ||
| 392 | mul_add_c(5,1,c1,c2,c3); | ||
| 393 | mul_add_c(4,2,c1,c2,c3); | ||
| 394 | mul_add_c(3,3,c1,c2,c3); | ||
| 395 | mul_add_c(2,4,c1,c2,c3); | ||
| 396 | mul_add_c(1,5,c1,c2,c3); | ||
| 397 | mul_add_c(0,6,c1,c2,c3); | ||
| 398 | stg c1,6*8(%r2) | ||
| 399 | lghi c1,0 | ||
| 400 | |||
| 401 | mul_add_c(0,7,c2,c3,c1); | ||
| 402 | mul_add_c(1,6,c2,c3,c1); | ||
| 403 | mul_add_c(2,5,c2,c3,c1); | ||
| 404 | mul_add_c(3,4,c2,c3,c1); | ||
| 405 | mul_add_c(4,3,c2,c3,c1); | ||
| 406 | mul_add_c(5,2,c2,c3,c1); | ||
| 407 | mul_add_c(6,1,c2,c3,c1); | ||
| 408 | mul_add_c(7,0,c2,c3,c1); | ||
| 409 | stg c2,7*8(%r2) | ||
| 410 | lghi c2,0 | ||
| 411 | |||
| 412 | mul_add_c(7,1,c3,c1,c2); | ||
| 413 | mul_add_c(6,2,c3,c1,c2); | ||
| 414 | mul_add_c(5,3,c3,c1,c2); | ||
| 415 | mul_add_c(4,4,c3,c1,c2); | ||
| 416 | mul_add_c(3,5,c3,c1,c2); | ||
| 417 | mul_add_c(2,6,c3,c1,c2); | ||
| 418 | mul_add_c(1,7,c3,c1,c2); | ||
| 419 | stg c3,8*8(%r2) | ||
| 420 | lghi c3,0 | ||
| 421 | |||
| 422 | mul_add_c(2,7,c1,c2,c3); | ||
| 423 | mul_add_c(3,6,c1,c2,c3); | ||
| 424 | mul_add_c(4,5,c1,c2,c3); | ||
| 425 | mul_add_c(5,4,c1,c2,c3); | ||
| 426 | mul_add_c(6,3,c1,c2,c3); | ||
| 427 | mul_add_c(7,2,c1,c2,c3); | ||
| 428 | stg c1,9*8(%r2) | ||
| 429 | lghi c1,0 | ||
| 430 | |||
| 431 | mul_add_c(7,3,c2,c3,c1); | ||
| 432 | mul_add_c(6,4,c2,c3,c1); | ||
| 433 | mul_add_c(5,5,c2,c3,c1); | ||
| 434 | mul_add_c(4,6,c2,c3,c1); | ||
| 435 | mul_add_c(3,7,c2,c3,c1); | ||
| 436 | stg c2,10*8(%r2) | ||
| 437 | lghi c2,0 | ||
| 438 | |||
| 439 | mul_add_c(4,7,c3,c1,c2); | ||
| 440 | mul_add_c(5,6,c3,c1,c2); | ||
| 441 | mul_add_c(6,5,c3,c1,c2); | ||
| 442 | mul_add_c(7,4,c3,c1,c2); | ||
| 443 | stg c3,11*8(%r2) | ||
| 444 | lghi c3,0 | ||
| 445 | |||
| 446 | mul_add_c(7,5,c1,c2,c3); | ||
| 447 | mul_add_c(6,6,c1,c2,c3); | ||
| 448 | mul_add_c(5,7,c1,c2,c3); | ||
| 449 | stg c1,12*8(%r2) | ||
| 450 | lghi c1,0 | ||
| 451 | |||
| 452 | |||
| 453 | mul_add_c(6,7,c2,c3,c1); | ||
| 454 | mul_add_c(7,6,c2,c3,c1); | ||
| 455 | stg c2,13*8(%r2) | ||
| 456 | lghi c2,0 | ||
| 457 | |||
| 458 | mul_add_c(7,7,c3,c1,c2); | ||
| 459 | stg c3,14*8(%r2) | ||
| 460 | stg c1,15*8(%r2) | ||
| 461 | |||
| 462 | lmg %r6,%r8,48(%r15) | ||
| 463 | br %r14 | ||
| 464 | .size bn_mul_comba8,.-bn_mul_comba8 | ||
| 465 | |||
| 466 | // void bn_mul_comba4(BN_ULONG *r2,BN_ULONG *r3,BN_ULONG *r4); | ||
| 467 | .globl bn_mul_comba4 | ||
| 468 | .type bn_mul_comba4,@function | ||
| 469 | .align 4 | ||
| 470 | bn_mul_comba4: | ||
| 471 | stmg %r6,%r8,48(%r15) | ||
| 472 | |||
| 473 | lghi c1,0 | ||
| 474 | lghi c2,0 | ||
| 475 | lghi c3,0 | ||
| 476 | lghi zero,0 | ||
| 477 | |||
| 478 | mul_add_c(0,0,c1,c2,c3); | ||
| 479 | stg c1,0*8(%r3) | ||
| 480 | lghi c1,0 | ||
| 481 | |||
| 482 | mul_add_c(0,1,c2,c3,c1); | ||
| 483 | mul_add_c(1,0,c2,c3,c1); | ||
| 484 | stg c2,1*8(%r2) | ||
| 485 | lghi c2,0 | ||
| 486 | |||
| 487 | mul_add_c(2,0,c3,c1,c2); | ||
| 488 | mul_add_c(1,1,c3,c1,c2); | ||
| 489 | mul_add_c(0,2,c3,c1,c2); | ||
| 490 | stg c3,2*8(%r2) | ||
| 491 | lghi c3,0 | ||
| 492 | |||
| 493 | mul_add_c(0,3,c1,c2,c3); | ||
| 494 | mul_add_c(1,2,c1,c2,c3); | ||
| 495 | mul_add_c(2,1,c1,c2,c3); | ||
| 496 | mul_add_c(3,0,c1,c2,c3); | ||
| 497 | stg c1,3*8(%r2) | ||
| 498 | lghi c1,0 | ||
| 499 | |||
| 500 | mul_add_c(3,1,c2,c3,c1); | ||
| 501 | mul_add_c(2,2,c2,c3,c1); | ||
| 502 | mul_add_c(1,3,c2,c3,c1); | ||
| 503 | stg c2,4*8(%r2) | ||
| 504 | lghi c2,0 | ||
| 505 | |||
| 506 | mul_add_c(2,3,c3,c1,c2); | ||
| 507 | mul_add_c(3,2,c3,c1,c2); | ||
| 508 | stg c3,5*8(%r2) | ||
| 509 | lghi c3,0 | ||
| 510 | |||
| 511 | mul_add_c(3,3,c1,c2,c3); | ||
| 512 | stg c1,6*8(%r2) | ||
| 513 | stg c2,7*8(%r2) | ||
| 514 | |||
| 515 | stmg %r6,%r8,48(%r15) | ||
| 516 | br %r14 | ||
| 517 | .size bn_mul_comba4,.-bn_mul_comba4 | ||
| 518 | |||
| 519 | #define sqr_add_c(ai,c1,c2,c3) \ | ||
| 520 | lg %r7,ai*8(%r3); \ | ||
| 521 | mlgr %r6,%r7; \ | ||
| 522 | algr c1,%r7; \ | ||
| 523 | alcgr c2,%r6; \ | ||
| 524 | alcgr c3,zero | ||
| 525 | |||
| 526 | #define sqr_add_c2(ai,aj,c1,c2,c3) \ | ||
| 527 | lg %r7,ai*8(%r3); \ | ||
| 528 | mlg %r6,aj*8(%r3); \ | ||
| 529 | algr c1,%r7; \ | ||
| 530 | alcgr c2,%r6; \ | ||
| 531 | alcgr c3,zero; \ | ||
| 532 | algr c1,%r7; \ | ||
| 533 | alcgr c2,%r6; \ | ||
| 534 | alcgr c3,zero | ||
| 535 | |||
| 536 | // void bn_sqr_comba8(BN_ULONG *r2,BN_ULONG *r3); | ||
| 537 | .globl bn_sqr_comba8 | ||
| 538 | .type bn_sqr_comba8,@function | ||
| 539 | .align 4 | ||
| 540 | bn_sqr_comba8: | ||
| 541 | stmg %r6,%r8,48(%r15) | ||
| 542 | |||
| 543 | lghi c1,0 | ||
| 544 | lghi c2,0 | ||
| 545 | lghi c3,0 | ||
| 546 | lghi zero,0 | ||
| 547 | |||
| 548 | sqr_add_c(0,c1,c2,c3); | ||
| 549 | stg c1,0*8(%r2) | ||
| 550 | lghi c1,0 | ||
| 551 | |||
| 552 | sqr_add_c2(1,0,c2,c3,c1); | ||
| 553 | stg c2,1*8(%r2) | ||
| 554 | lghi c2,0 | ||
| 555 | |||
| 556 | sqr_add_c(1,c3,c1,c2); | ||
| 557 | sqr_add_c2(2,0,c3,c1,c2); | ||
| 558 | stg c3,2*8(%r2) | ||
| 559 | lghi c3,0 | ||
| 560 | |||
| 561 | sqr_add_c2(3,0,c1,c2,c3); | ||
| 562 | sqr_add_c2(2,1,c1,c2,c3); | ||
| 563 | stg c1,3*8(%r2) | ||
| 564 | lghi c1,0 | ||
| 565 | |||
| 566 | sqr_add_c(2,c2,c3,c1); | ||
| 567 | sqr_add_c2(3,1,c2,c3,c1); | ||
| 568 | sqr_add_c2(4,0,c2,c3,c1); | ||
| 569 | stg c2,4*8(%r2) | ||
| 570 | lghi c2,0 | ||
| 571 | |||
| 572 | sqr_add_c2(5,0,c3,c1,c2); | ||
| 573 | sqr_add_c2(4,1,c3,c1,c2); | ||
| 574 | sqr_add_c2(3,2,c3,c1,c2); | ||
| 575 | stg c3,5*8(%r2) | ||
| 576 | lghi c3,0 | ||
| 577 | |||
| 578 | sqr_add_c(3,c1,c2,c3); | ||
| 579 | sqr_add_c2(4,2,c1,c2,c3); | ||
| 580 | sqr_add_c2(5,1,c1,c2,c3); | ||
| 581 | sqr_add_c2(6,0,c1,c2,c3); | ||
| 582 | stg c1,6*8(%r2) | ||
| 583 | lghi c1,0 | ||
| 584 | |||
| 585 | sqr_add_c2(7,0,c2,c3,c1); | ||
| 586 | sqr_add_c2(6,1,c2,c3,c1); | ||
| 587 | sqr_add_c2(5,2,c2,c3,c1); | ||
| 588 | sqr_add_c2(4,3,c2,c3,c1); | ||
| 589 | stg c2,7*8(%r2) | ||
| 590 | lghi c2,0 | ||
| 591 | |||
| 592 | sqr_add_c(4,c3,c1,c2); | ||
| 593 | sqr_add_c2(5,3,c3,c1,c2); | ||
| 594 | sqr_add_c2(6,2,c3,c1,c2); | ||
| 595 | sqr_add_c2(7,1,c3,c1,c2); | ||
| 596 | stg c3,8*8(%r2) | ||
| 597 | lghi c3,0 | ||
| 598 | |||
| 599 | sqr_add_c2(7,2,c1,c2,c3); | ||
| 600 | sqr_add_c2(6,3,c1,c2,c3); | ||
| 601 | sqr_add_c2(5,4,c1,c2,c3); | ||
| 602 | stg c1,9*8(%r2) | ||
| 603 | lghi c1,0 | ||
| 604 | |||
| 605 | sqr_add_c(5,c2,c3,c1); | ||
| 606 | sqr_add_c2(6,4,c2,c3,c1); | ||
| 607 | sqr_add_c2(7,3,c2,c3,c1); | ||
| 608 | stg c2,10*8(%r2) | ||
| 609 | lghi c2,0 | ||
| 610 | |||
| 611 | sqr_add_c2(7,4,c3,c1,c2); | ||
| 612 | sqr_add_c2(6,5,c3,c1,c2); | ||
| 613 | stg c3,11*8(%r2) | ||
| 614 | lghi c3,0 | ||
| 615 | |||
| 616 | sqr_add_c(6,c1,c2,c3); | ||
| 617 | sqr_add_c2(7,5,c1,c2,c3); | ||
| 618 | stg c1,12*8(%r2) | ||
| 619 | lghi c1,0 | ||
| 620 | |||
| 621 | sqr_add_c2(7,6,c2,c3,c1); | ||
| 622 | stg c2,13*8(%r2) | ||
| 623 | lghi c2,0 | ||
| 624 | |||
| 625 | sqr_add_c(7,c3,c1,c2); | ||
| 626 | stg c3,14*8(%r2) | ||
| 627 | stg c1,15*8(%r2) | ||
| 628 | |||
| 629 | lmg %r6,%r8,48(%r15) | ||
| 630 | br %r14 | ||
| 631 | .size bn_sqr_comba8,.-bn_sqr_comba8 | ||
| 632 | |||
| 633 | // void bn_sqr_comba4(BN_ULONG *r2,BN_ULONG *r3); | ||
| 634 | .globl bn_sqr_comba4 | ||
| 635 | .type bn_sqr_comba4,@function | ||
| 636 | .align 4 | ||
| 637 | bn_sqr_comba4: | ||
| 638 | stmg %r6,%r8,48(%r15) | ||
| 639 | |||
| 640 | lghi c1,0 | ||
| 641 | lghi c2,0 | ||
| 642 | lghi c3,0 | ||
| 643 | lghi zero,0 | ||
| 644 | |||
| 645 | sqr_add_c(0,c1,c2,c3); | ||
| 646 | stg c1,0*8(%r2) | ||
| 647 | lghi c1,0 | ||
| 648 | |||
| 649 | sqr_add_c2(1,0,c2,c3,c1); | ||
| 650 | stg c2,1*8(%r2) | ||
| 651 | lghi c2,0 | ||
| 652 | |||
| 653 | sqr_add_c(1,c3,c1,c2); | ||
| 654 | sqr_add_c2(2,0,c3,c1,c2); | ||
| 655 | stg c3,2*8(%r2) | ||
| 656 | lghi c3,0 | ||
| 657 | |||
| 658 | sqr_add_c2(3,0,c1,c2,c3); | ||
| 659 | sqr_add_c2(2,1,c1,c2,c3); | ||
| 660 | stg c1,3*8(%r2) | ||
| 661 | lghi c1,0 | ||
| 662 | |||
| 663 | sqr_add_c(2,c2,c3,c1); | ||
| 664 | sqr_add_c2(3,1,c2,c3,c1); | ||
| 665 | stg c2,4*8(%r2) | ||
| 666 | lghi c2,0 | ||
| 667 | |||
| 668 | sqr_add_c2(3,2,c3,c1,c2); | ||
| 669 | stg c3,5*8(%r2) | ||
| 670 | lghi c3,0 | ||
| 671 | |||
| 672 | sqr_add_c(3,c1,c2,c3); | ||
| 673 | stg c1,6*8(%r2) | ||
| 674 | stg c2,7*8(%r2) | ||
| 675 | |||
| 676 | lmg %r6,%r8,48(%r15) | ||
| 677 | br %r14 | ||
| 678 | .size bn_sqr_comba4,.-bn_sqr_comba4 | ||
diff --git a/src/lib/libssl/src/crypto/bn/asm/sparcv9-mont.pl b/src/lib/libssl/src/crypto/bn/asm/sparcv9-mont.pl new file mode 100644 index 0000000000..b8fb1e8a25 --- /dev/null +++ b/src/lib/libssl/src/crypto/bn/asm/sparcv9-mont.pl | |||
| @@ -0,0 +1,606 @@ | |||
| 1 | #!/usr/bin/env perl | ||
| 2 | |||
| 3 | # ==================================================================== | ||
| 4 | # Written by Andy Polyakov <appro@fy.chalmers.se> for the OpenSSL | ||
| 5 | # project. The module is, however, dual licensed under OpenSSL and | ||
| 6 | # CRYPTOGAMS licenses depending on where you obtain it. For further | ||
| 7 | # details see http://www.openssl.org/~appro/cryptogams/. | ||
| 8 | # ==================================================================== | ||
| 9 | |||
| 10 | # December 2005 | ||
| 11 | # | ||
| 12 | # Pure SPARCv9/8+ and IALU-only bn_mul_mont implementation. The reasons | ||
| 13 | # for undertaken effort are multiple. First of all, UltraSPARC is not | ||
| 14 | # the whole SPARCv9 universe and other VIS-free implementations deserve | ||
| 15 | # optimized code as much. Secondly, newly introduced UltraSPARC T1, | ||
| 16 | # a.k.a. Niagara, has shared FPU and concurrent FPU-intensive pathes, | ||
| 17 | # such as sparcv9a-mont, will simply sink it. Yes, T1 is equipped with | ||
| 18 | # several integrated RSA/DSA accelerator circuits accessible through | ||
| 19 | # kernel driver [only(*)], but having decent user-land software | ||
| 20 | # implementation is important too. Finally, reasons like desire to | ||
| 21 | # experiment with dedicated squaring procedure. Yes, this module | ||
| 22 | # implements one, because it was easiest to draft it in SPARCv9 | ||
| 23 | # instructions... | ||
| 24 | |||
| 25 | # (*) Engine accessing the driver in question is on my TODO list. | ||
| 26 | # For reference, acceleator is estimated to give 6 to 10 times | ||
| 27 | # improvement on single-threaded RSA sign. It should be noted | ||
| 28 | # that 6-10x improvement coefficient does not actually mean | ||
| 29 | # something extraordinary in terms of absolute [single-threaded] | ||
| 30 | # performance, as SPARCv9 instruction set is by all means least | ||
| 31 | # suitable for high performance crypto among other 64 bit | ||
| 32 | # platforms. 6-10x factor simply places T1 in same performance | ||
| 33 | # domain as say AMD64 and IA-64. Improvement of RSA verify don't | ||
| 34 | # appear impressive at all, but it's the sign operation which is | ||
| 35 | # far more critical/interesting. | ||
| 36 | |||
| 37 | # You might notice that inner loops are modulo-scheduled:-) This has | ||
| 38 | # essentially negligible impact on UltraSPARC performance, it's | ||
| 39 | # Fujitsu SPARC64 V users who should notice and hopefully appreciate | ||
| 40 | # the advantage... Currently this module surpasses sparcv9a-mont.pl | ||
| 41 | # by ~20% on UltraSPARC-III and later cores, but recall that sparcv9a | ||
| 42 | # module still have hidden potential [see TODO list there], which is | ||
| 43 | # estimated to be larger than 20%... | ||
| 44 | |||
| 45 | # int bn_mul_mont( | ||
| 46 | $rp="%i0"; # BN_ULONG *rp, | ||
| 47 | $ap="%i1"; # const BN_ULONG *ap, | ||
| 48 | $bp="%i2"; # const BN_ULONG *bp, | ||
| 49 | $np="%i3"; # const BN_ULONG *np, | ||
| 50 | $n0="%i4"; # const BN_ULONG *n0, | ||
| 51 | $num="%i5"; # int num); | ||
| 52 | |||
| 53 | $bits=32; | ||
| 54 | for (@ARGV) { $bits=64 if (/\-m64/ || /\-xarch\=v9/); } | ||
| 55 | if ($bits==64) { $bias=2047; $frame=192; } | ||
| 56 | else { $bias=0; $frame=128; } | ||
| 57 | |||
| 58 | $car0="%o0"; | ||
| 59 | $car1="%o1"; | ||
| 60 | $car2="%o2"; # 1 bit | ||
| 61 | $acc0="%o3"; | ||
| 62 | $acc1="%o4"; | ||
| 63 | $mask="%g1"; # 32 bits, what a waste... | ||
| 64 | $tmp0="%g4"; | ||
| 65 | $tmp1="%g5"; | ||
| 66 | |||
| 67 | $i="%l0"; | ||
| 68 | $j="%l1"; | ||
| 69 | $mul0="%l2"; | ||
| 70 | $mul1="%l3"; | ||
| 71 | $tp="%l4"; | ||
| 72 | $apj="%l5"; | ||
| 73 | $npj="%l6"; | ||
| 74 | $tpj="%l7"; | ||
| 75 | |||
| 76 | $fname="bn_mul_mont_int"; | ||
| 77 | |||
| 78 | $code=<<___; | ||
| 79 | .section ".text",#alloc,#execinstr | ||
| 80 | |||
| 81 | .global $fname | ||
| 82 | .align 32 | ||
| 83 | $fname: | ||
| 84 | cmp %o5,4 ! 128 bits minimum | ||
| 85 | bge,pt %icc,.Lenter | ||
| 86 | sethi %hi(0xffffffff),$mask | ||
| 87 | retl | ||
| 88 | clr %o0 | ||
| 89 | .align 32 | ||
| 90 | .Lenter: | ||
| 91 | save %sp,-$frame,%sp | ||
| 92 | sll $num,2,$num ! num*=4 | ||
| 93 | or $mask,%lo(0xffffffff),$mask | ||
| 94 | ld [$n0],$n0 | ||
| 95 | cmp $ap,$bp | ||
| 96 | and $num,$mask,$num | ||
| 97 | ld [$bp],$mul0 ! bp[0] | ||
| 98 | nop | ||
| 99 | |||
| 100 | add %sp,$bias,%o7 ! real top of stack | ||
| 101 | ld [$ap],$car0 ! ap[0] ! redundant in squaring context | ||
| 102 | sub %o7,$num,%o7 | ||
| 103 | ld [$ap+4],$apj ! ap[1] | ||
| 104 | and %o7,-1024,%o7 | ||
| 105 | ld [$np],$car1 ! np[0] | ||
| 106 | sub %o7,$bias,%sp ! alloca | ||
| 107 | ld [$np+4],$npj ! np[1] | ||
| 108 | be,pt `$bits==32?"%icc":"%xcc"`,.Lbn_sqr_mont | ||
| 109 | mov 12,$j | ||
| 110 | |||
| 111 | mulx $car0,$mul0,$car0 ! ap[0]*bp[0] | ||
| 112 | mulx $apj,$mul0,$tmp0 !prologue! ap[1]*bp[0] | ||
| 113 | and $car0,$mask,$acc0 | ||
| 114 | add %sp,$bias+$frame,$tp | ||
| 115 | ld [$ap+8],$apj !prologue! | ||
| 116 | |||
| 117 | mulx $n0,$acc0,$mul1 ! "t[0]"*n0 | ||
| 118 | and $mul1,$mask,$mul1 | ||
| 119 | |||
| 120 | mulx $car1,$mul1,$car1 ! np[0]*"t[0]"*n0 | ||
| 121 | mulx $npj,$mul1,$acc1 !prologue! np[1]*"t[0]"*n0 | ||
| 122 | srlx $car0,32,$car0 | ||
| 123 | add $acc0,$car1,$car1 | ||
| 124 | ld [$np+8],$npj !prologue! | ||
| 125 | srlx $car1,32,$car1 | ||
| 126 | mov $tmp0,$acc0 !prologue! | ||
| 127 | |||
| 128 | .L1st: | ||
| 129 | mulx $apj,$mul0,$tmp0 | ||
| 130 | mulx $npj,$mul1,$tmp1 | ||
| 131 | add $acc0,$car0,$car0 | ||
| 132 | ld [$ap+$j],$apj ! ap[j] | ||
| 133 | and $car0,$mask,$acc0 | ||
| 134 | add $acc1,$car1,$car1 | ||
| 135 | ld [$np+$j],$npj ! np[j] | ||
| 136 | srlx $car0,32,$car0 | ||
| 137 | add $acc0,$car1,$car1 | ||
| 138 | add $j,4,$j ! j++ | ||
| 139 | mov $tmp0,$acc0 | ||
| 140 | st $car1,[$tp] | ||
| 141 | cmp $j,$num | ||
| 142 | mov $tmp1,$acc1 | ||
| 143 | srlx $car1,32,$car1 | ||
| 144 | bl %icc,.L1st | ||
| 145 | add $tp,4,$tp ! tp++ | ||
| 146 | !.L1st | ||
| 147 | |||
| 148 | mulx $apj,$mul0,$tmp0 !epilogue! | ||
| 149 | mulx $npj,$mul1,$tmp1 | ||
| 150 | add $acc0,$car0,$car0 | ||
| 151 | and $car0,$mask,$acc0 | ||
| 152 | add $acc1,$car1,$car1 | ||
| 153 | srlx $car0,32,$car0 | ||
| 154 | add $acc0,$car1,$car1 | ||
| 155 | st $car1,[$tp] | ||
| 156 | srlx $car1,32,$car1 | ||
| 157 | |||
| 158 | add $tmp0,$car0,$car0 | ||
| 159 | and $car0,$mask,$acc0 | ||
| 160 | add $tmp1,$car1,$car1 | ||
| 161 | srlx $car0,32,$car0 | ||
| 162 | add $acc0,$car1,$car1 | ||
| 163 | st $car1,[$tp+4] | ||
| 164 | srlx $car1,32,$car1 | ||
| 165 | |||
| 166 | add $car0,$car1,$car1 | ||
| 167 | st $car1,[$tp+8] | ||
| 168 | srlx $car1,32,$car2 | ||
| 169 | |||
| 170 | mov 4,$i ! i++ | ||
| 171 | ld [$bp+4],$mul0 ! bp[1] | ||
| 172 | .Louter: | ||
| 173 | add %sp,$bias+$frame,$tp | ||
| 174 | ld [$ap],$car0 ! ap[0] | ||
| 175 | ld [$ap+4],$apj ! ap[1] | ||
| 176 | ld [$np],$car1 ! np[0] | ||
| 177 | ld [$np+4],$npj ! np[1] | ||
| 178 | ld [$tp],$tmp1 ! tp[0] | ||
| 179 | ld [$tp+4],$tpj ! tp[1] | ||
| 180 | mov 12,$j | ||
| 181 | |||
| 182 | mulx $car0,$mul0,$car0 | ||
| 183 | mulx $apj,$mul0,$tmp0 !prologue! | ||
| 184 | add $tmp1,$car0,$car0 | ||
| 185 | ld [$ap+8],$apj !prologue! | ||
| 186 | and $car0,$mask,$acc0 | ||
| 187 | |||
| 188 | mulx $n0,$acc0,$mul1 | ||
| 189 | and $mul1,$mask,$mul1 | ||
| 190 | |||
| 191 | mulx $car1,$mul1,$car1 | ||
| 192 | mulx $npj,$mul1,$acc1 !prologue! | ||
| 193 | srlx $car0,32,$car0 | ||
| 194 | add $acc0,$car1,$car1 | ||
| 195 | ld [$np+8],$npj !prologue! | ||
| 196 | srlx $car1,32,$car1 | ||
| 197 | mov $tmp0,$acc0 !prologue! | ||
| 198 | |||
| 199 | .Linner: | ||
| 200 | mulx $apj,$mul0,$tmp0 | ||
| 201 | mulx $npj,$mul1,$tmp1 | ||
| 202 | add $tpj,$car0,$car0 | ||
| 203 | ld [$ap+$j],$apj ! ap[j] | ||
| 204 | add $acc0,$car0,$car0 | ||
| 205 | add $acc1,$car1,$car1 | ||
| 206 | ld [$np+$j],$npj ! np[j] | ||
| 207 | and $car0,$mask,$acc0 | ||
| 208 | ld [$tp+8],$tpj ! tp[j] | ||
| 209 | srlx $car0,32,$car0 | ||
| 210 | add $acc0,$car1,$car1 | ||
| 211 | add $j,4,$j ! j++ | ||
| 212 | mov $tmp0,$acc0 | ||
| 213 | st $car1,[$tp] ! tp[j-1] | ||
| 214 | srlx $car1,32,$car1 | ||
| 215 | mov $tmp1,$acc1 | ||
| 216 | cmp $j,$num | ||
| 217 | bl %icc,.Linner | ||
| 218 | add $tp,4,$tp ! tp++ | ||
| 219 | !.Linner | ||
| 220 | |||
| 221 | mulx $apj,$mul0,$tmp0 !epilogue! | ||
| 222 | mulx $npj,$mul1,$tmp1 | ||
| 223 | add $tpj,$car0,$car0 | ||
| 224 | add $acc0,$car0,$car0 | ||
| 225 | ld [$tp+8],$tpj ! tp[j] | ||
| 226 | and $car0,$mask,$acc0 | ||
| 227 | add $acc1,$car1,$car1 | ||
| 228 | srlx $car0,32,$car0 | ||
| 229 | add $acc0,$car1,$car1 | ||
| 230 | st $car1,[$tp] ! tp[j-1] | ||
| 231 | srlx $car1,32,$car1 | ||
| 232 | |||
| 233 | add $tpj,$car0,$car0 | ||
| 234 | add $tmp0,$car0,$car0 | ||
| 235 | and $car0,$mask,$acc0 | ||
| 236 | add $tmp1,$car1,$car1 | ||
| 237 | add $acc0,$car1,$car1 | ||
| 238 | st $car1,[$tp+4] ! tp[j-1] | ||
| 239 | srlx $car0,32,$car0 | ||
| 240 | add $i,4,$i ! i++ | ||
| 241 | srlx $car1,32,$car1 | ||
| 242 | |||
| 243 | add $car0,$car1,$car1 | ||
| 244 | cmp $i,$num | ||
| 245 | add $car2,$car1,$car1 | ||
| 246 | st $car1,[$tp+8] | ||
| 247 | |||
| 248 | srlx $car1,32,$car2 | ||
| 249 | bl,a %icc,.Louter | ||
| 250 | ld [$bp+$i],$mul0 ! bp[i] | ||
| 251 | !.Louter | ||
| 252 | |||
| 253 | add $tp,12,$tp | ||
| 254 | |||
| 255 | .Ltail: | ||
| 256 | add $np,$num,$np | ||
| 257 | add $rp,$num,$rp | ||
| 258 | mov $tp,$ap | ||
| 259 | sub %g0,$num,%o7 ! k=-num | ||
| 260 | ba .Lsub | ||
| 261 | subcc %g0,%g0,%g0 ! clear %icc.c | ||
| 262 | .align 16 | ||
| 263 | .Lsub: | ||
| 264 | ld [$tp+%o7],%o0 | ||
| 265 | ld [$np+%o7],%o1 | ||
| 266 | subccc %o0,%o1,%o1 ! tp[j]-np[j] | ||
| 267 | add $rp,%o7,$i | ||
| 268 | add %o7,4,%o7 | ||
| 269 | brnz %o7,.Lsub | ||
| 270 | st %o1,[$i] | ||
| 271 | subc $car2,0,$car2 ! handle upmost overflow bit | ||
| 272 | and $tp,$car2,$ap | ||
| 273 | andn $rp,$car2,$np | ||
| 274 | or $ap,$np,$ap | ||
| 275 | sub %g0,$num,%o7 | ||
| 276 | |||
| 277 | .Lcopy: | ||
| 278 | ld [$ap+%o7],%o0 ! copy or in-place refresh | ||
| 279 | st %g0,[$tp+%o7] ! zap tp | ||
| 280 | st %o0,[$rp+%o7] | ||
| 281 | add %o7,4,%o7 | ||
| 282 | brnz %o7,.Lcopy | ||
| 283 | nop | ||
| 284 | mov 1,%i0 | ||
| 285 | ret | ||
| 286 | restore | ||
| 287 | ___ | ||
| 288 | |||
| 289 | ######## | ||
| 290 | ######## .Lbn_sqr_mont gives up to 20% *overall* improvement over | ||
| 291 | ######## code without following dedicated squaring procedure. | ||
| 292 | ######## | ||
| 293 | $sbit="%i2"; # re-use $bp! | ||
| 294 | |||
| 295 | $code.=<<___; | ||
| 296 | .align 32 | ||
| 297 | .Lbn_sqr_mont: | ||
| 298 | mulx $mul0,$mul0,$car0 ! ap[0]*ap[0] | ||
| 299 | mulx $apj,$mul0,$tmp0 !prologue! | ||
| 300 | and $car0,$mask,$acc0 | ||
| 301 | add %sp,$bias+$frame,$tp | ||
| 302 | ld [$ap+8],$apj !prologue! | ||
| 303 | |||
| 304 | mulx $n0,$acc0,$mul1 ! "t[0]"*n0 | ||
| 305 | srlx $car0,32,$car0 | ||
| 306 | and $mul1,$mask,$mul1 | ||
| 307 | |||
| 308 | mulx $car1,$mul1,$car1 ! np[0]*"t[0]"*n0 | ||
| 309 | mulx $npj,$mul1,$acc1 !prologue! | ||
| 310 | and $car0,1,$sbit | ||
| 311 | ld [$np+8],$npj !prologue! | ||
| 312 | srlx $car0,1,$car0 | ||
| 313 | add $acc0,$car1,$car1 | ||
| 314 | srlx $car1,32,$car1 | ||
| 315 | mov $tmp0,$acc0 !prologue! | ||
| 316 | |||
| 317 | .Lsqr_1st: | ||
| 318 | mulx $apj,$mul0,$tmp0 | ||
| 319 | mulx $npj,$mul1,$tmp1 | ||
| 320 | add $acc0,$car0,$car0 ! ap[j]*a0+c0 | ||
| 321 | add $acc1,$car1,$car1 | ||
| 322 | ld [$ap+$j],$apj ! ap[j] | ||
| 323 | and $car0,$mask,$acc0 | ||
| 324 | ld [$np+$j],$npj ! np[j] | ||
| 325 | srlx $car0,32,$car0 | ||
| 326 | add $acc0,$acc0,$acc0 | ||
| 327 | or $sbit,$acc0,$acc0 | ||
| 328 | mov $tmp1,$acc1 | ||
| 329 | srlx $acc0,32,$sbit | ||
| 330 | add $j,4,$j ! j++ | ||
| 331 | and $acc0,$mask,$acc0 | ||
| 332 | cmp $j,$num | ||
| 333 | add $acc0,$car1,$car1 | ||
| 334 | st $car1,[$tp] | ||
| 335 | mov $tmp0,$acc0 | ||
| 336 | srlx $car1,32,$car1 | ||
| 337 | bl %icc,.Lsqr_1st | ||
| 338 | add $tp,4,$tp ! tp++ | ||
| 339 | !.Lsqr_1st | ||
| 340 | |||
| 341 | mulx $apj,$mul0,$tmp0 ! epilogue | ||
| 342 | mulx $npj,$mul1,$tmp1 | ||
| 343 | add $acc0,$car0,$car0 ! ap[j]*a0+c0 | ||
| 344 | add $acc1,$car1,$car1 | ||
| 345 | and $car0,$mask,$acc0 | ||
| 346 | srlx $car0,32,$car0 | ||
| 347 | add $acc0,$acc0,$acc0 | ||
| 348 | or $sbit,$acc0,$acc0 | ||
| 349 | srlx $acc0,32,$sbit | ||
| 350 | and $acc0,$mask,$acc0 | ||
| 351 | add $acc0,$car1,$car1 | ||
| 352 | st $car1,[$tp] | ||
| 353 | srlx $car1,32,$car1 | ||
| 354 | |||
| 355 | add $tmp0,$car0,$car0 ! ap[j]*a0+c0 | ||
| 356 | add $tmp1,$car1,$car1 | ||
| 357 | and $car0,$mask,$acc0 | ||
| 358 | srlx $car0,32,$car0 | ||
| 359 | add $acc0,$acc0,$acc0 | ||
| 360 | or $sbit,$acc0,$acc0 | ||
| 361 | srlx $acc0,32,$sbit | ||
| 362 | and $acc0,$mask,$acc0 | ||
| 363 | add $acc0,$car1,$car1 | ||
| 364 | st $car1,[$tp+4] | ||
| 365 | srlx $car1,32,$car1 | ||
| 366 | |||
| 367 | add $car0,$car0,$car0 | ||
| 368 | or $sbit,$car0,$car0 | ||
| 369 | add $car0,$car1,$car1 | ||
| 370 | st $car1,[$tp+8] | ||
| 371 | srlx $car1,32,$car2 | ||
| 372 | |||
| 373 | ld [%sp+$bias+$frame],$tmp0 ! tp[0] | ||
| 374 | ld [%sp+$bias+$frame+4],$tmp1 ! tp[1] | ||
| 375 | ld [%sp+$bias+$frame+8],$tpj ! tp[2] | ||
| 376 | ld [$ap+4],$mul0 ! ap[1] | ||
| 377 | ld [$ap+8],$apj ! ap[2] | ||
| 378 | ld [$np],$car1 ! np[0] | ||
| 379 | ld [$np+4],$npj ! np[1] | ||
| 380 | mulx $n0,$tmp0,$mul1 | ||
| 381 | |||
| 382 | mulx $mul0,$mul0,$car0 | ||
| 383 | and $mul1,$mask,$mul1 | ||
| 384 | |||
| 385 | mulx $car1,$mul1,$car1 | ||
| 386 | mulx $npj,$mul1,$acc1 | ||
| 387 | add $tmp0,$car1,$car1 | ||
| 388 | and $car0,$mask,$acc0 | ||
| 389 | ld [$np+8],$npj ! np[2] | ||
| 390 | srlx $car1,32,$car1 | ||
| 391 | add $tmp1,$car1,$car1 | ||
| 392 | srlx $car0,32,$car0 | ||
| 393 | add $acc0,$car1,$car1 | ||
| 394 | and $car0,1,$sbit | ||
| 395 | add $acc1,$car1,$car1 | ||
| 396 | srlx $car0,1,$car0 | ||
| 397 | mov 12,$j | ||
| 398 | st $car1,[%sp+$bias+$frame] ! tp[0]= | ||
| 399 | srlx $car1,32,$car1 | ||
| 400 | add %sp,$bias+$frame+4,$tp | ||
| 401 | |||
| 402 | .Lsqr_2nd: | ||
| 403 | mulx $apj,$mul0,$acc0 | ||
| 404 | mulx $npj,$mul1,$acc1 | ||
| 405 | add $acc0,$car0,$car0 | ||
| 406 | add $tpj,$car1,$car1 | ||
| 407 | ld [$ap+$j],$apj ! ap[j] | ||
| 408 | and $car0,$mask,$acc0 | ||
| 409 | ld [$np+$j],$npj ! np[j] | ||
| 410 | srlx $car0,32,$car0 | ||
| 411 | add $acc1,$car1,$car1 | ||
| 412 | ld [$tp+8],$tpj ! tp[j] | ||
| 413 | add $acc0,$acc0,$acc0 | ||
| 414 | add $j,4,$j ! j++ | ||
| 415 | or $sbit,$acc0,$acc0 | ||
| 416 | srlx $acc0,32,$sbit | ||
| 417 | and $acc0,$mask,$acc0 | ||
| 418 | cmp $j,$num | ||
| 419 | add $acc0,$car1,$car1 | ||
| 420 | st $car1,[$tp] ! tp[j-1] | ||
| 421 | srlx $car1,32,$car1 | ||
| 422 | bl %icc,.Lsqr_2nd | ||
| 423 | add $tp,4,$tp ! tp++ | ||
| 424 | !.Lsqr_2nd | ||
| 425 | |||
| 426 | mulx $apj,$mul0,$acc0 | ||
| 427 | mulx $npj,$mul1,$acc1 | ||
| 428 | add $acc0,$car0,$car0 | ||
| 429 | add $tpj,$car1,$car1 | ||
| 430 | and $car0,$mask,$acc0 | ||
| 431 | srlx $car0,32,$car0 | ||
| 432 | add $acc1,$car1,$car1 | ||
| 433 | add $acc0,$acc0,$acc0 | ||
| 434 | or $sbit,$acc0,$acc0 | ||
| 435 | srlx $acc0,32,$sbit | ||
| 436 | and $acc0,$mask,$acc0 | ||
| 437 | add $acc0,$car1,$car1 | ||
| 438 | st $car1,[$tp] ! tp[j-1] | ||
| 439 | srlx $car1,32,$car1 | ||
| 440 | |||
| 441 | add $car0,$car0,$car0 | ||
| 442 | or $sbit,$car0,$car0 | ||
| 443 | add $car0,$car1,$car1 | ||
| 444 | add $car2,$car1,$car1 | ||
| 445 | st $car1,[$tp+4] | ||
| 446 | srlx $car1,32,$car2 | ||
| 447 | |||
| 448 | ld [%sp+$bias+$frame],$tmp1 ! tp[0] | ||
| 449 | ld [%sp+$bias+$frame+4],$tpj ! tp[1] | ||
| 450 | ld [$ap+8],$mul0 ! ap[2] | ||
| 451 | ld [$np],$car1 ! np[0] | ||
| 452 | ld [$np+4],$npj ! np[1] | ||
| 453 | mulx $n0,$tmp1,$mul1 | ||
| 454 | and $mul1,$mask,$mul1 | ||
| 455 | mov 8,$i | ||
| 456 | |||
| 457 | mulx $mul0,$mul0,$car0 | ||
| 458 | mulx $car1,$mul1,$car1 | ||
| 459 | and $car0,$mask,$acc0 | ||
| 460 | add $tmp1,$car1,$car1 | ||
| 461 | srlx $car0,32,$car0 | ||
| 462 | add %sp,$bias+$frame,$tp | ||
| 463 | srlx $car1,32,$car1 | ||
| 464 | and $car0,1,$sbit | ||
| 465 | srlx $car0,1,$car0 | ||
| 466 | mov 4,$j | ||
| 467 | |||
| 468 | .Lsqr_outer: | ||
| 469 | .Lsqr_inner1: | ||
| 470 | mulx $npj,$mul1,$acc1 | ||
| 471 | add $tpj,$car1,$car1 | ||
| 472 | add $j,4,$j | ||
| 473 | ld [$tp+8],$tpj | ||
| 474 | cmp $j,$i | ||
| 475 | add $acc1,$car1,$car1 | ||
| 476 | ld [$np+$j],$npj | ||
| 477 | st $car1,[$tp] | ||
| 478 | srlx $car1,32,$car1 | ||
| 479 | bl %icc,.Lsqr_inner1 | ||
| 480 | add $tp,4,$tp | ||
| 481 | !.Lsqr_inner1 | ||
| 482 | |||
| 483 | add $j,4,$j | ||
| 484 | ld [$ap+$j],$apj ! ap[j] | ||
| 485 | mulx $npj,$mul1,$acc1 | ||
| 486 | add $tpj,$car1,$car1 | ||
| 487 | ld [$np+$j],$npj ! np[j] | ||
| 488 | add $acc0,$car1,$car1 | ||
| 489 | ld [$tp+8],$tpj ! tp[j] | ||
| 490 | add $acc1,$car1,$car1 | ||
| 491 | st $car1,[$tp] | ||
| 492 | srlx $car1,32,$car1 | ||
| 493 | |||
| 494 | add $j,4,$j | ||
| 495 | cmp $j,$num | ||
| 496 | be,pn %icc,.Lsqr_no_inner2 | ||
| 497 | add $tp,4,$tp | ||
| 498 | |||
| 499 | .Lsqr_inner2: | ||
| 500 | mulx $apj,$mul0,$acc0 | ||
| 501 | mulx $npj,$mul1,$acc1 | ||
| 502 | add $tpj,$car1,$car1 | ||
| 503 | add $acc0,$car0,$car0 | ||
| 504 | ld [$ap+$j],$apj ! ap[j] | ||
| 505 | and $car0,$mask,$acc0 | ||
| 506 | ld [$np+$j],$npj ! np[j] | ||
| 507 | srlx $car0,32,$car0 | ||
| 508 | add $acc0,$acc0,$acc0 | ||
| 509 | ld [$tp+8],$tpj ! tp[j] | ||
| 510 | or $sbit,$acc0,$acc0 | ||
| 511 | add $j,4,$j ! j++ | ||
| 512 | srlx $acc0,32,$sbit | ||
| 513 | and $acc0,$mask,$acc0 | ||
| 514 | cmp $j,$num | ||
| 515 | add $acc0,$car1,$car1 | ||
| 516 | add $acc1,$car1,$car1 | ||
| 517 | st $car1,[$tp] ! tp[j-1] | ||
| 518 | srlx $car1,32,$car1 | ||
| 519 | bl %icc,.Lsqr_inner2 | ||
| 520 | add $tp,4,$tp ! tp++ | ||
| 521 | |||
| 522 | .Lsqr_no_inner2: | ||
| 523 | mulx $apj,$mul0,$acc0 | ||
| 524 | mulx $npj,$mul1,$acc1 | ||
| 525 | add $tpj,$car1,$car1 | ||
| 526 | add $acc0,$car0,$car0 | ||
| 527 | and $car0,$mask,$acc0 | ||
| 528 | srlx $car0,32,$car0 | ||
| 529 | add $acc0,$acc0,$acc0 | ||
| 530 | or $sbit,$acc0,$acc0 | ||
| 531 | srlx $acc0,32,$sbit | ||
| 532 | and $acc0,$mask,$acc0 | ||
| 533 | add $acc0,$car1,$car1 | ||
| 534 | add $acc1,$car1,$car1 | ||
| 535 | st $car1,[$tp] ! tp[j-1] | ||
| 536 | srlx $car1,32,$car1 | ||
| 537 | |||
| 538 | add $car0,$car0,$car0 | ||
| 539 | or $sbit,$car0,$car0 | ||
| 540 | add $car0,$car1,$car1 | ||
| 541 | add $car2,$car1,$car1 | ||
| 542 | st $car1,[$tp+4] | ||
| 543 | srlx $car1,32,$car2 | ||
| 544 | |||
| 545 | add $i,4,$i ! i++ | ||
| 546 | ld [%sp+$bias+$frame],$tmp1 ! tp[0] | ||
| 547 | ld [%sp+$bias+$frame+4],$tpj ! tp[1] | ||
| 548 | ld [$ap+$i],$mul0 ! ap[j] | ||
| 549 | ld [$np],$car1 ! np[0] | ||
| 550 | ld [$np+4],$npj ! np[1] | ||
| 551 | mulx $n0,$tmp1,$mul1 | ||
| 552 | and $mul1,$mask,$mul1 | ||
| 553 | add $i,4,$tmp0 | ||
| 554 | |||
| 555 | mulx $mul0,$mul0,$car0 | ||
| 556 | mulx $car1,$mul1,$car1 | ||
| 557 | and $car0,$mask,$acc0 | ||
| 558 | add $tmp1,$car1,$car1 | ||
| 559 | srlx $car0,32,$car0 | ||
| 560 | add %sp,$bias+$frame,$tp | ||
| 561 | srlx $car1,32,$car1 | ||
| 562 | and $car0,1,$sbit | ||
| 563 | srlx $car0,1,$car0 | ||
| 564 | |||
| 565 | cmp $tmp0,$num ! i<num-1 | ||
| 566 | bl %icc,.Lsqr_outer | ||
| 567 | mov 4,$j | ||
| 568 | |||
| 569 | .Lsqr_last: | ||
| 570 | mulx $npj,$mul1,$acc1 | ||
| 571 | add $tpj,$car1,$car1 | ||
| 572 | add $j,4,$j | ||
| 573 | ld [$tp+8],$tpj | ||
| 574 | cmp $j,$i | ||
| 575 | add $acc1,$car1,$car1 | ||
| 576 | ld [$np+$j],$npj | ||
| 577 | st $car1,[$tp] | ||
| 578 | srlx $car1,32,$car1 | ||
| 579 | bl %icc,.Lsqr_last | ||
| 580 | add $tp,4,$tp | ||
| 581 | !.Lsqr_last | ||
| 582 | |||
| 583 | mulx $npj,$mul1,$acc1 | ||
| 584 | add $tpj,$car1,$car1 | ||
| 585 | add $acc0,$car1,$car1 | ||
| 586 | add $acc1,$car1,$car1 | ||
| 587 | st $car1,[$tp] | ||
| 588 | srlx $car1,32,$car1 | ||
| 589 | |||
| 590 | add $car0,$car0,$car0 ! recover $car0 | ||
| 591 | or $sbit,$car0,$car0 | ||
| 592 | add $car0,$car1,$car1 | ||
| 593 | add $car2,$car1,$car1 | ||
| 594 | st $car1,[$tp+4] | ||
| 595 | srlx $car1,32,$car2 | ||
| 596 | |||
| 597 | ba .Ltail | ||
| 598 | add $tp,8,$tp | ||
| 599 | .type $fname,#function | ||
| 600 | .size $fname,(.-$fname) | ||
| 601 | .asciz "Montgomery Multipltication for SPARCv9, CRYPTOGAMS by <appro\@openssl.org>" | ||
| 602 | .align 32 | ||
| 603 | ___ | ||
| 604 | $code =~ s/\`([^\`]*)\`/eval($1)/gem; | ||
| 605 | print $code; | ||
| 606 | close STDOUT; | ||
diff --git a/src/lib/libssl/src/crypto/bn/asm/sparcv9a-mont.pl b/src/lib/libssl/src/crypto/bn/asm/sparcv9a-mont.pl new file mode 100755 index 0000000000..a14205f2f0 --- /dev/null +++ b/src/lib/libssl/src/crypto/bn/asm/sparcv9a-mont.pl | |||
| @@ -0,0 +1,882 @@ | |||
| 1 | #!/usr/bin/env perl | ||
| 2 | |||
| 3 | # ==================================================================== | ||
| 4 | # Written by Andy Polyakov <appro@fy.chalmers.se> for the OpenSSL | ||
| 5 | # project. The module is, however, dual licensed under OpenSSL and | ||
| 6 | # CRYPTOGAMS licenses depending on where you obtain it. For further | ||
| 7 | # details see http://www.openssl.org/~appro/cryptogams/. | ||
| 8 | # ==================================================================== | ||
| 9 | |||
| 10 | # October 2005 | ||
| 11 | # | ||
| 12 | # "Teaser" Montgomery multiplication module for UltraSPARC. Why FPU? | ||
| 13 | # Because unlike integer multiplier, which simply stalls whole CPU, | ||
| 14 | # FPU is fully pipelined and can effectively emit 48 bit partial | ||
| 15 | # product every cycle. Why not blended SPARC v9? One can argue that | ||
| 16 | # making this module dependent on UltraSPARC VIS extension limits its | ||
| 17 | # binary compatibility. Well yes, it does exclude SPARC64 prior-V(!) | ||
| 18 | # implementations from compatibility matrix. But the rest, whole Sun | ||
| 19 | # UltraSPARC family and brand new Fujitsu's SPARC64 V, all support | ||
| 20 | # VIS extension instructions used in this module. This is considered | ||
| 21 | # good enough to not care about HAL SPARC64 users [if any] who have | ||
| 22 | # integer-only pure SPARCv9 module to "fall down" to. | ||
| 23 | |||
| 24 | # USI&II cores currently exhibit uniform 2x improvement [over pre- | ||
| 25 | # bn_mul_mont codebase] for all key lengths and benchmarks. On USIII | ||
| 26 | # performance improves few percents for shorter keys and worsens few | ||
| 27 | # percents for longer keys. This is because USIII integer multiplier | ||
| 28 | # is >3x faster than USI&II one, which is harder to match [but see | ||
| 29 | # TODO list below]. It should also be noted that SPARC64 V features | ||
| 30 | # out-of-order execution, which *might* mean that integer multiplier | ||
| 31 | # is pipelined, which in turn *might* be impossible to match... On | ||
| 32 | # additional note, SPARC64 V implements FP Multiply-Add instruction, | ||
| 33 | # which is perfectly usable in this context... In other words, as far | ||
| 34 | # as Fujitsu SPARC64 V goes, talk to the author:-) | ||
| 35 | |||
| 36 | # The implementation implies following "non-natural" limitations on | ||
| 37 | # input arguments: | ||
| 38 | # - num may not be less than 4; | ||
| 39 | # - num has to be even; | ||
| 40 | # Failure to meet either condition has no fatal effects, simply | ||
| 41 | # doesn't give any performance gain. | ||
| 42 | |||
| 43 | # TODO: | ||
| 44 | # - modulo-schedule inner loop for better performance (on in-order | ||
| 45 | # execution core such as UltraSPARC this shall result in further | ||
| 46 | # noticeable(!) improvement); | ||
| 47 | # - dedicated squaring procedure[?]; | ||
| 48 | |||
| 49 | ###################################################################### | ||
| 50 | # November 2006 | ||
| 51 | # | ||
| 52 | # Modulo-scheduled inner loops allow to interleave floating point and | ||
| 53 | # integer instructions and minimize Read-After-Write penalties. This | ||
| 54 | # results in *further* 20-50% perfromance improvement [depending on | ||
| 55 | # key length, more for longer keys] on USI&II cores and 30-80% - on | ||
| 56 | # USIII&IV. | ||
| 57 | |||
| 58 | $fname="bn_mul_mont_fpu"; | ||
| 59 | $bits=32; | ||
| 60 | for (@ARGV) { $bits=64 if (/\-m64/ || /\-xarch\=v9/); } | ||
| 61 | |||
| 62 | if ($bits==64) { | ||
| 63 | $bias=2047; | ||
| 64 | $frame=192; | ||
| 65 | } else { | ||
| 66 | $bias=0; | ||
| 67 | $frame=128; # 96 rounded up to largest known cache-line | ||
| 68 | } | ||
| 69 | $locals=64; | ||
| 70 | |||
| 71 | # In order to provide for 32-/64-bit ABI duality, I keep integers wider | ||
| 72 | # than 32 bit in %g1-%g4 and %o0-%o5. %l0-%l7 and %i0-%i5 are used | ||
| 73 | # exclusively for pointers, indexes and other small values... | ||
| 74 | # int bn_mul_mont( | ||
| 75 | $rp="%i0"; # BN_ULONG *rp, | ||
| 76 | $ap="%i1"; # const BN_ULONG *ap, | ||
| 77 | $bp="%i2"; # const BN_ULONG *bp, | ||
| 78 | $np="%i3"; # const BN_ULONG *np, | ||
| 79 | $n0="%i4"; # const BN_ULONG *n0, | ||
| 80 | $num="%i5"; # int num); | ||
| 81 | |||
| 82 | $tp="%l0"; # t[num] | ||
| 83 | $ap_l="%l1"; # a[num],n[num] are smashed to 32-bit words and saved | ||
| 84 | $ap_h="%l2"; # to these four vectors as double-precision FP values. | ||
| 85 | $np_l="%l3"; # This way a bunch of fxtods are eliminated in second | ||
| 86 | $np_h="%l4"; # loop and L1-cache aliasing is minimized... | ||
| 87 | $i="%l5"; | ||
| 88 | $j="%l6"; | ||
| 89 | $mask="%l7"; # 16-bit mask, 0xffff | ||
| 90 | |||
| 91 | $n0="%g4"; # reassigned(!) to "64-bit" register | ||
| 92 | $carry="%i4"; # %i4 reused(!) for a carry bit | ||
| 93 | |||
| 94 | # FP register naming chart | ||
| 95 | # | ||
| 96 | # ..HILO | ||
| 97 | # dcba | ||
| 98 | # -------- | ||
| 99 | # LOa | ||
| 100 | # LOb | ||
| 101 | # LOc | ||
| 102 | # LOd | ||
| 103 | # HIa | ||
| 104 | # HIb | ||
| 105 | # HIc | ||
| 106 | # HId | ||
| 107 | # ..a | ||
| 108 | # ..b | ||
| 109 | $ba="%f0"; $bb="%f2"; $bc="%f4"; $bd="%f6"; | ||
| 110 | $na="%f8"; $nb="%f10"; $nc="%f12"; $nd="%f14"; | ||
| 111 | $alo="%f16"; $alo_="%f17"; $ahi="%f18"; $ahi_="%f19"; | ||
| 112 | $nlo="%f20"; $nlo_="%f21"; $nhi="%f22"; $nhi_="%f23"; | ||
| 113 | |||
| 114 | $dota="%f24"; $dotb="%f26"; | ||
| 115 | |||
| 116 | $aloa="%f32"; $alob="%f34"; $aloc="%f36"; $alod="%f38"; | ||
| 117 | $ahia="%f40"; $ahib="%f42"; $ahic="%f44"; $ahid="%f46"; | ||
| 118 | $nloa="%f48"; $nlob="%f50"; $nloc="%f52"; $nlod="%f54"; | ||
| 119 | $nhia="%f56"; $nhib="%f58"; $nhic="%f60"; $nhid="%f62"; | ||
| 120 | |||
| 121 | $ASI_FL16_P=0xD2; # magic ASI value to engage 16-bit FP load | ||
| 122 | |||
| 123 | $code=<<___; | ||
| 124 | .section ".text",#alloc,#execinstr | ||
| 125 | |||
| 126 | .global $fname | ||
| 127 | .align 32 | ||
| 128 | $fname: | ||
| 129 | save %sp,-$frame-$locals,%sp | ||
| 130 | |||
| 131 | cmp $num,4 | ||
| 132 | bl,a,pn %icc,.Lret | ||
| 133 | clr %i0 | ||
| 134 | andcc $num,1,%g0 ! $num has to be even... | ||
| 135 | bnz,a,pn %icc,.Lret | ||
| 136 | clr %i0 ! signal "unsupported input value" | ||
| 137 | |||
| 138 | srl $num,1,$num | ||
| 139 | sethi %hi(0xffff),$mask | ||
| 140 | ld [%i4+0],$n0 ! $n0 reassigned, remember? | ||
| 141 | or $mask,%lo(0xffff),$mask | ||
| 142 | ld [%i4+4],%o0 | ||
| 143 | sllx %o0,32,%o0 | ||
| 144 | or %o0,$n0,$n0 ! $n0=n0[1].n0[0] | ||
| 145 | |||
| 146 | sll $num,3,$num ! num*=8 | ||
| 147 | |||
| 148 | add %sp,$bias,%o0 ! real top of stack | ||
| 149 | sll $num,2,%o1 | ||
| 150 | add %o1,$num,%o1 ! %o1=num*5 | ||
| 151 | sub %o0,%o1,%o0 | ||
| 152 | and %o0,-2048,%o0 ! optimize TLB utilization | ||
| 153 | sub %o0,$bias,%sp ! alloca(5*num*8) | ||
| 154 | |||
| 155 | rd %asi,%o7 ! save %asi | ||
| 156 | add %sp,$bias+$frame+$locals,$tp | ||
| 157 | add $tp,$num,$ap_l | ||
| 158 | add $ap_l,$num,$ap_l ! [an]p_[lh] point at the vectors' ends ! | ||
| 159 | add $ap_l,$num,$ap_h | ||
| 160 | add $ap_h,$num,$np_l | ||
| 161 | add $np_l,$num,$np_h | ||
| 162 | |||
| 163 | wr %g0,$ASI_FL16_P,%asi ! setup %asi for 16-bit FP loads | ||
| 164 | |||
| 165 | add $rp,$num,$rp ! readjust input pointers to point | ||
| 166 | add $ap,$num,$ap ! at the ends too... | ||
| 167 | add $bp,$num,$bp | ||
| 168 | add $np,$num,$np | ||
| 169 | |||
| 170 | stx %o7,[%sp+$bias+$frame+48] ! save %asi | ||
| 171 | |||
| 172 | sub %g0,$num,$i ! i=-num | ||
| 173 | sub %g0,$num,$j ! j=-num | ||
| 174 | |||
| 175 | add $ap,$j,%o3 | ||
| 176 | add $bp,$i,%o4 | ||
| 177 | |||
| 178 | ld [%o3+4],%g1 ! bp[0] | ||
| 179 | ld [%o3+0],%o0 | ||
| 180 | ld [%o4+4],%g5 ! ap[0] | ||
| 181 | sllx %g1,32,%g1 | ||
| 182 | ld [%o4+0],%o1 | ||
| 183 | sllx %g5,32,%g5 | ||
| 184 | or %g1,%o0,%o0 | ||
| 185 | or %g5,%o1,%o1 | ||
| 186 | |||
| 187 | add $np,$j,%o5 | ||
| 188 | |||
| 189 | mulx %o1,%o0,%o0 ! ap[0]*bp[0] | ||
| 190 | mulx $n0,%o0,%o0 ! ap[0]*bp[0]*n0 | ||
| 191 | stx %o0,[%sp+$bias+$frame+0] | ||
| 192 | |||
| 193 | ld [%o3+0],$alo_ ! load a[j] as pair of 32-bit words | ||
| 194 | fzeros $alo | ||
| 195 | ld [%o3+4],$ahi_ | ||
| 196 | fzeros $ahi | ||
| 197 | ld [%o5+0],$nlo_ ! load n[j] as pair of 32-bit words | ||
| 198 | fzeros $nlo | ||
| 199 | ld [%o5+4],$nhi_ | ||
| 200 | fzeros $nhi | ||
| 201 | |||
| 202 | ! transfer b[i] to FPU as 4x16-bit values | ||
| 203 | ldda [%o4+2]%asi,$ba | ||
| 204 | fxtod $alo,$alo | ||
| 205 | ldda [%o4+0]%asi,$bb | ||
| 206 | fxtod $ahi,$ahi | ||
| 207 | ldda [%o4+6]%asi,$bc | ||
| 208 | fxtod $nlo,$nlo | ||
| 209 | ldda [%o4+4]%asi,$bd | ||
| 210 | fxtod $nhi,$nhi | ||
| 211 | |||
| 212 | ! transfer ap[0]*b[0]*n0 to FPU as 4x16-bit values | ||
| 213 | ldda [%sp+$bias+$frame+6]%asi,$na | ||
| 214 | fxtod $ba,$ba | ||
| 215 | ldda [%sp+$bias+$frame+4]%asi,$nb | ||
| 216 | fxtod $bb,$bb | ||
| 217 | ldda [%sp+$bias+$frame+2]%asi,$nc | ||
| 218 | fxtod $bc,$bc | ||
| 219 | ldda [%sp+$bias+$frame+0]%asi,$nd | ||
| 220 | fxtod $bd,$bd | ||
| 221 | |||
| 222 | std $alo,[$ap_l+$j] ! save smashed ap[j] in double format | ||
| 223 | fxtod $na,$na | ||
| 224 | std $ahi,[$ap_h+$j] | ||
| 225 | fxtod $nb,$nb | ||
| 226 | std $nlo,[$np_l+$j] ! save smashed np[j] in double format | ||
| 227 | fxtod $nc,$nc | ||
| 228 | std $nhi,[$np_h+$j] | ||
| 229 | fxtod $nd,$nd | ||
| 230 | |||
| 231 | fmuld $alo,$ba,$aloa | ||
| 232 | fmuld $nlo,$na,$nloa | ||
| 233 | fmuld $alo,$bb,$alob | ||
| 234 | fmuld $nlo,$nb,$nlob | ||
| 235 | fmuld $alo,$bc,$aloc | ||
| 236 | faddd $aloa,$nloa,$nloa | ||
| 237 | fmuld $nlo,$nc,$nloc | ||
| 238 | fmuld $alo,$bd,$alod | ||
| 239 | faddd $alob,$nlob,$nlob | ||
| 240 | fmuld $nlo,$nd,$nlod | ||
| 241 | fmuld $ahi,$ba,$ahia | ||
| 242 | faddd $aloc,$nloc,$nloc | ||
| 243 | fmuld $nhi,$na,$nhia | ||
| 244 | fmuld $ahi,$bb,$ahib | ||
| 245 | faddd $alod,$nlod,$nlod | ||
| 246 | fmuld $nhi,$nb,$nhib | ||
| 247 | fmuld $ahi,$bc,$ahic | ||
| 248 | faddd $ahia,$nhia,$nhia | ||
| 249 | fmuld $nhi,$nc,$nhic | ||
| 250 | fmuld $ahi,$bd,$ahid | ||
| 251 | faddd $ahib,$nhib,$nhib | ||
| 252 | fmuld $nhi,$nd,$nhid | ||
| 253 | |||
| 254 | faddd $ahic,$nhic,$dota ! $nhic | ||
| 255 | faddd $ahid,$nhid,$dotb ! $nhid | ||
| 256 | |||
| 257 | faddd $nloc,$nhia,$nloc | ||
| 258 | faddd $nlod,$nhib,$nlod | ||
| 259 | |||
| 260 | fdtox $nloa,$nloa | ||
| 261 | fdtox $nlob,$nlob | ||
| 262 | fdtox $nloc,$nloc | ||
| 263 | fdtox $nlod,$nlod | ||
| 264 | |||
| 265 | std $nloa,[%sp+$bias+$frame+0] | ||
| 266 | add $j,8,$j | ||
| 267 | std $nlob,[%sp+$bias+$frame+8] | ||
| 268 | add $ap,$j,%o4 | ||
| 269 | std $nloc,[%sp+$bias+$frame+16] | ||
| 270 | add $np,$j,%o5 | ||
| 271 | std $nlod,[%sp+$bias+$frame+24] | ||
| 272 | |||
| 273 | ld [%o4+0],$alo_ ! load a[j] as pair of 32-bit words | ||
| 274 | fzeros $alo | ||
| 275 | ld [%o4+4],$ahi_ | ||
| 276 | fzeros $ahi | ||
| 277 | ld [%o5+0],$nlo_ ! load n[j] as pair of 32-bit words | ||
| 278 | fzeros $nlo | ||
| 279 | ld [%o5+4],$nhi_ | ||
| 280 | fzeros $nhi | ||
| 281 | |||
| 282 | fxtod $alo,$alo | ||
| 283 | fxtod $ahi,$ahi | ||
| 284 | fxtod $nlo,$nlo | ||
| 285 | fxtod $nhi,$nhi | ||
| 286 | |||
| 287 | ldx [%sp+$bias+$frame+0],%o0 | ||
| 288 | fmuld $alo,$ba,$aloa | ||
| 289 | ldx [%sp+$bias+$frame+8],%o1 | ||
| 290 | fmuld $nlo,$na,$nloa | ||
| 291 | ldx [%sp+$bias+$frame+16],%o2 | ||
| 292 | fmuld $alo,$bb,$alob | ||
| 293 | ldx [%sp+$bias+$frame+24],%o3 | ||
| 294 | fmuld $nlo,$nb,$nlob | ||
| 295 | |||
| 296 | srlx %o0,16,%o7 | ||
| 297 | std $alo,[$ap_l+$j] ! save smashed ap[j] in double format | ||
| 298 | fmuld $alo,$bc,$aloc | ||
| 299 | add %o7,%o1,%o1 | ||
| 300 | std $ahi,[$ap_h+$j] | ||
| 301 | faddd $aloa,$nloa,$nloa | ||
| 302 | fmuld $nlo,$nc,$nloc | ||
| 303 | srlx %o1,16,%o7 | ||
| 304 | std $nlo,[$np_l+$j] ! save smashed np[j] in double format | ||
| 305 | fmuld $alo,$bd,$alod | ||
| 306 | add %o7,%o2,%o2 | ||
| 307 | std $nhi,[$np_h+$j] | ||
| 308 | faddd $alob,$nlob,$nlob | ||
| 309 | fmuld $nlo,$nd,$nlod | ||
| 310 | srlx %o2,16,%o7 | ||
| 311 | fmuld $ahi,$ba,$ahia | ||
| 312 | add %o7,%o3,%o3 ! %o3.%o2[0..15].%o1[0..15].%o0[0..15] | ||
| 313 | faddd $aloc,$nloc,$nloc | ||
| 314 | fmuld $nhi,$na,$nhia | ||
| 315 | !and %o0,$mask,%o0 | ||
| 316 | !and %o1,$mask,%o1 | ||
| 317 | !and %o2,$mask,%o2 | ||
| 318 | !sllx %o1,16,%o1 | ||
| 319 | !sllx %o2,32,%o2 | ||
| 320 | !sllx %o3,48,%o7 | ||
| 321 | !or %o1,%o0,%o0 | ||
| 322 | !or %o2,%o0,%o0 | ||
| 323 | !or %o7,%o0,%o0 ! 64-bit result | ||
| 324 | srlx %o3,16,%g1 ! 34-bit carry | ||
| 325 | fmuld $ahi,$bb,$ahib | ||
| 326 | |||
| 327 | faddd $alod,$nlod,$nlod | ||
| 328 | fmuld $nhi,$nb,$nhib | ||
| 329 | fmuld $ahi,$bc,$ahic | ||
| 330 | faddd $ahia,$nhia,$nhia | ||
| 331 | fmuld $nhi,$nc,$nhic | ||
| 332 | fmuld $ahi,$bd,$ahid | ||
| 333 | faddd $ahib,$nhib,$nhib | ||
| 334 | fmuld $nhi,$nd,$nhid | ||
| 335 | |||
| 336 | faddd $dota,$nloa,$nloa | ||
| 337 | faddd $dotb,$nlob,$nlob | ||
| 338 | faddd $ahic,$nhic,$dota ! $nhic | ||
| 339 | faddd $ahid,$nhid,$dotb ! $nhid | ||
| 340 | |||
| 341 | faddd $nloc,$nhia,$nloc | ||
| 342 | faddd $nlod,$nhib,$nlod | ||
| 343 | |||
| 344 | fdtox $nloa,$nloa | ||
| 345 | fdtox $nlob,$nlob | ||
| 346 | fdtox $nloc,$nloc | ||
| 347 | fdtox $nlod,$nlod | ||
| 348 | |||
| 349 | std $nloa,[%sp+$bias+$frame+0] | ||
| 350 | std $nlob,[%sp+$bias+$frame+8] | ||
| 351 | addcc $j,8,$j | ||
| 352 | std $nloc,[%sp+$bias+$frame+16] | ||
| 353 | bz,pn %icc,.L1stskip | ||
| 354 | std $nlod,[%sp+$bias+$frame+24] | ||
| 355 | |||
| 356 | .align 32 ! incidentally already aligned ! | ||
| 357 | .L1st: | ||
| 358 | add $ap,$j,%o4 | ||
| 359 | add $np,$j,%o5 | ||
| 360 | ld [%o4+0],$alo_ ! load a[j] as pair of 32-bit words | ||
| 361 | fzeros $alo | ||
| 362 | ld [%o4+4],$ahi_ | ||
| 363 | fzeros $ahi | ||
| 364 | ld [%o5+0],$nlo_ ! load n[j] as pair of 32-bit words | ||
| 365 | fzeros $nlo | ||
| 366 | ld [%o5+4],$nhi_ | ||
| 367 | fzeros $nhi | ||
| 368 | |||
| 369 | fxtod $alo,$alo | ||
| 370 | fxtod $ahi,$ahi | ||
| 371 | fxtod $nlo,$nlo | ||
| 372 | fxtod $nhi,$nhi | ||
| 373 | |||
| 374 | ldx [%sp+$bias+$frame+0],%o0 | ||
| 375 | fmuld $alo,$ba,$aloa | ||
| 376 | ldx [%sp+$bias+$frame+8],%o1 | ||
| 377 | fmuld $nlo,$na,$nloa | ||
| 378 | ldx [%sp+$bias+$frame+16],%o2 | ||
| 379 | fmuld $alo,$bb,$alob | ||
| 380 | ldx [%sp+$bias+$frame+24],%o3 | ||
| 381 | fmuld $nlo,$nb,$nlob | ||
| 382 | |||
| 383 | srlx %o0,16,%o7 | ||
| 384 | std $alo,[$ap_l+$j] ! save smashed ap[j] in double format | ||
| 385 | fmuld $alo,$bc,$aloc | ||
| 386 | add %o7,%o1,%o1 | ||
| 387 | std $ahi,[$ap_h+$j] | ||
| 388 | faddd $aloa,$nloa,$nloa | ||
| 389 | fmuld $nlo,$nc,$nloc | ||
| 390 | srlx %o1,16,%o7 | ||
| 391 | std $nlo,[$np_l+$j] ! save smashed np[j] in double format | ||
| 392 | fmuld $alo,$bd,$alod | ||
| 393 | add %o7,%o2,%o2 | ||
| 394 | std $nhi,[$np_h+$j] | ||
| 395 | faddd $alob,$nlob,$nlob | ||
| 396 | fmuld $nlo,$nd,$nlod | ||
| 397 | srlx %o2,16,%o7 | ||
| 398 | fmuld $ahi,$ba,$ahia | ||
| 399 | add %o7,%o3,%o3 ! %o3.%o2[0..15].%o1[0..15].%o0[0..15] | ||
| 400 | and %o0,$mask,%o0 | ||
| 401 | faddd $aloc,$nloc,$nloc | ||
| 402 | fmuld $nhi,$na,$nhia | ||
| 403 | and %o1,$mask,%o1 | ||
| 404 | and %o2,$mask,%o2 | ||
| 405 | fmuld $ahi,$bb,$ahib | ||
| 406 | sllx %o1,16,%o1 | ||
| 407 | faddd $alod,$nlod,$nlod | ||
| 408 | fmuld $nhi,$nb,$nhib | ||
| 409 | sllx %o2,32,%o2 | ||
| 410 | fmuld $ahi,$bc,$ahic | ||
| 411 | sllx %o3,48,%o7 | ||
| 412 | or %o1,%o0,%o0 | ||
| 413 | faddd $ahia,$nhia,$nhia | ||
| 414 | fmuld $nhi,$nc,$nhic | ||
| 415 | or %o2,%o0,%o0 | ||
| 416 | fmuld $ahi,$bd,$ahid | ||
| 417 | or %o7,%o0,%o0 ! 64-bit result | ||
| 418 | faddd $ahib,$nhib,$nhib | ||
| 419 | fmuld $nhi,$nd,$nhid | ||
| 420 | addcc %g1,%o0,%o0 | ||
| 421 | faddd $dota,$nloa,$nloa | ||
| 422 | srlx %o3,16,%g1 ! 34-bit carry | ||
| 423 | faddd $dotb,$nlob,$nlob | ||
| 424 | bcs,a %xcc,.+8 | ||
| 425 | add %g1,1,%g1 | ||
| 426 | |||
| 427 | stx %o0,[$tp] ! tp[j-1]= | ||
| 428 | |||
| 429 | faddd $ahic,$nhic,$dota ! $nhic | ||
| 430 | faddd $ahid,$nhid,$dotb ! $nhid | ||
| 431 | |||
| 432 | faddd $nloc,$nhia,$nloc | ||
| 433 | faddd $nlod,$nhib,$nlod | ||
| 434 | |||
| 435 | fdtox $nloa,$nloa | ||
| 436 | fdtox $nlob,$nlob | ||
| 437 | fdtox $nloc,$nloc | ||
| 438 | fdtox $nlod,$nlod | ||
| 439 | |||
| 440 | std $nloa,[%sp+$bias+$frame+0] | ||
| 441 | std $nlob,[%sp+$bias+$frame+8] | ||
| 442 | std $nloc,[%sp+$bias+$frame+16] | ||
| 443 | std $nlod,[%sp+$bias+$frame+24] | ||
| 444 | |||
| 445 | addcc $j,8,$j | ||
| 446 | bnz,pt %icc,.L1st | ||
| 447 | add $tp,8,$tp | ||
| 448 | |||
| 449 | .L1stskip: | ||
| 450 | fdtox $dota,$dota | ||
| 451 | fdtox $dotb,$dotb | ||
| 452 | |||
| 453 | ldx [%sp+$bias+$frame+0],%o0 | ||
| 454 | ldx [%sp+$bias+$frame+8],%o1 | ||
| 455 | ldx [%sp+$bias+$frame+16],%o2 | ||
| 456 | ldx [%sp+$bias+$frame+24],%o3 | ||
| 457 | |||
| 458 | srlx %o0,16,%o7 | ||
| 459 | std $dota,[%sp+$bias+$frame+32] | ||
| 460 | add %o7,%o1,%o1 | ||
| 461 | std $dotb,[%sp+$bias+$frame+40] | ||
| 462 | srlx %o1,16,%o7 | ||
| 463 | add %o7,%o2,%o2 | ||
| 464 | srlx %o2,16,%o7 | ||
| 465 | add %o7,%o3,%o3 ! %o3.%o2[0..15].%o1[0..15].%o0[0..15] | ||
| 466 | and %o0,$mask,%o0 | ||
| 467 | and %o1,$mask,%o1 | ||
| 468 | and %o2,$mask,%o2 | ||
| 469 | sllx %o1,16,%o1 | ||
| 470 | sllx %o2,32,%o2 | ||
| 471 | sllx %o3,48,%o7 | ||
| 472 | or %o1,%o0,%o0 | ||
| 473 | or %o2,%o0,%o0 | ||
| 474 | or %o7,%o0,%o0 ! 64-bit result | ||
| 475 | ldx [%sp+$bias+$frame+32],%o4 | ||
| 476 | addcc %g1,%o0,%o0 | ||
| 477 | ldx [%sp+$bias+$frame+40],%o5 | ||
| 478 | srlx %o3,16,%g1 ! 34-bit carry | ||
| 479 | bcs,a %xcc,.+8 | ||
| 480 | add %g1,1,%g1 | ||
| 481 | |||
| 482 | stx %o0,[$tp] ! tp[j-1]= | ||
| 483 | add $tp,8,$tp | ||
| 484 | |||
| 485 | srlx %o4,16,%o7 | ||
| 486 | add %o7,%o5,%o5 | ||
| 487 | and %o4,$mask,%o4 | ||
| 488 | sllx %o5,16,%o7 | ||
| 489 | or %o7,%o4,%o4 | ||
| 490 | addcc %g1,%o4,%o4 | ||
| 491 | srlx %o5,48,%g1 | ||
| 492 | bcs,a %xcc,.+8 | ||
| 493 | add %g1,1,%g1 | ||
| 494 | |||
| 495 | mov %g1,$carry | ||
| 496 | stx %o4,[$tp] ! tp[num-1]= | ||
| 497 | |||
| 498 | ba .Louter | ||
| 499 | add $i,8,$i | ||
| 500 | .align 32 | ||
| 501 | .Louter: | ||
| 502 | sub %g0,$num,$j ! j=-num | ||
| 503 | add %sp,$bias+$frame+$locals,$tp | ||
| 504 | |||
| 505 | add $ap,$j,%o3 | ||
| 506 | add $bp,$i,%o4 | ||
| 507 | |||
| 508 | ld [%o3+4],%g1 ! bp[i] | ||
| 509 | ld [%o3+0],%o0 | ||
| 510 | ld [%o4+4],%g5 ! ap[0] | ||
| 511 | sllx %g1,32,%g1 | ||
| 512 | ld [%o4+0],%o1 | ||
| 513 | sllx %g5,32,%g5 | ||
| 514 | or %g1,%o0,%o0 | ||
| 515 | or %g5,%o1,%o1 | ||
| 516 | |||
| 517 | ldx [$tp],%o2 ! tp[0] | ||
| 518 | mulx %o1,%o0,%o0 | ||
| 519 | addcc %o2,%o0,%o0 | ||
| 520 | mulx $n0,%o0,%o0 ! (ap[0]*bp[i]+t[0])*n0 | ||
| 521 | stx %o0,[%sp+$bias+$frame+0] | ||
| 522 | |||
| 523 | ! transfer b[i] to FPU as 4x16-bit values | ||
| 524 | ldda [%o4+2]%asi,$ba | ||
| 525 | ldda [%o4+0]%asi,$bb | ||
| 526 | ldda [%o4+6]%asi,$bc | ||
| 527 | ldda [%o4+4]%asi,$bd | ||
| 528 | |||
| 529 | ! transfer (ap[0]*b[i]+t[0])*n0 to FPU as 4x16-bit values | ||
| 530 | ldda [%sp+$bias+$frame+6]%asi,$na | ||
| 531 | fxtod $ba,$ba | ||
| 532 | ldda [%sp+$bias+$frame+4]%asi,$nb | ||
| 533 | fxtod $bb,$bb | ||
| 534 | ldda [%sp+$bias+$frame+2]%asi,$nc | ||
| 535 | fxtod $bc,$bc | ||
| 536 | ldda [%sp+$bias+$frame+0]%asi,$nd | ||
| 537 | fxtod $bd,$bd | ||
| 538 | ldd [$ap_l+$j],$alo ! load a[j] in double format | ||
| 539 | fxtod $na,$na | ||
| 540 | ldd [$ap_h+$j],$ahi | ||
| 541 | fxtod $nb,$nb | ||
| 542 | ldd [$np_l+$j],$nlo ! load n[j] in double format | ||
| 543 | fxtod $nc,$nc | ||
| 544 | ldd [$np_h+$j],$nhi | ||
| 545 | fxtod $nd,$nd | ||
| 546 | |||
| 547 | fmuld $alo,$ba,$aloa | ||
| 548 | fmuld $nlo,$na,$nloa | ||
| 549 | fmuld $alo,$bb,$alob | ||
| 550 | fmuld $nlo,$nb,$nlob | ||
| 551 | fmuld $alo,$bc,$aloc | ||
| 552 | faddd $aloa,$nloa,$nloa | ||
| 553 | fmuld $nlo,$nc,$nloc | ||
| 554 | fmuld $alo,$bd,$alod | ||
| 555 | faddd $alob,$nlob,$nlob | ||
| 556 | fmuld $nlo,$nd,$nlod | ||
| 557 | fmuld $ahi,$ba,$ahia | ||
| 558 | faddd $aloc,$nloc,$nloc | ||
| 559 | fmuld $nhi,$na,$nhia | ||
| 560 | fmuld $ahi,$bb,$ahib | ||
| 561 | faddd $alod,$nlod,$nlod | ||
| 562 | fmuld $nhi,$nb,$nhib | ||
| 563 | fmuld $ahi,$bc,$ahic | ||
| 564 | faddd $ahia,$nhia,$nhia | ||
| 565 | fmuld $nhi,$nc,$nhic | ||
| 566 | fmuld $ahi,$bd,$ahid | ||
| 567 | faddd $ahib,$nhib,$nhib | ||
| 568 | fmuld $nhi,$nd,$nhid | ||
| 569 | |||
| 570 | faddd $ahic,$nhic,$dota ! $nhic | ||
| 571 | faddd $ahid,$nhid,$dotb ! $nhid | ||
| 572 | |||
| 573 | faddd $nloc,$nhia,$nloc | ||
| 574 | faddd $nlod,$nhib,$nlod | ||
| 575 | |||
| 576 | fdtox $nloa,$nloa | ||
| 577 | fdtox $nlob,$nlob | ||
| 578 | fdtox $nloc,$nloc | ||
| 579 | fdtox $nlod,$nlod | ||
| 580 | |||
| 581 | std $nloa,[%sp+$bias+$frame+0] | ||
| 582 | std $nlob,[%sp+$bias+$frame+8] | ||
| 583 | std $nloc,[%sp+$bias+$frame+16] | ||
| 584 | add $j,8,$j | ||
| 585 | std $nlod,[%sp+$bias+$frame+24] | ||
| 586 | |||
| 587 | ldd [$ap_l+$j],$alo ! load a[j] in double format | ||
| 588 | ldd [$ap_h+$j],$ahi | ||
| 589 | ldd [$np_l+$j],$nlo ! load n[j] in double format | ||
| 590 | ldd [$np_h+$j],$nhi | ||
| 591 | |||
| 592 | fmuld $alo,$ba,$aloa | ||
| 593 | fmuld $nlo,$na,$nloa | ||
| 594 | fmuld $alo,$bb,$alob | ||
| 595 | fmuld $nlo,$nb,$nlob | ||
| 596 | fmuld $alo,$bc,$aloc | ||
| 597 | ldx [%sp+$bias+$frame+0],%o0 | ||
| 598 | faddd $aloa,$nloa,$nloa | ||
| 599 | fmuld $nlo,$nc,$nloc | ||
| 600 | ldx [%sp+$bias+$frame+8],%o1 | ||
| 601 | fmuld $alo,$bd,$alod | ||
| 602 | ldx [%sp+$bias+$frame+16],%o2 | ||
| 603 | faddd $alob,$nlob,$nlob | ||
| 604 | fmuld $nlo,$nd,$nlod | ||
| 605 | ldx [%sp+$bias+$frame+24],%o3 | ||
| 606 | fmuld $ahi,$ba,$ahia | ||
| 607 | |||
| 608 | srlx %o0,16,%o7 | ||
| 609 | faddd $aloc,$nloc,$nloc | ||
| 610 | fmuld $nhi,$na,$nhia | ||
| 611 | add %o7,%o1,%o1 | ||
| 612 | fmuld $ahi,$bb,$ahib | ||
| 613 | srlx %o1,16,%o7 | ||
| 614 | faddd $alod,$nlod,$nlod | ||
| 615 | fmuld $nhi,$nb,$nhib | ||
| 616 | add %o7,%o2,%o2 | ||
| 617 | fmuld $ahi,$bc,$ahic | ||
| 618 | srlx %o2,16,%o7 | ||
| 619 | faddd $ahia,$nhia,$nhia | ||
| 620 | fmuld $nhi,$nc,$nhic | ||
| 621 | add %o7,%o3,%o3 ! %o3.%o2[0..15].%o1[0..15].%o0[0..15] | ||
| 622 | ! why? | ||
| 623 | and %o0,$mask,%o0 | ||
| 624 | fmuld $ahi,$bd,$ahid | ||
| 625 | and %o1,$mask,%o1 | ||
| 626 | and %o2,$mask,%o2 | ||
| 627 | faddd $ahib,$nhib,$nhib | ||
| 628 | fmuld $nhi,$nd,$nhid | ||
| 629 | sllx %o1,16,%o1 | ||
| 630 | faddd $dota,$nloa,$nloa | ||
| 631 | sllx %o2,32,%o2 | ||
| 632 | faddd $dotb,$nlob,$nlob | ||
| 633 | sllx %o3,48,%o7 | ||
| 634 | or %o1,%o0,%o0 | ||
| 635 | faddd $ahic,$nhic,$dota ! $nhic | ||
| 636 | or %o2,%o0,%o0 | ||
| 637 | faddd $ahid,$nhid,$dotb ! $nhid | ||
| 638 | or %o7,%o0,%o0 ! 64-bit result | ||
| 639 | ldx [$tp],%o7 | ||
| 640 | faddd $nloc,$nhia,$nloc | ||
| 641 | addcc %o7,%o0,%o0 | ||
| 642 | ! end-of-why? | ||
| 643 | faddd $nlod,$nhib,$nlod | ||
| 644 | srlx %o3,16,%g1 ! 34-bit carry | ||
| 645 | fdtox $nloa,$nloa | ||
| 646 | bcs,a %xcc,.+8 | ||
| 647 | add %g1,1,%g1 | ||
| 648 | |||
| 649 | fdtox $nlob,$nlob | ||
| 650 | fdtox $nloc,$nloc | ||
| 651 | fdtox $nlod,$nlod | ||
| 652 | |||
| 653 | std $nloa,[%sp+$bias+$frame+0] | ||
| 654 | std $nlob,[%sp+$bias+$frame+8] | ||
| 655 | addcc $j,8,$j | ||
| 656 | std $nloc,[%sp+$bias+$frame+16] | ||
| 657 | bz,pn %icc,.Linnerskip | ||
| 658 | std $nlod,[%sp+$bias+$frame+24] | ||
| 659 | |||
| 660 | ba .Linner | ||
| 661 | nop | ||
| 662 | .align 32 | ||
| 663 | .Linner: | ||
| 664 | ldd [$ap_l+$j],$alo ! load a[j] in double format | ||
| 665 | ldd [$ap_h+$j],$ahi | ||
| 666 | ldd [$np_l+$j],$nlo ! load n[j] in double format | ||
| 667 | ldd [$np_h+$j],$nhi | ||
| 668 | |||
| 669 | fmuld $alo,$ba,$aloa | ||
| 670 | fmuld $nlo,$na,$nloa | ||
| 671 | fmuld $alo,$bb,$alob | ||
| 672 | fmuld $nlo,$nb,$nlob | ||
| 673 | fmuld $alo,$bc,$aloc | ||
| 674 | ldx [%sp+$bias+$frame+0],%o0 | ||
| 675 | faddd $aloa,$nloa,$nloa | ||
| 676 | fmuld $nlo,$nc,$nloc | ||
| 677 | ldx [%sp+$bias+$frame+8],%o1 | ||
| 678 | fmuld $alo,$bd,$alod | ||
| 679 | ldx [%sp+$bias+$frame+16],%o2 | ||
| 680 | faddd $alob,$nlob,$nlob | ||
| 681 | fmuld $nlo,$nd,$nlod | ||
| 682 | ldx [%sp+$bias+$frame+24],%o3 | ||
| 683 | fmuld $ahi,$ba,$ahia | ||
| 684 | |||
| 685 | srlx %o0,16,%o7 | ||
| 686 | faddd $aloc,$nloc,$nloc | ||
| 687 | fmuld $nhi,$na,$nhia | ||
| 688 | add %o7,%o1,%o1 | ||
| 689 | fmuld $ahi,$bb,$ahib | ||
| 690 | srlx %o1,16,%o7 | ||
| 691 | faddd $alod,$nlod,$nlod | ||
| 692 | fmuld $nhi,$nb,$nhib | ||
| 693 | add %o7,%o2,%o2 | ||
| 694 | fmuld $ahi,$bc,$ahic | ||
| 695 | srlx %o2,16,%o7 | ||
| 696 | faddd $ahia,$nhia,$nhia | ||
| 697 | fmuld $nhi,$nc,$nhic | ||
| 698 | add %o7,%o3,%o3 ! %o3.%o2[0..15].%o1[0..15].%o0[0..15] | ||
| 699 | and %o0,$mask,%o0 | ||
| 700 | fmuld $ahi,$bd,$ahid | ||
| 701 | and %o1,$mask,%o1 | ||
| 702 | and %o2,$mask,%o2 | ||
| 703 | faddd $ahib,$nhib,$nhib | ||
| 704 | fmuld $nhi,$nd,$nhid | ||
| 705 | sllx %o1,16,%o1 | ||
| 706 | faddd $dota,$nloa,$nloa | ||
| 707 | sllx %o2,32,%o2 | ||
| 708 | faddd $dotb,$nlob,$nlob | ||
| 709 | sllx %o3,48,%o7 | ||
| 710 | or %o1,%o0,%o0 | ||
| 711 | faddd $ahic,$nhic,$dota ! $nhic | ||
| 712 | or %o2,%o0,%o0 | ||
| 713 | faddd $ahid,$nhid,$dotb ! $nhid | ||
| 714 | or %o7,%o0,%o0 ! 64-bit result | ||
| 715 | faddd $nloc,$nhia,$nloc | ||
| 716 | addcc %g1,%o0,%o0 | ||
| 717 | ldx [$tp+8],%o7 ! tp[j] | ||
| 718 | faddd $nlod,$nhib,$nlod | ||
| 719 | srlx %o3,16,%g1 ! 34-bit carry | ||
| 720 | fdtox $nloa,$nloa | ||
| 721 | bcs,a %xcc,.+8 | ||
| 722 | add %g1,1,%g1 | ||
| 723 | fdtox $nlob,$nlob | ||
| 724 | addcc %o7,%o0,%o0 | ||
| 725 | fdtox $nloc,$nloc | ||
| 726 | bcs,a %xcc,.+8 | ||
| 727 | add %g1,1,%g1 | ||
| 728 | |||
| 729 | stx %o0,[$tp] ! tp[j-1] | ||
| 730 | fdtox $nlod,$nlod | ||
| 731 | |||
| 732 | std $nloa,[%sp+$bias+$frame+0] | ||
| 733 | std $nlob,[%sp+$bias+$frame+8] | ||
| 734 | std $nloc,[%sp+$bias+$frame+16] | ||
| 735 | addcc $j,8,$j | ||
| 736 | std $nlod,[%sp+$bias+$frame+24] | ||
| 737 | bnz,pt %icc,.Linner | ||
| 738 | add $tp,8,$tp | ||
| 739 | |||
| 740 | .Linnerskip: | ||
| 741 | fdtox $dota,$dota | ||
| 742 | fdtox $dotb,$dotb | ||
| 743 | |||
| 744 | ldx [%sp+$bias+$frame+0],%o0 | ||
| 745 | ldx [%sp+$bias+$frame+8],%o1 | ||
| 746 | ldx [%sp+$bias+$frame+16],%o2 | ||
| 747 | ldx [%sp+$bias+$frame+24],%o3 | ||
| 748 | |||
| 749 | srlx %o0,16,%o7 | ||
| 750 | std $dota,[%sp+$bias+$frame+32] | ||
| 751 | add %o7,%o1,%o1 | ||
| 752 | std $dotb,[%sp+$bias+$frame+40] | ||
| 753 | srlx %o1,16,%o7 | ||
| 754 | add %o7,%o2,%o2 | ||
| 755 | srlx %o2,16,%o7 | ||
| 756 | add %o7,%o3,%o3 ! %o3.%o2[0..15].%o1[0..15].%o0[0..15] | ||
| 757 | and %o0,$mask,%o0 | ||
| 758 | and %o1,$mask,%o1 | ||
| 759 | and %o2,$mask,%o2 | ||
| 760 | sllx %o1,16,%o1 | ||
| 761 | sllx %o2,32,%o2 | ||
| 762 | sllx %o3,48,%o7 | ||
| 763 | or %o1,%o0,%o0 | ||
| 764 | or %o2,%o0,%o0 | ||
| 765 | ldx [%sp+$bias+$frame+32],%o4 | ||
| 766 | or %o7,%o0,%o0 ! 64-bit result | ||
| 767 | ldx [%sp+$bias+$frame+40],%o5 | ||
| 768 | addcc %g1,%o0,%o0 | ||
| 769 | ldx [$tp+8],%o7 ! tp[j] | ||
| 770 | srlx %o3,16,%g1 ! 34-bit carry | ||
| 771 | bcs,a %xcc,.+8 | ||
| 772 | add %g1,1,%g1 | ||
| 773 | |||
| 774 | addcc %o7,%o0,%o0 | ||
| 775 | bcs,a %xcc,.+8 | ||
| 776 | add %g1,1,%g1 | ||
| 777 | |||
| 778 | stx %o0,[$tp] ! tp[j-1] | ||
| 779 | add $tp,8,$tp | ||
| 780 | |||
| 781 | srlx %o4,16,%o7 | ||
| 782 | add %o7,%o5,%o5 | ||
| 783 | and %o4,$mask,%o4 | ||
| 784 | sllx %o5,16,%o7 | ||
| 785 | or %o7,%o4,%o4 | ||
| 786 | addcc %g1,%o4,%o4 | ||
| 787 | srlx %o5,48,%g1 | ||
| 788 | bcs,a %xcc,.+8 | ||
| 789 | add %g1,1,%g1 | ||
| 790 | |||
| 791 | addcc $carry,%o4,%o4 | ||
| 792 | stx %o4,[$tp] ! tp[num-1] | ||
| 793 | mov %g1,$carry | ||
| 794 | bcs,a %xcc,.+8 | ||
| 795 | add $carry,1,$carry | ||
| 796 | |||
| 797 | addcc $i,8,$i | ||
| 798 | bnz %icc,.Louter | ||
| 799 | nop | ||
| 800 | |||
| 801 | add $tp,8,$tp ! adjust tp to point at the end | ||
| 802 | orn %g0,%g0,%g4 | ||
| 803 | sub %g0,$num,%o7 ! n=-num | ||
| 804 | ba .Lsub | ||
| 805 | subcc %g0,%g0,%g0 ! clear %icc.c | ||
| 806 | |||
| 807 | .align 32 | ||
| 808 | .Lsub: | ||
| 809 | ldx [$tp+%o7],%o0 | ||
| 810 | add $np,%o7,%g1 | ||
| 811 | ld [%g1+0],%o2 | ||
| 812 | ld [%g1+4],%o3 | ||
| 813 | srlx %o0,32,%o1 | ||
| 814 | subccc %o0,%o2,%o2 | ||
| 815 | add $rp,%o7,%g1 | ||
| 816 | subccc %o1,%o3,%o3 | ||
| 817 | st %o2,[%g1+0] | ||
| 818 | add %o7,8,%o7 | ||
| 819 | brnz,pt %o7,.Lsub | ||
| 820 | st %o3,[%g1+4] | ||
| 821 | subc $carry,0,%g4 | ||
| 822 | sub %g0,$num,%o7 ! n=-num | ||
| 823 | ba .Lcopy | ||
| 824 | nop | ||
| 825 | |||
| 826 | .align 32 | ||
| 827 | .Lcopy: | ||
| 828 | ldx [$tp+%o7],%o0 | ||
| 829 | add $rp,%o7,%g1 | ||
| 830 | ld [%g1+0],%o2 | ||
| 831 | ld [%g1+4],%o3 | ||
| 832 | stx %g0,[$tp+%o7] | ||
| 833 | and %o0,%g4,%o0 | ||
| 834 | srlx %o0,32,%o1 | ||
| 835 | andn %o2,%g4,%o2 | ||
| 836 | andn %o3,%g4,%o3 | ||
| 837 | or %o2,%o0,%o0 | ||
| 838 | or %o3,%o1,%o1 | ||
| 839 | st %o0,[%g1+0] | ||
| 840 | add %o7,8,%o7 | ||
| 841 | brnz,pt %o7,.Lcopy | ||
| 842 | st %o1,[%g1+4] | ||
| 843 | sub %g0,$num,%o7 ! n=-num | ||
| 844 | |||
| 845 | .Lzap: | ||
| 846 | stx %g0,[$ap_l+%o7] | ||
| 847 | stx %g0,[$ap_h+%o7] | ||
| 848 | stx %g0,[$np_l+%o7] | ||
| 849 | stx %g0,[$np_h+%o7] | ||
| 850 | add %o7,8,%o7 | ||
| 851 | brnz,pt %o7,.Lzap | ||
| 852 | nop | ||
| 853 | |||
| 854 | ldx [%sp+$bias+$frame+48],%o7 | ||
| 855 | wr %g0,%o7,%asi ! restore %asi | ||
| 856 | |||
| 857 | mov 1,%i0 | ||
| 858 | .Lret: | ||
| 859 | ret | ||
| 860 | restore | ||
| 861 | .type $fname,#function | ||
| 862 | .size $fname,(.-$fname) | ||
| 863 | .asciz "Montgomery Multipltication for UltraSPARC, CRYPTOGAMS by <appro\@openssl.org>" | ||
| 864 | .align 32 | ||
| 865 | ___ | ||
| 866 | |||
| 867 | $code =~ s/\`([^\`]*)\`/eval($1)/gem; | ||
| 868 | |||
| 869 | # Below substitution makes it possible to compile without demanding | ||
| 870 | # VIS extentions on command line, e.g. -xarch=v9 vs. -xarch=v9a. I | ||
| 871 | # dare to do this, because VIS capability is detected at run-time now | ||
| 872 | # and this routine is not called on CPU not capable to execute it. Do | ||
| 873 | # note that fzeros is not the only VIS dependency! Another dependency | ||
| 874 | # is implicit and is just _a_ numerical value loaded to %asi register, | ||
| 875 | # which assembler can't recognize as VIS specific... | ||
| 876 | $code =~ s/fzeros\s+%f([0-9]+)/ | ||
| 877 | sprintf(".word\t0x%x\t! fzeros %%f%d",0x81b00c20|($1<<25),$1) | ||
| 878 | /gem; | ||
| 879 | |||
| 880 | print $code; | ||
| 881 | # flush | ||
| 882 | close STDOUT; | ||
diff --git a/src/lib/libssl/src/crypto/bn/asm/via-mont.pl b/src/lib/libssl/src/crypto/bn/asm/via-mont.pl new file mode 100644 index 0000000000..c046a514c8 --- /dev/null +++ b/src/lib/libssl/src/crypto/bn/asm/via-mont.pl | |||
| @@ -0,0 +1,242 @@ | |||
| 1 | #!/usr/bin/env perl | ||
| 2 | # | ||
| 3 | # ==================================================================== | ||
| 4 | # Written by Andy Polyakov <appro@fy.chalmers.se> for the OpenSSL | ||
| 5 | # project. The module is, however, dual licensed under OpenSSL and | ||
| 6 | # CRYPTOGAMS licenses depending on where you obtain it. For further | ||
| 7 | # details see http://www.openssl.org/~appro/cryptogams/. | ||
| 8 | # ==================================================================== | ||
| 9 | # | ||
| 10 | # Wrapper around 'rep montmul', VIA-specific instruction accessing | ||
| 11 | # PadLock Montgomery Multiplier. The wrapper is designed as drop-in | ||
| 12 | # replacement for OpenSSL bn_mul_mont [first implemented in 0.9.9]. | ||
| 13 | # | ||
| 14 | # Below are interleaved outputs from 'openssl speed rsa dsa' for 4 | ||
| 15 | # different software configurations on 1.5GHz VIA Esther processor. | ||
| 16 | # Lines marked with "software integer" denote performance of hand- | ||
| 17 | # coded integer-only assembler found in OpenSSL 0.9.7. "Software SSE2" | ||
| 18 | # refers to hand-coded SSE2 Montgomery multiplication procedure found | ||
| 19 | # OpenSSL 0.9.9. "Hardware VIA SDK" refers to padlock_pmm routine from | ||
| 20 | # Padlock SDK 2.0.1 available for download from VIA, which naturally | ||
| 21 | # utilizes the magic 'repz montmul' instruction. And finally "hardware | ||
| 22 | # this" refers to *this* implementation which also uses 'repz montmul' | ||
| 23 | # | ||
| 24 | # sign verify sign/s verify/s | ||
| 25 | # rsa 512 bits 0.001720s 0.000140s 581.4 7149.7 software integer | ||
| 26 | # rsa 512 bits 0.000690s 0.000086s 1450.3 11606.0 software SSE2 | ||
| 27 | # rsa 512 bits 0.006136s 0.000201s 163.0 4974.5 hardware VIA SDK | ||
| 28 | # rsa 512 bits 0.000712s 0.000050s 1404.9 19858.5 hardware this | ||
| 29 | # | ||
| 30 | # rsa 1024 bits 0.008518s 0.000413s 117.4 2420.8 software integer | ||
| 31 | # rsa 1024 bits 0.004275s 0.000277s 233.9 3609.7 software SSE2 | ||
| 32 | # rsa 1024 bits 0.012136s 0.000260s 82.4 3844.5 hardware VIA SDK | ||
| 33 | # rsa 1024 bits 0.002522s 0.000116s 396.5 8650.9 hardware this | ||
| 34 | # | ||
| 35 | # rsa 2048 bits 0.050101s 0.001371s 20.0 729.6 software integer | ||
| 36 | # rsa 2048 bits 0.030273s 0.001008s 33.0 991.9 software SSE2 | ||
| 37 | # rsa 2048 bits 0.030833s 0.000976s 32.4 1025.1 hardware VIA SDK | ||
| 38 | # rsa 2048 bits 0.011879s 0.000342s 84.2 2921.7 hardware this | ||
| 39 | # | ||
| 40 | # rsa 4096 bits 0.327097s 0.004859s 3.1 205.8 software integer | ||
| 41 | # rsa 4096 bits 0.229318s 0.003859s 4.4 259.2 software SSE2 | ||
| 42 | # rsa 4096 bits 0.233953s 0.003274s 4.3 305.4 hardware VIA SDK | ||
| 43 | # rsa 4096 bits 0.070493s 0.001166s 14.2 857.6 hardware this | ||
| 44 | # | ||
| 45 | # dsa 512 bits 0.001342s 0.001651s 745.2 605.7 software integer | ||
| 46 | # dsa 512 bits 0.000844s 0.000987s 1185.3 1013.1 software SSE2 | ||
| 47 | # dsa 512 bits 0.001902s 0.002247s 525.6 444.9 hardware VIA SDK | ||
| 48 | # dsa 512 bits 0.000458s 0.000524s 2182.2 1909.1 hardware this | ||
| 49 | # | ||
| 50 | # dsa 1024 bits 0.003964s 0.004926s 252.3 203.0 software integer | ||
| 51 | # dsa 1024 bits 0.002686s 0.003166s 372.3 315.8 software SSE2 | ||
| 52 | # dsa 1024 bits 0.002397s 0.002823s 417.1 354.3 hardware VIA SDK | ||
| 53 | # dsa 1024 bits 0.000978s 0.001170s 1022.2 855.0 hardware this | ||
| 54 | # | ||
| 55 | # dsa 2048 bits 0.013280s 0.016518s 75.3 60.5 software integer | ||
| 56 | # dsa 2048 bits 0.009911s 0.011522s 100.9 86.8 software SSE2 | ||
| 57 | # dsa 2048 bits 0.009542s 0.011763s 104.8 85.0 hardware VIA SDK | ||
| 58 | # dsa 2048 bits 0.002884s 0.003352s 346.8 298.3 hardware this | ||
| 59 | # | ||
| 60 | # To give you some other reference point here is output for 2.4GHz P4 | ||
| 61 | # running hand-coded SSE2 bn_mul_mont found in 0.9.9, i.e. "software | ||
| 62 | # SSE2" in above terms. | ||
| 63 | # | ||
| 64 | # rsa 512 bits 0.000407s 0.000047s 2454.2 21137.0 | ||
| 65 | # rsa 1024 bits 0.002426s 0.000141s 412.1 7100.0 | ||
| 66 | # rsa 2048 bits 0.015046s 0.000491s 66.5 2034.9 | ||
| 67 | # rsa 4096 bits 0.109770s 0.002379s 9.1 420.3 | ||
| 68 | # dsa 512 bits 0.000438s 0.000525s 2281.1 1904.1 | ||
| 69 | # dsa 1024 bits 0.001346s 0.001595s 742.7 627.0 | ||
| 70 | # dsa 2048 bits 0.004745s 0.005582s 210.7 179.1 | ||
| 71 | # | ||
| 72 | # Conclusions: | ||
| 73 | # - VIA SDK leaves a *lot* of room for improvement (which this | ||
| 74 | # implementation successfully fills:-); | ||
| 75 | # - 'rep montmul' gives up to >3x performance improvement depending on | ||
| 76 | # key length; | ||
| 77 | # - in terms of absolute performance it delivers approximately as much | ||
| 78 | # as modern out-of-order 32-bit cores [again, for longer keys]. | ||
| 79 | |||
| 80 | $0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1; | ||
| 81 | push(@INC,"${dir}","${dir}../../perlasm"); | ||
| 82 | require "x86asm.pl"; | ||
| 83 | |||
| 84 | &asm_init($ARGV[0],"via-mont.pl"); | ||
| 85 | |||
| 86 | # int bn_mul_mont(BN_ULONG *rp, const BN_ULONG *ap, const BN_ULONG *bp, const BN_ULONG *np,const BN_ULONG *n0, int num); | ||
| 87 | $func="bn_mul_mont_padlock"; | ||
| 88 | |||
| 89 | $pad=16*1; # amount of reserved bytes on top of every vector | ||
| 90 | |||
| 91 | # stack layout | ||
| 92 | $mZeroPrime=&DWP(0,"esp"); # these are specified by VIA | ||
| 93 | $A=&DWP(4,"esp"); | ||
| 94 | $B=&DWP(8,"esp"); | ||
| 95 | $T=&DWP(12,"esp"); | ||
| 96 | $M=&DWP(16,"esp"); | ||
| 97 | $scratch=&DWP(20,"esp"); | ||
| 98 | $rp=&DWP(24,"esp"); # these are mine | ||
| 99 | $sp=&DWP(28,"esp"); | ||
| 100 | # &DWP(32,"esp") # 32 byte scratch area | ||
| 101 | # &DWP(64+(4*$num+$pad)*0,"esp") # padded tp[num] | ||
| 102 | # &DWP(64+(4*$num+$pad)*1,"esp") # padded copy of ap[num] | ||
| 103 | # &DWP(64+(4*$num+$pad)*2,"esp") # padded copy of bp[num] | ||
| 104 | # &DWP(64+(4*$num+$pad)*3,"esp") # padded copy of np[num] | ||
| 105 | # Note that SDK suggests to unconditionally allocate 2K per vector. This | ||
| 106 | # has quite an impact on performance. It naturally depends on key length, | ||
| 107 | # but to give an example 1024 bit private RSA key operations suffer >30% | ||
| 108 | # penalty. I allocate only as much as actually required... | ||
| 109 | |||
| 110 | &function_begin($func); | ||
| 111 | &xor ("eax","eax"); | ||
| 112 | &mov ("ecx",&wparam(5)); # num | ||
| 113 | # meet VIA's limitations for num [note that the specification | ||
| 114 | # expresses them in bits, while we work with amount of 32-bit words] | ||
| 115 | &test ("ecx",3); | ||
| 116 | &jnz (&label("leave")); # num % 4 != 0 | ||
| 117 | &cmp ("ecx",8); | ||
| 118 | &jb (&label("leave")); # num < 8 | ||
| 119 | &cmp ("ecx",1024); | ||
| 120 | &ja (&label("leave")); # num > 1024 | ||
| 121 | |||
| 122 | &pushf (); | ||
| 123 | &cld (); | ||
| 124 | |||
| 125 | &mov ("edi",&wparam(0)); # rp | ||
| 126 | &mov ("eax",&wparam(1)); # ap | ||
| 127 | &mov ("ebx",&wparam(2)); # bp | ||
| 128 | &mov ("edx",&wparam(3)); # np | ||
| 129 | &mov ("esi",&wparam(4)); # n0 | ||
| 130 | &mov ("esi",&DWP(0,"esi")); # *n0 | ||
| 131 | |||
| 132 | &lea ("ecx",&DWP($pad,"","ecx",4)); # ecx becomes vector size in bytes | ||
| 133 | &lea ("ebp",&DWP(64,"","ecx",4)); # allocate 4 vectors + 64 bytes | ||
| 134 | &neg ("ebp"); | ||
| 135 | &add ("ebp","esp"); | ||
| 136 | &and ("ebp",-64); # align to cache-line | ||
| 137 | &xchg ("ebp","esp"); # alloca | ||
| 138 | |||
| 139 | &mov ($rp,"edi"); # save rp | ||
| 140 | &mov ($sp,"ebp"); # save esp | ||
| 141 | |||
| 142 | &mov ($mZeroPrime,"esi"); | ||
| 143 | &lea ("esi",&DWP(64,"esp")); # tp | ||
| 144 | &mov ($T,"esi"); | ||
| 145 | &lea ("edi",&DWP(32,"esp")); # scratch area | ||
| 146 | &mov ($scratch,"edi"); | ||
| 147 | &mov ("esi","eax"); | ||
| 148 | |||
| 149 | &lea ("ebp",&DWP(-$pad,"ecx")); | ||
| 150 | &shr ("ebp",2); # restore original num value in ebp | ||
| 151 | |||
| 152 | &xor ("eax","eax"); | ||
| 153 | |||
| 154 | &mov ("ecx","ebp"); | ||
| 155 | &lea ("ecx",&DWP((32+$pad)/4,"ecx"));# padded tp + scratch | ||
| 156 | &data_byte(0xf3,0xab); # rep stosl, bzero | ||
| 157 | |||
| 158 | &mov ("ecx","ebp"); | ||
| 159 | &lea ("edi",&DWP(64+$pad,"esp","ecx",4));# pointer to ap copy | ||
| 160 | &mov ($A,"edi"); | ||
| 161 | &data_byte(0xf3,0xa5); # rep movsl, memcpy | ||
| 162 | &mov ("ecx",$pad/4); | ||
| 163 | &data_byte(0xf3,0xab); # rep stosl, bzero pad | ||
| 164 | # edi points at the end of padded ap copy... | ||
| 165 | |||
| 166 | &mov ("ecx","ebp"); | ||
| 167 | &mov ("esi","ebx"); | ||
| 168 | &mov ($B,"edi"); | ||
| 169 | &data_byte(0xf3,0xa5); # rep movsl, memcpy | ||
| 170 | &mov ("ecx",$pad/4); | ||
| 171 | &data_byte(0xf3,0xab); # rep stosl, bzero pad | ||
| 172 | # edi points at the end of padded bp copy... | ||
| 173 | |||
| 174 | &mov ("ecx","ebp"); | ||
| 175 | &mov ("esi","edx"); | ||
| 176 | &mov ($M,"edi"); | ||
| 177 | &data_byte(0xf3,0xa5); # rep movsl, memcpy | ||
| 178 | &mov ("ecx",$pad/4); | ||
| 179 | &data_byte(0xf3,0xab); # rep stosl, bzero pad | ||
| 180 | # edi points at the end of padded np copy... | ||
| 181 | |||
| 182 | # let magic happen... | ||
| 183 | &mov ("ecx","ebp"); | ||
| 184 | &mov ("esi","esp"); | ||
| 185 | &shl ("ecx",5); # convert word counter to bit counter | ||
| 186 | &align (4); | ||
| 187 | &data_byte(0xf3,0x0f,0xa6,0xc0);# rep montmul | ||
| 188 | |||
| 189 | &mov ("ecx","ebp"); | ||
| 190 | &lea ("esi",&DWP(64,"esp")); # tp | ||
| 191 | # edi still points at the end of padded np copy... | ||
| 192 | &neg ("ebp"); | ||
| 193 | &lea ("ebp",&DWP(-$pad,"edi","ebp",4)); # so just "rewind" | ||
| 194 | &mov ("edi",$rp); # restore rp | ||
| 195 | &xor ("edx","edx"); # i=0 and clear CF | ||
| 196 | |||
| 197 | &set_label("sub",8); | ||
| 198 | &mov ("eax",&DWP(0,"esi","edx",4)); | ||
| 199 | &sbb ("eax",&DWP(0,"ebp","edx",4)); | ||
| 200 | &mov (&DWP(0,"edi","edx",4),"eax"); # rp[i]=tp[i]-np[i] | ||
| 201 | &lea ("edx",&DWP(1,"edx")); # i++ | ||
| 202 | &loop (&label("sub")); # doesn't affect CF! | ||
| 203 | |||
| 204 | &mov ("eax",&DWP(0,"esi","edx",4)); # upmost overflow bit | ||
| 205 | &sbb ("eax",0); | ||
| 206 | &and ("esi","eax"); | ||
| 207 | ¬ ("eax"); | ||
| 208 | &mov ("ebp","edi"); | ||
| 209 | &and ("ebp","eax"); | ||
| 210 | &or ("esi","ebp"); # tp=carry?tp:rp | ||
| 211 | |||
| 212 | &mov ("ecx","edx"); # num | ||
| 213 | &xor ("edx","edx"); # i=0 | ||
| 214 | |||
| 215 | &set_label("copy",8); | ||
| 216 | &mov ("eax",&DWP(0,"esi","edx",4)); | ||
| 217 | &mov (&DWP(64,"esp","edx",4),"ecx"); # zap tp | ||
| 218 | &mov (&DWP(0,"edi","edx",4),"eax"); | ||
| 219 | &lea ("edx",&DWP(1,"edx")); # i++ | ||
| 220 | &loop (&label("copy")); | ||
| 221 | |||
| 222 | &mov ("ebp",$sp); | ||
| 223 | &xor ("eax","eax"); | ||
| 224 | |||
| 225 | &mov ("ecx",64/4); | ||
| 226 | &mov ("edi","esp"); # zap frame including scratch area | ||
| 227 | &data_byte(0xf3,0xab); # rep stosl, bzero | ||
| 228 | |||
| 229 | # zap copies of ap, bp and np | ||
| 230 | &lea ("edi",&DWP(64+$pad,"esp","edx",4));# pointer to ap | ||
| 231 | &lea ("ecx",&DWP(3*$pad/4,"edx","edx",2)); | ||
| 232 | &data_byte(0xf3,0xab); # rep stosl, bzero | ||
| 233 | |||
| 234 | &mov ("esp","ebp"); | ||
| 235 | &inc ("eax"); # signal "done" | ||
| 236 | &popf (); | ||
| 237 | &set_label("leave"); | ||
| 238 | &function_end($func); | ||
| 239 | |||
| 240 | &asciz("Padlock Montgomery Multiplication, CRYPTOGAMS by <appro\@openssl.org>"); | ||
| 241 | |||
| 242 | &asm_finish(); | ||
diff --git a/src/lib/libssl/src/crypto/bn/asm/x86-mont.pl b/src/lib/libssl/src/crypto/bn/asm/x86-mont.pl new file mode 100755 index 0000000000..5cd3cd2ed5 --- /dev/null +++ b/src/lib/libssl/src/crypto/bn/asm/x86-mont.pl | |||
| @@ -0,0 +1,591 @@ | |||
| 1 | #!/usr/bin/env perl | ||
| 2 | |||
| 3 | # ==================================================================== | ||
| 4 | # Written by Andy Polyakov <appro@fy.chalmers.se> for the OpenSSL | ||
| 5 | # project. The module is, however, dual licensed under OpenSSL and | ||
| 6 | # CRYPTOGAMS licenses depending on where you obtain it. For further | ||
| 7 | # details see http://www.openssl.org/~appro/cryptogams/. | ||
| 8 | # ==================================================================== | ||
| 9 | |||
| 10 | # October 2005 | ||
| 11 | # | ||
| 12 | # This is a "teaser" code, as it can be improved in several ways... | ||
| 13 | # First of all non-SSE2 path should be implemented (yes, for now it | ||
| 14 | # performs Montgomery multiplication/convolution only on SSE2-capable | ||
| 15 | # CPUs such as P4, others fall down to original code). Then inner loop | ||
| 16 | # can be unrolled and modulo-scheduled to improve ILP and possibly | ||
| 17 | # moved to 128-bit XMM register bank (though it would require input | ||
| 18 | # rearrangement and/or increase bus bandwidth utilization). Dedicated | ||
| 19 | # squaring procedure should give further performance improvement... | ||
| 20 | # Yet, for being draft, the code improves rsa512 *sign* benchmark by | ||
| 21 | # 110%(!), rsa1024 one - by 70% and rsa4096 - by 20%:-) | ||
| 22 | |||
| 23 | # December 2006 | ||
| 24 | # | ||
| 25 | # Modulo-scheduling SSE2 loops results in further 15-20% improvement. | ||
| 26 | # Integer-only code [being equipped with dedicated squaring procedure] | ||
| 27 | # gives ~40% on rsa512 sign benchmark... | ||
| 28 | |||
| 29 | $0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1; | ||
| 30 | push(@INC,"${dir}","${dir}../../perlasm"); | ||
| 31 | require "x86asm.pl"; | ||
| 32 | |||
| 33 | &asm_init($ARGV[0],$0); | ||
| 34 | |||
| 35 | $sse2=0; | ||
| 36 | for (@ARGV) { $sse2=1 if (/-DOPENSSL_IA32_SSE2/); } | ||
| 37 | |||
| 38 | &external_label("OPENSSL_ia32cap_P") if ($sse2); | ||
| 39 | |||
| 40 | &function_begin("bn_mul_mont"); | ||
| 41 | |||
| 42 | $i="edx"; | ||
| 43 | $j="ecx"; | ||
| 44 | $ap="esi"; $tp="esi"; # overlapping variables!!! | ||
| 45 | $rp="edi"; $bp="edi"; # overlapping variables!!! | ||
| 46 | $np="ebp"; | ||
| 47 | $num="ebx"; | ||
| 48 | |||
| 49 | $_num=&DWP(4*0,"esp"); # stack top layout | ||
| 50 | $_rp=&DWP(4*1,"esp"); | ||
| 51 | $_ap=&DWP(4*2,"esp"); | ||
| 52 | $_bp=&DWP(4*3,"esp"); | ||
| 53 | $_np=&DWP(4*4,"esp"); | ||
| 54 | $_n0=&DWP(4*5,"esp"); $_n0q=&QWP(4*5,"esp"); | ||
| 55 | $_sp=&DWP(4*6,"esp"); | ||
| 56 | $_bpend=&DWP(4*7,"esp"); | ||
| 57 | $frame=32; # size of above frame rounded up to 16n | ||
| 58 | |||
| 59 | &xor ("eax","eax"); | ||
| 60 | &mov ("edi",&wparam(5)); # int num | ||
| 61 | &cmp ("edi",4); | ||
| 62 | &jl (&label("just_leave")); | ||
| 63 | |||
| 64 | &lea ("esi",&wparam(0)); # put aside pointer to argument block | ||
| 65 | &lea ("edx",&wparam(1)); # load ap | ||
| 66 | &mov ("ebp","esp"); # saved stack pointer! | ||
| 67 | &add ("edi",2); # extra two words on top of tp | ||
| 68 | &neg ("edi"); | ||
| 69 | &lea ("esp",&DWP(-$frame,"esp","edi",4)); # alloca($frame+4*(num+2)) | ||
| 70 | &neg ("edi"); | ||
| 71 | |||
| 72 | # minimize cache contention by arraning 2K window between stack | ||
| 73 | # pointer and ap argument [np is also position sensitive vector, | ||
| 74 | # but it's assumed to be near ap, as it's allocated at ~same | ||
| 75 | # time]. | ||
| 76 | &mov ("eax","esp"); | ||
| 77 | &sub ("eax","edx"); | ||
| 78 | &and ("eax",2047); | ||
| 79 | &sub ("esp","eax"); # this aligns sp and ap modulo 2048 | ||
| 80 | |||
| 81 | &xor ("edx","esp"); | ||
| 82 | &and ("edx",2048); | ||
| 83 | &xor ("edx",2048); | ||
| 84 | &sub ("esp","edx"); # this splits them apart modulo 4096 | ||
| 85 | |||
| 86 | &and ("esp",-64); # align to cache line | ||
| 87 | |||
| 88 | ################################# load argument block... | ||
| 89 | &mov ("eax",&DWP(0*4,"esi"));# BN_ULONG *rp | ||
| 90 | &mov ("ebx",&DWP(1*4,"esi"));# const BN_ULONG *ap | ||
| 91 | &mov ("ecx",&DWP(2*4,"esi"));# const BN_ULONG *bp | ||
| 92 | &mov ("edx",&DWP(3*4,"esi"));# const BN_ULONG *np | ||
| 93 | &mov ("esi",&DWP(4*4,"esi"));# const BN_ULONG *n0 | ||
| 94 | #&mov ("edi",&DWP(5*4,"esi"));# int num | ||
| 95 | |||
| 96 | &mov ("esi",&DWP(0,"esi")); # pull n0[0] | ||
| 97 | &mov ($_rp,"eax"); # ... save a copy of argument block | ||
| 98 | &mov ($_ap,"ebx"); | ||
| 99 | &mov ($_bp,"ecx"); | ||
| 100 | &mov ($_np,"edx"); | ||
| 101 | &mov ($_n0,"esi"); | ||
| 102 | &lea ($num,&DWP(-3,"edi")); # num=num-1 to assist modulo-scheduling | ||
| 103 | #&mov ($_num,$num); # redundant as $num is not reused | ||
| 104 | &mov ($_sp,"ebp"); # saved stack pointer! | ||
| 105 | |||
| 106 | if($sse2) { | ||
| 107 | $acc0="mm0"; # mmx register bank layout | ||
| 108 | $acc1="mm1"; | ||
| 109 | $car0="mm2"; | ||
| 110 | $car1="mm3"; | ||
| 111 | $mul0="mm4"; | ||
| 112 | $mul1="mm5"; | ||
| 113 | $temp="mm6"; | ||
| 114 | $mask="mm7"; | ||
| 115 | |||
| 116 | &picmeup("eax","OPENSSL_ia32cap_P"); | ||
| 117 | &bt (&DWP(0,"eax"),26); | ||
| 118 | &jnc (&label("non_sse2")); | ||
| 119 | |||
| 120 | &mov ("eax",-1); | ||
| 121 | &movd ($mask,"eax"); # mask 32 lower bits | ||
| 122 | |||
| 123 | &mov ($ap,$_ap); # load input pointers | ||
| 124 | &mov ($bp,$_bp); | ||
| 125 | &mov ($np,$_np); | ||
| 126 | |||
| 127 | &xor ($i,$i); # i=0 | ||
| 128 | &xor ($j,$j); # j=0 | ||
| 129 | |||
| 130 | &movd ($mul0,&DWP(0,$bp)); # bp[0] | ||
| 131 | &movd ($mul1,&DWP(0,$ap)); # ap[0] | ||
| 132 | &movd ($car1,&DWP(0,$np)); # np[0] | ||
| 133 | |||
| 134 | &pmuludq($mul1,$mul0); # ap[0]*bp[0] | ||
| 135 | &movq ($car0,$mul1); | ||
| 136 | &movq ($acc0,$mul1); # I wish movd worked for | ||
| 137 | &pand ($acc0,$mask); # inter-register transfers | ||
| 138 | |||
| 139 | &pmuludq($mul1,$_n0q); # *=n0 | ||
| 140 | |||
| 141 | &pmuludq($car1,$mul1); # "t[0]"*np[0]*n0 | ||
| 142 | &paddq ($car1,$acc0); | ||
| 143 | |||
| 144 | &movd ($acc1,&DWP(4,$np)); # np[1] | ||
| 145 | &movd ($acc0,&DWP(4,$ap)); # ap[1] | ||
| 146 | |||
| 147 | &psrlq ($car0,32); | ||
| 148 | &psrlq ($car1,32); | ||
| 149 | |||
| 150 | &inc ($j); # j++ | ||
| 151 | &set_label("1st",16); | ||
| 152 | &pmuludq($acc0,$mul0); # ap[j]*bp[0] | ||
| 153 | &pmuludq($acc1,$mul1); # np[j]*m1 | ||
| 154 | &paddq ($car0,$acc0); # +=c0 | ||
| 155 | &paddq ($car1,$acc1); # +=c1 | ||
| 156 | |||
| 157 | &movq ($acc0,$car0); | ||
| 158 | &pand ($acc0,$mask); | ||
| 159 | &movd ($acc1,&DWP(4,$np,$j,4)); # np[j+1] | ||
| 160 | &paddq ($car1,$acc0); # +=ap[j]*bp[0]; | ||
| 161 | &movd ($acc0,&DWP(4,$ap,$j,4)); # ap[j+1] | ||
| 162 | &psrlq ($car0,32); | ||
| 163 | &movd (&DWP($frame-4,"esp",$j,4),$car1); # tp[j-1]= | ||
| 164 | &psrlq ($car1,32); | ||
| 165 | |||
| 166 | &lea ($j,&DWP(1,$j)); | ||
| 167 | &cmp ($j,$num); | ||
| 168 | &jl (&label("1st")); | ||
| 169 | |||
| 170 | &pmuludq($acc0,$mul0); # ap[num-1]*bp[0] | ||
| 171 | &pmuludq($acc1,$mul1); # np[num-1]*m1 | ||
| 172 | &paddq ($car0,$acc0); # +=c0 | ||
| 173 | &paddq ($car1,$acc1); # +=c1 | ||
| 174 | |||
| 175 | &movq ($acc0,$car0); | ||
| 176 | &pand ($acc0,$mask); | ||
| 177 | &paddq ($car1,$acc0); # +=ap[num-1]*bp[0]; | ||
| 178 | &movd (&DWP($frame-4,"esp",$j,4),$car1); # tp[num-2]= | ||
| 179 | |||
| 180 | &psrlq ($car0,32); | ||
| 181 | &psrlq ($car1,32); | ||
| 182 | |||
| 183 | &paddq ($car1,$car0); | ||
| 184 | &movq (&QWP($frame,"esp",$num,4),$car1); # tp[num].tp[num-1] | ||
| 185 | |||
| 186 | &inc ($i); # i++ | ||
| 187 | &set_label("outer"); | ||
| 188 | &xor ($j,$j); # j=0 | ||
| 189 | |||
| 190 | &movd ($mul0,&DWP(0,$bp,$i,4)); # bp[i] | ||
| 191 | &movd ($mul1,&DWP(0,$ap)); # ap[0] | ||
| 192 | &movd ($temp,&DWP($frame,"esp")); # tp[0] | ||
| 193 | &movd ($car1,&DWP(0,$np)); # np[0] | ||
| 194 | &pmuludq($mul1,$mul0); # ap[0]*bp[i] | ||
| 195 | |||
| 196 | &paddq ($mul1,$temp); # +=tp[0] | ||
| 197 | &movq ($acc0,$mul1); | ||
| 198 | &movq ($car0,$mul1); | ||
| 199 | &pand ($acc0,$mask); | ||
| 200 | |||
| 201 | &pmuludq($mul1,$_n0q); # *=n0 | ||
| 202 | |||
| 203 | &pmuludq($car1,$mul1); | ||
| 204 | &paddq ($car1,$acc0); | ||
| 205 | |||
| 206 | &movd ($temp,&DWP($frame+4,"esp")); # tp[1] | ||
| 207 | &movd ($acc1,&DWP(4,$np)); # np[1] | ||
| 208 | &movd ($acc0,&DWP(4,$ap)); # ap[1] | ||
| 209 | |||
| 210 | &psrlq ($car0,32); | ||
| 211 | &psrlq ($car1,32); | ||
| 212 | &paddq ($car0,$temp); # +=tp[1] | ||
| 213 | |||
| 214 | &inc ($j); # j++ | ||
| 215 | &dec ($num); | ||
| 216 | &set_label("inner"); | ||
| 217 | &pmuludq($acc0,$mul0); # ap[j]*bp[i] | ||
| 218 | &pmuludq($acc1,$mul1); # np[j]*m1 | ||
| 219 | &paddq ($car0,$acc0); # +=c0 | ||
| 220 | &paddq ($car1,$acc1); # +=c1 | ||
| 221 | |||
| 222 | &movq ($acc0,$car0); | ||
| 223 | &movd ($temp,&DWP($frame+4,"esp",$j,4));# tp[j+1] | ||
| 224 | &pand ($acc0,$mask); | ||
| 225 | &movd ($acc1,&DWP(4,$np,$j,4)); # np[j+1] | ||
| 226 | &paddq ($car1,$acc0); # +=ap[j]*bp[i]+tp[j] | ||
| 227 | &movd ($acc0,&DWP(4,$ap,$j,4)); # ap[j+1] | ||
| 228 | &psrlq ($car0,32); | ||
| 229 | &movd (&DWP($frame-4,"esp",$j,4),$car1);# tp[j-1]= | ||
| 230 | &psrlq ($car1,32); | ||
| 231 | &paddq ($car0,$temp); # +=tp[j+1] | ||
| 232 | |||
| 233 | &dec ($num); | ||
| 234 | &lea ($j,&DWP(1,$j)); # j++ | ||
| 235 | &jnz (&label("inner")); | ||
| 236 | |||
| 237 | &mov ($num,$j); | ||
| 238 | &pmuludq($acc0,$mul0); # ap[num-1]*bp[i] | ||
| 239 | &pmuludq($acc1,$mul1); # np[num-1]*m1 | ||
| 240 | &paddq ($car0,$acc0); # +=c0 | ||
| 241 | &paddq ($car1,$acc1); # +=c1 | ||
| 242 | |||
| 243 | &movq ($acc0,$car0); | ||
| 244 | &pand ($acc0,$mask); | ||
| 245 | &paddq ($car1,$acc0); # +=ap[num-1]*bp[i]+tp[num-1] | ||
| 246 | &movd (&DWP($frame-4,"esp",$j,4),$car1); # tp[num-2]= | ||
| 247 | &psrlq ($car0,32); | ||
| 248 | &psrlq ($car1,32); | ||
| 249 | |||
| 250 | &movd ($temp,&DWP($frame+4,"esp",$num,4)); # += tp[num] | ||
| 251 | &paddq ($car1,$car0); | ||
| 252 | &paddq ($car1,$temp); | ||
| 253 | &movq (&QWP($frame,"esp",$num,4),$car1); # tp[num].tp[num-1] | ||
| 254 | |||
| 255 | &lea ($i,&DWP(1,$i)); # i++ | ||
| 256 | &cmp ($i,$num); | ||
| 257 | &jle (&label("outer")); | ||
| 258 | |||
| 259 | &emms (); # done with mmx bank | ||
| 260 | &jmp (&label("common_tail")); | ||
| 261 | |||
| 262 | &set_label("non_sse2",16); | ||
| 263 | } | ||
| 264 | |||
| 265 | if (0) { | ||
| 266 | &mov ("esp",$_sp); | ||
| 267 | &xor ("eax","eax"); # signal "not fast enough [yet]" | ||
| 268 | &jmp (&label("just_leave")); | ||
| 269 | # While the below code provides competitive performance for | ||
| 270 | # all key lengthes on modern Intel cores, it's still more | ||
| 271 | # than 10% slower for 4096-bit key elsewhere:-( "Competitive" | ||
| 272 | # means compared to the original integer-only assembler. | ||
| 273 | # 512-bit RSA sign is better by ~40%, but that's about all | ||
| 274 | # one can say about all CPUs... | ||
| 275 | } else { | ||
| 276 | $inp="esi"; # integer path uses these registers differently | ||
| 277 | $word="edi"; | ||
| 278 | $carry="ebp"; | ||
| 279 | |||
| 280 | &mov ($inp,$_ap); | ||
| 281 | &lea ($carry,&DWP(1,$num)); | ||
| 282 | &mov ($word,$_bp); | ||
| 283 | &xor ($j,$j); # j=0 | ||
| 284 | &mov ("edx",$inp); | ||
| 285 | &and ($carry,1); # see if num is even | ||
| 286 | &sub ("edx",$word); # see if ap==bp | ||
| 287 | &lea ("eax",&DWP(4,$word,$num,4)); # &bp[num] | ||
| 288 | &or ($carry,"edx"); | ||
| 289 | &mov ($word,&DWP(0,$word)); # bp[0] | ||
| 290 | &jz (&label("bn_sqr_mont")); | ||
| 291 | &mov ($_bpend,"eax"); | ||
| 292 | &mov ("eax",&DWP(0,$inp)); | ||
| 293 | &xor ("edx","edx"); | ||
| 294 | |||
| 295 | &set_label("mull",16); | ||
| 296 | &mov ($carry,"edx"); | ||
| 297 | &mul ($word); # ap[j]*bp[0] | ||
| 298 | &add ($carry,"eax"); | ||
| 299 | &lea ($j,&DWP(1,$j)); | ||
| 300 | &adc ("edx",0); | ||
| 301 | &mov ("eax",&DWP(0,$inp,$j,4)); # ap[j+1] | ||
| 302 | &cmp ($j,$num); | ||
| 303 | &mov (&DWP($frame-4,"esp",$j,4),$carry); # tp[j]= | ||
| 304 | &jl (&label("mull")); | ||
| 305 | |||
| 306 | &mov ($carry,"edx"); | ||
| 307 | &mul ($word); # ap[num-1]*bp[0] | ||
| 308 | &mov ($word,$_n0); | ||
| 309 | &add ("eax",$carry); | ||
| 310 | &mov ($inp,$_np); | ||
| 311 | &adc ("edx",0); | ||
| 312 | &imul ($word,&DWP($frame,"esp")); # n0*tp[0] | ||
| 313 | |||
| 314 | &mov (&DWP($frame,"esp",$num,4),"eax"); # tp[num-1]= | ||
| 315 | &xor ($j,$j); | ||
| 316 | &mov (&DWP($frame+4,"esp",$num,4),"edx"); # tp[num]= | ||
| 317 | &mov (&DWP($frame+8,"esp",$num,4),$j); # tp[num+1]= | ||
| 318 | |||
| 319 | &mov ("eax",&DWP(0,$inp)); # np[0] | ||
| 320 | &mul ($word); # np[0]*m | ||
| 321 | &add ("eax",&DWP($frame,"esp")); # +=tp[0] | ||
| 322 | &mov ("eax",&DWP(4,$inp)); # np[1] | ||
| 323 | &adc ("edx",0); | ||
| 324 | &inc ($j); | ||
| 325 | |||
| 326 | &jmp (&label("2ndmadd")); | ||
| 327 | |||
| 328 | &set_label("1stmadd",16); | ||
| 329 | &mov ($carry,"edx"); | ||
| 330 | &mul ($word); # ap[j]*bp[i] | ||
| 331 | &add ($carry,&DWP($frame,"esp",$j,4)); # +=tp[j] | ||
| 332 | &lea ($j,&DWP(1,$j)); | ||
| 333 | &adc ("edx",0); | ||
| 334 | &add ($carry,"eax"); | ||
| 335 | &mov ("eax",&DWP(0,$inp,$j,4)); # ap[j+1] | ||
| 336 | &adc ("edx",0); | ||
| 337 | &cmp ($j,$num); | ||
| 338 | &mov (&DWP($frame-4,"esp",$j,4),$carry); # tp[j]= | ||
| 339 | &jl (&label("1stmadd")); | ||
| 340 | |||
| 341 | &mov ($carry,"edx"); | ||
| 342 | &mul ($word); # ap[num-1]*bp[i] | ||
| 343 | &add ("eax",&DWP($frame,"esp",$num,4)); # +=tp[num-1] | ||
| 344 | &mov ($word,$_n0); | ||
| 345 | &adc ("edx",0); | ||
| 346 | &mov ($inp,$_np); | ||
| 347 | &add ($carry,"eax"); | ||
| 348 | &adc ("edx",0); | ||
| 349 | &imul ($word,&DWP($frame,"esp")); # n0*tp[0] | ||
| 350 | |||
| 351 | &xor ($j,$j); | ||
| 352 | &add ("edx",&DWP($frame+4,"esp",$num,4)); # carry+=tp[num] | ||
| 353 | &mov (&DWP($frame,"esp",$num,4),$carry); # tp[num-1]= | ||
| 354 | &adc ($j,0); | ||
| 355 | &mov ("eax",&DWP(0,$inp)); # np[0] | ||
| 356 | &mov (&DWP($frame+4,"esp",$num,4),"edx"); # tp[num]= | ||
| 357 | &mov (&DWP($frame+8,"esp",$num,4),$j); # tp[num+1]= | ||
| 358 | |||
| 359 | &mul ($word); # np[0]*m | ||
| 360 | &add ("eax",&DWP($frame,"esp")); # +=tp[0] | ||
| 361 | &mov ("eax",&DWP(4,$inp)); # np[1] | ||
| 362 | &adc ("edx",0); | ||
| 363 | &mov ($j,1); | ||
| 364 | |||
| 365 | &set_label("2ndmadd",16); | ||
| 366 | &mov ($carry,"edx"); | ||
| 367 | &mul ($word); # np[j]*m | ||
| 368 | &add ($carry,&DWP($frame,"esp",$j,4)); # +=tp[j] | ||
| 369 | &lea ($j,&DWP(1,$j)); | ||
| 370 | &adc ("edx",0); | ||
| 371 | &add ($carry,"eax"); | ||
| 372 | &mov ("eax",&DWP(0,$inp,$j,4)); # np[j+1] | ||
| 373 | &adc ("edx",0); | ||
| 374 | &cmp ($j,$num); | ||
| 375 | &mov (&DWP($frame-8,"esp",$j,4),$carry); # tp[j-1]= | ||
| 376 | &jl (&label("2ndmadd")); | ||
| 377 | |||
| 378 | &mov ($carry,"edx"); | ||
| 379 | &mul ($word); # np[j]*m | ||
| 380 | &add ($carry,&DWP($frame,"esp",$num,4)); # +=tp[num-1] | ||
| 381 | &adc ("edx",0); | ||
| 382 | &add ($carry,"eax"); | ||
| 383 | &adc ("edx",0); | ||
| 384 | &mov (&DWP($frame-4,"esp",$num,4),$carry); # tp[num-2]= | ||
| 385 | |||
| 386 | &xor ("eax","eax"); | ||
| 387 | &mov ($j,$_bp); # &bp[i] | ||
| 388 | &add ("edx",&DWP($frame+4,"esp",$num,4)); # carry+=tp[num] | ||
| 389 | &adc ("eax",&DWP($frame+8,"esp",$num,4)); # +=tp[num+1] | ||
| 390 | &lea ($j,&DWP(4,$j)); | ||
| 391 | &mov (&DWP($frame,"esp",$num,4),"edx"); # tp[num-1]= | ||
| 392 | &cmp ($j,$_bpend); | ||
| 393 | &mov (&DWP($frame+4,"esp",$num,4),"eax"); # tp[num]= | ||
| 394 | &je (&label("common_tail")); | ||
| 395 | |||
| 396 | &mov ($word,&DWP(0,$j)); # bp[i+1] | ||
| 397 | &mov ($inp,$_ap); | ||
| 398 | &mov ($_bp,$j); # &bp[++i] | ||
| 399 | &xor ($j,$j); | ||
| 400 | &xor ("edx","edx"); | ||
| 401 | &mov ("eax",&DWP(0,$inp)); | ||
| 402 | &jmp (&label("1stmadd")); | ||
| 403 | |||
| 404 | &set_label("bn_sqr_mont",16); | ||
| 405 | $sbit=$num; | ||
| 406 | &mov ($_num,$num); | ||
| 407 | &mov ($_bp,$j); # i=0 | ||
| 408 | |||
| 409 | &mov ("eax",$word); # ap[0] | ||
| 410 | &mul ($word); # ap[0]*ap[0] | ||
| 411 | &mov (&DWP($frame,"esp"),"eax"); # tp[0]= | ||
| 412 | &mov ($sbit,"edx"); | ||
| 413 | &shr ("edx",1); | ||
| 414 | &and ($sbit,1); | ||
| 415 | &inc ($j); | ||
| 416 | &set_label("sqr",16); | ||
| 417 | &mov ("eax",&DWP(0,$inp,$j,4)); # ap[j] | ||
| 418 | &mov ($carry,"edx"); | ||
| 419 | &mul ($word); # ap[j]*ap[0] | ||
| 420 | &add ("eax",$carry); | ||
| 421 | &lea ($j,&DWP(1,$j)); | ||
| 422 | &adc ("edx",0); | ||
| 423 | &lea ($carry,&DWP(0,$sbit,"eax",2)); | ||
| 424 | &shr ("eax",31); | ||
| 425 | &cmp ($j,$_num); | ||
| 426 | &mov ($sbit,"eax"); | ||
| 427 | &mov (&DWP($frame-4,"esp",$j,4),$carry); # tp[j]= | ||
| 428 | &jl (&label("sqr")); | ||
| 429 | |||
| 430 | &mov ("eax",&DWP(0,$inp,$j,4)); # ap[num-1] | ||
| 431 | &mov ($carry,"edx"); | ||
| 432 | &mul ($word); # ap[num-1]*ap[0] | ||
| 433 | &add ("eax",$carry); | ||
| 434 | &mov ($word,$_n0); | ||
| 435 | &adc ("edx",0); | ||
| 436 | &mov ($inp,$_np); | ||
| 437 | &lea ($carry,&DWP(0,$sbit,"eax",2)); | ||
| 438 | &imul ($word,&DWP($frame,"esp")); # n0*tp[0] | ||
| 439 | &shr ("eax",31); | ||
| 440 | &mov (&DWP($frame,"esp",$j,4),$carry); # tp[num-1]= | ||
| 441 | |||
| 442 | &lea ($carry,&DWP(0,"eax","edx",2)); | ||
| 443 | &mov ("eax",&DWP(0,$inp)); # np[0] | ||
| 444 | &shr ("edx",31); | ||
| 445 | &mov (&DWP($frame+4,"esp",$j,4),$carry); # tp[num]= | ||
| 446 | &mov (&DWP($frame+8,"esp",$j,4),"edx"); # tp[num+1]= | ||
| 447 | |||
| 448 | &mul ($word); # np[0]*m | ||
| 449 | &add ("eax",&DWP($frame,"esp")); # +=tp[0] | ||
| 450 | &mov ($num,$j); | ||
| 451 | &adc ("edx",0); | ||
| 452 | &mov ("eax",&DWP(4,$inp)); # np[1] | ||
| 453 | &mov ($j,1); | ||
| 454 | |||
| 455 | &set_label("3rdmadd",16); | ||
| 456 | &mov ($carry,"edx"); | ||
| 457 | &mul ($word); # np[j]*m | ||
| 458 | &add ($carry,&DWP($frame,"esp",$j,4)); # +=tp[j] | ||
| 459 | &adc ("edx",0); | ||
| 460 | &add ($carry,"eax"); | ||
| 461 | &mov ("eax",&DWP(4,$inp,$j,4)); # np[j+1] | ||
| 462 | &adc ("edx",0); | ||
| 463 | &mov (&DWP($frame-4,"esp",$j,4),$carry); # tp[j-1]= | ||
| 464 | |||
| 465 | &mov ($carry,"edx"); | ||
| 466 | &mul ($word); # np[j+1]*m | ||
| 467 | &add ($carry,&DWP($frame+4,"esp",$j,4)); # +=tp[j+1] | ||
| 468 | &lea ($j,&DWP(2,$j)); | ||
| 469 | &adc ("edx",0); | ||
| 470 | &add ($carry,"eax"); | ||
| 471 | &mov ("eax",&DWP(0,$inp,$j,4)); # np[j+2] | ||
| 472 | &adc ("edx",0); | ||
| 473 | &cmp ($j,$num); | ||
| 474 | &mov (&DWP($frame-8,"esp",$j,4),$carry); # tp[j]= | ||
| 475 | &jl (&label("3rdmadd")); | ||
| 476 | |||
| 477 | &mov ($carry,"edx"); | ||
| 478 | &mul ($word); # np[j]*m | ||
| 479 | &add ($carry,&DWP($frame,"esp",$num,4)); # +=tp[num-1] | ||
| 480 | &adc ("edx",0); | ||
| 481 | &add ($carry,"eax"); | ||
| 482 | &adc ("edx",0); | ||
| 483 | &mov (&DWP($frame-4,"esp",$num,4),$carry); # tp[num-2]= | ||
| 484 | |||
| 485 | &mov ($j,$_bp); # i | ||
| 486 | &xor ("eax","eax"); | ||
| 487 | &mov ($inp,$_ap); | ||
| 488 | &add ("edx",&DWP($frame+4,"esp",$num,4)); # carry+=tp[num] | ||
| 489 | &adc ("eax",&DWP($frame+8,"esp",$num,4)); # +=tp[num+1] | ||
| 490 | &mov (&DWP($frame,"esp",$num,4),"edx"); # tp[num-1]= | ||
| 491 | &cmp ($j,$num); | ||
| 492 | &mov (&DWP($frame+4,"esp",$num,4),"eax"); # tp[num]= | ||
| 493 | &je (&label("common_tail")); | ||
| 494 | |||
| 495 | &mov ($word,&DWP(4,$inp,$j,4)); # ap[i] | ||
| 496 | &lea ($j,&DWP(1,$j)); | ||
| 497 | &mov ("eax",$word); | ||
| 498 | &mov ($_bp,$j); # ++i | ||
| 499 | &mul ($word); # ap[i]*ap[i] | ||
| 500 | &add ("eax",&DWP($frame,"esp",$j,4)); # +=tp[i] | ||
| 501 | &adc ("edx",0); | ||
| 502 | &mov (&DWP($frame,"esp",$j,4),"eax"); # tp[i]= | ||
| 503 | &xor ($carry,$carry); | ||
| 504 | &cmp ($j,$num); | ||
| 505 | &lea ($j,&DWP(1,$j)); | ||
| 506 | &je (&label("sqrlast")); | ||
| 507 | |||
| 508 | &mov ($sbit,"edx"); # zaps $num | ||
| 509 | &shr ("edx",1); | ||
| 510 | &and ($sbit,1); | ||
| 511 | &set_label("sqradd",16); | ||
| 512 | &mov ("eax",&DWP(0,$inp,$j,4)); # ap[j] | ||
| 513 | &mov ($carry,"edx"); | ||
| 514 | &mul ($word); # ap[j]*ap[i] | ||
| 515 | &add ("eax",$carry); | ||
| 516 | &lea ($carry,&DWP(0,"eax","eax")); | ||
| 517 | &adc ("edx",0); | ||
| 518 | &shr ("eax",31); | ||
| 519 | &add ($carry,&DWP($frame,"esp",$j,4)); # +=tp[j] | ||
| 520 | &lea ($j,&DWP(1,$j)); | ||
| 521 | &adc ("eax",0); | ||
| 522 | &add ($carry,$sbit); | ||
| 523 | &adc ("eax",0); | ||
| 524 | &cmp ($j,$_num); | ||
| 525 | &mov (&DWP($frame-4,"esp",$j,4),$carry); # tp[j]= | ||
| 526 | &mov ($sbit,"eax"); | ||
| 527 | &jle (&label("sqradd")); | ||
| 528 | |||
| 529 | &mov ($carry,"edx"); | ||
| 530 | &lea ("edx",&DWP(0,$sbit,"edx",2)); | ||
| 531 | &shr ($carry,31); | ||
| 532 | &set_label("sqrlast"); | ||
| 533 | &mov ($word,$_n0); | ||
| 534 | &mov ($inp,$_np); | ||
| 535 | &imul ($word,&DWP($frame,"esp")); # n0*tp[0] | ||
| 536 | |||
| 537 | &add ("edx",&DWP($frame,"esp",$j,4)); # +=tp[num] | ||
| 538 | &mov ("eax",&DWP(0,$inp)); # np[0] | ||
| 539 | &adc ($carry,0); | ||
| 540 | &mov (&DWP($frame,"esp",$j,4),"edx"); # tp[num]= | ||
| 541 | &mov (&DWP($frame+4,"esp",$j,4),$carry); # tp[num+1]= | ||
| 542 | |||
| 543 | &mul ($word); # np[0]*m | ||
| 544 | &add ("eax",&DWP($frame,"esp")); # +=tp[0] | ||
| 545 | &lea ($num,&DWP(-1,$j)); | ||
| 546 | &adc ("edx",0); | ||
| 547 | &mov ($j,1); | ||
| 548 | &mov ("eax",&DWP(4,$inp)); # np[1] | ||
| 549 | |||
| 550 | &jmp (&label("3rdmadd")); | ||
| 551 | } | ||
| 552 | |||
| 553 | &set_label("common_tail",16); | ||
| 554 | &mov ($np,$_np); # load modulus pointer | ||
| 555 | &mov ($rp,$_rp); # load result pointer | ||
| 556 | &lea ($tp,&DWP($frame,"esp")); # [$ap and $bp are zapped] | ||
| 557 | |||
| 558 | &mov ("eax",&DWP(0,$tp)); # tp[0] | ||
| 559 | &mov ($j,$num); # j=num-1 | ||
| 560 | &xor ($i,$i); # i=0 and clear CF! | ||
| 561 | |||
| 562 | &set_label("sub",16); | ||
| 563 | &sbb ("eax",&DWP(0,$np,$i,4)); | ||
| 564 | &mov (&DWP(0,$rp,$i,4),"eax"); # rp[i]=tp[i]-np[i] | ||
| 565 | &dec ($j); # doesn't affect CF! | ||
| 566 | &mov ("eax",&DWP(4,$tp,$i,4)); # tp[i+1] | ||
| 567 | &lea ($i,&DWP(1,$i)); # i++ | ||
| 568 | &jge (&label("sub")); | ||
| 569 | |||
| 570 | &sbb ("eax",0); # handle upmost overflow bit | ||
| 571 | &and ($tp,"eax"); | ||
| 572 | ¬ ("eax"); | ||
| 573 | &mov ($np,$rp); | ||
| 574 | &and ($np,"eax"); | ||
| 575 | &or ($tp,$np); # tp=carry?tp:rp | ||
| 576 | |||
| 577 | &set_label("copy",16); # copy or in-place refresh | ||
| 578 | &mov ("eax",&DWP(0,$tp,$num,4)); | ||
| 579 | &mov (&DWP(0,$rp,$num,4),"eax"); # rp[i]=tp[i] | ||
| 580 | &mov (&DWP($frame,"esp",$num,4),$j); # zap temporary vector | ||
| 581 | &dec ($num); | ||
| 582 | &jge (&label("copy")); | ||
| 583 | |||
| 584 | &mov ("esp",$_sp); # pull saved stack pointer | ||
| 585 | &mov ("eax",1); | ||
| 586 | &set_label("just_leave"); | ||
| 587 | &function_end("bn_mul_mont"); | ||
| 588 | |||
| 589 | &asciz("Montgomery Multiplication for x86, CRYPTOGAMS by <appro\@openssl.org>"); | ||
| 590 | |||
| 591 | &asm_finish(); | ||
diff --git a/src/lib/libssl/src/crypto/camellia/asm/cmll-x86.pl b/src/lib/libssl/src/crypto/camellia/asm/cmll-x86.pl new file mode 100644 index 0000000000..0812815bfb --- /dev/null +++ b/src/lib/libssl/src/crypto/camellia/asm/cmll-x86.pl | |||
| @@ -0,0 +1,1138 @@ | |||
| 1 | #!/usr/bin/env perl | ||
| 2 | |||
| 3 | # ==================================================================== | ||
| 4 | # Copyright (c) 2008 Andy Polyakov <appro@openssl.org> | ||
| 5 | # | ||
| 6 | # This module may be used under the terms of either the GNU General | ||
| 7 | # Public License version 2 or later, the GNU Lesser General Public | ||
| 8 | # License version 2.1 or later, the Mozilla Public License version | ||
| 9 | # 1.1 or the BSD License. The exact terms of either license are | ||
| 10 | # distributed along with this module. For further details see | ||
| 11 | # http://www.openssl.org/~appro/camellia/. | ||
| 12 | # ==================================================================== | ||
| 13 | |||
| 14 | # Performance in cycles per processed byte (less is better) in | ||
| 15 | # 'openssl speed ...' benchmark: | ||
| 16 | # | ||
| 17 | # AMD K8 Core2 PIII P4 | ||
| 18 | # -evp camellia-128-ecb 21.5 22.8 27.0 28.9 | ||
| 19 | # + over gcc 3.4.6 +90/11% +70/10% +53/4% +160/64% | ||
| 20 | # + over icc 8.0 +48/19% +21/15% +21/17% +55/37% | ||
| 21 | # | ||
| 22 | # camellia-128-cbc 17.3 21.1 23.9 25.9 | ||
| 23 | # | ||
| 24 | # 128-bit key setup 196 280 256 240 cycles/key | ||
| 25 | # + over gcc 3.4.6 +30/0% +17/11% +11/0% +63/40% | ||
| 26 | # + over icc 8.0 +18/3% +10/0% +10/3% +21/10% | ||
| 27 | # | ||
| 28 | # Pairs of numbers in "+" rows represent performance improvement over | ||
| 29 | # compiler generated position-independent code, PIC, and non-PIC | ||
| 30 | # respectively. PIC results are of greater relevance, as this module | ||
| 31 | # is position-independent, i.e. suitable for a shared library or PIE. | ||
| 32 | # Position independence "costs" one register, which is why compilers | ||
| 33 | # are so close with non-PIC results, they have an extra register to | ||
| 34 | # spare. CBC results are better than ECB ones thanks to "zero-copy" | ||
| 35 | # private _x86_* interface, and are ~30-40% better than with compiler | ||
| 36 | # generated cmll_cbc.o, and reach ~80-90% of x86_64 performance on | ||
| 37 | # same CPU (where applicable). | ||
| 38 | |||
| 39 | $0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1; | ||
| 40 | push(@INC,"${dir}","${dir}../../perlasm"); | ||
| 41 | require "x86asm.pl"; | ||
| 42 | |||
| 43 | $OPENSSL=1; | ||
| 44 | |||
| 45 | &asm_init($ARGV[0],"cmll-586.pl",$ARGV[$#ARGV] eq "386"); | ||
| 46 | |||
| 47 | @T=("eax","ebx","ecx","edx"); | ||
| 48 | $idx="esi"; | ||
| 49 | $key="edi"; | ||
| 50 | $Tbl="ebp"; | ||
| 51 | |||
| 52 | # stack frame layout in _x86_Camellia_* routines, frame is allocated | ||
| 53 | # by caller | ||
| 54 | $__ra=&DWP(0,"esp"); # return address | ||
| 55 | $__s0=&DWP(4,"esp"); # s0 backing store | ||
| 56 | $__s1=&DWP(8,"esp"); # s1 backing store | ||
| 57 | $__s2=&DWP(12,"esp"); # s2 backing store | ||
| 58 | $__s3=&DWP(16,"esp"); # s3 backing store | ||
| 59 | $__end=&DWP(20,"esp"); # pointer to end/start of key schedule | ||
| 60 | |||
| 61 | # stack frame layout in Camellia_[en|crypt] routines, which differs from | ||
| 62 | # above by 4 and overlaps by pointer to end/start of key schedule | ||
| 63 | $_end=&DWP(16,"esp"); | ||
| 64 | $_esp=&DWP(20,"esp"); | ||
| 65 | |||
| 66 | # const unsigned int Camellia_SBOX[4][256]; | ||
| 67 | # Well, sort of... Camellia_SBOX[0][] is interleaved with [1][], | ||
| 68 | # and [2][] - with [3][]. This is done to optimize code size. | ||
| 69 | $SBOX1_1110=0; # Camellia_SBOX[0] | ||
| 70 | $SBOX4_4404=4; # Camellia_SBOX[1] | ||
| 71 | $SBOX2_0222=2048; # Camellia_SBOX[2] | ||
| 72 | $SBOX3_3033=2052; # Camellia_SBOX[3] | ||
| 73 | &static_label("Camellia_SIGMA"); | ||
| 74 | &static_label("Camellia_SBOX"); | ||
| 75 | |||
| 76 | sub Camellia_Feistel { | ||
| 77 | my $i=@_[0]; | ||
| 78 | my $seed=defined(@_[1])?@_[1]:0; | ||
| 79 | my $scale=$seed<0?-8:8; | ||
| 80 | my $frame=defined(@_[2])?@_[2]:0; | ||
| 81 | my $j=($i&1)*2; | ||
| 82 | my $t0=@T[($j)%4],$t1=@T[($j+1)%4],$t2=@T[($j+2)%4],$t3=@T[($j+3)%4]; | ||
| 83 | |||
| 84 | &xor ($t0,$idx); # t0^=key[0] | ||
| 85 | &xor ($t1,&DWP($seed+$i*$scale+4,$key)); # t1^=key[1] | ||
| 86 | &movz ($idx,&HB($t0)); # (t0>>8)&0xff | ||
| 87 | &mov ($t3,&DWP($SBOX3_3033,$Tbl,$idx,8)); # t3=SBOX3_3033[0] | ||
| 88 | &movz ($idx,&LB($t0)); # (t0>>0)&0xff | ||
| 89 | &xor ($t3,&DWP($SBOX4_4404,$Tbl,$idx,8)); # t3^=SBOX4_4404[0] | ||
| 90 | &shr ($t0,16); | ||
| 91 | &movz ($idx,&LB($t1)); # (t1>>0)&0xff | ||
| 92 | &mov ($t2,&DWP($SBOX1_1110,$Tbl,$idx,8)); # t2=SBOX1_1110[1] | ||
| 93 | &movz ($idx,&HB($t0)); # (t0>>24)&0xff | ||
| 94 | &xor ($t3,&DWP($SBOX1_1110,$Tbl,$idx,8)); # t3^=SBOX1_1110[0] | ||
| 95 | &movz ($idx,&HB($t1)); # (t1>>8)&0xff | ||
| 96 | &xor ($t2,&DWP($SBOX4_4404,$Tbl,$idx,8)); # t2^=SBOX4_4404[1] | ||
| 97 | &shr ($t1,16); | ||
| 98 | &movz ($t0,&LB($t0)); # (t0>>16)&0xff | ||
| 99 | &xor ($t3,&DWP($SBOX2_0222,$Tbl,$t0,8)); # t3^=SBOX2_0222[0] | ||
| 100 | &movz ($idx,&HB($t1)); # (t1>>24)&0xff | ||
| 101 | &mov ($t0,&DWP($frame+4*(($j+3)%4),"esp")); # prefetch "s3" | ||
| 102 | &xor ($t2,$t3); # t2^=t3 | ||
| 103 | &rotr ($t3,8); # t3=RightRotate(t3,8) | ||
| 104 | &xor ($t2,&DWP($SBOX2_0222,$Tbl,$idx,8)); # t2^=SBOX2_0222[1] | ||
| 105 | &movz ($idx,&LB($t1)); # (t1>>16)&0xff | ||
| 106 | &mov ($t1,&DWP($frame+4*(($j+2)%4),"esp")); # prefetch "s2" | ||
| 107 | &xor ($t3,$t0); # t3^=s3 | ||
| 108 | &xor ($t2,&DWP($SBOX3_3033,$Tbl,$idx,8)); # t2^=SBOX3_3033[1] | ||
| 109 | &mov ($idx,&DWP($seed+($i+1)*$scale,$key)); # prefetch key[i+1] | ||
| 110 | &xor ($t3,$t2); # t3^=t2 | ||
| 111 | &mov (&DWP($frame+4*(($j+3)%4),"esp"),$t3); # s3=t3 | ||
| 112 | &xor ($t2,$t1); # t2^=s2 | ||
| 113 | &mov (&DWP($frame+4*(($j+2)%4),"esp"),$t2); # s2=t2 | ||
| 114 | } | ||
| 115 | |||
| 116 | # void Camellia_EncryptBlock_Rounds( | ||
| 117 | # int grandRounds, | ||
| 118 | # const Byte plaintext[], | ||
| 119 | # const KEY_TABLE_TYPE keyTable, | ||
| 120 | # Byte ciphertext[]) | ||
| 121 | &function_begin("Camellia_EncryptBlock_Rounds"); | ||
| 122 | &mov ("eax",&wparam(0)); # load grandRounds | ||
| 123 | &mov ($idx,&wparam(1)); # load plaintext pointer | ||
| 124 | &mov ($key,&wparam(2)); # load key schedule pointer | ||
| 125 | |||
| 126 | &mov ("ebx","esp"); | ||
| 127 | &sub ("esp",7*4); # place for s[0-3],keyEnd,esp and ra | ||
| 128 | &and ("esp",-64); | ||
| 129 | |||
| 130 | # place stack frame just "above mod 1024" the key schedule | ||
| 131 | # this ensures that cache associativity of 2 suffices | ||
| 132 | &lea ("ecx",&DWP(-64-63,$key)); | ||
| 133 | &sub ("ecx","esp"); | ||
| 134 | &neg ("ecx"); | ||
| 135 | &and ("ecx",0x3C0); # modulo 1024, but aligned to cache-line | ||
| 136 | &sub ("esp","ecx"); | ||
| 137 | &add ("esp",4); # 4 is reserved for callee's return address | ||
| 138 | |||
| 139 | &shl ("eax",6); | ||
| 140 | &lea ("eax",&DWP(0,$key,"eax")); | ||
| 141 | &mov ($_esp,"ebx"); # save %esp | ||
| 142 | &mov ($_end,"eax"); # save keyEnd | ||
| 143 | |||
| 144 | &call (&label("pic_point")); | ||
| 145 | &set_label("pic_point"); | ||
| 146 | &blindpop($Tbl); | ||
| 147 | &lea ($Tbl,&DWP(&label("Camellia_SBOX")."-".&label("pic_point"),$Tbl)); | ||
| 148 | |||
| 149 | &mov (@T[0],&DWP(0,$idx)); # load plaintext | ||
| 150 | &mov (@T[1],&DWP(4,$idx)); | ||
| 151 | &mov (@T[2],&DWP(8,$idx)); | ||
| 152 | &bswap (@T[0]); | ||
| 153 | &mov (@T[3],&DWP(12,$idx)); | ||
| 154 | &bswap (@T[1]); | ||
| 155 | &bswap (@T[2]); | ||
| 156 | &bswap (@T[3]); | ||
| 157 | |||
| 158 | &call ("_x86_Camellia_encrypt"); | ||
| 159 | |||
| 160 | &mov ("esp",$_esp); | ||
| 161 | &bswap (@T[0]); | ||
| 162 | &mov ($idx,&wparam(3)); # load ciphertext pointer | ||
| 163 | &bswap (@T[1]); | ||
| 164 | &bswap (@T[2]); | ||
| 165 | &bswap (@T[3]); | ||
| 166 | &mov (&DWP(0,$idx),@T[0]); # write ciphertext | ||
| 167 | &mov (&DWP(4,$idx),@T[1]); | ||
| 168 | &mov (&DWP(8,$idx),@T[2]); | ||
| 169 | &mov (&DWP(12,$idx),@T[3]); | ||
| 170 | &function_end("Camellia_EncryptBlock_Rounds"); | ||
| 171 | # V1.x API | ||
| 172 | &function_begin_B("Camellia_EncryptBlock"); | ||
| 173 | &mov ("eax",128); | ||
| 174 | &sub ("eax",&wparam(0)); # load keyBitLength | ||
| 175 | &mov ("eax",3); | ||
| 176 | &adc ("eax",0); # keyBitLength==128?3:4 | ||
| 177 | &mov (&wparam(0),"eax"); | ||
| 178 | &jmp (&label("Camellia_EncryptBlock_Rounds")); | ||
| 179 | &function_end_B("Camellia_EncryptBlock"); | ||
| 180 | |||
| 181 | if ($OPENSSL) { | ||
| 182 | # void Camellia_encrypt( | ||
| 183 | # const unsigned char *in, | ||
| 184 | # unsigned char *out, | ||
| 185 | # const CAMELLIA_KEY *key) | ||
| 186 | &function_begin("Camellia_encrypt"); | ||
| 187 | &mov ($idx,&wparam(0)); # load plaintext pointer | ||
| 188 | &mov ($key,&wparam(2)); # load key schedule pointer | ||
| 189 | |||
| 190 | &mov ("ebx","esp"); | ||
| 191 | &sub ("esp",7*4); # place for s[0-3],keyEnd,esp and ra | ||
| 192 | &and ("esp",-64); | ||
| 193 | &mov ("eax",&DWP(272,$key)); # load grandRounds counter | ||
| 194 | |||
| 195 | # place stack frame just "above mod 1024" the key schedule | ||
| 196 | # this ensures that cache associativity of 2 suffices | ||
| 197 | &lea ("ecx",&DWP(-64-63,$key)); | ||
| 198 | &sub ("ecx","esp"); | ||
| 199 | &neg ("ecx"); | ||
| 200 | &and ("ecx",0x3C0); # modulo 1024, but aligned to cache-line | ||
| 201 | &sub ("esp","ecx"); | ||
| 202 | &add ("esp",4); # 4 is reserved for callee's return address | ||
| 203 | |||
| 204 | &shl ("eax",6); | ||
| 205 | &lea ("eax",&DWP(0,$key,"eax")); | ||
| 206 | &mov ($_esp,"ebx"); # save %esp | ||
| 207 | &mov ($_end,"eax"); # save keyEnd | ||
| 208 | |||
| 209 | &call (&label("pic_point")); | ||
| 210 | &set_label("pic_point"); | ||
| 211 | &blindpop($Tbl); | ||
| 212 | &lea ($Tbl,&DWP(&label("Camellia_SBOX")."-".&label("pic_point"),$Tbl)); | ||
| 213 | |||
| 214 | &mov (@T[0],&DWP(0,$idx)); # load plaintext | ||
| 215 | &mov (@T[1],&DWP(4,$idx)); | ||
| 216 | &mov (@T[2],&DWP(8,$idx)); | ||
| 217 | &bswap (@T[0]); | ||
| 218 | &mov (@T[3],&DWP(12,$idx)); | ||
| 219 | &bswap (@T[1]); | ||
| 220 | &bswap (@T[2]); | ||
| 221 | &bswap (@T[3]); | ||
| 222 | |||
| 223 | &call ("_x86_Camellia_encrypt"); | ||
| 224 | |||
| 225 | &mov ("esp",$_esp); | ||
| 226 | &bswap (@T[0]); | ||
| 227 | &mov ($idx,&wparam(1)); # load ciphertext pointer | ||
| 228 | &bswap (@T[1]); | ||
| 229 | &bswap (@T[2]); | ||
| 230 | &bswap (@T[3]); | ||
| 231 | &mov (&DWP(0,$idx),@T[0]); # write ciphertext | ||
| 232 | &mov (&DWP(4,$idx),@T[1]); | ||
| 233 | &mov (&DWP(8,$idx),@T[2]); | ||
| 234 | &mov (&DWP(12,$idx),@T[3]); | ||
| 235 | &function_end("Camellia_encrypt"); | ||
| 236 | } | ||
| 237 | |||
| 238 | &function_begin_B("_x86_Camellia_encrypt"); | ||
| 239 | &xor (@T[0],&DWP(0,$key)); # ^=key[0-3] | ||
| 240 | &xor (@T[1],&DWP(4,$key)); | ||
| 241 | &xor (@T[2],&DWP(8,$key)); | ||
| 242 | &xor (@T[3],&DWP(12,$key)); | ||
| 243 | &mov ($idx,&DWP(16,$key)); # prefetch key[4] | ||
| 244 | |||
| 245 | &mov ($__s0,@T[0]); # save s[0-3] | ||
| 246 | &mov ($__s1,@T[1]); | ||
| 247 | &mov ($__s2,@T[2]); | ||
| 248 | &mov ($__s3,@T[3]); | ||
| 249 | |||
| 250 | &set_label("loop",16); | ||
| 251 | for ($i=0;$i<6;$i++) { Camellia_Feistel($i,16,4); } | ||
| 252 | |||
| 253 | &add ($key,16*4); | ||
| 254 | &cmp ($key,$__end); | ||
| 255 | &je (&label("done")); | ||
| 256 | |||
| 257 | # @T[0-1] are preloaded, $idx is preloaded with key[0] | ||
| 258 | &and ($idx,@T[0]); | ||
| 259 | &mov (@T[3],$__s3); | ||
| 260 | &rotl ($idx,1); | ||
| 261 | &mov (@T[2],@T[3]); | ||
| 262 | &xor (@T[1],$idx); | ||
| 263 | &or (@T[2],&DWP(12,$key)); | ||
| 264 | &mov ($__s1,@T[1]); # s1^=LeftRotate(s0&key[0],1); | ||
| 265 | &xor (@T[2],$__s2); | ||
| 266 | |||
| 267 | &mov ($idx,&DWP(4,$key)); | ||
| 268 | &mov ($__s2,@T[2]); # s2^=s3|key[3]; | ||
| 269 | &or ($idx,@T[1]); | ||
| 270 | &and (@T[2],&DWP(8,$key)); | ||
| 271 | &xor (@T[0],$idx); | ||
| 272 | &rotl (@T[2],1); | ||
| 273 | &mov ($__s0,@T[0]); # s0^=s1|key[1]; | ||
| 274 | &xor (@T[3],@T[2]); | ||
| 275 | &mov ($idx,&DWP(16,$key)); # prefetch key[4] | ||
| 276 | &mov ($__s3,@T[3]); # s3^=LeftRotate(s2&key[2],1); | ||
| 277 | &jmp (&label("loop")); | ||
| 278 | |||
| 279 | &set_label("done",8); | ||
| 280 | &mov (@T[2],@T[0]); # SwapHalf | ||
| 281 | &mov (@T[3],@T[1]); | ||
| 282 | &mov (@T[0],$__s2); | ||
| 283 | &mov (@T[1],$__s3); | ||
| 284 | &xor (@T[0],$idx); # $idx is preloaded with key[0] | ||
| 285 | &xor (@T[1],&DWP(4,$key)); | ||
| 286 | &xor (@T[2],&DWP(8,$key)); | ||
| 287 | &xor (@T[3],&DWP(12,$key)); | ||
| 288 | &ret (); | ||
| 289 | &function_end_B("_x86_Camellia_encrypt"); | ||
| 290 | |||
| 291 | # void Camellia_DecryptBlock_Rounds( | ||
| 292 | # int grandRounds, | ||
| 293 | # const Byte ciphertext[], | ||
| 294 | # const KEY_TABLE_TYPE keyTable, | ||
| 295 | # Byte plaintext[]) | ||
| 296 | &function_begin("Camellia_DecryptBlock_Rounds"); | ||
| 297 | &mov ("eax",&wparam(0)); # load grandRounds | ||
| 298 | &mov ($idx,&wparam(1)); # load ciphertext pointer | ||
| 299 | &mov ($key,&wparam(2)); # load key schedule pointer | ||
| 300 | |||
| 301 | &mov ("ebx","esp"); | ||
| 302 | &sub ("esp",7*4); # place for s[0-3],keyEnd,esp and ra | ||
| 303 | &and ("esp",-64); | ||
| 304 | |||
| 305 | # place stack frame just "above mod 1024" the key schedule | ||
| 306 | # this ensures that cache associativity of 2 suffices | ||
| 307 | &lea ("ecx",&DWP(-64-63,$key)); | ||
| 308 | &sub ("ecx","esp"); | ||
| 309 | &neg ("ecx"); | ||
| 310 | &and ("ecx",0x3C0); # modulo 1024, but aligned to cache-line | ||
| 311 | &sub ("esp","ecx"); | ||
| 312 | &add ("esp",4); # 4 is reserved for callee's return address | ||
| 313 | |||
| 314 | &shl ("eax",6); | ||
| 315 | &mov (&DWP(4*4,"esp"),$key); # save keyStart | ||
| 316 | &lea ($key,&DWP(0,$key,"eax")); | ||
| 317 | &mov (&DWP(5*4,"esp"),"ebx");# save %esp | ||
| 318 | |||
| 319 | &call (&label("pic_point")); | ||
| 320 | &set_label("pic_point"); | ||
| 321 | &blindpop($Tbl); | ||
| 322 | &lea ($Tbl,&DWP(&label("Camellia_SBOX")."-".&label("pic_point"),$Tbl)); | ||
| 323 | |||
| 324 | &mov (@T[0],&DWP(0,$idx)); # load ciphertext | ||
| 325 | &mov (@T[1],&DWP(4,$idx)); | ||
| 326 | &mov (@T[2],&DWP(8,$idx)); | ||
| 327 | &bswap (@T[0]); | ||
| 328 | &mov (@T[3],&DWP(12,$idx)); | ||
| 329 | &bswap (@T[1]); | ||
| 330 | &bswap (@T[2]); | ||
| 331 | &bswap (@T[3]); | ||
| 332 | |||
| 333 | &call ("_x86_Camellia_decrypt"); | ||
| 334 | |||
| 335 | &mov ("esp",&DWP(5*4,"esp")); | ||
| 336 | &bswap (@T[0]); | ||
| 337 | &mov ($idx,&wparam(3)); # load plaintext pointer | ||
| 338 | &bswap (@T[1]); | ||
| 339 | &bswap (@T[2]); | ||
| 340 | &bswap (@T[3]); | ||
| 341 | &mov (&DWP(0,$idx),@T[0]); # write plaintext | ||
| 342 | &mov (&DWP(4,$idx),@T[1]); | ||
| 343 | &mov (&DWP(8,$idx),@T[2]); | ||
| 344 | &mov (&DWP(12,$idx),@T[3]); | ||
| 345 | &function_end("Camellia_DecryptBlock_Rounds"); | ||
| 346 | # V1.x API | ||
| 347 | &function_begin_B("Camellia_DecryptBlock"); | ||
| 348 | &mov ("eax",128); | ||
| 349 | &sub ("eax",&wparam(0)); # load keyBitLength | ||
| 350 | &mov ("eax",3); | ||
| 351 | &adc ("eax",0); # keyBitLength==128?3:4 | ||
| 352 | &mov (&wparam(0),"eax"); | ||
| 353 | &jmp (&label("Camellia_DecryptBlock_Rounds")); | ||
| 354 | &function_end_B("Camellia_DecryptBlock"); | ||
| 355 | |||
| 356 | if ($OPENSSL) { | ||
| 357 | # void Camellia_decrypt( | ||
| 358 | # const unsigned char *in, | ||
| 359 | # unsigned char *out, | ||
| 360 | # const CAMELLIA_KEY *key) | ||
| 361 | &function_begin("Camellia_decrypt"); | ||
| 362 | &mov ($idx,&wparam(0)); # load ciphertext pointer | ||
| 363 | &mov ($key,&wparam(2)); # load key schedule pointer | ||
| 364 | |||
| 365 | &mov ("ebx","esp"); | ||
| 366 | &sub ("esp",7*4); # place for s[0-3],keyEnd,esp and ra | ||
| 367 | &and ("esp",-64); | ||
| 368 | &mov ("eax",&DWP(272,$key)); # load grandRounds counter | ||
| 369 | |||
| 370 | # place stack frame just "above mod 1024" the key schedule | ||
| 371 | # this ensures that cache associativity of 2 suffices | ||
| 372 | &lea ("ecx",&DWP(-64-63,$key)); | ||
| 373 | &sub ("ecx","esp"); | ||
| 374 | &neg ("ecx"); | ||
| 375 | &and ("ecx",0x3C0); # modulo 1024, but aligned to cache-line | ||
| 376 | &sub ("esp","ecx"); | ||
| 377 | &add ("esp",4); # 4 is reserved for callee's return address | ||
| 378 | |||
| 379 | &shl ("eax",6); | ||
| 380 | &mov (&DWP(4*4,"esp"),$key); # save keyStart | ||
| 381 | &lea ($key,&DWP(0,$key,"eax")); | ||
| 382 | &mov (&DWP(5*4,"esp"),"ebx");# save %esp | ||
| 383 | |||
| 384 | &call (&label("pic_point")); | ||
| 385 | &set_label("pic_point"); | ||
| 386 | &blindpop($Tbl); | ||
| 387 | &lea ($Tbl,&DWP(&label("Camellia_SBOX")."-".&label("pic_point"),$Tbl)); | ||
| 388 | |||
| 389 | &mov (@T[0],&DWP(0,$idx)); # load ciphertext | ||
| 390 | &mov (@T[1],&DWP(4,$idx)); | ||
| 391 | &mov (@T[2],&DWP(8,$idx)); | ||
| 392 | &bswap (@T[0]); | ||
| 393 | &mov (@T[3],&DWP(12,$idx)); | ||
| 394 | &bswap (@T[1]); | ||
| 395 | &bswap (@T[2]); | ||
| 396 | &bswap (@T[3]); | ||
| 397 | |||
| 398 | &call ("_x86_Camellia_decrypt"); | ||
| 399 | |||
| 400 | &mov ("esp",&DWP(5*4,"esp")); | ||
| 401 | &bswap (@T[0]); | ||
| 402 | &mov ($idx,&wparam(1)); # load plaintext pointer | ||
| 403 | &bswap (@T[1]); | ||
| 404 | &bswap (@T[2]); | ||
| 405 | &bswap (@T[3]); | ||
| 406 | &mov (&DWP(0,$idx),@T[0]); # write plaintext | ||
| 407 | &mov (&DWP(4,$idx),@T[1]); | ||
| 408 | &mov (&DWP(8,$idx),@T[2]); | ||
| 409 | &mov (&DWP(12,$idx),@T[3]); | ||
| 410 | &function_end("Camellia_decrypt"); | ||
| 411 | } | ||
| 412 | |||
| 413 | &function_begin_B("_x86_Camellia_decrypt"); | ||
| 414 | &xor (@T[0],&DWP(0,$key)); # ^=key[0-3] | ||
| 415 | &xor (@T[1],&DWP(4,$key)); | ||
| 416 | &xor (@T[2],&DWP(8,$key)); | ||
| 417 | &xor (@T[3],&DWP(12,$key)); | ||
| 418 | &mov ($idx,&DWP(-8,$key)); # prefetch key[-2] | ||
| 419 | |||
| 420 | &mov ($__s0,@T[0]); # save s[0-3] | ||
| 421 | &mov ($__s1,@T[1]); | ||
| 422 | &mov ($__s2,@T[2]); | ||
| 423 | &mov ($__s3,@T[3]); | ||
| 424 | |||
| 425 | &set_label("loop",16); | ||
| 426 | for ($i=0;$i<6;$i++) { Camellia_Feistel($i,-8,4); } | ||
| 427 | |||
| 428 | &sub ($key,16*4); | ||
| 429 | &cmp ($key,$__end); | ||
| 430 | &je (&label("done")); | ||
| 431 | |||
| 432 | # @T[0-1] are preloaded, $idx is preloaded with key[2] | ||
| 433 | &and ($idx,@T[0]); | ||
| 434 | &mov (@T[3],$__s3); | ||
| 435 | &rotl ($idx,1); | ||
| 436 | &mov (@T[2],@T[3]); | ||
| 437 | &xor (@T[1],$idx); | ||
| 438 | &or (@T[2],&DWP(4,$key)); | ||
| 439 | &mov ($__s1,@T[1]); # s1^=LeftRotate(s0&key[0],1); | ||
| 440 | &xor (@T[2],$__s2); | ||
| 441 | |||
| 442 | &mov ($idx,&DWP(12,$key)); | ||
| 443 | &mov ($__s2,@T[2]); # s2^=s3|key[3]; | ||
| 444 | &or ($idx,@T[1]); | ||
| 445 | &and (@T[2],&DWP(0,$key)); | ||
| 446 | &xor (@T[0],$idx); | ||
| 447 | &rotl (@T[2],1); | ||
| 448 | &mov ($__s0,@T[0]); # s0^=s1|key[1]; | ||
| 449 | &xor (@T[3],@T[2]); | ||
| 450 | &mov ($idx,&DWP(-8,$key)); # prefetch key[4] | ||
| 451 | &mov ($__s3,@T[3]); # s3^=LeftRotate(s2&key[2],1); | ||
| 452 | &jmp (&label("loop")); | ||
| 453 | |||
| 454 | &set_label("done",8); | ||
| 455 | &mov (@T[2],@T[0]); # SwapHalf | ||
| 456 | &mov (@T[3],@T[1]); | ||
| 457 | &mov (@T[0],$__s2); | ||
| 458 | &mov (@T[1],$__s3); | ||
| 459 | &xor (@T[2],$idx); # $idx is preloaded with key[2] | ||
| 460 | &xor (@T[3],&DWP(12,$key)); | ||
| 461 | &xor (@T[0],&DWP(0,$key)); | ||
| 462 | &xor (@T[1],&DWP(4,$key)); | ||
| 463 | &ret (); | ||
| 464 | &function_end_B("_x86_Camellia_decrypt"); | ||
| 465 | |||
| 466 | # shld is very slow on Intel P4 family. Even on AMD it limits | ||
| 467 | # instruction decode rate [because it's VectorPath] and consequently | ||
| 468 | # performance. PIII, PM and Core[2] seem to be the only ones which | ||
| 469 | # execute this code ~7% faster... | ||
| 470 | sub __rotl128 { | ||
| 471 | my ($i0,$i1,$i2,$i3,$rot,$rnd,@T)=@_; | ||
| 472 | |||
| 473 | $rnd *= 2; | ||
| 474 | if ($rot) { | ||
| 475 | &mov ($idx,$i0); | ||
| 476 | &shld ($i0,$i1,$rot); | ||
| 477 | &shld ($i1,$i2,$rot); | ||
| 478 | &shld ($i2,$i3,$rot); | ||
| 479 | &shld ($i3,$idx,$rot); | ||
| 480 | } | ||
| 481 | &mov (&DWP(-128+4*$rnd++,$key),shift(@T)) if ($i0 eq @T[0]); | ||
| 482 | &mov (&DWP(-128+4*$rnd++,$key),shift(@T)) if ($i1 eq @T[0]); | ||
| 483 | &mov (&DWP(-128+4*$rnd++,$key),shift(@T)) if ($i2 eq @T[0]); | ||
| 484 | &mov (&DWP(-128+4*$rnd++,$key),shift(@T)) if ($i3 eq @T[0]); | ||
| 485 | } | ||
| 486 | |||
| 487 | # ... Implementing 128-bit rotate without shld gives >3x performance | ||
| 488 | # improvement on P4, only ~7% degradation on other Intel CPUs and | ||
| 489 | # not worse performance on AMD. This is therefore preferred. | ||
| 490 | sub _rotl128 { | ||
| 491 | my ($i0,$i1,$i2,$i3,$rot,$rnd,@T)=@_; | ||
| 492 | |||
| 493 | $rnd *= 2; | ||
| 494 | if ($rot) { | ||
| 495 | &mov ($Tbl,$i0); | ||
| 496 | &shl ($i0,$rot); | ||
| 497 | &mov ($idx,$i1); | ||
| 498 | &shr ($idx,32-$rot); | ||
| 499 | &shl ($i1,$rot); | ||
| 500 | &or ($i0,$idx); | ||
| 501 | &mov ($idx,$i2); | ||
| 502 | &shl ($i2,$rot); | ||
| 503 | &mov (&DWP(-128+4*$rnd++,$key),shift(@T)) if ($i0 eq @T[0]); | ||
| 504 | &shr ($idx,32-$rot); | ||
| 505 | &or ($i1,$idx); | ||
| 506 | &shr ($Tbl,32-$rot); | ||
| 507 | &mov ($idx,$i3); | ||
| 508 | &shr ($idx,32-$rot); | ||
| 509 | &mov (&DWP(-128+4*$rnd++,$key),shift(@T)) if ($i1 eq @T[0]); | ||
| 510 | &shl ($i3,$rot); | ||
| 511 | &or ($i2,$idx); | ||
| 512 | &or ($i3,$Tbl); | ||
| 513 | &mov (&DWP(-128+4*$rnd++,$key),shift(@T)) if ($i2 eq @T[0]); | ||
| 514 | &mov (&DWP(-128+4*$rnd++,$key),shift(@T)) if ($i3 eq @T[0]); | ||
| 515 | } else { | ||
| 516 | &mov (&DWP(-128+4*$rnd++,$key),shift(@T)) if ($i0 eq @T[0]); | ||
| 517 | &mov (&DWP(-128+4*$rnd++,$key),shift(@T)) if ($i1 eq @T[0]); | ||
| 518 | &mov (&DWP(-128+4*$rnd++,$key),shift(@T)) if ($i2 eq @T[0]); | ||
| 519 | &mov (&DWP(-128+4*$rnd++,$key),shift(@T)) if ($i3 eq @T[0]); | ||
| 520 | } | ||
| 521 | } | ||
| 522 | |||
| 523 | sub _saveround { | ||
| 524 | my ($rnd,$key,@T)=@_; | ||
| 525 | my $bias=int(@T[0])?shift(@T):0; | ||
| 526 | |||
| 527 | &mov (&DWP($bias+$rnd*8+0,$key),@T[0]); | ||
| 528 | &mov (&DWP($bias+$rnd*8+4,$key),@T[1]) if ($#T>=1); | ||
| 529 | &mov (&DWP($bias+$rnd*8+8,$key),@T[2]) if ($#T>=2); | ||
| 530 | &mov (&DWP($bias+$rnd*8+12,$key),@T[3]) if ($#T>=3); | ||
| 531 | } | ||
| 532 | |||
| 533 | sub _loadround { | ||
| 534 | my ($rnd,$key,@T)=@_; | ||
| 535 | my $bias=int(@T[0])?shift(@T):0; | ||
| 536 | |||
| 537 | &mov (@T[0],&DWP($bias+$rnd*8+0,$key)); | ||
| 538 | &mov (@T[1],&DWP($bias+$rnd*8+4,$key)) if ($#T>=1); | ||
| 539 | &mov (@T[2],&DWP($bias+$rnd*8+8,$key)) if ($#T>=2); | ||
| 540 | &mov (@T[3],&DWP($bias+$rnd*8+12,$key)) if ($#T>=3); | ||
| 541 | } | ||
| 542 | |||
| 543 | # void Camellia_Ekeygen( | ||
| 544 | # const int keyBitLength, | ||
| 545 | # const Byte *rawKey, | ||
| 546 | # KEY_TABLE_TYPE keyTable) | ||
| 547 | &function_begin("Camellia_Ekeygen"); | ||
| 548 | { my $step=0; | ||
| 549 | |||
| 550 | &stack_push(4); # place for s[0-3] | ||
| 551 | |||
| 552 | &mov ($Tbl,&wparam(0)); # load arguments | ||
| 553 | &mov ($idx,&wparam(1)); | ||
| 554 | &mov ($key,&wparam(2)); | ||
| 555 | |||
| 556 | &mov (@T[0],&DWP(0,$idx)); # load 0-127 bits | ||
| 557 | &mov (@T[1],&DWP(4,$idx)); | ||
| 558 | &mov (@T[2],&DWP(8,$idx)); | ||
| 559 | &mov (@T[3],&DWP(12,$idx)); | ||
| 560 | |||
| 561 | &bswap (@T[0]); | ||
| 562 | &bswap (@T[1]); | ||
| 563 | &bswap (@T[2]); | ||
| 564 | &bswap (@T[3]); | ||
| 565 | |||
| 566 | &_saveround (0,$key,@T); # KL<<<0 | ||
| 567 | |||
| 568 | &cmp ($Tbl,128); | ||
| 569 | &je (&label("1st128")); | ||
| 570 | |||
| 571 | &mov (@T[0],&DWP(16,$idx)); # load 128-191 bits | ||
| 572 | &mov (@T[1],&DWP(20,$idx)); | ||
| 573 | &cmp ($Tbl,192); | ||
| 574 | &je (&label("1st192")); | ||
| 575 | &mov (@T[2],&DWP(24,$idx)); # load 192-255 bits | ||
| 576 | &mov (@T[3],&DWP(28,$idx)); | ||
| 577 | &jmp (&label("1st256")); | ||
| 578 | &set_label("1st192",4); | ||
| 579 | &mov (@T[2],@T[0]); | ||
| 580 | &mov (@T[3],@T[1]); | ||
| 581 | ¬ (@T[2]); | ||
| 582 | ¬ (@T[3]); | ||
| 583 | &set_label("1st256",4); | ||
| 584 | &bswap (@T[0]); | ||
| 585 | &bswap (@T[1]); | ||
| 586 | &bswap (@T[2]); | ||
| 587 | &bswap (@T[3]); | ||
| 588 | |||
| 589 | &_saveround (4,$key,@T); # temporary storage for KR! | ||
| 590 | |||
| 591 | &xor (@T[0],&DWP(0*8+0,$key)); # KR^KL | ||
| 592 | &xor (@T[1],&DWP(0*8+4,$key)); | ||
| 593 | &xor (@T[2],&DWP(1*8+0,$key)); | ||
| 594 | &xor (@T[3],&DWP(1*8+4,$key)); | ||
| 595 | |||
| 596 | &set_label("1st128",4); | ||
| 597 | &call (&label("pic_point")); | ||
| 598 | &set_label("pic_point"); | ||
| 599 | &blindpop($Tbl); | ||
| 600 | &lea ($Tbl,&DWP(&label("Camellia_SBOX")."-".&label("pic_point"),$Tbl)); | ||
| 601 | &lea ($key,&DWP(&label("Camellia_SIGMA")."-".&label("Camellia_SBOX"),$Tbl)); | ||
| 602 | |||
| 603 | &mov ($idx,&DWP($step*8,$key)); # prefetch SIGMA[0] | ||
| 604 | &mov (&swtmp(0),@T[0]); # save s[0-3] | ||
| 605 | &mov (&swtmp(1),@T[1]); | ||
| 606 | &mov (&swtmp(2),@T[2]); | ||
| 607 | &mov (&swtmp(3),@T[3]); | ||
| 608 | &Camellia_Feistel($step++); | ||
| 609 | &Camellia_Feistel($step++); | ||
| 610 | &mov (@T[2],&swtmp(2)); | ||
| 611 | &mov (@T[3],&swtmp(3)); | ||
| 612 | |||
| 613 | &mov ($idx,&wparam(2)); | ||
| 614 | &xor (@T[0],&DWP(0*8+0,$idx)); # ^KL | ||
| 615 | &xor (@T[1],&DWP(0*8+4,$idx)); | ||
| 616 | &xor (@T[2],&DWP(1*8+0,$idx)); | ||
| 617 | &xor (@T[3],&DWP(1*8+4,$idx)); | ||
| 618 | |||
| 619 | &mov ($idx,&DWP($step*8,$key)); # prefetch SIGMA[4] | ||
| 620 | &mov (&swtmp(0),@T[0]); # save s[0-3] | ||
| 621 | &mov (&swtmp(1),@T[1]); | ||
| 622 | &mov (&swtmp(2),@T[2]); | ||
| 623 | &mov (&swtmp(3),@T[3]); | ||
| 624 | &Camellia_Feistel($step++); | ||
| 625 | &Camellia_Feistel($step++); | ||
| 626 | &mov (@T[2],&swtmp(2)); | ||
| 627 | &mov (@T[3],&swtmp(3)); | ||
| 628 | |||
| 629 | &mov ($idx,&wparam(0)); | ||
| 630 | &cmp ($idx,128); | ||
| 631 | &jne (&label("2nd256")); | ||
| 632 | |||
| 633 | &mov ($key,&wparam(2)); | ||
| 634 | &lea ($key,&DWP(128,$key)); # size optimization | ||
| 635 | |||
| 636 | ####### process KA | ||
| 637 | &_saveround (2,$key,-128,@T); # KA<<<0 | ||
| 638 | &_rotl128 (@T,15,6,@T); # KA<<<15 | ||
| 639 | &_rotl128 (@T,15,8,@T); # KA<<<(15+15=30) | ||
| 640 | &_rotl128 (@T,15,12,@T[0],@T[1]); # KA<<<(30+15=45) | ||
| 641 | &_rotl128 (@T,15,14,@T); # KA<<<(45+15=60) | ||
| 642 | push (@T,shift(@T)); # rotl128(@T,32); | ||
| 643 | &_rotl128 (@T,2,20,@T); # KA<<<(60+32+2=94) | ||
| 644 | &_rotl128 (@T,17,24,@T); # KA<<<(94+17=111) | ||
| 645 | |||
| 646 | ####### process KL | ||
| 647 | &_loadround (0,$key,-128,@T); # load KL | ||
| 648 | &_rotl128 (@T,15,4,@T); # KL<<<15 | ||
| 649 | &_rotl128 (@T,30,10,@T); # KL<<<(15+30=45) | ||
| 650 | &_rotl128 (@T,15,13,@T[2],@T[3]); # KL<<<(45+15=60) | ||
| 651 | &_rotl128 (@T,17,16,@T); # KL<<<(60+17=77) | ||
| 652 | &_rotl128 (@T,17,18,@T); # KL<<<(77+17=94) | ||
| 653 | &_rotl128 (@T,17,22,@T); # KL<<<(94+17=111) | ||
| 654 | |||
| 655 | while (@T[0] ne "eax") # restore order | ||
| 656 | { unshift (@T,pop(@T)); } | ||
| 657 | |||
| 658 | &mov ("eax",3); # 3 grandRounds | ||
| 659 | &jmp (&label("done")); | ||
| 660 | |||
| 661 | &set_label("2nd256",16); | ||
| 662 | &mov ($idx,&wparam(2)); | ||
| 663 | &_saveround (6,$idx,@T); # temporary storage for KA! | ||
| 664 | |||
| 665 | &xor (@T[0],&DWP(4*8+0,$idx)); # KA^KR | ||
| 666 | &xor (@T[1],&DWP(4*8+4,$idx)); | ||
| 667 | &xor (@T[2],&DWP(5*8+0,$idx)); | ||
| 668 | &xor (@T[3],&DWP(5*8+4,$idx)); | ||
| 669 | |||
| 670 | &mov ($idx,&DWP($step*8,$key)); # prefetch SIGMA[8] | ||
| 671 | &mov (&swtmp(0),@T[0]); # save s[0-3] | ||
| 672 | &mov (&swtmp(1),@T[1]); | ||
| 673 | &mov (&swtmp(2),@T[2]); | ||
| 674 | &mov (&swtmp(3),@T[3]); | ||
| 675 | &Camellia_Feistel($step++); | ||
| 676 | &Camellia_Feistel($step++); | ||
| 677 | &mov (@T[2],&swtmp(2)); | ||
| 678 | &mov (@T[3],&swtmp(3)); | ||
| 679 | |||
| 680 | &mov ($key,&wparam(2)); | ||
| 681 | &lea ($key,&DWP(128,$key)); # size optimization | ||
| 682 | |||
| 683 | ####### process KB | ||
| 684 | &_saveround (2,$key,-128,@T); # KB<<<0 | ||
| 685 | &_rotl128 (@T,30,10,@T); # KB<<<30 | ||
| 686 | &_rotl128 (@T,30,20,@T); # KB<<<(30+30=60) | ||
| 687 | push (@T,shift(@T)); # rotl128(@T,32); | ||
| 688 | &_rotl128 (@T,19,32,@T); # KB<<<(60+32+19=111) | ||
| 689 | |||
| 690 | ####### process KR | ||
| 691 | &_loadround (4,$key,-128,@T); # load KR | ||
| 692 | &_rotl128 (@T,15,4,@T); # KR<<<15 | ||
| 693 | &_rotl128 (@T,15,8,@T); # KR<<<(15+15=30) | ||
| 694 | &_rotl128 (@T,30,18,@T); # KR<<<(30+30=60) | ||
| 695 | push (@T,shift(@T)); # rotl128(@T,32); | ||
| 696 | &_rotl128 (@T,2,26,@T); # KR<<<(60+32+2=94) | ||
| 697 | |||
| 698 | ####### process KA | ||
| 699 | &_loadround (6,$key,-128,@T); # load KA | ||
| 700 | &_rotl128 (@T,15,6,@T); # KA<<<15 | ||
| 701 | &_rotl128 (@T,30,14,@T); # KA<<<(15+30=45) | ||
| 702 | push (@T,shift(@T)); # rotl128(@T,32); | ||
| 703 | &_rotl128 (@T,0,24,@T); # KA<<<(45+32+0=77) | ||
| 704 | &_rotl128 (@T,17,28,@T); # KA<<<(77+17=94) | ||
| 705 | |||
| 706 | ####### process KL | ||
| 707 | &_loadround (0,$key,-128,@T); # load KL | ||
| 708 | push (@T,shift(@T)); # rotl128(@T,32); | ||
| 709 | &_rotl128 (@T,13,12,@T); # KL<<<(32+13=45) | ||
| 710 | &_rotl128 (@T,15,16,@T); # KL<<<(45+15=60) | ||
| 711 | &_rotl128 (@T,17,22,@T); # KL<<<(60+17=77) | ||
| 712 | push (@T,shift(@T)); # rotl128(@T,32); | ||
| 713 | &_rotl128 (@T,2,30,@T); # KL<<<(77+32+2=111) | ||
| 714 | |||
| 715 | while (@T[0] ne "eax") # restore order | ||
| 716 | { unshift (@T,pop(@T)); } | ||
| 717 | |||
| 718 | &mov ("eax",4); # 4 grandRounds | ||
| 719 | &set_label("done"); | ||
| 720 | &lea ("edx",&DWP(272-128,$key)); # end of key schedule | ||
| 721 | &stack_pop(4); | ||
| 722 | } | ||
| 723 | &function_end("Camellia_Ekeygen"); | ||
| 724 | |||
| 725 | if ($OPENSSL) { | ||
| 726 | # int Camellia_set_key ( | ||
| 727 | # const unsigned char *userKey, | ||
| 728 | # int bits, | ||
| 729 | # CAMELLIA_KEY *key) | ||
| 730 | &function_begin_B("Camellia_set_key"); | ||
| 731 | &push ("ebx"); | ||
| 732 | &mov ("ecx",&wparam(0)); # pull arguments | ||
| 733 | &mov ("ebx",&wparam(1)); | ||
| 734 | &mov ("edx",&wparam(2)); | ||
| 735 | |||
| 736 | &mov ("eax",-1); | ||
| 737 | &test ("ecx","ecx"); | ||
| 738 | &jz (&label("done")); # userKey==NULL? | ||
| 739 | &test ("edx","edx"); | ||
| 740 | &jz (&label("done")); # key==NULL? | ||
| 741 | |||
| 742 | &mov ("eax",-2); | ||
| 743 | &cmp ("ebx",256); | ||
| 744 | &je (&label("arg_ok")); # bits==256? | ||
| 745 | &cmp ("ebx",192); | ||
| 746 | &je (&label("arg_ok")); # bits==192? | ||
| 747 | &cmp ("ebx",128); | ||
| 748 | &jne (&label("done")); # bits!=128? | ||
| 749 | &set_label("arg_ok",4); | ||
| 750 | |||
| 751 | &push ("edx"); # push arguments | ||
| 752 | &push ("ecx"); | ||
| 753 | &push ("ebx"); | ||
| 754 | &call ("Camellia_Ekeygen"); | ||
| 755 | &stack_pop(3); | ||
| 756 | |||
| 757 | # eax holds grandRounds and edx points at where to put it | ||
| 758 | &mov (&DWP(0,"edx"),"eax"); | ||
| 759 | &xor ("eax","eax"); | ||
| 760 | &set_label("done",4); | ||
| 761 | &pop ("ebx"); | ||
| 762 | &ret (); | ||
| 763 | &function_end_B("Camellia_set_key"); | ||
| 764 | } | ||
| 765 | |||
| 766 | @SBOX=( | ||
| 767 | 112,130, 44,236,179, 39,192,229,228,133, 87, 53,234, 12,174, 65, | ||
| 768 | 35,239,107,147, 69, 25,165, 33,237, 14, 79, 78, 29,101,146,189, | ||
| 769 | 134,184,175,143,124,235, 31,206, 62, 48,220, 95, 94,197, 11, 26, | ||
| 770 | 166,225, 57,202,213, 71, 93, 61,217, 1, 90,214, 81, 86,108, 77, | ||
| 771 | 139, 13,154,102,251,204,176, 45,116, 18, 43, 32,240,177,132,153, | ||
| 772 | 223, 76,203,194, 52,126,118, 5,109,183,169, 49,209, 23, 4,215, | ||
| 773 | 20, 88, 58, 97,222, 27, 17, 28, 50, 15,156, 22, 83, 24,242, 34, | ||
| 774 | 254, 68,207,178,195,181,122,145, 36, 8,232,168, 96,252,105, 80, | ||
| 775 | 170,208,160,125,161,137, 98,151, 84, 91, 30,149,224,255,100,210, | ||
| 776 | 16,196, 0, 72,163,247,117,219,138, 3,230,218, 9, 63,221,148, | ||
| 777 | 135, 92,131, 2,205, 74,144, 51,115,103,246,243,157,127,191,226, | ||
| 778 | 82,155,216, 38,200, 55,198, 59,129,150,111, 75, 19,190, 99, 46, | ||
| 779 | 233,121,167,140,159,110,188,142, 41,245,249,182, 47,253,180, 89, | ||
| 780 | 120,152, 6,106,231, 70,113,186,212, 37,171, 66,136,162,141,250, | ||
| 781 | 114, 7,185, 85,248,238,172, 10, 54, 73, 42,104, 60, 56,241,164, | ||
| 782 | 64, 40,211,123,187,201, 67,193, 21,227,173,244,119,199,128,158); | ||
| 783 | |||
| 784 | sub S1110 { my $i=shift; $i=@SBOX[$i]; return $i<<24|$i<<16|$i<<8; } | ||
| 785 | sub S4404 { my $i=shift; $i=($i<<1|$i>>7)&0xff; $i=@SBOX[$i]; return $i<<24|$i<<16|$i; } | ||
| 786 | sub S0222 { my $i=shift; $i=@SBOX[$i]; $i=($i<<1|$i>>7)&0xff; return $i<<16|$i<<8|$i; } | ||
| 787 | sub S3033 { my $i=shift; $i=@SBOX[$i]; $i=($i>>1|$i<<7)&0xff; return $i<<24|$i<<8|$i; } | ||
| 788 | |||
| 789 | &set_label("Camellia_SIGMA",64); | ||
| 790 | &data_word( | ||
| 791 | 0xa09e667f, 0x3bcc908b, 0xb67ae858, 0x4caa73b2, | ||
| 792 | 0xc6ef372f, 0xe94f82be, 0x54ff53a5, 0xf1d36f1c, | ||
| 793 | 0x10e527fa, 0xde682d1d, 0xb05688c2, 0xb3e6c1fd, | ||
| 794 | 0, 0, 0, 0); | ||
| 795 | &set_label("Camellia_SBOX",64); | ||
| 796 | # tables are interleaved, remember? | ||
| 797 | for ($i=0;$i<256;$i++) { &data_word(&S1110($i),&S4404($i)); } | ||
| 798 | for ($i=0;$i<256;$i++) { &data_word(&S0222($i),&S3033($i)); } | ||
| 799 | |||
| 800 | # void Camellia_cbc_encrypt (const void char *inp, unsigned char *out, | ||
| 801 | # size_t length, const CAMELLIA_KEY *key, | ||
| 802 | # unsigned char *ivp,const int enc); | ||
| 803 | { | ||
| 804 | # stack frame layout | ||
| 805 | # -4(%esp) # return address 0(%esp) | ||
| 806 | # 0(%esp) # s0 4(%esp) | ||
| 807 | # 4(%esp) # s1 8(%esp) | ||
| 808 | # 8(%esp) # s2 12(%esp) | ||
| 809 | # 12(%esp) # s3 16(%esp) | ||
| 810 | # 16(%esp) # end of key schedule 20(%esp) | ||
| 811 | # 20(%esp) # %esp backup | ||
| 812 | my $_inp=&DWP(24,"esp"); #copy of wparam(0) | ||
| 813 | my $_out=&DWP(28,"esp"); #copy of wparam(1) | ||
| 814 | my $_len=&DWP(32,"esp"); #copy of wparam(2) | ||
| 815 | my $_key=&DWP(36,"esp"); #copy of wparam(3) | ||
| 816 | my $_ivp=&DWP(40,"esp"); #copy of wparam(4) | ||
| 817 | my $ivec=&DWP(44,"esp"); #ivec[16] | ||
| 818 | my $_tmp=&DWP(44,"esp"); #volatile variable [yes, aliases with ivec] | ||
| 819 | my ($s0,$s1,$s2,$s3) = @T; | ||
| 820 | |||
| 821 | &function_begin("Camellia_cbc_encrypt"); | ||
| 822 | &mov ($s2 eq "ecx"? $s2 : "",&wparam(2)); # load len | ||
| 823 | &cmp ($s2,0); | ||
| 824 | &je (&label("enc_out")); | ||
| 825 | |||
| 826 | &pushf (); | ||
| 827 | &cld (); | ||
| 828 | |||
| 829 | &mov ($s0,&wparam(0)); # load inp | ||
| 830 | &mov ($s1,&wparam(1)); # load out | ||
| 831 | #&mov ($s2,&wparam(2)); # load len | ||
| 832 | &mov ($s3,&wparam(3)); # load key | ||
| 833 | &mov ($Tbl,&wparam(4)); # load ivp | ||
| 834 | |||
| 835 | # allocate aligned stack frame... | ||
| 836 | &lea ($idx,&DWP(-64,"esp")); | ||
| 837 | &and ($idx,-64); | ||
| 838 | |||
| 839 | # place stack frame just "above mod 1024" the key schedule | ||
| 840 | # this ensures that cache associativity of 2 suffices | ||
| 841 | &lea ($key,&DWP(-64-63,$s3)); | ||
| 842 | &sub ($key,$idx); | ||
| 843 | &neg ($key); | ||
| 844 | &and ($key,0x3C0); # modulo 1024, but aligned to cache-line | ||
| 845 | &sub ($idx,$key); | ||
| 846 | |||
| 847 | &mov ($key,&wparam(5)); # load enc | ||
| 848 | |||
| 849 | &exch ("esp",$idx); | ||
| 850 | &add ("esp",4); # reserve for return address! | ||
| 851 | &mov ($_esp,$idx); # save %esp | ||
| 852 | |||
| 853 | &mov ($_inp,$s0); # save copy of inp | ||
| 854 | &mov ($_out,$s1); # save copy of out | ||
| 855 | &mov ($_len,$s2); # save copy of len | ||
| 856 | &mov ($_key,$s3); # save copy of key | ||
| 857 | &mov ($_ivp,$Tbl); # save copy of ivp | ||
| 858 | |||
| 859 | &call (&label("pic_point")); # make it PIC! | ||
| 860 | &set_label("pic_point"); | ||
| 861 | &blindpop($Tbl); | ||
| 862 | &lea ($Tbl,&DWP(&label("Camellia_SBOX")."-".&label("pic_point"),$Tbl)); | ||
| 863 | |||
| 864 | &mov ($idx,32); | ||
| 865 | &set_label("prefetch_sbox",4); | ||
| 866 | &mov ($s0,&DWP(0,$Tbl)); | ||
| 867 | &mov ($s1,&DWP(32,$Tbl)); | ||
| 868 | &mov ($s2,&DWP(64,$Tbl)); | ||
| 869 | &mov ($s3,&DWP(96,$Tbl)); | ||
| 870 | &lea ($Tbl,&DWP(128,$Tbl)); | ||
| 871 | &dec ($idx); | ||
| 872 | &jnz (&label("prefetch_sbox")); | ||
| 873 | &mov ($s0,$_key); | ||
| 874 | &sub ($Tbl,4096); | ||
| 875 | &mov ($idx,$_inp); | ||
| 876 | &mov ($s3,&DWP(272,$s0)); # load grandRounds | ||
| 877 | |||
| 878 | &cmp ($key,0); | ||
| 879 | &je (&label("DECRYPT")); | ||
| 880 | |||
| 881 | &mov ($s2,$_len); | ||
| 882 | &mov ($key,$_ivp); | ||
| 883 | &shl ($s3,6); | ||
| 884 | &lea ($s3,&DWP(0,$s0,$s3)); | ||
| 885 | &mov ($_end,$s3); | ||
| 886 | |||
| 887 | &test ($s2,0xFFFFFFF0); | ||
| 888 | &jz (&label("enc_tail")); # short input... | ||
| 889 | |||
| 890 | &mov ($s0,&DWP(0,$key)); # load iv | ||
| 891 | &mov ($s1,&DWP(4,$key)); | ||
| 892 | |||
| 893 | &set_label("enc_loop",4); | ||
| 894 | &mov ($s2,&DWP(8,$key)); | ||
| 895 | &mov ($s3,&DWP(12,$key)); | ||
| 896 | |||
| 897 | &xor ($s0,&DWP(0,$idx)); # xor input data | ||
| 898 | &xor ($s1,&DWP(4,$idx)); | ||
| 899 | &xor ($s2,&DWP(8,$idx)); | ||
| 900 | &bswap ($s0); | ||
| 901 | &xor ($s3,&DWP(12,$idx)); | ||
| 902 | &bswap ($s1); | ||
| 903 | &mov ($key,$_key); # load key | ||
| 904 | &bswap ($s2); | ||
| 905 | &bswap ($s3); | ||
| 906 | |||
| 907 | &call ("_x86_Camellia_encrypt"); | ||
| 908 | |||
| 909 | &mov ($idx,$_inp); # load inp | ||
| 910 | &mov ($key,$_out); # load out | ||
| 911 | |||
| 912 | &bswap ($s0); | ||
| 913 | &bswap ($s1); | ||
| 914 | &bswap ($s2); | ||
| 915 | &mov (&DWP(0,$key),$s0); # save output data | ||
| 916 | &bswap ($s3); | ||
| 917 | &mov (&DWP(4,$key),$s1); | ||
| 918 | &mov (&DWP(8,$key),$s2); | ||
| 919 | &mov (&DWP(12,$key),$s3); | ||
| 920 | |||
| 921 | &mov ($s2,$_len); # load len | ||
| 922 | |||
| 923 | &lea ($idx,&DWP(16,$idx)); | ||
| 924 | &mov ($_inp,$idx); # save inp | ||
| 925 | |||
| 926 | &lea ($s3,&DWP(16,$key)); | ||
| 927 | &mov ($_out,$s3); # save out | ||
| 928 | |||
| 929 | &sub ($s2,16); | ||
| 930 | &test ($s2,0xFFFFFFF0); | ||
| 931 | &mov ($_len,$s2); # save len | ||
| 932 | &jnz (&label("enc_loop")); | ||
| 933 | &test ($s2,15); | ||
| 934 | &jnz (&label("enc_tail")); | ||
| 935 | &mov ($idx,$_ivp); # load ivp | ||
| 936 | &mov ($s2,&DWP(8,$key)); # restore last dwords | ||
| 937 | &mov ($s3,&DWP(12,$key)); | ||
| 938 | &mov (&DWP(0,$idx),$s0); # save ivec | ||
| 939 | &mov (&DWP(4,$idx),$s1); | ||
| 940 | &mov (&DWP(8,$idx),$s2); | ||
| 941 | &mov (&DWP(12,$idx),$s3); | ||
| 942 | |||
| 943 | &mov ("esp",$_esp); | ||
| 944 | &popf (); | ||
| 945 | &set_label("enc_out"); | ||
| 946 | &function_end_A(); | ||
| 947 | &pushf (); # kludge, never executed | ||
| 948 | |||
| 949 | &set_label("enc_tail",4); | ||
| 950 | &mov ($s0,$key eq "edi" ? $key : ""); | ||
| 951 | &mov ($key,$_out); # load out | ||
| 952 | &push ($s0); # push ivp | ||
| 953 | &mov ($s1,16); | ||
| 954 | &sub ($s1,$s2); | ||
| 955 | &cmp ($key,$idx); # compare with inp | ||
| 956 | &je (&label("enc_in_place")); | ||
| 957 | &align (4); | ||
| 958 | &data_word(0xA4F3F689); # rep movsb # copy input | ||
| 959 | &jmp (&label("enc_skip_in_place")); | ||
| 960 | &set_label("enc_in_place"); | ||
| 961 | &lea ($key,&DWP(0,$key,$s2)); | ||
| 962 | &set_label("enc_skip_in_place"); | ||
| 963 | &mov ($s2,$s1); | ||
| 964 | &xor ($s0,$s0); | ||
| 965 | &align (4); | ||
| 966 | &data_word(0xAAF3F689); # rep stosb # zero tail | ||
| 967 | &pop ($key); # pop ivp | ||
| 968 | |||
| 969 | &mov ($idx,$_out); # output as input | ||
| 970 | &mov ($s0,&DWP(0,$key)); | ||
| 971 | &mov ($s1,&DWP(4,$key)); | ||
| 972 | &mov ($_len,16); # len=16 | ||
| 973 | &jmp (&label("enc_loop")); # one more spin... | ||
| 974 | |||
| 975 | #----------------------------- DECRYPT -----------------------------# | ||
| 976 | &set_label("DECRYPT",16); | ||
| 977 | &shl ($s3,6); | ||
| 978 | &lea ($s3,&DWP(0,$s0,$s3)); | ||
| 979 | &mov ($_end,$s0); | ||
| 980 | &mov ($_key,$s3); | ||
| 981 | |||
| 982 | &cmp ($idx,$_out); | ||
| 983 | &je (&label("dec_in_place")); # in-place processing... | ||
| 984 | |||
| 985 | &mov ($key,$_ivp); # load ivp | ||
| 986 | &mov ($_tmp,$key); | ||
| 987 | |||
| 988 | &set_label("dec_loop",4); | ||
| 989 | &mov ($s0,&DWP(0,$idx)); # read input | ||
| 990 | &mov ($s1,&DWP(4,$idx)); | ||
| 991 | &mov ($s2,&DWP(8,$idx)); | ||
| 992 | &bswap ($s0); | ||
| 993 | &mov ($s3,&DWP(12,$idx)); | ||
| 994 | &bswap ($s1); | ||
| 995 | &mov ($key,$_key); # load key | ||
| 996 | &bswap ($s2); | ||
| 997 | &bswap ($s3); | ||
| 998 | |||
| 999 | &call ("_x86_Camellia_decrypt"); | ||
| 1000 | |||
| 1001 | &mov ($key,$_tmp); # load ivp | ||
| 1002 | &mov ($idx,$_len); # load len | ||
| 1003 | |||
| 1004 | &bswap ($s0); | ||
| 1005 | &bswap ($s1); | ||
| 1006 | &bswap ($s2); | ||
| 1007 | &xor ($s0,&DWP(0,$key)); # xor iv | ||
| 1008 | &bswap ($s3); | ||
| 1009 | &xor ($s1,&DWP(4,$key)); | ||
| 1010 | &xor ($s2,&DWP(8,$key)); | ||
| 1011 | &xor ($s3,&DWP(12,$key)); | ||
| 1012 | |||
| 1013 | &sub ($idx,16); | ||
| 1014 | &jc (&label("dec_partial")); | ||
| 1015 | &mov ($_len,$idx); # save len | ||
| 1016 | &mov ($idx,$_inp); # load inp | ||
| 1017 | &mov ($key,$_out); # load out | ||
| 1018 | |||
| 1019 | &mov (&DWP(0,$key),$s0); # write output | ||
| 1020 | &mov (&DWP(4,$key),$s1); | ||
| 1021 | &mov (&DWP(8,$key),$s2); | ||
| 1022 | &mov (&DWP(12,$key),$s3); | ||
| 1023 | |||
| 1024 | &mov ($_tmp,$idx); # save ivp | ||
| 1025 | &lea ($idx,&DWP(16,$idx)); | ||
| 1026 | &mov ($_inp,$idx); # save inp | ||
| 1027 | |||
| 1028 | &lea ($key,&DWP(16,$key)); | ||
| 1029 | &mov ($_out,$key); # save out | ||
| 1030 | |||
| 1031 | &jnz (&label("dec_loop")); | ||
| 1032 | &mov ($key,$_tmp); # load temp ivp | ||
| 1033 | &set_label("dec_end"); | ||
| 1034 | &mov ($idx,$_ivp); # load user ivp | ||
| 1035 | &mov ($s0,&DWP(0,$key)); # load iv | ||
| 1036 | &mov ($s1,&DWP(4,$key)); | ||
| 1037 | &mov ($s2,&DWP(8,$key)); | ||
| 1038 | &mov ($s3,&DWP(12,$key)); | ||
| 1039 | &mov (&DWP(0,$idx),$s0); # copy back to user | ||
| 1040 | &mov (&DWP(4,$idx),$s1); | ||
| 1041 | &mov (&DWP(8,$idx),$s2); | ||
| 1042 | &mov (&DWP(12,$idx),$s3); | ||
| 1043 | &jmp (&label("dec_out")); | ||
| 1044 | |||
| 1045 | &set_label("dec_partial",4); | ||
| 1046 | &lea ($key,$ivec); | ||
| 1047 | &mov (&DWP(0,$key),$s0); # dump output to stack | ||
| 1048 | &mov (&DWP(4,$key),$s1); | ||
| 1049 | &mov (&DWP(8,$key),$s2); | ||
| 1050 | &mov (&DWP(12,$key),$s3); | ||
| 1051 | &lea ($s2 eq "ecx" ? $s2 : "",&DWP(16,$idx)); | ||
| 1052 | &mov ($idx eq "esi" ? $idx : "",$key); | ||
| 1053 | &mov ($key eq "edi" ? $key : "",$_out); # load out | ||
| 1054 | &data_word(0xA4F3F689); # rep movsb # copy output | ||
| 1055 | &mov ($key,$_inp); # use inp as temp ivp | ||
| 1056 | &jmp (&label("dec_end")); | ||
| 1057 | |||
| 1058 | &set_label("dec_in_place",4); | ||
| 1059 | &set_label("dec_in_place_loop"); | ||
| 1060 | &lea ($key,$ivec); | ||
| 1061 | &mov ($s0,&DWP(0,$idx)); # read input | ||
| 1062 | &mov ($s1,&DWP(4,$idx)); | ||
| 1063 | &mov ($s2,&DWP(8,$idx)); | ||
| 1064 | &mov ($s3,&DWP(12,$idx)); | ||
| 1065 | |||
| 1066 | &mov (&DWP(0,$key),$s0); # copy to temp | ||
| 1067 | &mov (&DWP(4,$key),$s1); | ||
| 1068 | &mov (&DWP(8,$key),$s2); | ||
| 1069 | &bswap ($s0); | ||
| 1070 | &mov (&DWP(12,$key),$s3); | ||
| 1071 | &bswap ($s1); | ||
| 1072 | &mov ($key,$_key); # load key | ||
| 1073 | &bswap ($s2); | ||
| 1074 | &bswap ($s3); | ||
| 1075 | |||
| 1076 | &call ("_x86_Camellia_decrypt"); | ||
| 1077 | |||
| 1078 | &mov ($key,$_ivp); # load ivp | ||
| 1079 | &mov ($idx,$_out); # load out | ||
| 1080 | |||
| 1081 | &bswap ($s0); | ||
| 1082 | &bswap ($s1); | ||
| 1083 | &bswap ($s2); | ||
| 1084 | &xor ($s0,&DWP(0,$key)); # xor iv | ||
| 1085 | &bswap ($s3); | ||
| 1086 | &xor ($s1,&DWP(4,$key)); | ||
| 1087 | &xor ($s2,&DWP(8,$key)); | ||
| 1088 | &xor ($s3,&DWP(12,$key)); | ||
| 1089 | |||
| 1090 | &mov (&DWP(0,$idx),$s0); # write output | ||
| 1091 | &mov (&DWP(4,$idx),$s1); | ||
| 1092 | &mov (&DWP(8,$idx),$s2); | ||
| 1093 | &mov (&DWP(12,$idx),$s3); | ||
| 1094 | |||
| 1095 | &lea ($idx,&DWP(16,$idx)); | ||
| 1096 | &mov ($_out,$idx); # save out | ||
| 1097 | |||
| 1098 | &lea ($idx,$ivec); | ||
| 1099 | &mov ($s0,&DWP(0,$idx)); # read temp | ||
| 1100 | &mov ($s1,&DWP(4,$idx)); | ||
| 1101 | &mov ($s2,&DWP(8,$idx)); | ||
| 1102 | &mov ($s3,&DWP(12,$idx)); | ||
| 1103 | |||
| 1104 | &mov (&DWP(0,$key),$s0); # copy iv | ||
| 1105 | &mov (&DWP(4,$key),$s1); | ||
| 1106 | &mov (&DWP(8,$key),$s2); | ||
| 1107 | &mov (&DWP(12,$key),$s3); | ||
| 1108 | |||
| 1109 | &mov ($idx,$_inp); # load inp | ||
| 1110 | |||
| 1111 | &lea ($idx,&DWP(16,$idx)); | ||
| 1112 | &mov ($_inp,$idx); # save inp | ||
| 1113 | |||
| 1114 | &mov ($s2,$_len); # load len | ||
| 1115 | &sub ($s2,16); | ||
| 1116 | &jc (&label("dec_in_place_partial")); | ||
| 1117 | &mov ($_len,$s2); # save len | ||
| 1118 | &jnz (&label("dec_in_place_loop")); | ||
| 1119 | &jmp (&label("dec_out")); | ||
| 1120 | |||
| 1121 | &set_label("dec_in_place_partial",4); | ||
| 1122 | # one can argue if this is actually required... | ||
| 1123 | &mov ($key eq "edi" ? $key : "",$_out); | ||
| 1124 | &lea ($idx eq "esi" ? $idx : "",$ivec); | ||
| 1125 | &lea ($key,&DWP(0,$key,$s2)); | ||
| 1126 | &lea ($idx,&DWP(16,$idx,$s2)); | ||
| 1127 | &neg ($s2 eq "ecx" ? $s2 : ""); | ||
| 1128 | &data_word(0xA4F3F689); # rep movsb # restore tail | ||
| 1129 | |||
| 1130 | &set_label("dec_out",4); | ||
| 1131 | &mov ("esp",$_esp); | ||
| 1132 | &popf (); | ||
| 1133 | &function_end("Camellia_cbc_encrypt"); | ||
| 1134 | } | ||
| 1135 | |||
| 1136 | &asciz("Camellia for x86 by <appro@openssl.org>"); | ||
| 1137 | |||
| 1138 | &asm_finish(); | ||
diff --git a/src/lib/libssl/src/crypto/camellia/asm/cmll-x86_64.pl b/src/lib/libssl/src/crypto/camellia/asm/cmll-x86_64.pl new file mode 100644 index 0000000000..c683646ca7 --- /dev/null +++ b/src/lib/libssl/src/crypto/camellia/asm/cmll-x86_64.pl | |||
| @@ -0,0 +1,1080 @@ | |||
| 1 | #!/usr/bin/env perl | ||
| 2 | |||
| 3 | # ==================================================================== | ||
| 4 | # Copyright (c) 2008 Andy Polyakov <appro@openssl.org> | ||
| 5 | # | ||
| 6 | # This module may be used under the terms of either the GNU General | ||
| 7 | # Public License version 2 or later, the GNU Lesser General Public | ||
| 8 | # License version 2.1 or later, the Mozilla Public License version | ||
| 9 | # 1.1 or the BSD License. The exact terms of either license are | ||
| 10 | # distributed along with this module. For further details see | ||
| 11 | # http://www.openssl.org/~appro/camellia/. | ||
| 12 | # ==================================================================== | ||
| 13 | |||
| 14 | # Performance in cycles per processed byte (less is better) in | ||
| 15 | # 'openssl speed ...' benchmark: | ||
| 16 | # | ||
| 17 | # AMD64 Core2 EM64T | ||
| 18 | # -evp camellia-128-ecb 16.7 21.0 22.7 | ||
| 19 | # + over gcc 3.4.6 +25% +5% 0% | ||
| 20 | # | ||
| 21 | # camellia-128-cbc 15.7 20.4 21.1 | ||
| 22 | # | ||
| 23 | # 128-bit key setup 128 216 205 cycles/key | ||
| 24 | # + over gcc 3.4.6 +54% +39% +15% | ||
| 25 | # | ||
| 26 | # Numbers in "+" rows represent performance improvement over compiler | ||
| 27 | # generated code. Key setup timings are impressive on AMD and Core2 | ||
| 28 | # thanks to 64-bit operations being covertly deployed. Improvement on | ||
| 29 | # EM64T, pre-Core2 Intel x86_64 CPU, is not as impressive, because it | ||
| 30 | # apparently emulates some of 64-bit operations in [32-bit] microcode. | ||
| 31 | |||
| 32 | $flavour = shift; | ||
| 33 | $output = shift; | ||
| 34 | if ($flavour =~ /\./) { $output = $flavour; undef $flavour; } | ||
| 35 | |||
| 36 | $win64=0; $win64=1 if ($flavour =~ /[nm]asm|mingw64/ || $output =~ /\.asm$/); | ||
| 37 | |||
| 38 | $0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1; | ||
| 39 | ( $xlate="${dir}x86_64-xlate.pl" and -f $xlate ) or | ||
| 40 | ( $xlate="${dir}../../perlasm/x86_64-xlate.pl" and -f $xlate) or | ||
| 41 | die "can't locate x86_64-xlate.pl"; | ||
| 42 | |||
| 43 | open STDOUT,"| $^X $xlate $flavour $output"; | ||
| 44 | |||
| 45 | sub hi() { my $r=shift; $r =~ s/%[er]([a-d])x/%\1h/; $r; } | ||
| 46 | sub lo() { my $r=shift; $r =~ s/%[er]([a-d])x/%\1l/; | ||
| 47 | $r =~ s/%[er]([sd]i)/%\1l/; | ||
| 48 | $r =~ s/%(r[0-9]+)[d]?/%\1b/; $r; } | ||
| 49 | |||
| 50 | $t0="%eax";$t1="%ebx";$t2="%ecx";$t3="%edx"; | ||
| 51 | @S=("%r8d","%r9d","%r10d","%r11d"); | ||
| 52 | $i0="%esi"; | ||
| 53 | $i1="%edi"; | ||
| 54 | $Tbl="%rbp"; # size optimization | ||
| 55 | $inp="%r12"; | ||
| 56 | $out="%r13"; | ||
| 57 | $key="%r14"; | ||
| 58 | $keyend="%r15"; | ||
| 59 | $arg0d=$win64?"%ecx":"%edi"; | ||
| 60 | |||
| 61 | # const unsigned int Camellia_SBOX[4][256]; | ||
| 62 | # Well, sort of... Camellia_SBOX[0][] is interleaved with [1][], | ||
| 63 | # and [2][] - with [3][]. This is done to minimize code size. | ||
| 64 | $SBOX1_1110=0; # Camellia_SBOX[0] | ||
| 65 | $SBOX4_4404=4; # Camellia_SBOX[1] | ||
| 66 | $SBOX2_0222=2048; # Camellia_SBOX[2] | ||
| 67 | $SBOX3_3033=2052; # Camellia_SBOX[3] | ||
| 68 | |||
| 69 | sub Camellia_Feistel { | ||
| 70 | my $i=@_[0]; | ||
| 71 | my $seed=defined(@_[1])?@_[1]:0; | ||
| 72 | my $scale=$seed<0?-8:8; | ||
| 73 | my $j=($i&1)*2; | ||
| 74 | my $s0=@S[($j)%4],$s1=@S[($j+1)%4],$s2=@S[($j+2)%4],$s3=@S[($j+3)%4]; | ||
| 75 | |||
| 76 | $code.=<<___; | ||
| 77 | xor $s0,$t0 # t0^=key[0] | ||
| 78 | xor $s1,$t1 # t1^=key[1] | ||
| 79 | movz `&hi("$t0")`,$i0 # (t0>>8)&0xff | ||
| 80 | movz `&lo("$t1")`,$i1 # (t1>>0)&0xff | ||
| 81 | mov $SBOX3_3033($Tbl,$i0,8),$t3 # t3=SBOX3_3033[0] | ||
| 82 | mov $SBOX1_1110($Tbl,$i1,8),$t2 # t2=SBOX1_1110[1] | ||
| 83 | movz `&lo("$t0")`,$i0 # (t0>>0)&0xff | ||
| 84 | shr \$16,$t0 | ||
| 85 | movz `&hi("$t1")`,$i1 # (t1>>8)&0xff | ||
| 86 | xor $SBOX4_4404($Tbl,$i0,8),$t3 # t3^=SBOX4_4404[0] | ||
| 87 | shr \$16,$t1 | ||
| 88 | xor $SBOX4_4404($Tbl,$i1,8),$t2 # t2^=SBOX4_4404[1] | ||
| 89 | movz `&hi("$t0")`,$i0 # (t0>>24)&0xff | ||
| 90 | movz `&lo("$t1")`,$i1 # (t1>>16)&0xff | ||
| 91 | xor $SBOX1_1110($Tbl,$i0,8),$t3 # t3^=SBOX1_1110[0] | ||
| 92 | xor $SBOX3_3033($Tbl,$i1,8),$t2 # t2^=SBOX3_3033[1] | ||
| 93 | movz `&lo("$t0")`,$i0 # (t0>>16)&0xff | ||
| 94 | movz `&hi("$t1")`,$i1 # (t1>>24)&0xff | ||
| 95 | xor $SBOX2_0222($Tbl,$i0,8),$t3 # t3^=SBOX2_0222[0] | ||
| 96 | xor $SBOX2_0222($Tbl,$i1,8),$t2 # t2^=SBOX2_0222[1] | ||
| 97 | mov `$seed+($i+1)*$scale`($key),$t1 # prefetch key[i+1] | ||
| 98 | mov `$seed+($i+1)*$scale+4`($key),$t0 | ||
| 99 | xor $t3,$t2 # t2^=t3 | ||
| 100 | ror \$8,$t3 # t3=RightRotate(t3,8) | ||
| 101 | xor $t2,$s2 | ||
| 102 | xor $t2,$s3 | ||
| 103 | xor $t3,$s3 | ||
| 104 | ___ | ||
| 105 | } | ||
| 106 | |||
| 107 | # void Camellia_EncryptBlock_Rounds( | ||
| 108 | # int grandRounds, | ||
| 109 | # const Byte plaintext[], | ||
| 110 | # const KEY_TABLE_TYPE keyTable, | ||
| 111 | # Byte ciphertext[]) | ||
| 112 | $code=<<___; | ||
| 113 | .text | ||
| 114 | |||
| 115 | # V1.x API | ||
| 116 | .globl Camellia_EncryptBlock | ||
| 117 | .type Camellia_EncryptBlock,\@abi-omnipotent | ||
| 118 | .align 16 | ||
| 119 | Camellia_EncryptBlock: | ||
| 120 | movl \$128,%eax | ||
| 121 | subl $arg0d,%eax | ||
| 122 | movl \$3,$arg0d | ||
| 123 | adcl \$0,$arg0d # keyBitLength==128?3:4 | ||
| 124 | jmp .Lenc_rounds | ||
| 125 | .size Camellia_EncryptBlock,.-Camellia_EncryptBlock | ||
| 126 | # V2 | ||
| 127 | .globl Camellia_EncryptBlock_Rounds | ||
| 128 | .type Camellia_EncryptBlock_Rounds,\@function,4 | ||
| 129 | .align 16 | ||
| 130 | .Lenc_rounds: | ||
| 131 | Camellia_EncryptBlock_Rounds: | ||
| 132 | push %rbx | ||
| 133 | push %rbp | ||
| 134 | push %r13 | ||
| 135 | push %r14 | ||
| 136 | push %r15 | ||
| 137 | .Lenc_prologue: | ||
| 138 | |||
| 139 | #mov %rsi,$inp # put away arguments | ||
| 140 | mov %rcx,$out | ||
| 141 | mov %rdx,$key | ||
| 142 | |||
| 143 | shl \$6,%edi # process grandRounds | ||
| 144 | lea .LCamellia_SBOX(%rip),$Tbl | ||
| 145 | lea ($key,%rdi),$keyend | ||
| 146 | |||
| 147 | mov 0(%rsi),@S[0] # load plaintext | ||
| 148 | mov 4(%rsi),@S[1] | ||
| 149 | mov 8(%rsi),@S[2] | ||
| 150 | bswap @S[0] | ||
| 151 | mov 12(%rsi),@S[3] | ||
| 152 | bswap @S[1] | ||
| 153 | bswap @S[2] | ||
| 154 | bswap @S[3] | ||
| 155 | |||
| 156 | call _x86_64_Camellia_encrypt | ||
| 157 | |||
| 158 | bswap @S[0] | ||
| 159 | bswap @S[1] | ||
| 160 | bswap @S[2] | ||
| 161 | mov @S[0],0($out) | ||
| 162 | bswap @S[3] | ||
| 163 | mov @S[1],4($out) | ||
| 164 | mov @S[2],8($out) | ||
| 165 | mov @S[3],12($out) | ||
| 166 | |||
| 167 | mov 0(%rsp),%r15 | ||
| 168 | mov 8(%rsp),%r14 | ||
| 169 | mov 16(%rsp),%r13 | ||
| 170 | mov 24(%rsp),%rbp | ||
| 171 | mov 32(%rsp),%rbx | ||
| 172 | lea 40(%rsp),%rsp | ||
| 173 | .Lenc_epilogue: | ||
| 174 | ret | ||
| 175 | .size Camellia_EncryptBlock_Rounds,.-Camellia_EncryptBlock_Rounds | ||
| 176 | |||
| 177 | .type _x86_64_Camellia_encrypt,\@abi-omnipotent | ||
| 178 | .align 16 | ||
| 179 | _x86_64_Camellia_encrypt: | ||
| 180 | xor 0($key),@S[1] | ||
| 181 | xor 4($key),@S[0] # ^=key[0-3] | ||
| 182 | xor 8($key),@S[3] | ||
| 183 | xor 12($key),@S[2] | ||
| 184 | .align 16 | ||
| 185 | .Leloop: | ||
| 186 | mov 16($key),$t1 # prefetch key[4-5] | ||
| 187 | mov 20($key),$t0 | ||
| 188 | |||
| 189 | ___ | ||
| 190 | for ($i=0;$i<6;$i++) { Camellia_Feistel($i,16); } | ||
| 191 | $code.=<<___; | ||
| 192 | lea 16*4($key),$key | ||
| 193 | cmp $keyend,$key | ||
| 194 | mov 8($key),$t3 # prefetch key[2-3] | ||
| 195 | mov 12($key),$t2 | ||
| 196 | je .Ledone | ||
| 197 | |||
| 198 | and @S[0],$t0 | ||
| 199 | or @S[3],$t3 | ||
| 200 | rol \$1,$t0 | ||
| 201 | xor $t3,@S[2] # s2^=s3|key[3]; | ||
| 202 | xor $t0,@S[1] # s1^=LeftRotate(s0&key[0],1); | ||
| 203 | and @S[2],$t2 | ||
| 204 | or @S[1],$t1 | ||
| 205 | rol \$1,$t2 | ||
| 206 | xor $t1,@S[0] # s0^=s1|key[1]; | ||
| 207 | xor $t2,@S[3] # s3^=LeftRotate(s2&key[2],1); | ||
| 208 | jmp .Leloop | ||
| 209 | |||
| 210 | .align 16 | ||
| 211 | .Ledone: | ||
| 212 | xor @S[2],$t0 # SwapHalf | ||
| 213 | xor @S[3],$t1 | ||
| 214 | xor @S[0],$t2 | ||
| 215 | xor @S[1],$t3 | ||
| 216 | |||
| 217 | mov $t0,@S[0] | ||
| 218 | mov $t1,@S[1] | ||
| 219 | mov $t2,@S[2] | ||
| 220 | mov $t3,@S[3] | ||
| 221 | |||
| 222 | .byte 0xf3,0xc3 # rep ret | ||
| 223 | .size _x86_64_Camellia_encrypt,.-_x86_64_Camellia_encrypt | ||
| 224 | |||
| 225 | # V1.x API | ||
| 226 | .globl Camellia_DecryptBlock | ||
| 227 | .type Camellia_DecryptBlock,\@abi-omnipotent | ||
| 228 | .align 16 | ||
| 229 | Camellia_DecryptBlock: | ||
| 230 | movl \$128,%eax | ||
| 231 | subl $arg0d,%eax | ||
| 232 | movl \$3,$arg0d | ||
| 233 | adcl \$0,$arg0d # keyBitLength==128?3:4 | ||
| 234 | jmp .Ldec_rounds | ||
| 235 | .size Camellia_DecryptBlock,.-Camellia_DecryptBlock | ||
| 236 | # V2 | ||
| 237 | .globl Camellia_DecryptBlock_Rounds | ||
| 238 | .type Camellia_DecryptBlock_Rounds,\@function,4 | ||
| 239 | .align 16 | ||
| 240 | .Ldec_rounds: | ||
| 241 | Camellia_DecryptBlock_Rounds: | ||
| 242 | push %rbx | ||
| 243 | push %rbp | ||
| 244 | push %r13 | ||
| 245 | push %r14 | ||
| 246 | push %r15 | ||
| 247 | .Ldec_prologue: | ||
| 248 | |||
| 249 | #mov %rsi,$inp # put away arguments | ||
| 250 | mov %rcx,$out | ||
| 251 | mov %rdx,$keyend | ||
| 252 | |||
| 253 | shl \$6,%edi # process grandRounds | ||
| 254 | lea .LCamellia_SBOX(%rip),$Tbl | ||
| 255 | lea ($keyend,%rdi),$key | ||
| 256 | |||
| 257 | mov 0(%rsi),@S[0] # load plaintext | ||
| 258 | mov 4(%rsi),@S[1] | ||
| 259 | mov 8(%rsi),@S[2] | ||
| 260 | bswap @S[0] | ||
| 261 | mov 12(%rsi),@S[3] | ||
| 262 | bswap @S[1] | ||
| 263 | bswap @S[2] | ||
| 264 | bswap @S[3] | ||
| 265 | |||
| 266 | call _x86_64_Camellia_decrypt | ||
| 267 | |||
| 268 | bswap @S[0] | ||
| 269 | bswap @S[1] | ||
| 270 | bswap @S[2] | ||
| 271 | mov @S[0],0($out) | ||
| 272 | bswap @S[3] | ||
| 273 | mov @S[1],4($out) | ||
| 274 | mov @S[2],8($out) | ||
| 275 | mov @S[3],12($out) | ||
| 276 | |||
| 277 | mov 0(%rsp),%r15 | ||
| 278 | mov 8(%rsp),%r14 | ||
| 279 | mov 16(%rsp),%r13 | ||
| 280 | mov 24(%rsp),%rbp | ||
| 281 | mov 32(%rsp),%rbx | ||
| 282 | lea 40(%rsp),%rsp | ||
| 283 | .Ldec_epilogue: | ||
| 284 | ret | ||
| 285 | .size Camellia_DecryptBlock_Rounds,.-Camellia_DecryptBlock_Rounds | ||
| 286 | |||
| 287 | .type _x86_64_Camellia_decrypt,\@abi-omnipotent | ||
| 288 | .align 16 | ||
| 289 | _x86_64_Camellia_decrypt: | ||
| 290 | xor 0($key),@S[1] | ||
| 291 | xor 4($key),@S[0] # ^=key[0-3] | ||
| 292 | xor 8($key),@S[3] | ||
| 293 | xor 12($key),@S[2] | ||
| 294 | .align 16 | ||
| 295 | .Ldloop: | ||
| 296 | mov -8($key),$t1 # prefetch key[4-5] | ||
| 297 | mov -4($key),$t0 | ||
| 298 | |||
| 299 | ___ | ||
| 300 | for ($i=0;$i<6;$i++) { Camellia_Feistel($i,-8); } | ||
| 301 | $code.=<<___; | ||
| 302 | lea -16*4($key),$key | ||
| 303 | cmp $keyend,$key | ||
| 304 | mov 0($key),$t3 # prefetch key[2-3] | ||
| 305 | mov 4($key),$t2 | ||
| 306 | je .Lddone | ||
| 307 | |||
| 308 | and @S[0],$t0 | ||
| 309 | or @S[3],$t3 | ||
| 310 | rol \$1,$t0 | ||
| 311 | xor $t3,@S[2] # s2^=s3|key[3]; | ||
| 312 | xor $t0,@S[1] # s1^=LeftRotate(s0&key[0],1); | ||
| 313 | and @S[2],$t2 | ||
| 314 | or @S[1],$t1 | ||
| 315 | rol \$1,$t2 | ||
| 316 | xor $t1,@S[0] # s0^=s1|key[1]; | ||
| 317 | xor $t2,@S[3] # s3^=LeftRotate(s2&key[2],1); | ||
| 318 | |||
| 319 | jmp .Ldloop | ||
| 320 | |||
| 321 | .align 16 | ||
| 322 | .Lddone: | ||
| 323 | xor @S[2],$t2 | ||
| 324 | xor @S[3],$t3 | ||
| 325 | xor @S[0],$t0 | ||
| 326 | xor @S[1],$t1 | ||
| 327 | |||
| 328 | mov $t2,@S[0] # SwapHalf | ||
| 329 | mov $t3,@S[1] | ||
| 330 | mov $t0,@S[2] | ||
| 331 | mov $t1,@S[3] | ||
| 332 | |||
| 333 | .byte 0xf3,0xc3 # rep ret | ||
| 334 | .size _x86_64_Camellia_decrypt,.-_x86_64_Camellia_decrypt | ||
| 335 | ___ | ||
| 336 | |||
| 337 | sub _saveround { | ||
| 338 | my ($rnd,$key,@T)=@_; | ||
| 339 | my $bias=int(@T[0])?shift(@T):0; | ||
| 340 | |||
| 341 | if ($#T==3) { | ||
| 342 | $code.=<<___; | ||
| 343 | mov @T[1],`$bias+$rnd*8+0`($key) | ||
| 344 | mov @T[0],`$bias+$rnd*8+4`($key) | ||
| 345 | mov @T[3],`$bias+$rnd*8+8`($key) | ||
| 346 | mov @T[2],`$bias+$rnd*8+12`($key) | ||
| 347 | ___ | ||
| 348 | } else { | ||
| 349 | $code.=" mov @T[0],`$bias+$rnd*8+0`($key)\n"; | ||
| 350 | $code.=" mov @T[1],`$bias+$rnd*8+8`($key)\n" if ($#T>=1); | ||
| 351 | } | ||
| 352 | } | ||
| 353 | |||
| 354 | sub _loadround { | ||
| 355 | my ($rnd,$key,@T)=@_; | ||
| 356 | my $bias=int(@T[0])?shift(@T):0; | ||
| 357 | |||
| 358 | $code.=" mov `$bias+$rnd*8+0`($key),@T[0]\n"; | ||
| 359 | $code.=" mov `$bias+$rnd*8+8`($key),@T[1]\n" if ($#T>=1); | ||
| 360 | } | ||
| 361 | |||
| 362 | # shld is very slow on Intel EM64T family. Even on AMD it limits | ||
| 363 | # instruction decode rate [because it's VectorPath] and consequently | ||
| 364 | # performance... | ||
| 365 | sub __rotl128 { | ||
| 366 | my ($i0,$i1,$rot)=@_; | ||
| 367 | |||
| 368 | if ($rot) { | ||
| 369 | $code.=<<___; | ||
| 370 | mov $i0,%r11 | ||
| 371 | shld \$$rot,$i1,$i0 | ||
| 372 | shld \$$rot,%r11,$i1 | ||
| 373 | ___ | ||
| 374 | } | ||
| 375 | } | ||
| 376 | |||
| 377 | # ... Implementing 128-bit rotate without shld gives 80% better | ||
| 378 | # performance EM64T, +15% on AMD64 and only ~7% degradation on | ||
| 379 | # Core2. This is therefore preferred. | ||
| 380 | sub _rotl128 { | ||
| 381 | my ($i0,$i1,$rot)=@_; | ||
| 382 | |||
| 383 | if ($rot) { | ||
| 384 | $code.=<<___; | ||
| 385 | mov $i0,%r11 | ||
| 386 | shl \$$rot,$i0 | ||
| 387 | mov $i1,%r9 | ||
| 388 | shr \$`64-$rot`,%r9 | ||
| 389 | shr \$`64-$rot`,%r11 | ||
| 390 | or %r9,$i0 | ||
| 391 | shl \$$rot,$i1 | ||
| 392 | or %r11,$i1 | ||
| 393 | ___ | ||
| 394 | } | ||
| 395 | } | ||
| 396 | |||
| 397 | { my $step=0; | ||
| 398 | |||
| 399 | $code.=<<___; | ||
| 400 | .globl Camellia_Ekeygen | ||
| 401 | .type Camellia_Ekeygen,\@function,3 | ||
| 402 | .align 16 | ||
| 403 | Camellia_Ekeygen: | ||
| 404 | push %rbx | ||
| 405 | push %rbp | ||
| 406 | push %r13 | ||
| 407 | push %r14 | ||
| 408 | push %r15 | ||
| 409 | .Lkey_prologue: | ||
| 410 | |||
| 411 | mov %rdi,$keyend # put away arguments, keyBitLength | ||
| 412 | mov %rdx,$out # keyTable | ||
| 413 | |||
| 414 | mov 0(%rsi),@S[0] # load 0-127 bits | ||
| 415 | mov 4(%rsi),@S[1] | ||
| 416 | mov 8(%rsi),@S[2] | ||
| 417 | mov 12(%rsi),@S[3] | ||
| 418 | |||
| 419 | bswap @S[0] | ||
| 420 | bswap @S[1] | ||
| 421 | bswap @S[2] | ||
| 422 | bswap @S[3] | ||
| 423 | ___ | ||
| 424 | &_saveround (0,$out,@S); # KL<<<0 | ||
| 425 | $code.=<<___; | ||
| 426 | cmp \$128,$keyend # check keyBitLength | ||
| 427 | je .L1st128 | ||
| 428 | |||
| 429 | mov 16(%rsi),@S[0] # load 128-191 bits | ||
| 430 | mov 20(%rsi),@S[1] | ||
| 431 | cmp \$192,$keyend | ||
| 432 | je .L1st192 | ||
| 433 | mov 24(%rsi),@S[2] # load 192-255 bits | ||
| 434 | mov 28(%rsi),@S[3] | ||
| 435 | jmp .L1st256 | ||
| 436 | .L1st192: | ||
| 437 | mov @S[0],@S[2] | ||
| 438 | mov @S[1],@S[3] | ||
| 439 | not @S[2] | ||
| 440 | not @S[3] | ||
| 441 | .L1st256: | ||
| 442 | bswap @S[0] | ||
| 443 | bswap @S[1] | ||
| 444 | bswap @S[2] | ||
| 445 | bswap @S[3] | ||
| 446 | ___ | ||
| 447 | &_saveround (4,$out,@S); # temp storage for KR! | ||
| 448 | $code.=<<___; | ||
| 449 | xor 0($out),@S[1] # KR^KL | ||
| 450 | xor 4($out),@S[0] | ||
| 451 | xor 8($out),@S[3] | ||
| 452 | xor 12($out),@S[2] | ||
| 453 | |||
| 454 | .L1st128: | ||
| 455 | lea .LCamellia_SIGMA(%rip),$key | ||
| 456 | lea .LCamellia_SBOX(%rip),$Tbl | ||
| 457 | |||
| 458 | mov 0($key),$t1 | ||
| 459 | mov 4($key),$t0 | ||
| 460 | ___ | ||
| 461 | &Camellia_Feistel($step++); | ||
| 462 | &Camellia_Feistel($step++); | ||
| 463 | $code.=<<___; | ||
| 464 | xor 0($out),@S[1] # ^KL | ||
| 465 | xor 4($out),@S[0] | ||
| 466 | xor 8($out),@S[3] | ||
| 467 | xor 12($out),@S[2] | ||
| 468 | ___ | ||
| 469 | &Camellia_Feistel($step++); | ||
| 470 | &Camellia_Feistel($step++); | ||
| 471 | $code.=<<___; | ||
| 472 | cmp \$128,$keyend | ||
| 473 | jne .L2nd256 | ||
| 474 | |||
| 475 | lea 128($out),$out # size optimization | ||
| 476 | shl \$32,%r8 # @S[0]|| | ||
| 477 | shl \$32,%r10 # @S[2]|| | ||
| 478 | or %r9,%r8 # ||@S[1] | ||
| 479 | or %r11,%r10 # ||@S[3] | ||
| 480 | ___ | ||
| 481 | &_loadround (0,$out,-128,"%rax","%rbx"); # KL | ||
| 482 | &_saveround (2,$out,-128,"%r8","%r10"); # KA<<<0 | ||
| 483 | &_rotl128 ("%rax","%rbx",15); | ||
| 484 | &_saveround (4,$out,-128,"%rax","%rbx"); # KL<<<15 | ||
| 485 | &_rotl128 ("%r8","%r10",15); | ||
| 486 | &_saveround (6,$out,-128,"%r8","%r10"); # KA<<<15 | ||
| 487 | &_rotl128 ("%r8","%r10",15); # 15+15=30 | ||
| 488 | &_saveround (8,$out,-128,"%r8","%r10"); # KA<<<30 | ||
| 489 | &_rotl128 ("%rax","%rbx",30); # 15+30=45 | ||
| 490 | &_saveround (10,$out,-128,"%rax","%rbx"); # KL<<<45 | ||
| 491 | &_rotl128 ("%r8","%r10",15); # 30+15=45 | ||
| 492 | &_saveround (12,$out,-128,"%r8"); # KA<<<45 | ||
| 493 | &_rotl128 ("%rax","%rbx",15); # 45+15=60 | ||
| 494 | &_saveround (13,$out,-128,"%rbx"); # KL<<<60 | ||
| 495 | &_rotl128 ("%r8","%r10",15); # 45+15=60 | ||
| 496 | &_saveround (14,$out,-128,"%r8","%r10"); # KA<<<60 | ||
| 497 | &_rotl128 ("%rax","%rbx",17); # 60+17=77 | ||
| 498 | &_saveround (16,$out,-128,"%rax","%rbx"); # KL<<<77 | ||
| 499 | &_rotl128 ("%rax","%rbx",17); # 77+17=94 | ||
| 500 | &_saveround (18,$out,-128,"%rax","%rbx"); # KL<<<94 | ||
| 501 | &_rotl128 ("%r8","%r10",34); # 60+34=94 | ||
| 502 | &_saveround (20,$out,-128,"%r8","%r10"); # KA<<<94 | ||
| 503 | &_rotl128 ("%rax","%rbx",17); # 94+17=111 | ||
| 504 | &_saveround (22,$out,-128,"%rax","%rbx"); # KL<<<111 | ||
| 505 | &_rotl128 ("%r8","%r10",17); # 94+17=111 | ||
| 506 | &_saveround (24,$out,-128,"%r8","%r10"); # KA<<<111 | ||
| 507 | $code.=<<___; | ||
| 508 | mov \$3,%eax | ||
| 509 | jmp .Ldone | ||
| 510 | .align 16 | ||
| 511 | .L2nd256: | ||
| 512 | ___ | ||
| 513 | &_saveround (6,$out,@S); # temp storage for KA! | ||
| 514 | $code.=<<___; | ||
| 515 | xor `4*8+0`($out),@S[1] # KA^KR | ||
| 516 | xor `4*8+4`($out),@S[0] | ||
| 517 | xor `5*8+0`($out),@S[3] | ||
| 518 | xor `5*8+4`($out),@S[2] | ||
| 519 | ___ | ||
| 520 | &Camellia_Feistel($step++); | ||
| 521 | &Camellia_Feistel($step++); | ||
| 522 | |||
| 523 | &_loadround (0,$out,"%rax","%rbx"); # KL | ||
| 524 | &_loadround (4,$out,"%rcx","%rdx"); # KR | ||
| 525 | &_loadround (6,$out,"%r14","%r15"); # KA | ||
| 526 | $code.=<<___; | ||
| 527 | lea 128($out),$out # size optimization | ||
| 528 | shl \$32,%r8 # @S[0]|| | ||
| 529 | shl \$32,%r10 # @S[2]|| | ||
| 530 | or %r9,%r8 # ||@S[1] | ||
| 531 | or %r11,%r10 # ||@S[3] | ||
| 532 | ___ | ||
| 533 | &_saveround (2,$out,-128,"%r8","%r10"); # KB<<<0 | ||
| 534 | &_rotl128 ("%rcx","%rdx",15); | ||
| 535 | &_saveround (4,$out,-128,"%rcx","%rdx"); # KR<<<15 | ||
| 536 | &_rotl128 ("%r14","%r15",15); | ||
| 537 | &_saveround (6,$out,-128,"%r14","%r15"); # KA<<<15 | ||
| 538 | &_rotl128 ("%rcx","%rdx",15); # 15+15=30 | ||
| 539 | &_saveround (8,$out,-128,"%rcx","%rdx"); # KR<<<30 | ||
| 540 | &_rotl128 ("%r8","%r10",30); | ||
| 541 | &_saveround (10,$out,-128,"%r8","%r10"); # KB<<<30 | ||
| 542 | &_rotl128 ("%rax","%rbx",45); | ||
| 543 | &_saveround (12,$out,-128,"%rax","%rbx"); # KL<<<45 | ||
| 544 | &_rotl128 ("%r14","%r15",30); # 15+30=45 | ||
| 545 | &_saveround (14,$out,-128,"%r14","%r15"); # KA<<<45 | ||
| 546 | &_rotl128 ("%rax","%rbx",15); # 45+15=60 | ||
| 547 | &_saveround (16,$out,-128,"%rax","%rbx"); # KL<<<60 | ||
| 548 | &_rotl128 ("%rcx","%rdx",30); # 30+30=60 | ||
| 549 | &_saveround (18,$out,-128,"%rcx","%rdx"); # KR<<<60 | ||
| 550 | &_rotl128 ("%r8","%r10",30); # 30+30=60 | ||
| 551 | &_saveround (20,$out,-128,"%r8","%r10"); # KB<<<60 | ||
| 552 | &_rotl128 ("%rax","%rbx",17); # 60+17=77 | ||
| 553 | &_saveround (22,$out,-128,"%rax","%rbx"); # KL<<<77 | ||
| 554 | &_rotl128 ("%r14","%r15",32); # 45+32=77 | ||
| 555 | &_saveround (24,$out,-128,"%r14","%r15"); # KA<<<77 | ||
| 556 | &_rotl128 ("%rcx","%rdx",34); # 60+34=94 | ||
| 557 | &_saveround (26,$out,-128,"%rcx","%rdx"); # KR<<<94 | ||
| 558 | &_rotl128 ("%r14","%r15",17); # 77+17=94 | ||
| 559 | &_saveround (28,$out,-128,"%r14","%r15"); # KA<<<77 | ||
| 560 | &_rotl128 ("%rax","%rbx",34); # 77+34=111 | ||
| 561 | &_saveround (30,$out,-128,"%rax","%rbx"); # KL<<<111 | ||
| 562 | &_rotl128 ("%r8","%r10",51); # 60+51=111 | ||
| 563 | &_saveround (32,$out,-128,"%r8","%r10"); # KB<<<111 | ||
| 564 | $code.=<<___; | ||
| 565 | mov \$4,%eax | ||
| 566 | .Ldone: | ||
| 567 | mov 0(%rsp),%r15 | ||
| 568 | mov 8(%rsp),%r14 | ||
| 569 | mov 16(%rsp),%r13 | ||
| 570 | mov 24(%rsp),%rbp | ||
| 571 | mov 32(%rsp),%rbx | ||
| 572 | lea 40(%rsp),%rsp | ||
| 573 | .Lkey_epilogue: | ||
| 574 | ret | ||
| 575 | .size Camellia_Ekeygen,.-Camellia_Ekeygen | ||
| 576 | ___ | ||
| 577 | } | ||
| 578 | |||
| 579 | @SBOX=( | ||
| 580 | 112,130, 44,236,179, 39,192,229,228,133, 87, 53,234, 12,174, 65, | ||
| 581 | 35,239,107,147, 69, 25,165, 33,237, 14, 79, 78, 29,101,146,189, | ||
| 582 | 134,184,175,143,124,235, 31,206, 62, 48,220, 95, 94,197, 11, 26, | ||
| 583 | 166,225, 57,202,213, 71, 93, 61,217, 1, 90,214, 81, 86,108, 77, | ||
| 584 | 139, 13,154,102,251,204,176, 45,116, 18, 43, 32,240,177,132,153, | ||
| 585 | 223, 76,203,194, 52,126,118, 5,109,183,169, 49,209, 23, 4,215, | ||
| 586 | 20, 88, 58, 97,222, 27, 17, 28, 50, 15,156, 22, 83, 24,242, 34, | ||
| 587 | 254, 68,207,178,195,181,122,145, 36, 8,232,168, 96,252,105, 80, | ||
| 588 | 170,208,160,125,161,137, 98,151, 84, 91, 30,149,224,255,100,210, | ||
| 589 | 16,196, 0, 72,163,247,117,219,138, 3,230,218, 9, 63,221,148, | ||
| 590 | 135, 92,131, 2,205, 74,144, 51,115,103,246,243,157,127,191,226, | ||
| 591 | 82,155,216, 38,200, 55,198, 59,129,150,111, 75, 19,190, 99, 46, | ||
| 592 | 233,121,167,140,159,110,188,142, 41,245,249,182, 47,253,180, 89, | ||
| 593 | 120,152, 6,106,231, 70,113,186,212, 37,171, 66,136,162,141,250, | ||
| 594 | 114, 7,185, 85,248,238,172, 10, 54, 73, 42,104, 60, 56,241,164, | ||
| 595 | 64, 40,211,123,187,201, 67,193, 21,227,173,244,119,199,128,158); | ||
| 596 | |||
| 597 | sub S1110 { my $i=shift; $i=@SBOX[$i]; $i=$i<<24|$i<<16|$i<<8; sprintf("0x%08x",$i); } | ||
| 598 | sub S4404 { my $i=shift; $i=($i<<1|$i>>7)&0xff; $i=@SBOX[$i]; $i=$i<<24|$i<<16|$i; sprintf("0x%08x",$i); } | ||
| 599 | sub S0222 { my $i=shift; $i=@SBOX[$i]; $i=($i<<1|$i>>7)&0xff; $i=$i<<16|$i<<8|$i; sprintf("0x%08x",$i); } | ||
| 600 | sub S3033 { my $i=shift; $i=@SBOX[$i]; $i=($i>>1|$i<<7)&0xff; $i=$i<<24|$i<<8|$i; sprintf("0x%08x",$i); } | ||
| 601 | |||
| 602 | $code.=<<___; | ||
| 603 | .align 64 | ||
| 604 | .LCamellia_SIGMA: | ||
| 605 | .long 0x3bcc908b, 0xa09e667f, 0x4caa73b2, 0xb67ae858 | ||
| 606 | .long 0xe94f82be, 0xc6ef372f, 0xf1d36f1c, 0x54ff53a5 | ||
| 607 | .long 0xde682d1d, 0x10e527fa, 0xb3e6c1fd, 0xb05688c2 | ||
| 608 | .long 0, 0, 0, 0 | ||
| 609 | .LCamellia_SBOX: | ||
| 610 | ___ | ||
| 611 | # tables are interleaved, remember? | ||
| 612 | sub data_word { $code.=".long\t".join(',',@_)."\n"; } | ||
| 613 | for ($i=0;$i<256;$i++) { &data_word(&S1110($i),&S4404($i)); } | ||
| 614 | for ($i=0;$i<256;$i++) { &data_word(&S0222($i),&S3033($i)); } | ||
| 615 | |||
| 616 | # void Camellia_cbc_encrypt (const void char *inp, unsigned char *out, | ||
| 617 | # size_t length, const CAMELLIA_KEY *key, | ||
| 618 | # unsigned char *ivp,const int enc); | ||
| 619 | { | ||
| 620 | $_key="0(%rsp)"; | ||
| 621 | $_end="8(%rsp)"; # inp+len&~15 | ||
| 622 | $_res="16(%rsp)"; # len&15 | ||
| 623 | $ivec="24(%rsp)"; | ||
| 624 | $_ivp="40(%rsp)"; | ||
| 625 | $_rsp="48(%rsp)"; | ||
| 626 | |||
| 627 | $code.=<<___; | ||
| 628 | .globl Camellia_cbc_encrypt | ||
| 629 | .type Camellia_cbc_encrypt,\@function,6 | ||
| 630 | .align 16 | ||
| 631 | Camellia_cbc_encrypt: | ||
| 632 | cmp \$0,%rdx | ||
| 633 | je .Lcbc_abort | ||
| 634 | push %rbx | ||
| 635 | push %rbp | ||
| 636 | push %r12 | ||
| 637 | push %r13 | ||
| 638 | push %r14 | ||
| 639 | push %r15 | ||
| 640 | .Lcbc_prologue: | ||
| 641 | |||
| 642 | mov %rsp,%rbp | ||
| 643 | sub \$64,%rsp | ||
| 644 | and \$-64,%rsp | ||
| 645 | |||
| 646 | # place stack frame just "above mod 1024" the key schedule, | ||
| 647 | # this ensures that cache associativity suffices | ||
| 648 | lea -64-63(%rcx),%r10 | ||
| 649 | sub %rsp,%r10 | ||
| 650 | neg %r10 | ||
| 651 | and \$0x3C0,%r10 | ||
| 652 | sub %r10,%rsp | ||
| 653 | #add \$8,%rsp # 8 is reserved for callee's ra | ||
| 654 | |||
| 655 | mov %rdi,$inp # inp argument | ||
| 656 | mov %rsi,$out # out argument | ||
| 657 | mov %r8,%rbx # ivp argument | ||
| 658 | mov %rcx,$key # key argument | ||
| 659 | mov 272(%rcx),$keyend # grandRounds | ||
| 660 | |||
| 661 | mov %r8,$_ivp | ||
| 662 | mov %rbp,$_rsp | ||
| 663 | |||
| 664 | .Lcbc_body: | ||
| 665 | lea .LCamellia_SBOX(%rip),$Tbl | ||
| 666 | |||
| 667 | mov \$32,%ecx | ||
| 668 | .align 4 | ||
| 669 | .Lcbc_prefetch_sbox: | ||
| 670 | mov 0($Tbl),%rax | ||
| 671 | mov 32($Tbl),%rsi | ||
| 672 | mov 64($Tbl),%rdi | ||
| 673 | mov 96($Tbl),%r11 | ||
| 674 | lea 128($Tbl),$Tbl | ||
| 675 | loop .Lcbc_prefetch_sbox | ||
| 676 | sub \$4096,$Tbl | ||
| 677 | shl \$6,$keyend | ||
| 678 | mov %rdx,%rcx # len argument | ||
| 679 | lea ($key,$keyend),$keyend | ||
| 680 | |||
| 681 | cmp \$0,%r9d # enc argument | ||
| 682 | je .LCBC_DECRYPT | ||
| 683 | |||
| 684 | and \$-16,%rdx | ||
| 685 | and \$15,%rcx # length residue | ||
| 686 | lea ($inp,%rdx),%rdx | ||
| 687 | mov $key,$_key | ||
| 688 | mov %rdx,$_end | ||
| 689 | mov %rcx,$_res | ||
| 690 | |||
| 691 | cmp $inp,%rdx | ||
| 692 | mov 0(%rbx),@S[0] # load IV | ||
| 693 | mov 4(%rbx),@S[1] | ||
| 694 | mov 8(%rbx),@S[2] | ||
| 695 | mov 12(%rbx),@S[3] | ||
| 696 | je .Lcbc_enc_tail | ||
| 697 | jmp .Lcbc_eloop | ||
| 698 | |||
| 699 | .align 16 | ||
| 700 | .Lcbc_eloop: | ||
| 701 | xor 0($inp),@S[0] | ||
| 702 | xor 4($inp),@S[1] | ||
| 703 | xor 8($inp),@S[2] | ||
| 704 | bswap @S[0] | ||
| 705 | xor 12($inp),@S[3] | ||
| 706 | bswap @S[1] | ||
| 707 | bswap @S[2] | ||
| 708 | bswap @S[3] | ||
| 709 | |||
| 710 | call _x86_64_Camellia_encrypt | ||
| 711 | |||
| 712 | mov $_key,$key # "rewind" the key | ||
| 713 | bswap @S[0] | ||
| 714 | mov $_end,%rdx | ||
| 715 | bswap @S[1] | ||
| 716 | mov $_res,%rcx | ||
| 717 | bswap @S[2] | ||
| 718 | mov @S[0],0($out) | ||
| 719 | bswap @S[3] | ||
| 720 | mov @S[1],4($out) | ||
| 721 | mov @S[2],8($out) | ||
| 722 | lea 16($inp),$inp | ||
| 723 | mov @S[3],12($out) | ||
| 724 | cmp %rdx,$inp | ||
| 725 | lea 16($out),$out | ||
| 726 | jne .Lcbc_eloop | ||
| 727 | |||
| 728 | cmp \$0,%rcx | ||
| 729 | jne .Lcbc_enc_tail | ||
| 730 | |||
| 731 | mov $_ivp,$out | ||
| 732 | mov @S[0],0($out) # write out IV residue | ||
| 733 | mov @S[1],4($out) | ||
| 734 | mov @S[2],8($out) | ||
| 735 | mov @S[3],12($out) | ||
| 736 | jmp .Lcbc_done | ||
| 737 | |||
| 738 | .align 16 | ||
| 739 | .Lcbc_enc_tail: | ||
| 740 | xor %rax,%rax | ||
| 741 | mov %rax,0+$ivec | ||
| 742 | mov %rax,8+$ivec | ||
| 743 | mov %rax,$_res | ||
| 744 | |||
| 745 | .Lcbc_enc_pushf: | ||
| 746 | pushfq | ||
| 747 | cld | ||
| 748 | mov $inp,%rsi | ||
| 749 | lea 8+$ivec,%rdi | ||
| 750 | .long 0x9066A4F3 # rep movsb | ||
| 751 | popfq | ||
| 752 | .Lcbc_enc_popf: | ||
| 753 | |||
| 754 | lea $ivec,$inp | ||
| 755 | lea 16+$ivec,%rax | ||
| 756 | mov %rax,$_end | ||
| 757 | jmp .Lcbc_eloop # one more time | ||
| 758 | |||
| 759 | .align 16 | ||
| 760 | .LCBC_DECRYPT: | ||
| 761 | xchg $key,$keyend | ||
| 762 | add \$15,%rdx | ||
| 763 | and \$15,%rcx # length residue | ||
| 764 | and \$-16,%rdx | ||
| 765 | mov $key,$_key | ||
| 766 | lea ($inp,%rdx),%rdx | ||
| 767 | mov %rdx,$_end | ||
| 768 | mov %rcx,$_res | ||
| 769 | |||
| 770 | mov (%rbx),%rax # load IV | ||
| 771 | mov 8(%rbx),%rbx | ||
| 772 | jmp .Lcbc_dloop | ||
| 773 | .align 16 | ||
| 774 | .Lcbc_dloop: | ||
| 775 | mov 0($inp),@S[0] | ||
| 776 | mov 4($inp),@S[1] | ||
| 777 | mov 8($inp),@S[2] | ||
| 778 | bswap @S[0] | ||
| 779 | mov 12($inp),@S[3] | ||
| 780 | bswap @S[1] | ||
| 781 | mov %rax,0+$ivec # save IV to temporary storage | ||
| 782 | bswap @S[2] | ||
| 783 | mov %rbx,8+$ivec | ||
| 784 | bswap @S[3] | ||
| 785 | |||
| 786 | call _x86_64_Camellia_decrypt | ||
| 787 | |||
| 788 | mov $_key,$key # "rewind" the key | ||
| 789 | mov $_end,%rdx | ||
| 790 | mov $_res,%rcx | ||
| 791 | |||
| 792 | bswap @S[0] | ||
| 793 | mov ($inp),%rax # load IV for next iteration | ||
| 794 | bswap @S[1] | ||
| 795 | mov 8($inp),%rbx | ||
| 796 | bswap @S[2] | ||
| 797 | xor 0+$ivec,@S[0] | ||
| 798 | bswap @S[3] | ||
| 799 | xor 4+$ivec,@S[1] | ||
| 800 | xor 8+$ivec,@S[2] | ||
| 801 | lea 16($inp),$inp | ||
| 802 | xor 12+$ivec,@S[3] | ||
| 803 | cmp %rdx,$inp | ||
| 804 | je .Lcbc_ddone | ||
| 805 | |||
| 806 | mov @S[0],0($out) | ||
| 807 | mov @S[1],4($out) | ||
| 808 | mov @S[2],8($out) | ||
| 809 | mov @S[3],12($out) | ||
| 810 | |||
| 811 | lea 16($out),$out | ||
| 812 | jmp .Lcbc_dloop | ||
| 813 | |||
| 814 | .align 16 | ||
| 815 | .Lcbc_ddone: | ||
| 816 | mov $_ivp,%rdx | ||
| 817 | cmp \$0,%rcx | ||
| 818 | jne .Lcbc_dec_tail | ||
| 819 | |||
| 820 | mov @S[0],0($out) | ||
| 821 | mov @S[1],4($out) | ||
| 822 | mov @S[2],8($out) | ||
| 823 | mov @S[3],12($out) | ||
| 824 | |||
| 825 | mov %rax,(%rdx) # write out IV residue | ||
| 826 | mov %rbx,8(%rdx) | ||
| 827 | jmp .Lcbc_done | ||
| 828 | .align 16 | ||
| 829 | .Lcbc_dec_tail: | ||
| 830 | mov @S[0],0+$ivec | ||
| 831 | mov @S[1],4+$ivec | ||
| 832 | mov @S[2],8+$ivec | ||
| 833 | mov @S[3],12+$ivec | ||
| 834 | |||
| 835 | .Lcbc_dec_pushf: | ||
| 836 | pushfq | ||
| 837 | cld | ||
| 838 | lea 8+$ivec,%rsi | ||
| 839 | lea ($out),%rdi | ||
| 840 | .long 0x9066A4F3 # rep movsb | ||
| 841 | popfq | ||
| 842 | .Lcbc_dec_popf: | ||
| 843 | |||
| 844 | mov %rax,(%rdx) # write out IV residue | ||
| 845 | mov %rbx,8(%rdx) | ||
| 846 | jmp .Lcbc_done | ||
| 847 | |||
| 848 | .align 16 | ||
| 849 | .Lcbc_done: | ||
| 850 | mov $_rsp,%rcx | ||
| 851 | mov 0(%rcx),%r15 | ||
| 852 | mov 8(%rcx),%r14 | ||
| 853 | mov 16(%rcx),%r13 | ||
| 854 | mov 24(%rcx),%r12 | ||
| 855 | mov 32(%rcx),%rbp | ||
| 856 | mov 40(%rcx),%rbx | ||
| 857 | lea 48(%rcx),%rsp | ||
| 858 | .Lcbc_abort: | ||
| 859 | ret | ||
| 860 | .size Camellia_cbc_encrypt,.-Camellia_cbc_encrypt | ||
| 861 | |||
| 862 | .asciz "Camellia for x86_64 by <appro@openssl.org>" | ||
| 863 | ___ | ||
| 864 | } | ||
| 865 | |||
| 866 | # EXCEPTION_DISPOSITION handler (EXCEPTION_RECORD *rec,ULONG64 frame, | ||
| 867 | # CONTEXT *context,DISPATCHER_CONTEXT *disp) | ||
| 868 | if ($win64) { | ||
| 869 | $rec="%rcx"; | ||
| 870 | $frame="%rdx"; | ||
| 871 | $context="%r8"; | ||
| 872 | $disp="%r9"; | ||
| 873 | |||
| 874 | $code.=<<___; | ||
| 875 | .extern __imp_RtlVirtualUnwind | ||
| 876 | .type common_se_handler,\@abi-omnipotent | ||
| 877 | .align 16 | ||
| 878 | common_se_handler: | ||
| 879 | push %rsi | ||
| 880 | push %rdi | ||
| 881 | push %rbx | ||
| 882 | push %rbp | ||
| 883 | push %r12 | ||
| 884 | push %r13 | ||
| 885 | push %r14 | ||
| 886 | push %r15 | ||
| 887 | pushfq | ||
| 888 | lea -64(%rsp),%rsp | ||
| 889 | |||
| 890 | mov 120($context),%rax # pull context->Rax | ||
| 891 | mov 248($context),%rbx # pull context->Rip | ||
| 892 | |||
| 893 | mov 8($disp),%rsi # disp->ImageBase | ||
| 894 | mov 56($disp),%r11 # disp->HandlerData | ||
| 895 | |||
| 896 | mov 0(%r11),%r10d # HandlerData[0] | ||
| 897 | lea (%rsi,%r10),%r10 # prologue label | ||
| 898 | cmp %r10,%rbx # context->Rip<prologue label | ||
| 899 | jb .Lin_prologue | ||
| 900 | |||
| 901 | mov 152($context),%rax # pull context->Rsp | ||
| 902 | |||
| 903 | mov 4(%r11),%r10d # HandlerData[1] | ||
| 904 | lea (%rsi,%r10),%r10 # epilogue label | ||
| 905 | cmp %r10,%rbx # context->Rip>=epilogue label | ||
| 906 | jae .Lin_prologue | ||
| 907 | |||
| 908 | lea 40(%rax),%rax | ||
| 909 | mov -8(%rax),%rbx | ||
| 910 | mov -16(%rax),%rbp | ||
| 911 | mov -24(%rax),%r13 | ||
| 912 | mov -32(%rax),%r14 | ||
| 913 | mov -40(%rax),%r15 | ||
| 914 | mov %rbx,144($context) # restore context->Rbx | ||
| 915 | mov %rbp,160($context) # restore context->Rbp | ||
| 916 | mov %r13,224($context) # restore context->R13 | ||
| 917 | mov %r14,232($context) # restore context->R14 | ||
| 918 | mov %r15,240($context) # restore context->R15 | ||
| 919 | |||
| 920 | .Lin_prologue: | ||
| 921 | mov 8(%rax),%rdi | ||
| 922 | mov 16(%rax),%rsi | ||
| 923 | mov %rax,152($context) # restore context->Rsp | ||
| 924 | mov %rsi,168($context) # restore context->Rsi | ||
| 925 | mov %rdi,176($context) # restore context->Rdi | ||
| 926 | |||
| 927 | jmp .Lcommon_seh_exit | ||
| 928 | .size common_se_handler,.-common_se_handler | ||
| 929 | |||
| 930 | .type cbc_se_handler,\@abi-omnipotent | ||
| 931 | .align 16 | ||
| 932 | cbc_se_handler: | ||
| 933 | push %rsi | ||
| 934 | push %rdi | ||
| 935 | push %rbx | ||
| 936 | push %rbp | ||
| 937 | push %r12 | ||
| 938 | push %r13 | ||
| 939 | push %r14 | ||
| 940 | push %r15 | ||
| 941 | pushfq | ||
| 942 | lea -64(%rsp),%rsp | ||
| 943 | |||
| 944 | mov 120($context),%rax # pull context->Rax | ||
| 945 | mov 248($context),%rbx # pull context->Rip | ||
| 946 | |||
| 947 | lea .Lcbc_prologue(%rip),%r10 | ||
| 948 | cmp %r10,%rbx # context->Rip<.Lcbc_prologue | ||
| 949 | jb .Lin_cbc_prologue | ||
| 950 | |||
| 951 | lea .Lcbc_body(%rip),%r10 | ||
| 952 | cmp %r10,%rbx # context->Rip<.Lcbc_body | ||
| 953 | jb .Lin_cbc_frame_setup | ||
| 954 | |||
| 955 | mov 152($context),%rax # pull context->Rsp | ||
| 956 | |||
| 957 | lea .Lcbc_abort(%rip),%r10 | ||
| 958 | cmp %r10,%rbx # context->Rip>=.Lcbc_abort | ||
| 959 | jae .Lin_cbc_prologue | ||
| 960 | |||
| 961 | # handle pushf/popf in Camellia_cbc_encrypt | ||
| 962 | lea .Lcbc_enc_pushf(%rip),%r10 | ||
| 963 | cmp %r10,%rbx # context->Rip<=.Lcbc_enc_pushf | ||
| 964 | jbe .Lin_cbc_no_flag | ||
| 965 | lea 8(%rax),%rax | ||
| 966 | lea .Lcbc_enc_popf(%rip),%r10 | ||
| 967 | cmp %r10,%rbx # context->Rip<.Lcbc_enc_popf | ||
| 968 | jb .Lin_cbc_no_flag | ||
| 969 | lea -8(%rax),%rax | ||
| 970 | lea .Lcbc_dec_pushf(%rip),%r10 | ||
| 971 | cmp %r10,%rbx # context->Rip<=.Lcbc_dec_pushf | ||
| 972 | jbe .Lin_cbc_no_flag | ||
| 973 | lea 8(%rax),%rax | ||
| 974 | lea .Lcbc_dec_popf(%rip),%r10 | ||
| 975 | cmp %r10,%rbx # context->Rip<.Lcbc_dec_popf | ||
| 976 | jb .Lin_cbc_no_flag | ||
| 977 | lea -8(%rax),%rax | ||
| 978 | |||
| 979 | .Lin_cbc_no_flag: | ||
| 980 | mov 48(%rax),%rax # $_rsp | ||
| 981 | lea 48(%rax),%rax | ||
| 982 | |||
| 983 | .Lin_cbc_frame_setup: | ||
| 984 | mov -8(%rax),%rbx | ||
| 985 | mov -16(%rax),%rbp | ||
| 986 | mov -24(%rax),%r12 | ||
| 987 | mov -32(%rax),%r13 | ||
| 988 | mov -40(%rax),%r14 | ||
| 989 | mov -48(%rax),%r15 | ||
| 990 | mov %rbx,144($context) # restore context->Rbx | ||
| 991 | mov %rbp,160($context) # restore context->Rbp | ||
| 992 | mov %r12,216($context) # restore context->R12 | ||
| 993 | mov %r13,224($context) # restore context->R13 | ||
| 994 | mov %r14,232($context) # restore context->R14 | ||
| 995 | mov %r15,240($context) # restore context->R15 | ||
| 996 | |||
| 997 | .Lin_cbc_prologue: | ||
| 998 | mov 8(%rax),%rdi | ||
| 999 | mov 16(%rax),%rsi | ||
| 1000 | mov %rax,152($context) # restore context->Rsp | ||
| 1001 | mov %rsi,168($context) # restore context->Rsi | ||
| 1002 | mov %rdi,176($context) # restore context->Rdi | ||
| 1003 | |||
| 1004 | .align 4 | ||
| 1005 | .Lcommon_seh_exit: | ||
| 1006 | |||
| 1007 | mov 40($disp),%rdi # disp->ContextRecord | ||
| 1008 | mov $context,%rsi # context | ||
| 1009 | mov \$`1232/8`,%ecx # sizeof(CONTEXT) | ||
| 1010 | .long 0xa548f3fc # cld; rep movsq | ||
| 1011 | |||
| 1012 | mov $disp,%rsi | ||
| 1013 | xor %rcx,%rcx # arg1, UNW_FLAG_NHANDLER | ||
| 1014 | mov 8(%rsi),%rdx # arg2, disp->ImageBase | ||
| 1015 | mov 0(%rsi),%r8 # arg3, disp->ControlPc | ||
| 1016 | mov 16(%rsi),%r9 # arg4, disp->FunctionEntry | ||
| 1017 | mov 40(%rsi),%r10 # disp->ContextRecord | ||
| 1018 | lea 56(%rsi),%r11 # &disp->HandlerData | ||
| 1019 | lea 24(%rsi),%r12 # &disp->EstablisherFrame | ||
| 1020 | mov %r10,32(%rsp) # arg5 | ||
| 1021 | mov %r11,40(%rsp) # arg6 | ||
| 1022 | mov %r12,48(%rsp) # arg7 | ||
| 1023 | mov %rcx,56(%rsp) # arg8, (NULL) | ||
| 1024 | call *__imp_RtlVirtualUnwind(%rip) | ||
| 1025 | |||
| 1026 | mov \$1,%eax # ExceptionContinueSearch | ||
| 1027 | lea 64(%rsp),%rsp | ||
| 1028 | popfq | ||
| 1029 | pop %r15 | ||
| 1030 | pop %r14 | ||
| 1031 | pop %r13 | ||
| 1032 | pop %r12 | ||
| 1033 | pop %rbp | ||
| 1034 | pop %rbx | ||
| 1035 | pop %rdi | ||
| 1036 | pop %rsi | ||
| 1037 | ret | ||
| 1038 | .size cbc_se_handler,.-cbc_se_handler | ||
| 1039 | |||
| 1040 | .section .pdata | ||
| 1041 | .align 4 | ||
| 1042 | .rva .LSEH_begin_Camellia_EncryptBlock_Rounds | ||
| 1043 | .rva .LSEH_end_Camellia_EncryptBlock_Rounds | ||
| 1044 | .rva .LSEH_info_Camellia_EncryptBlock_Rounds | ||
| 1045 | |||
| 1046 | .rva .LSEH_begin_Camellia_DecryptBlock_Rounds | ||
| 1047 | .rva .LSEH_end_Camellia_DecryptBlock_Rounds | ||
| 1048 | .rva .LSEH_info_Camellia_DecryptBlock_Rounds | ||
| 1049 | |||
| 1050 | .rva .LSEH_begin_Camellia_Ekeygen | ||
| 1051 | .rva .LSEH_end_Camellia_Ekeygen | ||
| 1052 | .rva .LSEH_info_Camellia_Ekeygen | ||
| 1053 | |||
| 1054 | .rva .LSEH_begin_Camellia_cbc_encrypt | ||
| 1055 | .rva .LSEH_end_Camellia_cbc_encrypt | ||
| 1056 | .rva .LSEH_info_Camellia_cbc_encrypt | ||
| 1057 | |||
| 1058 | .section .xdata | ||
| 1059 | .align 8 | ||
| 1060 | .LSEH_info_Camellia_EncryptBlock_Rounds: | ||
| 1061 | .byte 9,0,0,0 | ||
| 1062 | .rva common_se_handler | ||
| 1063 | .rva .Lenc_prologue,.Lenc_epilogue # HandlerData[] | ||
| 1064 | .LSEH_info_Camellia_DecryptBlock_Rounds: | ||
| 1065 | .byte 9,0,0,0 | ||
| 1066 | .rva common_se_handler | ||
| 1067 | .rva .Ldec_prologue,.Ldec_epilogue # HandlerData[] | ||
| 1068 | .LSEH_info_Camellia_Ekeygen: | ||
| 1069 | .byte 9,0,0,0 | ||
| 1070 | .rva common_se_handler | ||
| 1071 | .rva .Lkey_prologue,.Lkey_epilogue # HandlerData[] | ||
| 1072 | .LSEH_info_Camellia_cbc_encrypt: | ||
| 1073 | .byte 9,0,0,0 | ||
| 1074 | .rva cbc_se_handler | ||
| 1075 | ___ | ||
| 1076 | } | ||
| 1077 | |||
| 1078 | $code =~ s/\`([^\`]*)\`/eval $1/gem; | ||
| 1079 | print $code; | ||
| 1080 | close STDOUT; | ||
diff --git a/src/lib/libssl/src/crypto/cms/cms_smime.c b/src/lib/libssl/src/crypto/cms/cms_smime.c index b9463f9abb..f35883aa22 100644 --- a/src/lib/libssl/src/crypto/cms/cms_smime.c +++ b/src/lib/libssl/src/crypto/cms/cms_smime.c | |||
| @@ -298,7 +298,7 @@ static int cms_signerinfo_verify_cert(CMS_SignerInfo *si, | |||
| 298 | CMS_R_STORE_INIT_ERROR); | 298 | CMS_R_STORE_INIT_ERROR); |
| 299 | goto err; | 299 | goto err; |
| 300 | } | 300 | } |
| 301 | X509_STORE_CTX_set_purpose(&ctx, X509_PURPOSE_SMIME_SIGN); | 301 | X509_STORE_CTX_set_default(&ctx, "smime_sign"); |
| 302 | if (crls) | 302 | if (crls) |
| 303 | X509_STORE_CTX_set0_crls(&ctx, crls); | 303 | X509_STORE_CTX_set0_crls(&ctx, crls); |
| 304 | 304 | ||
| @@ -425,7 +425,7 @@ int CMS_verify(CMS_ContentInfo *cms, STACK_OF(X509) *certs, | |||
| 425 | for (i = 0; i < sk_CMS_SignerInfo_num(sinfos); i++) | 425 | for (i = 0; i < sk_CMS_SignerInfo_num(sinfos); i++) |
| 426 | { | 426 | { |
| 427 | si = sk_CMS_SignerInfo_value(sinfos, i); | 427 | si = sk_CMS_SignerInfo_value(sinfos, i); |
| 428 | if (!CMS_SignerInfo_verify_content(si, cmsbio)) | 428 | if (CMS_SignerInfo_verify_content(si, cmsbio) <= 0) |
| 429 | { | 429 | { |
| 430 | CMSerr(CMS_F_CMS_VERIFY, | 430 | CMSerr(CMS_F_CMS_VERIFY, |
| 431 | CMS_R_CONTENT_VERIFY_ERROR); | 431 | CMS_R_CONTENT_VERIFY_ERROR); |
diff --git a/src/lib/libssl/src/crypto/des/asm/des_enc.m4 b/src/lib/libssl/src/crypto/des/asm/des_enc.m4 index f5b1928f99..f59333a030 100644 --- a/src/lib/libssl/src/crypto/des/asm/des_enc.m4 +++ b/src/lib/libssl/src/crypto/des/asm/des_enc.m4 | |||
| @@ -44,6 +44,7 @@ | |||
| 44 | ! | 44 | ! |
| 45 | 45 | ||
| 46 | .ident "des_enc.m4 2.1" | 46 | .ident "des_enc.m4 2.1" |
| 47 | .file "des_enc-sparc.S" | ||
| 47 | 48 | ||
| 48 | #if defined(__SUNPRO_C) && defined(__sparcv9) | 49 | #if defined(__SUNPRO_C) && defined(__sparcv9) |
| 49 | # define ABI64 /* They've said -xarch=v9 at command line */ | 50 | # define ABI64 /* They've said -xarch=v9 at command line */ |
| @@ -315,16 +316,16 @@ $4: | |||
| 315 | ld [global1+local1], local1 | 316 | ld [global1+local1], local1 |
| 316 | xor $2, out1, out1 ! 8642 | 317 | xor $2, out1, out1 ! 8642 |
| 317 | xor $2, out0, out0 ! 7531 | 318 | xor $2, out0, out0 ! 7531 |
| 318 | fmovs %f0, %f0 ! fxor used for alignment | 319 | ! fmovs %f0, %f0 ! fxor used for alignment |
| 319 | 320 | ||
| 320 | srl out1, 4, local0 ! rotate 4 right | 321 | srl out1, 4, local0 ! rotate 4 right |
| 321 | and out0, local5, local3 ! 3 | 322 | and out0, local5, local3 ! 3 |
| 322 | fmovs %f0, %f0 | 323 | ! fmovs %f0, %f0 |
| 323 | 324 | ||
| 324 | ld [$5+$3*8], local7 ! key 7531 next round | 325 | ld [$5+$3*8], local7 ! key 7531 next round |
| 325 | srl local3, 8, local3 ! 3 | 326 | srl local3, 8, local3 ! 3 |
| 326 | and local0, 252, local2 ! 2 | 327 | and local0, 252, local2 ! 2 |
| 327 | fmovs %f0, %f0 | 328 | ! fmovs %f0, %f0 |
| 328 | 329 | ||
| 329 | ld [global3+local3],local3 ! 3 | 330 | ld [global3+local3],local3 ! 3 |
| 330 | sll out1, 28, out1 ! rotate | 331 | sll out1, 28, out1 ! rotate |
| @@ -1179,8 +1180,11 @@ DES_encrypt1: | |||
| 1179 | 1180 | ||
| 1180 | save %sp, FRAME, %sp | 1181 | save %sp, FRAME, %sp |
| 1181 | 1182 | ||
| 1182 | call .PIC.me.up | 1183 | sethi %hi(.PIC.DES_SPtrans-1f),global1 |
| 1183 | mov .PIC.me.up-(.-4),out0 | 1184 | or global1,%lo(.PIC.DES_SPtrans-1f),global1 |
| 1185 | 1: call .+8 | ||
| 1186 | add %o7,global1,global1 | ||
| 1187 | sub global1,.PIC.DES_SPtrans-.des_and,out2 | ||
| 1184 | 1188 | ||
| 1185 | ld [in0], in5 ! left | 1189 | ld [in0], in5 ! left |
| 1186 | cmp in2, 0 ! enc | 1190 | cmp in2, 0 ! enc |
| @@ -1237,8 +1241,11 @@ DES_encrypt2: | |||
| 1237 | 1241 | ||
| 1238 | save %sp, FRAME, %sp | 1242 | save %sp, FRAME, %sp |
| 1239 | 1243 | ||
| 1240 | call .PIC.me.up | 1244 | sethi %hi(.PIC.DES_SPtrans-1f),global1 |
| 1241 | mov .PIC.me.up-(.-4),out0 | 1245 | or global1,%lo(.PIC.DES_SPtrans-1f),global1 |
| 1246 | 1: call .+8 | ||
| 1247 | add %o7,global1,global1 | ||
| 1248 | sub global1,.PIC.DES_SPtrans-.des_and,out2 | ||
| 1242 | 1249 | ||
| 1243 | ! Set sbox address 1 to 6 and rotate halfs 3 left | 1250 | ! Set sbox address 1 to 6 and rotate halfs 3 left |
| 1244 | ! Errors caught by destest? Yes. Still? *NO* | 1251 | ! Errors caught by destest? Yes. Still? *NO* |
| @@ -1352,8 +1359,11 @@ DES_encrypt3: | |||
| 1352 | 1359 | ||
| 1353 | save %sp, FRAME, %sp | 1360 | save %sp, FRAME, %sp |
| 1354 | 1361 | ||
| 1355 | call .PIC.me.up | 1362 | sethi %hi(.PIC.DES_SPtrans-1f),global1 |
| 1356 | mov .PIC.me.up-(.-4),out0 | 1363 | or global1,%lo(.PIC.DES_SPtrans-1f),global1 |
| 1364 | 1: call .+8 | ||
| 1365 | add %o7,global1,global1 | ||
| 1366 | sub global1,.PIC.DES_SPtrans-.des_and,out2 | ||
| 1357 | 1367 | ||
| 1358 | ld [in0], in5 ! left | 1368 | ld [in0], in5 ! left |
| 1359 | add in2, 120, in4 ! ks2 | 1369 | add in2, 120, in4 ! ks2 |
| @@ -1394,8 +1404,11 @@ DES_decrypt3: | |||
| 1394 | 1404 | ||
| 1395 | save %sp, FRAME, %sp | 1405 | save %sp, FRAME, %sp |
| 1396 | 1406 | ||
| 1397 | call .PIC.me.up | 1407 | sethi %hi(.PIC.DES_SPtrans-1f),global1 |
| 1398 | mov .PIC.me.up-(.-4),out0 | 1408 | or global1,%lo(.PIC.DES_SPtrans-1f),global1 |
| 1409 | 1: call .+8 | ||
| 1410 | add %o7,global1,global1 | ||
| 1411 | sub global1,.PIC.DES_SPtrans-.des_and,out2 | ||
| 1399 | 1412 | ||
| 1400 | ld [in0], in5 ! left | 1413 | ld [in0], in5 ! left |
| 1401 | add in3, 120, in4 ! ks3 | 1414 | add in3, 120, in4 ! ks3 |
| @@ -1424,105 +1437,6 @@ DES_decrypt3: | |||
| 1424 | .DES_decrypt3.end: | 1437 | .DES_decrypt3.end: |
| 1425 | .size DES_decrypt3,.DES_decrypt3.end-DES_decrypt3 | 1438 | .size DES_decrypt3,.DES_decrypt3.end-DES_decrypt3 |
| 1426 | 1439 | ||
| 1427 | .align 256 | ||
| 1428 | .type .des_and,#object | ||
| 1429 | .size .des_and,284 | ||
| 1430 | |||
| 1431 | .des_and: | ||
| 1432 | |||
| 1433 | ! This table is used for AND 0xFC when it is known that register | ||
| 1434 | ! bits 8-31 are zero. Makes it possible to do three arithmetic | ||
| 1435 | ! operations in one cycle. | ||
| 1436 | |||
| 1437 | .byte 0, 0, 0, 0, 4, 4, 4, 4 | ||
| 1438 | .byte 8, 8, 8, 8, 12, 12, 12, 12 | ||
| 1439 | .byte 16, 16, 16, 16, 20, 20, 20, 20 | ||
| 1440 | .byte 24, 24, 24, 24, 28, 28, 28, 28 | ||
| 1441 | .byte 32, 32, 32, 32, 36, 36, 36, 36 | ||
| 1442 | .byte 40, 40, 40, 40, 44, 44, 44, 44 | ||
| 1443 | .byte 48, 48, 48, 48, 52, 52, 52, 52 | ||
| 1444 | .byte 56, 56, 56, 56, 60, 60, 60, 60 | ||
| 1445 | .byte 64, 64, 64, 64, 68, 68, 68, 68 | ||
| 1446 | .byte 72, 72, 72, 72, 76, 76, 76, 76 | ||
| 1447 | .byte 80, 80, 80, 80, 84, 84, 84, 84 | ||
| 1448 | .byte 88, 88, 88, 88, 92, 92, 92, 92 | ||
| 1449 | .byte 96, 96, 96, 96, 100, 100, 100, 100 | ||
| 1450 | .byte 104, 104, 104, 104, 108, 108, 108, 108 | ||
| 1451 | .byte 112, 112, 112, 112, 116, 116, 116, 116 | ||
| 1452 | .byte 120, 120, 120, 120, 124, 124, 124, 124 | ||
| 1453 | .byte 128, 128, 128, 128, 132, 132, 132, 132 | ||
| 1454 | .byte 136, 136, 136, 136, 140, 140, 140, 140 | ||
| 1455 | .byte 144, 144, 144, 144, 148, 148, 148, 148 | ||
| 1456 | .byte 152, 152, 152, 152, 156, 156, 156, 156 | ||
| 1457 | .byte 160, 160, 160, 160, 164, 164, 164, 164 | ||
| 1458 | .byte 168, 168, 168, 168, 172, 172, 172, 172 | ||
| 1459 | .byte 176, 176, 176, 176, 180, 180, 180, 180 | ||
| 1460 | .byte 184, 184, 184, 184, 188, 188, 188, 188 | ||
| 1461 | .byte 192, 192, 192, 192, 196, 196, 196, 196 | ||
| 1462 | .byte 200, 200, 200, 200, 204, 204, 204, 204 | ||
| 1463 | .byte 208, 208, 208, 208, 212, 212, 212, 212 | ||
| 1464 | .byte 216, 216, 216, 216, 220, 220, 220, 220 | ||
| 1465 | .byte 224, 224, 224, 224, 228, 228, 228, 228 | ||
| 1466 | .byte 232, 232, 232, 232, 236, 236, 236, 236 | ||
| 1467 | .byte 240, 240, 240, 240, 244, 244, 244, 244 | ||
| 1468 | .byte 248, 248, 248, 248, 252, 252, 252, 252 | ||
| 1469 | |||
| 1470 | ! 5 numbers for initil/final permutation | ||
| 1471 | |||
| 1472 | .word 0x0f0f0f0f ! offset 256 | ||
| 1473 | .word 0x0000ffff ! 260 | ||
| 1474 | .word 0x33333333 ! 264 | ||
| 1475 | .word 0x00ff00ff ! 268 | ||
| 1476 | .word 0x55555555 ! 272 | ||
| 1477 | |||
| 1478 | .word 0 ! 276 | ||
| 1479 | .word LOOPS ! 280 | ||
| 1480 | .word 0x0000FC00 ! 284 | ||
| 1481 | .PIC.DES_SPtrans: | ||
| 1482 | .word %r_disp32(DES_SPtrans) | ||
| 1483 | |||
| 1484 | ! input: out0 offset between .PIC.me.up and caller | ||
| 1485 | ! output: out0 pointer to .PIC.me.up | ||
| 1486 | ! out2 pointer to .des_and | ||
| 1487 | ! global1 pointer to DES_SPtrans | ||
| 1488 | .align 32 | ||
| 1489 | .PIC.me.up: | ||
| 1490 | add out0,%o7,out0 ! pointer to .PIC.me.up | ||
| 1491 | #if 1 | ||
| 1492 | ld [out0+(.PIC.DES_SPtrans-.PIC.me.up)],global1 | ||
| 1493 | add global1,(.PIC.DES_SPtrans-.PIC.me.up),global1 | ||
| 1494 | add global1,out0,global1 | ||
| 1495 | #else | ||
| 1496 | # ifdef OPENSSL_PIC | ||
| 1497 | ! In case anybody wonders why this code is same for both ABI. | ||
| 1498 | ! To start with it is not. Do note LDPTR below. But of course | ||
| 1499 | ! you must be wondering why the rest of it does not contain | ||
| 1500 | ! things like %hh, %hm and %lm. Well, those are needed only | ||
| 1501 | ! if OpenSSL library *itself* will become larger than 4GB, | ||
| 1502 | ! which is not going to happen any time soon. | ||
| 1503 | sethi %hi(DES_SPtrans),global1 | ||
| 1504 | or global1,%lo(DES_SPtrans),global1 | ||
| 1505 | sethi %hi(_GLOBAL_OFFSET_TABLE_-(.PIC.me.up-.)),out2 | ||
| 1506 | add global1,out0,global1 | ||
| 1507 | add out2,%lo(_GLOBAL_OFFSET_TABLE_-(.PIC.me.up-.)),out2 | ||
| 1508 | LDPTR [out2+global1],global1 | ||
| 1509 | # elif 0 | ||
| 1510 | setn DES_SPtrans,out2,global1 ! synthetic instruction ! | ||
| 1511 | # elif defined(ABI64) | ||
| 1512 | sethi %hh(DES_SPtrans),out2 | ||
| 1513 | or out2,%hm(DES_SPtrans),out2 | ||
| 1514 | sethi %lm(DES_SPtrans),global1 | ||
| 1515 | or global1,%lo(DES_SPtrans),global1 | ||
| 1516 | sllx out2,32,out2 | ||
| 1517 | or out2,global1,global1 | ||
| 1518 | # else | ||
| 1519 | sethi %hi(DES_SPtrans),global1 | ||
| 1520 | or global1,%lo(DES_SPtrans),global1 | ||
| 1521 | # endif | ||
| 1522 | #endif | ||
| 1523 | retl | ||
| 1524 | add out0,.des_and-.PIC.me.up,out2 | ||
| 1525 | |||
| 1526 | ! void DES_ncbc_encrypt(input, output, length, schedule, ivec, enc) | 1440 | ! void DES_ncbc_encrypt(input, output, length, schedule, ivec, enc) |
| 1527 | ! ***************************************************************** | 1441 | ! ***************************************************************** |
| 1528 | 1442 | ||
| @@ -1539,8 +1453,11 @@ DES_ncbc_encrypt: | |||
| 1539 | define({OUTPUT}, { [%sp+BIAS+ARG0+1*ARGSZ] }) | 1453 | define({OUTPUT}, { [%sp+BIAS+ARG0+1*ARGSZ] }) |
| 1540 | define({IVEC}, { [%sp+BIAS+ARG0+4*ARGSZ] }) | 1454 | define({IVEC}, { [%sp+BIAS+ARG0+4*ARGSZ] }) |
| 1541 | 1455 | ||
| 1542 | call .PIC.me.up | 1456 | sethi %hi(.PIC.DES_SPtrans-1f),global1 |
| 1543 | mov .PIC.me.up-(.-4),out0 | 1457 | or global1,%lo(.PIC.DES_SPtrans-1f),global1 |
| 1458 | 1: call .+8 | ||
| 1459 | add %o7,global1,global1 | ||
| 1460 | sub global1,.PIC.DES_SPtrans-.des_and,out2 | ||
| 1544 | 1461 | ||
| 1545 | cmp in5, 0 ! enc | 1462 | cmp in5, 0 ! enc |
| 1546 | 1463 | ||
| @@ -1761,8 +1678,11 @@ DES_ede3_cbc_encrypt: | |||
| 1761 | define({KS2}, { [%sp+BIAS+ARG0+4*ARGSZ] }) | 1678 | define({KS2}, { [%sp+BIAS+ARG0+4*ARGSZ] }) |
| 1762 | define({KS3}, { [%sp+BIAS+ARG0+5*ARGSZ] }) | 1679 | define({KS3}, { [%sp+BIAS+ARG0+5*ARGSZ] }) |
| 1763 | 1680 | ||
| 1764 | call .PIC.me.up | 1681 | sethi %hi(.PIC.DES_SPtrans-1f),global1 |
| 1765 | mov .PIC.me.up-(.-4),out0 | 1682 | or global1,%lo(.PIC.DES_SPtrans-1f),global1 |
| 1683 | 1: call .+8 | ||
| 1684 | add %o7,global1,global1 | ||
| 1685 | sub global1,.PIC.DES_SPtrans-.des_and,out2 | ||
| 1766 | 1686 | ||
| 1767 | LDPTR [%fp+BIAS+ARG0+7*ARGSZ], local3 ! enc | 1687 | LDPTR [%fp+BIAS+ARG0+7*ARGSZ], local3 ! enc |
| 1768 | LDPTR [%fp+BIAS+ARG0+6*ARGSZ], local4 ! ivec | 1688 | LDPTR [%fp+BIAS+ARG0+6*ARGSZ], local4 ! ivec |
| @@ -1978,3 +1898,200 @@ DES_ede3_cbc_encrypt: | |||
| 1978 | 1898 | ||
| 1979 | .DES_ede3_cbc_encrypt.end: | 1899 | .DES_ede3_cbc_encrypt.end: |
| 1980 | .size DES_ede3_cbc_encrypt,.DES_ede3_cbc_encrypt.end-DES_ede3_cbc_encrypt | 1900 | .size DES_ede3_cbc_encrypt,.DES_ede3_cbc_encrypt.end-DES_ede3_cbc_encrypt |
| 1901 | |||
| 1902 | .align 256 | ||
| 1903 | .type .des_and,#object | ||
| 1904 | .size .des_and,284 | ||
| 1905 | |||
| 1906 | .des_and: | ||
| 1907 | |||
| 1908 | ! This table is used for AND 0xFC when it is known that register | ||
| 1909 | ! bits 8-31 are zero. Makes it possible to do three arithmetic | ||
| 1910 | ! operations in one cycle. | ||
| 1911 | |||
| 1912 | .byte 0, 0, 0, 0, 4, 4, 4, 4 | ||
| 1913 | .byte 8, 8, 8, 8, 12, 12, 12, 12 | ||
| 1914 | .byte 16, 16, 16, 16, 20, 20, 20, 20 | ||
| 1915 | .byte 24, 24, 24, 24, 28, 28, 28, 28 | ||
| 1916 | .byte 32, 32, 32, 32, 36, 36, 36, 36 | ||
| 1917 | .byte 40, 40, 40, 40, 44, 44, 44, 44 | ||
| 1918 | .byte 48, 48, 48, 48, 52, 52, 52, 52 | ||
| 1919 | .byte 56, 56, 56, 56, 60, 60, 60, 60 | ||
| 1920 | .byte 64, 64, 64, 64, 68, 68, 68, 68 | ||
| 1921 | .byte 72, 72, 72, 72, 76, 76, 76, 76 | ||
| 1922 | .byte 80, 80, 80, 80, 84, 84, 84, 84 | ||
| 1923 | .byte 88, 88, 88, 88, 92, 92, 92, 92 | ||
| 1924 | .byte 96, 96, 96, 96, 100, 100, 100, 100 | ||
| 1925 | .byte 104, 104, 104, 104, 108, 108, 108, 108 | ||
| 1926 | .byte 112, 112, 112, 112, 116, 116, 116, 116 | ||
| 1927 | .byte 120, 120, 120, 120, 124, 124, 124, 124 | ||
| 1928 | .byte 128, 128, 128, 128, 132, 132, 132, 132 | ||
| 1929 | .byte 136, 136, 136, 136, 140, 140, 140, 140 | ||
| 1930 | .byte 144, 144, 144, 144, 148, 148, 148, 148 | ||
| 1931 | .byte 152, 152, 152, 152, 156, 156, 156, 156 | ||
| 1932 | .byte 160, 160, 160, 160, 164, 164, 164, 164 | ||
| 1933 | .byte 168, 168, 168, 168, 172, 172, 172, 172 | ||
| 1934 | .byte 176, 176, 176, 176, 180, 180, 180, 180 | ||
| 1935 | .byte 184, 184, 184, 184, 188, 188, 188, 188 | ||
| 1936 | .byte 192, 192, 192, 192, 196, 196, 196, 196 | ||
| 1937 | .byte 200, 200, 200, 200, 204, 204, 204, 204 | ||
| 1938 | .byte 208, 208, 208, 208, 212, 212, 212, 212 | ||
| 1939 | .byte 216, 216, 216, 216, 220, 220, 220, 220 | ||
| 1940 | .byte 224, 224, 224, 224, 228, 228, 228, 228 | ||
| 1941 | .byte 232, 232, 232, 232, 236, 236, 236, 236 | ||
| 1942 | .byte 240, 240, 240, 240, 244, 244, 244, 244 | ||
| 1943 | .byte 248, 248, 248, 248, 252, 252, 252, 252 | ||
| 1944 | |||
| 1945 | ! 5 numbers for initil/final permutation | ||
| 1946 | |||
| 1947 | .word 0x0f0f0f0f ! offset 256 | ||
| 1948 | .word 0x0000ffff ! 260 | ||
| 1949 | .word 0x33333333 ! 264 | ||
| 1950 | .word 0x00ff00ff ! 268 | ||
| 1951 | .word 0x55555555 ! 272 | ||
| 1952 | |||
| 1953 | .word 0 ! 276 | ||
| 1954 | .word LOOPS ! 280 | ||
| 1955 | .word 0x0000FC00 ! 284 | ||
| 1956 | |||
| 1957 | .type .PIC.DES_SPtrans,#object | ||
| 1958 | .size .PIC.DES_SPtrans,2048 | ||
| 1959 | .align 64 | ||
| 1960 | .PIC.DES_SPtrans: | ||
| 1961 | ! nibble 0 | ||
| 1962 | .word 0x02080800, 0x00080000, 0x02000002, 0x02080802 | ||
| 1963 | .word 0x02000000, 0x00080802, 0x00080002, 0x02000002 | ||
| 1964 | .word 0x00080802, 0x02080800, 0x02080000, 0x00000802 | ||
| 1965 | .word 0x02000802, 0x02000000, 0x00000000, 0x00080002 | ||
| 1966 | .word 0x00080000, 0x00000002, 0x02000800, 0x00080800 | ||
| 1967 | .word 0x02080802, 0x02080000, 0x00000802, 0x02000800 | ||
| 1968 | .word 0x00000002, 0x00000800, 0x00080800, 0x02080002 | ||
| 1969 | .word 0x00000800, 0x02000802, 0x02080002, 0x00000000 | ||
| 1970 | .word 0x00000000, 0x02080802, 0x02000800, 0x00080002 | ||
| 1971 | .word 0x02080800, 0x00080000, 0x00000802, 0x02000800 | ||
| 1972 | .word 0x02080002, 0x00000800, 0x00080800, 0x02000002 | ||
| 1973 | .word 0x00080802, 0x00000002, 0x02000002, 0x02080000 | ||
| 1974 | .word 0x02080802, 0x00080800, 0x02080000, 0x02000802 | ||
| 1975 | .word 0x02000000, 0x00000802, 0x00080002, 0x00000000 | ||
| 1976 | .word 0x00080000, 0x02000000, 0x02000802, 0x02080800 | ||
| 1977 | .word 0x00000002, 0x02080002, 0x00000800, 0x00080802 | ||
| 1978 | ! nibble 1 | ||
| 1979 | .word 0x40108010, 0x00000000, 0x00108000, 0x40100000 | ||
| 1980 | .word 0x40000010, 0x00008010, 0x40008000, 0x00108000 | ||
| 1981 | .word 0x00008000, 0x40100010, 0x00000010, 0x40008000 | ||
| 1982 | .word 0x00100010, 0x40108000, 0x40100000, 0x00000010 | ||
| 1983 | .word 0x00100000, 0x40008010, 0x40100010, 0x00008000 | ||
| 1984 | .word 0x00108010, 0x40000000, 0x00000000, 0x00100010 | ||
| 1985 | .word 0x40008010, 0x00108010, 0x40108000, 0x40000010 | ||
| 1986 | .word 0x40000000, 0x00100000, 0x00008010, 0x40108010 | ||
| 1987 | .word 0x00100010, 0x40108000, 0x40008000, 0x00108010 | ||
| 1988 | .word 0x40108010, 0x00100010, 0x40000010, 0x00000000 | ||
| 1989 | .word 0x40000000, 0x00008010, 0x00100000, 0x40100010 | ||
| 1990 | .word 0x00008000, 0x40000000, 0x00108010, 0x40008010 | ||
| 1991 | .word 0x40108000, 0x00008000, 0x00000000, 0x40000010 | ||
| 1992 | .word 0x00000010, 0x40108010, 0x00108000, 0x40100000 | ||
| 1993 | .word 0x40100010, 0x00100000, 0x00008010, 0x40008000 | ||
| 1994 | .word 0x40008010, 0x00000010, 0x40100000, 0x00108000 | ||
| 1995 | ! nibble 2 | ||
| 1996 | .word 0x04000001, 0x04040100, 0x00000100, 0x04000101 | ||
| 1997 | .word 0x00040001, 0x04000000, 0x04000101, 0x00040100 | ||
| 1998 | .word 0x04000100, 0x00040000, 0x04040000, 0x00000001 | ||
| 1999 | .word 0x04040101, 0x00000101, 0x00000001, 0x04040001 | ||
| 2000 | .word 0x00000000, 0x00040001, 0x04040100, 0x00000100 | ||
| 2001 | .word 0x00000101, 0x04040101, 0x00040000, 0x04000001 | ||
| 2002 | .word 0x04040001, 0x04000100, 0x00040101, 0x04040000 | ||
| 2003 | .word 0x00040100, 0x00000000, 0x04000000, 0x00040101 | ||
| 2004 | .word 0x04040100, 0x00000100, 0x00000001, 0x00040000 | ||
| 2005 | .word 0x00000101, 0x00040001, 0x04040000, 0x04000101 | ||
| 2006 | .word 0x00000000, 0x04040100, 0x00040100, 0x04040001 | ||
| 2007 | .word 0x00040001, 0x04000000, 0x04040101, 0x00000001 | ||
| 2008 | .word 0x00040101, 0x04000001, 0x04000000, 0x04040101 | ||
| 2009 | .word 0x00040000, 0x04000100, 0x04000101, 0x00040100 | ||
| 2010 | .word 0x04000100, 0x00000000, 0x04040001, 0x00000101 | ||
| 2011 | .word 0x04000001, 0x00040101, 0x00000100, 0x04040000 | ||
| 2012 | ! nibble 3 | ||
| 2013 | .word 0x00401008, 0x10001000, 0x00000008, 0x10401008 | ||
| 2014 | .word 0x00000000, 0x10400000, 0x10001008, 0x00400008 | ||
| 2015 | .word 0x10401000, 0x10000008, 0x10000000, 0x00001008 | ||
| 2016 | .word 0x10000008, 0x00401008, 0x00400000, 0x10000000 | ||
| 2017 | .word 0x10400008, 0x00401000, 0x00001000, 0x00000008 | ||
| 2018 | .word 0x00401000, 0x10001008, 0x10400000, 0x00001000 | ||
| 2019 | .word 0x00001008, 0x00000000, 0x00400008, 0x10401000 | ||
| 2020 | .word 0x10001000, 0x10400008, 0x10401008, 0x00400000 | ||
| 2021 | .word 0x10400008, 0x00001008, 0x00400000, 0x10000008 | ||
| 2022 | .word 0x00401000, 0x10001000, 0x00000008, 0x10400000 | ||
| 2023 | .word 0x10001008, 0x00000000, 0x00001000, 0x00400008 | ||
| 2024 | .word 0x00000000, 0x10400008, 0x10401000, 0x00001000 | ||
| 2025 | .word 0x10000000, 0x10401008, 0x00401008, 0x00400000 | ||
| 2026 | .word 0x10401008, 0x00000008, 0x10001000, 0x00401008 | ||
| 2027 | .word 0x00400008, 0x00401000, 0x10400000, 0x10001008 | ||
| 2028 | .word 0x00001008, 0x10000000, 0x10000008, 0x10401000 | ||
| 2029 | ! nibble 4 | ||
| 2030 | .word 0x08000000, 0x00010000, 0x00000400, 0x08010420 | ||
| 2031 | .word 0x08010020, 0x08000400, 0x00010420, 0x08010000 | ||
| 2032 | .word 0x00010000, 0x00000020, 0x08000020, 0x00010400 | ||
| 2033 | .word 0x08000420, 0x08010020, 0x08010400, 0x00000000 | ||
| 2034 | .word 0x00010400, 0x08000000, 0x00010020, 0x00000420 | ||
| 2035 | .word 0x08000400, 0x00010420, 0x00000000, 0x08000020 | ||
| 2036 | .word 0x00000020, 0x08000420, 0x08010420, 0x00010020 | ||
| 2037 | .word 0x08010000, 0x00000400, 0x00000420, 0x08010400 | ||
| 2038 | .word 0x08010400, 0x08000420, 0x00010020, 0x08010000 | ||
| 2039 | .word 0x00010000, 0x00000020, 0x08000020, 0x08000400 | ||
| 2040 | .word 0x08000000, 0x00010400, 0x08010420, 0x00000000 | ||
| 2041 | .word 0x00010420, 0x08000000, 0x00000400, 0x00010020 | ||
| 2042 | .word 0x08000420, 0x00000400, 0x00000000, 0x08010420 | ||
| 2043 | .word 0x08010020, 0x08010400, 0x00000420, 0x00010000 | ||
| 2044 | .word 0x00010400, 0x08010020, 0x08000400, 0x00000420 | ||
| 2045 | .word 0x00000020, 0x00010420, 0x08010000, 0x08000020 | ||
| 2046 | ! nibble 5 | ||
| 2047 | .word 0x80000040, 0x00200040, 0x00000000, 0x80202000 | ||
| 2048 | .word 0x00200040, 0x00002000, 0x80002040, 0x00200000 | ||
| 2049 | .word 0x00002040, 0x80202040, 0x00202000, 0x80000000 | ||
| 2050 | .word 0x80002000, 0x80000040, 0x80200000, 0x00202040 | ||
| 2051 | .word 0x00200000, 0x80002040, 0x80200040, 0x00000000 | ||
| 2052 | .word 0x00002000, 0x00000040, 0x80202000, 0x80200040 | ||
| 2053 | .word 0x80202040, 0x80200000, 0x80000000, 0x00002040 | ||
| 2054 | .word 0x00000040, 0x00202000, 0x00202040, 0x80002000 | ||
| 2055 | .word 0x00002040, 0x80000000, 0x80002000, 0x00202040 | ||
| 2056 | .word 0x80202000, 0x00200040, 0x00000000, 0x80002000 | ||
| 2057 | .word 0x80000000, 0x00002000, 0x80200040, 0x00200000 | ||
| 2058 | .word 0x00200040, 0x80202040, 0x00202000, 0x00000040 | ||
| 2059 | .word 0x80202040, 0x00202000, 0x00200000, 0x80002040 | ||
| 2060 | .word 0x80000040, 0x80200000, 0x00202040, 0x00000000 | ||
| 2061 | .word 0x00002000, 0x80000040, 0x80002040, 0x80202000 | ||
| 2062 | .word 0x80200000, 0x00002040, 0x00000040, 0x80200040 | ||
| 2063 | ! nibble 6 | ||
| 2064 | .word 0x00004000, 0x00000200, 0x01000200, 0x01000004 | ||
| 2065 | .word 0x01004204, 0x00004004, 0x00004200, 0x00000000 | ||
| 2066 | .word 0x01000000, 0x01000204, 0x00000204, 0x01004000 | ||
| 2067 | .word 0x00000004, 0x01004200, 0x01004000, 0x00000204 | ||
| 2068 | .word 0x01000204, 0x00004000, 0x00004004, 0x01004204 | ||
| 2069 | .word 0x00000000, 0x01000200, 0x01000004, 0x00004200 | ||
| 2070 | .word 0x01004004, 0x00004204, 0x01004200, 0x00000004 | ||
| 2071 | .word 0x00004204, 0x01004004, 0x00000200, 0x01000000 | ||
| 2072 | .word 0x00004204, 0x01004000, 0x01004004, 0x00000204 | ||
| 2073 | .word 0x00004000, 0x00000200, 0x01000000, 0x01004004 | ||
| 2074 | .word 0x01000204, 0x00004204, 0x00004200, 0x00000000 | ||
| 2075 | .word 0x00000200, 0x01000004, 0x00000004, 0x01000200 | ||
| 2076 | .word 0x00000000, 0x01000204, 0x01000200, 0x00004200 | ||
| 2077 | .word 0x00000204, 0x00004000, 0x01004204, 0x01000000 | ||
| 2078 | .word 0x01004200, 0x00000004, 0x00004004, 0x01004204 | ||
| 2079 | .word 0x01000004, 0x01004200, 0x01004000, 0x00004004 | ||
| 2080 | ! nibble 7 | ||
| 2081 | .word 0x20800080, 0x20820000, 0x00020080, 0x00000000 | ||
| 2082 | .word 0x20020000, 0x00800080, 0x20800000, 0x20820080 | ||
| 2083 | .word 0x00000080, 0x20000000, 0x00820000, 0x00020080 | ||
| 2084 | .word 0x00820080, 0x20020080, 0x20000080, 0x20800000 | ||
| 2085 | .word 0x00020000, 0x00820080, 0x00800080, 0x20020000 | ||
| 2086 | .word 0x20820080, 0x20000080, 0x00000000, 0x00820000 | ||
| 2087 | .word 0x20000000, 0x00800000, 0x20020080, 0x20800080 | ||
| 2088 | .word 0x00800000, 0x00020000, 0x20820000, 0x00000080 | ||
| 2089 | .word 0x00800000, 0x00020000, 0x20000080, 0x20820080 | ||
| 2090 | .word 0x00020080, 0x20000000, 0x00000000, 0x00820000 | ||
| 2091 | .word 0x20800080, 0x20020080, 0x20020000, 0x00800080 | ||
| 2092 | .word 0x20820000, 0x00000080, 0x00800080, 0x20020000 | ||
| 2093 | .word 0x20820080, 0x00800000, 0x20800000, 0x20000080 | ||
| 2094 | .word 0x00820000, 0x00020080, 0x20020080, 0x20800000 | ||
| 2095 | .word 0x00000080, 0x20820000, 0x00820080, 0x00000000 | ||
| 2096 | .word 0x20000000, 0x20800080, 0x00020000, 0x00820080 | ||
| 2097 | |||
diff --git a/src/lib/libssl/src/crypto/ppccpuid.pl b/src/lib/libssl/src/crypto/ppccpuid.pl new file mode 100755 index 0000000000..fe44ff07bc --- /dev/null +++ b/src/lib/libssl/src/crypto/ppccpuid.pl | |||
| @@ -0,0 +1,94 @@ | |||
| 1 | #!/usr/bin/env perl | ||
| 2 | |||
| 3 | $flavour = shift; | ||
| 4 | |||
| 5 | $0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1; | ||
| 6 | ( $xlate="${dir}ppc-xlate.pl" and -f $xlate ) or | ||
| 7 | ( $xlate="${dir}perlasm/ppc-xlate.pl" and -f $xlate) or | ||
| 8 | die "can't locate ppc-xlate.pl"; | ||
| 9 | |||
| 10 | open STDOUT,"| $^X $xlate $flavour ".shift || die "can't call $xlate: $!"; | ||
| 11 | |||
| 12 | if ($flavour=~/64/) { | ||
| 13 | $CMPLI="cmpldi"; | ||
| 14 | $SHRLI="srdi"; | ||
| 15 | $SIGNX="extsw"; | ||
| 16 | } else { | ||
| 17 | $CMPLI="cmplwi"; | ||
| 18 | $SHRLI="srwi"; | ||
| 19 | $SIGNX="mr"; | ||
| 20 | } | ||
| 21 | |||
| 22 | $code=<<___; | ||
| 23 | .machine "any" | ||
| 24 | .text | ||
| 25 | |||
| 26 | .globl .OPENSSL_cpuid_setup | ||
| 27 | .align 4 | ||
| 28 | .OPENSSL_cpuid_setup: | ||
| 29 | blr | ||
| 30 | |||
| 31 | .globl .OPENSSL_wipe_cpu | ||
| 32 | .align 4 | ||
| 33 | .OPENSSL_wipe_cpu: | ||
| 34 | xor r0,r0,r0 | ||
| 35 | mr r3,r1 | ||
| 36 | xor r4,r4,r4 | ||
| 37 | xor r5,r5,r5 | ||
| 38 | xor r6,r6,r6 | ||
| 39 | xor r7,r7,r7 | ||
| 40 | xor r8,r8,r8 | ||
| 41 | xor r9,r9,r9 | ||
| 42 | xor r10,r10,r10 | ||
| 43 | xor r11,r11,r11 | ||
| 44 | xor r12,r12,r12 | ||
| 45 | blr | ||
| 46 | |||
| 47 | .globl .OPENSSL_atomic_add | ||
| 48 | .align 4 | ||
| 49 | .OPENSSL_atomic_add: | ||
| 50 | Loop: lwarx r5,0,r3 | ||
| 51 | add r0,r4,r5 | ||
| 52 | stwcx. r0,0,r3 | ||
| 53 | bne- Loop | ||
| 54 | $SIGNX r3,r0 | ||
| 55 | blr | ||
| 56 | |||
| 57 | .globl .OPENSSL_rdtsc | ||
| 58 | .align 4 | ||
| 59 | .OPENSSL_rdtsc: | ||
| 60 | mftb r3 | ||
| 61 | mftbu r4 | ||
| 62 | blr | ||
| 63 | |||
| 64 | .globl .OPENSSL_cleanse | ||
| 65 | .align 4 | ||
| 66 | .OPENSSL_cleanse: | ||
| 67 | $CMPLI r4,7 | ||
| 68 | li r0,0 | ||
| 69 | bge Lot | ||
| 70 | Little: mtctr r4 | ||
| 71 | stb r0,0(r3) | ||
| 72 | addi r3,r3,1 | ||
| 73 | bdnz- \$-8 | ||
| 74 | blr | ||
| 75 | Lot: andi. r5,r3,3 | ||
| 76 | beq Laligned | ||
| 77 | stb r0,0(r3) | ||
| 78 | subi r4,r4,1 | ||
| 79 | addi r3,r3,1 | ||
| 80 | b Lot | ||
| 81 | Laligned: | ||
| 82 | $SHRLI r5,r4,2 | ||
| 83 | mtctr r5 | ||
| 84 | stw r0,0(r3) | ||
| 85 | addi r3,r3,4 | ||
| 86 | bdnz- \$-8 | ||
| 87 | andi. r4,r4,3 | ||
| 88 | bne Little | ||
| 89 | blr | ||
| 90 | ___ | ||
| 91 | |||
| 92 | $code =~ s/\`([^\`]*)\`/eval $1/gem; | ||
| 93 | print $code; | ||
| 94 | close STDOUT; | ||
diff --git a/src/lib/libssl/src/crypto/s390xcpuid.S b/src/lib/libssl/src/crypto/s390xcpuid.S new file mode 100644 index 0000000000..8500133ad0 --- /dev/null +++ b/src/lib/libssl/src/crypto/s390xcpuid.S | |||
| @@ -0,0 +1,90 @@ | |||
| 1 | .text | ||
| 2 | |||
| 3 | .globl OPENSSL_cpuid_setup | ||
| 4 | .type OPENSSL_cpuid_setup,@function | ||
| 5 | .align 16 | ||
| 6 | OPENSSL_cpuid_setup: | ||
| 7 | br %r14 # reserved for future | ||
| 8 | .size OPENSSL_cpuid_setup,.-OPENSSL_cpuid_setup | ||
| 9 | |||
| 10 | .globl OPENSSL_s390x_facilities | ||
| 11 | .type OPENSSL_s390x_facilities,@function | ||
| 12 | .align 16 | ||
| 13 | OPENSSL_s390x_facilities: | ||
| 14 | lghi %r0,0 | ||
| 15 | .long 0xb2b0f010 # stfle 16(%r15) | ||
| 16 | lg %r2,16(%r15) | ||
| 17 | br %r14 | ||
| 18 | .size OPENSSL_s390x_facilities,.-OPENSSL_s390x_facilities | ||
| 19 | |||
| 20 | .globl OPENSSL_rdtsc | ||
| 21 | .type OPENSSL_rdtsc,@function | ||
| 22 | .align 16 | ||
| 23 | OPENSSL_rdtsc: | ||
| 24 | stck 16(%r15) | ||
| 25 | lg %r2,16(%r15) | ||
| 26 | br %r14 | ||
| 27 | .size OPENSSL_rdtsc,.-OPENSSL_rdtsc | ||
| 28 | |||
| 29 | .globl OPENSSL_atomic_add | ||
| 30 | .type OPENSSL_atomic_add,@function | ||
| 31 | .align 16 | ||
| 32 | OPENSSL_atomic_add: | ||
| 33 | l %r1,0(%r2) | ||
| 34 | .Lspin: lr %r0,%r1 | ||
| 35 | ar %r0,%r3 | ||
| 36 | cs %r1,%r0,0(%r2) | ||
| 37 | brc 4,.Lspin | ||
| 38 | lgfr %r2,%r0 # OpenSSL expects the new value | ||
| 39 | br %r14 | ||
| 40 | .size OPENSSL_atomic_add,.-OPENSSL_atomic_add | ||
| 41 | |||
| 42 | .globl OPENSSL_wipe_cpu | ||
| 43 | .type OPENSSL_wipe_cpu,@function | ||
| 44 | .align 16 | ||
| 45 | OPENSSL_wipe_cpu: | ||
| 46 | xgr %r0,%r0 | ||
| 47 | xgr %r1,%r1 | ||
| 48 | lgr %r2,%r15 | ||
| 49 | xgr %r3,%r3 | ||
| 50 | xgr %r4,%r4 | ||
| 51 | lzdr %f0 | ||
| 52 | lzdr %f1 | ||
| 53 | lzdr %f2 | ||
| 54 | lzdr %f3 | ||
| 55 | lzdr %f4 | ||
| 56 | lzdr %f5 | ||
| 57 | lzdr %f6 | ||
| 58 | lzdr %f7 | ||
| 59 | br %r14 | ||
| 60 | .size OPENSSL_wipe_cpu,.-OPENSSL_wipe_cpu | ||
| 61 | |||
| 62 | .globl OPENSSL_cleanse | ||
| 63 | .type OPENSSL_cleanse,@function | ||
| 64 | .align 16 | ||
| 65 | OPENSSL_cleanse: | ||
| 66 | lghi %r4,15 | ||
| 67 | lghi %r0,0 | ||
| 68 | clgr %r3,%r4 | ||
| 69 | jh .Lot | ||
| 70 | .Little: | ||
| 71 | stc %r0,0(%r2) | ||
| 72 | la %r2,1(%r2) | ||
| 73 | brctg %r3,.Little | ||
| 74 | br %r14 | ||
| 75 | .align 4 | ||
| 76 | .Lot: tmll %r2,7 | ||
| 77 | jz .Laligned | ||
| 78 | stc %r0,0(%r2) | ||
| 79 | la %r2,1(%r2) | ||
| 80 | brctg %r3,.Lot | ||
| 81 | .Laligned: | ||
| 82 | srlg %r4,%r3,3 | ||
| 83 | .Loop: stg %r0,0(%r2) | ||
| 84 | la %r2,8(%r2) | ||
| 85 | brctg %r4,.Loop | ||
| 86 | lghi %r4,7 | ||
| 87 | ngr %r3,%r4 | ||
| 88 | jnz .Little | ||
| 89 | br %r14 | ||
| 90 | .size OPENSSL_cleanse,.-OPENSSL_cleanse | ||
diff --git a/src/lib/libssl/src/crypto/sparcv9cap.c b/src/lib/libssl/src/crypto/sparcv9cap.c new file mode 100644 index 0000000000..5f31d20bd0 --- /dev/null +++ b/src/lib/libssl/src/crypto/sparcv9cap.c | |||
| @@ -0,0 +1,154 @@ | |||
| 1 | #include <stdio.h> | ||
| 2 | #include <stdlib.h> | ||
| 3 | #include <string.h> | ||
| 4 | #include <sys/time.h> | ||
| 5 | #include <openssl/bn.h> | ||
| 6 | |||
| 7 | #define SPARCV9_TICK_PRIVILEGED (1<<0) | ||
| 8 | #define SPARCV9_PREFER_FPU (1<<1) | ||
| 9 | #define SPARCV9_VIS1 (1<<2) | ||
| 10 | #define SPARCV9_VIS2 (1<<3) /* reserved */ | ||
| 11 | #define SPARCV9_FMADD (1<<4) /* reserved for SPARC64 V */ | ||
| 12 | static int OPENSSL_sparcv9cap_P=SPARCV9_TICK_PRIVILEGED; | ||
| 13 | |||
| 14 | int bn_mul_mont(BN_ULONG *rp, const BN_ULONG *ap, const BN_ULONG *bp, const BN_ULONG *np,const BN_ULONG *n0, int num) | ||
| 15 | { | ||
| 16 | int bn_mul_mont_fpu(BN_ULONG *rp, const BN_ULONG *ap, const BN_ULONG *bp, const BN_ULONG *np,const BN_ULONG *n0, int num); | ||
| 17 | int bn_mul_mont_int(BN_ULONG *rp, const BN_ULONG *ap, const BN_ULONG *bp, const BN_ULONG *np,const BN_ULONG *n0, int num); | ||
| 18 | |||
| 19 | if ((OPENSSL_sparcv9cap_P&(SPARCV9_PREFER_FPU|SPARCV9_VIS1)) == | ||
| 20 | (SPARCV9_PREFER_FPU|SPARCV9_VIS1)) | ||
| 21 | return bn_mul_mont_fpu(rp,ap,bp,np,n0,num); | ||
| 22 | else | ||
| 23 | return bn_mul_mont_int(rp,ap,bp,np,n0,num); | ||
| 24 | } | ||
| 25 | |||
| 26 | unsigned long OPENSSL_rdtsc(void) | ||
| 27 | { | ||
| 28 | unsigned long _sparcv9_rdtick(void); | ||
| 29 | |||
| 30 | if (OPENSSL_sparcv9cap_P&SPARCV9_TICK_PRIVILEGED) | ||
| 31 | #if defined(__sun) && defined(__SVR4) | ||
| 32 | return gethrtime(); | ||
| 33 | #else | ||
| 34 | return 0; | ||
| 35 | #endif | ||
| 36 | else | ||
| 37 | return _sparcv9_rdtick(); | ||
| 38 | } | ||
| 39 | |||
| 40 | #if defined(__sun) && defined(__SVR4) | ||
| 41 | |||
| 42 | #include <dlfcn.h> | ||
| 43 | #include <libdevinfo.h> | ||
| 44 | #include <sys/systeminfo.h> | ||
| 45 | |||
| 46 | typedef di_node_t (*di_init_t)(const char *,uint_t); | ||
| 47 | typedef void (*di_fini_t)(di_node_t); | ||
| 48 | typedef char * (*di_node_name_t)(di_node_t); | ||
| 49 | typedef int (*di_walk_node_t)(di_node_t,uint_t,di_node_name_t,int (*)(di_node_t,di_node_name_t)); | ||
| 50 | |||
| 51 | #define DLLINK(h,name) (name=(name##_t)dlsym((h),#name)) | ||
| 52 | |||
| 53 | static int walk_nodename(di_node_t node, di_node_name_t di_node_name) | ||
| 54 | { | ||
| 55 | char *name = (*di_node_name)(node); | ||
| 56 | |||
| 57 | /* This is expected to catch all UltraSPARC flavors prior T1 */ | ||
| 58 | if (!strcmp (name,"SUNW,UltraSPARC") || | ||
| 59 | !strncmp(name,"SUNW,UltraSPARC-I",17)) /* covers II,III,IV */ | ||
| 60 | { | ||
| 61 | OPENSSL_sparcv9cap_P |= SPARCV9_PREFER_FPU|SPARCV9_VIS1; | ||
| 62 | |||
| 63 | /* %tick is privileged only on UltraSPARC-I/II, but not IIe */ | ||
| 64 | if (name[14]!='\0' && name[17]!='\0' && name[18]!='\0') | ||
| 65 | OPENSSL_sparcv9cap_P &= ~SPARCV9_TICK_PRIVILEGED; | ||
| 66 | |||
| 67 | return DI_WALK_TERMINATE; | ||
| 68 | } | ||
| 69 | /* This is expected to catch remaining UltraSPARCs, such as T1 */ | ||
| 70 | else if (!strncmp(name,"SUNW,UltraSPARC",15)) | ||
| 71 | { | ||
| 72 | OPENSSL_sparcv9cap_P &= ~SPARCV9_TICK_PRIVILEGED; | ||
| 73 | |||
| 74 | return DI_WALK_TERMINATE; | ||
| 75 | } | ||
| 76 | |||
| 77 | return DI_WALK_CONTINUE; | ||
| 78 | } | ||
| 79 | |||
| 80 | void OPENSSL_cpuid_setup(void) | ||
| 81 | { | ||
| 82 | void *h; | ||
| 83 | char *e,si[256]; | ||
| 84 | static int trigger=0; | ||
| 85 | |||
| 86 | if (trigger) return; | ||
| 87 | trigger=1; | ||
| 88 | |||
| 89 | if ((e=getenv("OPENSSL_sparcv9cap"))) | ||
| 90 | { | ||
| 91 | OPENSSL_sparcv9cap_P=strtoul(e,NULL,0); | ||
| 92 | return; | ||
| 93 | } | ||
| 94 | |||
| 95 | if (sysinfo(SI_MACHINE,si,sizeof(si))>0) | ||
| 96 | { | ||
| 97 | if (strcmp(si,"sun4v")) | ||
| 98 | /* FPU is preferred for all CPUs, but US-T1/2 */ | ||
| 99 | OPENSSL_sparcv9cap_P |= SPARCV9_PREFER_FPU; | ||
| 100 | } | ||
| 101 | |||
| 102 | if (sysinfo(SI_ISALIST,si,sizeof(si))>0) | ||
| 103 | { | ||
| 104 | if (strstr(si,"+vis")) | ||
| 105 | OPENSSL_sparcv9cap_P |= SPARCV9_VIS1; | ||
| 106 | if (strstr(si,"+vis2")) | ||
| 107 | { | ||
| 108 | OPENSSL_sparcv9cap_P |= SPARCV9_VIS2; | ||
| 109 | OPENSSL_sparcv9cap_P &= ~SPARCV9_TICK_PRIVILEGED; | ||
| 110 | return; | ||
| 111 | } | ||
| 112 | } | ||
| 113 | |||
| 114 | if ((h = dlopen("libdevinfo.so.1",RTLD_LAZY))) do | ||
| 115 | { | ||
| 116 | di_init_t di_init; | ||
| 117 | di_fini_t di_fini; | ||
| 118 | di_walk_node_t di_walk_node; | ||
| 119 | di_node_name_t di_node_name; | ||
| 120 | di_node_t root_node; | ||
| 121 | |||
| 122 | if (!DLLINK(h,di_init)) break; | ||
| 123 | if (!DLLINK(h,di_fini)) break; | ||
| 124 | if (!DLLINK(h,di_walk_node)) break; | ||
| 125 | if (!DLLINK(h,di_node_name)) break; | ||
| 126 | |||
| 127 | if ((root_node = (*di_init)("/",DINFOSUBTREE))!=DI_NODE_NIL) | ||
| 128 | { | ||
| 129 | (*di_walk_node)(root_node,DI_WALK_SIBFIRST, | ||
| 130 | di_node_name,walk_nodename); | ||
| 131 | (*di_fini)(root_node); | ||
| 132 | } | ||
| 133 | } while(0); | ||
| 134 | |||
| 135 | if (h) dlclose(h); | ||
| 136 | } | ||
| 137 | |||
| 138 | #else | ||
| 139 | |||
| 140 | void OPENSSL_cpuid_setup(void) | ||
| 141 | { | ||
| 142 | char *e; | ||
| 143 | |||
| 144 | if ((e=getenv("OPENSSL_sparcv9cap"))) | ||
| 145 | { | ||
| 146 | OPENSSL_sparcv9cap_P=strtoul(e,NULL,0); | ||
| 147 | return; | ||
| 148 | } | ||
| 149 | |||
| 150 | /* For now we assume that the rest supports UltraSPARC-I* only */ | ||
| 151 | OPENSSL_sparcv9cap_P |= SPARCV9_PREFER_FPU|SPARCV9_VIS1; | ||
| 152 | } | ||
| 153 | |||
| 154 | #endif | ||
diff --git a/src/lib/libssl/src/crypto/x509/x509_vpm.c b/src/lib/libssl/src/crypto/x509/x509_vpm.c index c92e65936f..2b06718aec 100644 --- a/src/lib/libssl/src/crypto/x509/x509_vpm.c +++ b/src/lib/libssl/src/crypto/x509/x509_vpm.c | |||
| @@ -74,7 +74,7 @@ static void x509_verify_param_zero(X509_VERIFY_PARAM *param) | |||
| 74 | param->name = NULL; | 74 | param->name = NULL; |
| 75 | param->purpose = 0; | 75 | param->purpose = 0; |
| 76 | param->trust = 0; | 76 | param->trust = 0; |
| 77 | param->inh_flags = X509_VP_FLAG_DEFAULT; | 77 | param->inh_flags = 0; |
| 78 | param->flags = 0; | 78 | param->flags = 0; |
| 79 | param->depth = -1; | 79 | param->depth = -1; |
| 80 | if (param->policies) | 80 | if (param->policies) |
| @@ -320,11 +320,21 @@ static const X509_VERIFY_PARAM default_table[] = { | |||
| 320 | 0, /* flags */ | 320 | 0, /* flags */ |
| 321 | 0, /* purpose */ | 321 | 0, /* purpose */ |
| 322 | 0, /* trust */ | 322 | 0, /* trust */ |
| 323 | 9, /* depth */ | 323 | 100, /* depth */ |
| 324 | NULL /* policies */ | 324 | NULL /* policies */ |
| 325 | }, | 325 | }, |
| 326 | { | 326 | { |
| 327 | "pkcs7", /* SSL/TLS client parameters */ | 327 | "pkcs7", /* S/MIME signing parameters */ |
| 328 | 0, /* Check time */ | ||
| 329 | 0, /* internal flags */ | ||
| 330 | 0, /* flags */ | ||
| 331 | X509_PURPOSE_SMIME_SIGN, /* purpose */ | ||
| 332 | X509_TRUST_EMAIL, /* trust */ | ||
| 333 | -1, /* depth */ | ||
| 334 | NULL /* policies */ | ||
| 335 | }, | ||
| 336 | { | ||
| 337 | "smime_sign", /* S/MIME signing parameters */ | ||
| 328 | 0, /* Check time */ | 338 | 0, /* Check time */ |
| 329 | 0, /* internal flags */ | 339 | 0, /* internal flags */ |
| 330 | 0, /* flags */ | 340 | 0, /* flags */ |
diff --git a/src/lib/libssl/src/crypto/x509v3/v3_addr.c b/src/lib/libssl/src/crypto/x509v3/v3_addr.c index a37f844d3c..efdf7c3ba7 100644 --- a/src/lib/libssl/src/crypto/x509v3/v3_addr.c +++ b/src/lib/libssl/src/crypto/x509v3/v3_addr.c | |||
| @@ -61,7 +61,7 @@ | |||
| 61 | 61 | ||
| 62 | #include <stdio.h> | 62 | #include <stdio.h> |
| 63 | #include <stdlib.h> | 63 | #include <stdlib.h> |
| 64 | #include <assert.h> | 64 | |
| 65 | #include "cryptlib.h" | 65 | #include "cryptlib.h" |
| 66 | #include <openssl/conf.h> | 66 | #include <openssl/conf.h> |
| 67 | #include <openssl/asn1.h> | 67 | #include <openssl/asn1.h> |
| @@ -128,7 +128,7 @@ static int length_from_afi(const unsigned afi) | |||
| 128 | /* | 128 | /* |
| 129 | * Extract the AFI from an IPAddressFamily. | 129 | * Extract the AFI from an IPAddressFamily. |
| 130 | */ | 130 | */ |
| 131 | unsigned v3_addr_get_afi(const IPAddressFamily *f) | 131 | unsigned int v3_addr_get_afi(const IPAddressFamily *f) |
| 132 | { | 132 | { |
| 133 | return ((f != NULL && | 133 | return ((f != NULL && |
| 134 | f->addressFamily != NULL && | 134 | f->addressFamily != NULL && |
| @@ -147,7 +147,7 @@ static void addr_expand(unsigned char *addr, | |||
| 147 | const int length, | 147 | const int length, |
| 148 | const unsigned char fill) | 148 | const unsigned char fill) |
| 149 | { | 149 | { |
| 150 | assert(bs->length >= 0 && bs->length <= length); | 150 | OPENSSL_assert(bs->length >= 0 && bs->length <= length); |
| 151 | if (bs->length > 0) { | 151 | if (bs->length > 0) { |
| 152 | memcpy(addr, bs->data, bs->length); | 152 | memcpy(addr, bs->data, bs->length); |
| 153 | if ((bs->flags & 7) != 0) { | 153 | if ((bs->flags & 7) != 0) { |
| @@ -190,6 +190,8 @@ static int i2r_address(BIO *out, | |||
| 190 | BIO_printf(out, "%x%s", (addr[i] << 8) | addr[i+1], (i < 14 ? ":" : "")); | 190 | BIO_printf(out, "%x%s", (addr[i] << 8) | addr[i+1], (i < 14 ? ":" : "")); |
| 191 | if (i < 16) | 191 | if (i < 16) |
| 192 | BIO_puts(out, ":"); | 192 | BIO_puts(out, ":"); |
| 193 | if (i == 0) | ||
| 194 | BIO_puts(out, ":"); | ||
| 193 | break; | 195 | break; |
| 194 | default: | 196 | default: |
| 195 | for (i = 0; i < bs->length; i++) | 197 | for (i = 0; i < bs->length; i++) |
| @@ -243,7 +245,7 @@ static int i2r_IPAddrBlocks(X509V3_EXT_METHOD *method, | |||
| 243 | int i; | 245 | int i; |
| 244 | for (i = 0; i < sk_IPAddressFamily_num(addr); i++) { | 246 | for (i = 0; i < sk_IPAddressFamily_num(addr); i++) { |
| 245 | IPAddressFamily *f = sk_IPAddressFamily_value(addr, i); | 247 | IPAddressFamily *f = sk_IPAddressFamily_value(addr, i); |
| 246 | const unsigned afi = v3_addr_get_afi(f); | 248 | const unsigned int afi = v3_addr_get_afi(f); |
| 247 | switch (afi) { | 249 | switch (afi) { |
| 248 | case IANA_AFI_IPV4: | 250 | case IANA_AFI_IPV4: |
| 249 | BIO_printf(out, "%*sIPv4", indent, ""); | 251 | BIO_printf(out, "%*sIPv4", indent, ""); |
| @@ -453,7 +455,7 @@ static int make_addressRange(IPAddressOrRange **result, | |||
| 453 | if ((aor = IPAddressOrRange_new()) == NULL) | 455 | if ((aor = IPAddressOrRange_new()) == NULL) |
| 454 | return 0; | 456 | return 0; |
| 455 | aor->type = IPAddressOrRange_addressRange; | 457 | aor->type = IPAddressOrRange_addressRange; |
| 456 | assert(aor->u.addressRange == NULL); | 458 | OPENSSL_assert(aor->u.addressRange == NULL); |
| 457 | if ((aor->u.addressRange = IPAddressRange_new()) == NULL) | 459 | if ((aor->u.addressRange = IPAddressRange_new()) == NULL) |
| 458 | goto err; | 460 | goto err; |
| 459 | if (aor->u.addressRange->min == NULL && | 461 | if (aor->u.addressRange->min == NULL && |
| @@ -522,7 +524,7 @@ static IPAddressFamily *make_IPAddressFamily(IPAddrBlocks *addr, | |||
| 522 | 524 | ||
| 523 | for (i = 0; i < sk_IPAddressFamily_num(addr); i++) { | 525 | for (i = 0; i < sk_IPAddressFamily_num(addr); i++) { |
| 524 | f = sk_IPAddressFamily_value(addr, i); | 526 | f = sk_IPAddressFamily_value(addr, i); |
| 525 | assert(f->addressFamily->data != NULL); | 527 | OPENSSL_assert(f->addressFamily->data != NULL); |
| 526 | if (f->addressFamily->length == keylen && | 528 | if (f->addressFamily->length == keylen && |
| 527 | !memcmp(f->addressFamily->data, key, keylen)) | 529 | !memcmp(f->addressFamily->data, key, keylen)) |
| 528 | return f; | 530 | return f; |
| @@ -654,7 +656,7 @@ static void extract_min_max(IPAddressOrRange *aor, | |||
| 654 | unsigned char *max, | 656 | unsigned char *max, |
| 655 | int length) | 657 | int length) |
| 656 | { | 658 | { |
| 657 | assert(aor != NULL && min != NULL && max != NULL); | 659 | OPENSSL_assert(aor != NULL && min != NULL && max != NULL); |
| 658 | switch (aor->type) { | 660 | switch (aor->type) { |
| 659 | case IPAddressOrRange_addressPrefix: | 661 | case IPAddressOrRange_addressPrefix: |
| 660 | addr_expand(min, aor->u.addressPrefix, length, 0x00); | 662 | addr_expand(min, aor->u.addressPrefix, length, 0x00); |
| @@ -880,7 +882,7 @@ int v3_addr_canonize(IPAddrBlocks *addr) | |||
| 880 | } | 882 | } |
| 881 | (void)sk_IPAddressFamily_set_cmp_func(addr, IPAddressFamily_cmp); | 883 | (void)sk_IPAddressFamily_set_cmp_func(addr, IPAddressFamily_cmp); |
| 882 | sk_IPAddressFamily_sort(addr); | 884 | sk_IPAddressFamily_sort(addr); |
| 883 | assert(v3_addr_is_canonical(addr)); | 885 | OPENSSL_assert(v3_addr_is_canonical(addr)); |
| 884 | return 1; | 886 | return 1; |
| 885 | } | 887 | } |
| 886 | 888 | ||
| @@ -1127,7 +1129,10 @@ int v3_addr_subset(IPAddrBlocks *a, IPAddrBlocks *b) | |||
| 1127 | for (i = 0; i < sk_IPAddressFamily_num(a); i++) { | 1129 | for (i = 0; i < sk_IPAddressFamily_num(a); i++) { |
| 1128 | IPAddressFamily *fa = sk_IPAddressFamily_value(a, i); | 1130 | IPAddressFamily *fa = sk_IPAddressFamily_value(a, i); |
| 1129 | int j = sk_IPAddressFamily_find(b, fa); | 1131 | int j = sk_IPAddressFamily_find(b, fa); |
| 1130 | IPAddressFamily *fb = sk_IPAddressFamily_value(b, j); | 1132 | IPAddressFamily *fb; |
| 1133 | fb = sk_IPAddressFamily_value(b, j); | ||
| 1134 | if (fb == NULL) | ||
| 1135 | return 0; | ||
| 1131 | if (!addr_contains(fb->ipAddressChoice->u.addressesOrRanges, | 1136 | if (!addr_contains(fb->ipAddressChoice->u.addressesOrRanges, |
| 1132 | fa->ipAddressChoice->u.addressesOrRanges, | 1137 | fa->ipAddressChoice->u.addressesOrRanges, |
| 1133 | length_from_afi(v3_addr_get_afi(fb)))) | 1138 | length_from_afi(v3_addr_get_afi(fb)))) |
| @@ -1164,9 +1169,9 @@ static int v3_addr_validate_path_internal(X509_STORE_CTX *ctx, | |||
| 1164 | int i, j, ret = 1; | 1169 | int i, j, ret = 1; |
| 1165 | X509 *x = NULL; | 1170 | X509 *x = NULL; |
| 1166 | 1171 | ||
| 1167 | assert(chain != NULL && sk_X509_num(chain) > 0); | 1172 | OPENSSL_assert(chain != NULL && sk_X509_num(chain) > 0); |
| 1168 | assert(ctx != NULL || ext != NULL); | 1173 | OPENSSL_assert(ctx != NULL || ext != NULL); |
| 1169 | assert(ctx == NULL || ctx->verify_cb != NULL); | 1174 | OPENSSL_assert(ctx == NULL || ctx->verify_cb != NULL); |
| 1170 | 1175 | ||
| 1171 | /* | 1176 | /* |
| 1172 | * Figure out where to start. If we don't have an extension to | 1177 | * Figure out where to start. If we don't have an extension to |
| @@ -1178,7 +1183,7 @@ static int v3_addr_validate_path_internal(X509_STORE_CTX *ctx, | |||
| 1178 | } else { | 1183 | } else { |
| 1179 | i = 0; | 1184 | i = 0; |
| 1180 | x = sk_X509_value(chain, i); | 1185 | x = sk_X509_value(chain, i); |
| 1181 | assert(x != NULL); | 1186 | OPENSSL_assert(x != NULL); |
| 1182 | if ((ext = x->rfc3779_addr) == NULL) | 1187 | if ((ext = x->rfc3779_addr) == NULL) |
| 1183 | goto done; | 1188 | goto done; |
| 1184 | } | 1189 | } |
| @@ -1197,7 +1202,7 @@ static int v3_addr_validate_path_internal(X509_STORE_CTX *ctx, | |||
| 1197 | */ | 1202 | */ |
| 1198 | for (i++; i < sk_X509_num(chain); i++) { | 1203 | for (i++; i < sk_X509_num(chain); i++) { |
| 1199 | x = sk_X509_value(chain, i); | 1204 | x = sk_X509_value(chain, i); |
| 1200 | assert(x != NULL); | 1205 | OPENSSL_assert(x != NULL); |
| 1201 | if (!v3_addr_is_canonical(x->rfc3779_addr)) | 1206 | if (!v3_addr_is_canonical(x->rfc3779_addr)) |
| 1202 | validation_err(X509_V_ERR_INVALID_EXTENSION); | 1207 | validation_err(X509_V_ERR_INVALID_EXTENSION); |
| 1203 | if (x->rfc3779_addr == NULL) { | 1208 | if (x->rfc3779_addr == NULL) { |
