diff options
| author | Jack Lloyd <[email protected]> | 2015-07-25 00:00:51 -0400 |
|---|---|---|
| committer | Jack Lloyd <[email protected]> | 2015-07-25 00:00:51 -0400 |
| commit | 46c134b0f9524a47e7ee74b798e83fcc33b74202 (patch) | |
| tree | 084b82e407e3dc92bdd70063d14e3302a43a2fd7 | |
| parent | 0689b07d9ddc7c10a868691b1ae33dd1c5432490 (diff) | |
Remove the x86 asm versions of MD4, MD5, SHA-1 and Serpent
With modern compilers, all are slower than the C++ and SSE2 versions
of the same algos.
GH #216
25 files changed, 7 insertions, 2223 deletions
diff --git a/doc/news.rst b/doc/news.rst index 144641913..6be3eb250 100644 --- a/doc/news.rst +++ b/doc/news.rst @@ -4,10 +4,16 @@ Release Notes Version 1.11.19, Not Yet Released ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +* The x86-32 assembly versions of MD4, MD5, SHA-1, and Serpent and the + x86-64 version of SHA-1 have been removed. With compilers from this + decade the C++ versions are significantly faster. The SSE2 versions + of SHA-1 and Serpent remain, as they are still the fastest version + for processors with SIMD extensions. GH #216 + * BigInt::to_u32bit would fail if the value was exactly 32 bits. GH #220 -Version 1.11.18, 2015-07-05 + Version 1.11.18, 2015-07-05 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ * In this release Botan has switched VCS from ``monotone`` to ``git``, diff --git a/src/lib/block/serpent_x86_32/info.txt b/src/lib/block/serpent_x86_32/info.txt deleted file mode 100644 index 370213e87..000000000 --- a/src/lib/block/serpent_x86_32/info.txt +++ /dev/null @@ -1,12 +0,0 @@ -define SERPENT_X86_32 20131128 - -load_on asm_ok - -<arch> -x86_32 -</arch> - -<requires> -asm_x86_32 -serpent -</requires> diff --git a/src/lib/block/serpent_x86_32/serp_x86_32.cpp b/src/lib/block/serpent_x86_32/serp_x86_32.cpp deleted file mode 100644 index f055880b3..000000000 --- a/src/lib/block/serpent_x86_32/serp_x86_32.cpp +++ /dev/null @@ -1,90 +0,0 @@ -/* -* Serpent in x86-32 -* (C) 1999-2007 Jack Lloyd -* -* Botan is released under the Simplified BSD License (see license.txt) -*/ - -#include <botan/internal/block_utils.h> -#include <botan/serp_x86_32.h> - -namespace Botan { - -BOTAN_REGISTER_NAMED_T_NOARGS(BlockCipher, Serpent_X86_32, "Serpent", "x86-32"); - -extern "C" { - -/** -* Entry point for Serpent encryption in x86 asm -* @param in the input block -* @param out the output block -* @param ks the key schedule -*/ -void botan_serpent_x86_32_encrypt(const byte in[16], - byte out[16], - const u32bit ks[132]); - -/** -* Entry point for Serpent decryption in x86 asm -* @param in the input block -* @param out the output block -* @param ks the key schedule -*/ -void botan_serpent_x86_32_decrypt(const byte in[16], - byte out[16], - const u32bit ks[132]); - -/** -* Entry point for Serpent key schedule in x86 asm -* @param ks holds the initial working key (padded), and is set to the - final key schedule -*/ -void botan_serpent_x86_32_key_schedule(u32bit ks[140]); - -} - -/* -* Serpent Encryption -*/ -void Serpent_X86_32::encrypt_n(const byte in[], byte out[], size_t blocks) const - { - auto keys = this->get_round_keys(); - - for(size_t i = 0; i != blocks; ++i) - { - botan_serpent_x86_32_encrypt(in, out, keys.data()); - in += BLOCK_SIZE; - out += BLOCK_SIZE; - } - } - -/* -* Serpent Decryption -*/ -void Serpent_X86_32::decrypt_n(const byte in[], byte out[], size_t blocks) const - { - auto keys = this->get_round_keys(); - - for(size_t i = 0; i != blocks; ++i) - { - botan_serpent_x86_32_decrypt(in, out, keys.data()); - in += BLOCK_SIZE; - out += BLOCK_SIZE; - } - } - -/* -* Serpent Key Schedule -*/ -void Serpent_X86_32::key_schedule(const byte key[], size_t length) - { - secure_vector<u32bit> W(140); - for(size_t i = 0; i != length / 4; ++i) - W[i] = load_le<u32bit>(key, i); - W[length / 4] |= u32bit(1) << ((length%4)*8); - - botan_serpent_x86_32_key_schedule(W.data()); - this->set_round_keys(&W[8]); - } - -} diff --git a/src/lib/block/serpent_x86_32/serp_x86_32.h b/src/lib/block/serpent_x86_32/serp_x86_32.h deleted file mode 100644 index 89fb1a8fe..000000000 --- a/src/lib/block/serpent_x86_32/serp_x86_32.h +++ /dev/null @@ -1,31 +0,0 @@ -/* -* Serpent in x86-32 asm -* (C) 1999-2007 Jack Lloyd -* -* Botan is released under the Simplified BSD License (see license.txt) -*/ - -#ifndef BOTAN_SERPENT_X86_32_H__ -#define BOTAN_SERPENT_X86_32_H__ - -#include <botan/serpent.h> - -namespace Botan { - -/** -* Serpent implementation in x86-32 assembly -*/ -class BOTAN_DLL Serpent_X86_32 : public Serpent - { - public: - void encrypt_n(const byte in[], byte out[], size_t blocks) const; - void decrypt_n(const byte in[], byte out[], size_t blocks) const; - - BlockCipher* clone() const { return new Serpent_X86_32; } - private: - void key_schedule(const byte[], size_t); - }; - -} - -#endif diff --git a/src/lib/block/serpent_x86_32/serp_x86_32_imp.S b/src/lib/block/serpent_x86_32/serp_x86_32_imp.S deleted file mode 100644 index 807c3fc54..000000000 --- a/src/lib/block/serpent_x86_32/serp_x86_32_imp.S +++ /dev/null @@ -1,669 +0,0 @@ -/* -* Serpent in x86-32 assembler -* (C) 1999-2007 Jack Lloyd -* -* Botan is released under the Simplified BSD License (see license.txt) -*/ - -#include <botan/internal/asm_x86_32.h> - -START_LISTING(serp_x86_32.S) - -#define SBOX_E1(A, B, C, D, T) \ - XOR(D, A) ; \ - ASSIGN(T, B) ; \ - AND(B, D) ; \ - XOR(T, C) ; \ - XOR(B, A) ; \ - OR(A, D) ; \ - XOR(A, T) ; \ - XOR(T, D) ; \ - XOR(D, C) ; \ - OR(C, B) ; \ - XOR(C, T) ; \ - NOT(T) ; \ - OR(T, B) ; \ - XOR(B, D) ; \ - XOR(B, T) ; \ - OR(D, A) ; \ - XOR(B, D) ; \ - XOR(T, D) ; \ - ASSIGN(D, A) ; \ - ASSIGN(A, B) ; \ - ASSIGN(B, T) ; - -#define SBOX_E2(A, B, C, D, T) \ - NOT(A) ; \ - NOT(C) ; \ - ASSIGN(T, A) ; \ - AND(A, B) ; \ - XOR(C, A) ; \ - OR(A, D) ; \ - XOR(D, C) ; \ - XOR(B, A) ; \ - XOR(A, T) ; \ - OR(T, B) ; \ - XOR(B, D) ; \ - OR(C, A) ; \ - AND(C, T) ; \ - XOR(A, B) ; \ - AND(B, C) ; \ - XOR(B, A) ; \ - AND(A, C) ; \ - XOR(T, A) ; \ - ASSIGN(A, C) ; \ - ASSIGN(C, D) ; \ - ASSIGN(D, B) ; \ - ASSIGN(B, T) ; - -#define SBOX_E3(A, B, C, D, T) \ - ASSIGN(T, A) ; \ - AND(A, C) ; \ - XOR(A, D) ; \ - XOR(C, B) ; \ - XOR(C, A) ; \ - OR(D, T) ; \ - XOR(D, B) ; \ - XOR(T, C) ; \ - ASSIGN(B, D) ; \ - OR(D, T) ; \ - XOR(D, A) ; \ - AND(A, B) ; \ - XOR(T, A) ; \ - XOR(B, D) ; \ - XOR(B, T) ; \ - NOT(T) ; \ - ASSIGN(A, C) ; \ - ASSIGN(C, B) ; \ - ASSIGN(B, D) ; \ - ASSIGN(D, T) ; - -#define SBOX_E4(A, B, C, D, T) \ - ASSIGN(T, A) ; \ - OR(A, D) ; \ - XOR(D, B) ; \ - AND(B, T) ; \ - XOR(T, C) ; \ - XOR(C, D) ; \ - AND(D, A) ; \ - OR(T, B) ; \ - XOR(D, T) ; \ - XOR(A, B) ; \ - AND(T, A) ; \ - XOR(B, D) ; \ - XOR(T, C) ; \ - OR(B, A) ; \ - XOR(B, C) ; \ - XOR(A, D) ; \ - ASSIGN(C, B) ; \ - OR(B, D) ; \ - XOR(B, A) ; \ - ASSIGN(A, B) ; \ - ASSIGN(B, C) ; \ - ASSIGN(C, D) ; \ - ASSIGN(D, T) ; - -#define SBOX_E5(A, B, C, D, T) \ - XOR(B, D) ; \ - NOT(D) ; \ - XOR(C, D) ; \ - XOR(D, A) ; \ - ASSIGN(T, B) ; \ - AND(B, D) ; \ - XOR(B, C) ; \ - XOR(T, D) ; \ - XOR(A, T) ; \ - AND(C, T) ; \ - XOR(C, A) ; \ - AND(A, B) ; \ - XOR(D, A) ; \ - OR(T, B) ; \ - XOR(T, A) ; \ - OR(A, D) ; \ - XOR(A, C) ; \ - AND(C, D) ; \ - NOT(A) ; \ - XOR(T, C) ; \ - ASSIGN(C, A) ; \ - ASSIGN(A, B) ; \ - ASSIGN(B, T) ; - -#define SBOX_E6(A, B, C, D, T) \ - XOR(A, B) ; \ - XOR(B, D) ; \ - NOT(D) ; \ - ASSIGN(T, B) ; \ - AND(B, A) ; \ - XOR(C, D) ; \ - XOR(B, C) ; \ - OR(C, T) ; \ - XOR(T, D) ; \ - AND(D, B) ; \ - XOR(D, A) ; \ - XOR(T, B) ; \ - XOR(T, C) ; \ - XOR(C, A) ; \ - AND(A, D) ; \ - NOT(C) ; \ - XOR(A, T) ; \ - OR(T, D) ; \ - XOR(T, C) ; \ - ASSIGN(C, A) ; \ - ASSIGN(A, B) ; \ - ASSIGN(B, D) ; \ - ASSIGN(D, T) ; - -#define SBOX_E7(A, B, C, D, T) \ - NOT(C) ; \ - ASSIGN(T, D) ; \ - AND(D, A) ; \ - XOR(A, T) ; \ - XOR(D, C) ; \ - OR(C, T) ; \ - XOR(B, D) ; \ - XOR(C, A) ; \ - OR(A, B) ; \ - XOR(C, B) ; \ - XOR(T, A) ; \ - OR(A, D) ; \ - XOR(A, C) ; \ - XOR(T, D) ; \ - XOR(T, A) ; \ - NOT(D) ; \ - AND(C, T) ; \ - XOR(C, D) ; \ - ASSIGN(D, C) ; \ - ASSIGN(C, T) ; - -#define SBOX_E8(A, B, C, D, T) \ - ASSIGN(T, B) ; \ - OR(B, C) ; \ - XOR(B, D) ; \ - XOR(T, C) ; \ - XOR(C, B) ; \ - OR(D, T) ; \ - AND(D, A) ; \ - XOR(T, C) ; \ - XOR(D, B) ; \ - OR(B, T) ; \ - XOR(B, A) ; \ - OR(A, T) ; \ - XOR(A, C) ; \ - XOR(B, T) ; \ - XOR(C, B) ; \ - AND(B, A) ; \ - XOR(B, T) ; \ - NOT(C) ; \ - OR(C, A) ; \ - XOR(T, C) ; \ - ASSIGN(C, B) ; \ - ASSIGN(B, D) ; \ - ASSIGN(D, A) ; \ - ASSIGN(A, T) ; - -#define SBOX_D1(A, B, C, D, T) \ - NOT(C) ; \ - ASSIGN(T, B) ; \ - OR(B, A) ; \ - NOT(T) ; \ - XOR(B, C) ; \ - OR(C, T) ; \ - XOR(B, D) ; \ - XOR(A, T) ; \ - XOR(C, A) ; \ - AND(A, D) ; \ - XOR(T, A) ; \ - OR(A, B) ; \ - XOR(A, C) ; \ - XOR(D, T) ; \ - XOR(C, B) ; \ - XOR(D, A) ; \ - XOR(D, B) ; \ - AND(C, D) ; \ - XOR(T, C) ; \ - ASSIGN(C, B) ; \ - ASSIGN(B, T) ; - -#define SBOX_D2(A, B, C, D, T) \ - ASSIGN(T, B) ; \ - XOR(B, D) ; \ - AND(D, B) ; \ - XOR(T, C) ; \ - XOR(D, A) ; \ - OR(A, B) ; \ - XOR(C, D) ; \ - XOR(A, T) ; \ - OR(A, C) ; \ - XOR(B, D) ; \ - XOR(A, B) ; \ - OR(B, D) ; \ - XOR(B, A) ; \ - NOT(T) ; \ - XOR(T, B) ; \ - OR(B, A) ; \ - XOR(B, A) ; \ - OR(B, T) ; \ - XOR(D, B) ; \ - ASSIGN(B, A) ; \ - ASSIGN(A, T) ; \ - ASSIGN(T, D) ; \ - ASSIGN(D, C) ; \ - ASSIGN(C, T) ; - -#define SBOX_D3(A, B, C, D, T) \ - XOR(C, D) ; \ - XOR(D, A) ; \ - ASSIGN(T, D) ; \ - AND(D, C) ; \ - XOR(D, B) ; \ - OR(B, C) ; \ - XOR(B, T) ; \ - AND(T, D) ; \ - XOR(C, D) ; \ - AND(T, A) ; \ - XOR(T, C) ; \ - AND(C, B) ; \ - OR(C, A) ; \ - NOT(D) ; \ - XOR(C, D) ; \ - XOR(A, D) ; \ - AND(A, B) ; \ - XOR(D, T) ; \ - XOR(D, A) ; \ - ASSIGN(A, B) ; \ - ASSIGN(B, T) ; - -#define SBOX_D4(A, B, C, D, T) \ - ASSIGN(T, C) ; \ - XOR(C, B) ; \ - XOR(A, C) ; \ - AND(T, C) ; \ - XOR(T, A) ; \ - AND(A, B) ; \ - XOR(B, D) ; \ - OR(D, T) ; \ - XOR(C, D) ; \ - XOR(A, D) ; \ - XOR(B, T) ; \ - AND(D, C) ; \ - XOR(D, B) ; \ - XOR(B, A) ; \ - OR(B, C) ; \ - XOR(A, D) ; \ - XOR(B, T) ; \ - XOR(A, B) ; \ - ASSIGN(T, A) ; \ - ASSIGN(A, C) ; \ - ASSIGN(C, D) ; \ - ASSIGN(D, T) ; - -#define SBOX_D5(A, B, C, D, T) \ - ASSIGN(T, C) ; \ - AND(C, D) ; \ - XOR(C, B) ; \ - OR(B, D) ; \ - AND(B, A) ; \ - XOR(T, C) ; \ - XOR(T, B) ; \ - AND(B, C) ; \ - NOT(A) ; \ - XOR(D, T) ; \ - XOR(B, D) ; \ - AND(D, A) ; \ - XOR(D, C) ; \ - XOR(A, B) ; \ - AND(C, A) ; \ - XOR(D, A) ; \ - XOR(C, T) ; \ - OR(C, D) ; \ - XOR(D, A) ; \ - XOR(C, B) ; \ - ASSIGN(B, D) ; \ - ASSIGN(D, T) ; - -#define SBOX_D6(A, B, C, D, T) \ - NOT(B) ; \ - ASSIGN(T, D) ; \ - XOR(C, B) ; \ - OR(D, A) ; \ - XOR(D, C) ; \ - OR(C, B) ; \ - AND(C, A) ; \ - XOR(T, D) ; \ - XOR(C, T) ; \ - OR(T, A) ; \ - XOR(T, B) ; \ - AND(B, C) ; \ - XOR(B, D) ; \ - XOR(T, C) ; \ - AND(D, T) ; \ - XOR(T, B) ; \ - XOR(D, T) ; \ - NOT(T) ; \ - XOR(D, A) ; \ - ASSIGN(A, B) ; \ - ASSIGN(B, T) ; \ - ASSIGN(T, D) ; \ - ASSIGN(D, C) ; \ - ASSIGN(C, T) ; - -#define SBOX_D7(A, B, C, D, T) \ - XOR(A, C) ; \ - ASSIGN(T, C) ; \ - AND(C, A) ; \ - XOR(T, D) ; \ - NOT(C) ; \ - XOR(D, B) ; \ - XOR(C, D) ; \ - OR(T, A) ; \ - XOR(A, C) ; \ - XOR(D, T) ; \ - XOR(T, B) ; \ - AND(B, D) ; \ - XOR(B, A) ; \ - XOR(A, D) ; \ - OR(A, C) ; \ - XOR(D, B) ; \ - XOR(T, A) ; \ - ASSIGN(A, B) ; \ - ASSIGN(B, C) ; \ - ASSIGN(C, T) ; - -#define SBOX_D8(A, B, C, D, T) \ - ASSIGN(T, C) ; \ - XOR(C, A) ; \ - AND(A, D) ; \ - OR(T, D) ; \ - NOT(C) ; \ - XOR(D, B) ; \ - OR(B, A) ; \ - XOR(A, C) ; \ - AND(C, T) ; \ - AND(D, T) ; \ - XOR(B, C) ; \ - XOR(C, A) ; \ - OR(A, C) ; \ - XOR(T, B) ; \ - XOR(A, D) ; \ - XOR(D, T) ; \ - OR(T, A) ; \ - XOR(D, C) ; \ - XOR(T, C) ; \ - ASSIGN(C, B) ; \ - ASSIGN(B, A) ; \ - ASSIGN(A, D) ; \ - ASSIGN(D, T) ; - -#define TRANSFORM(A, B, C, D, T) \ - ROTL_IMM(A, 13) ; \ - ROTL_IMM(C, 3) ; \ - SHL2_3(T, A) ; \ - XOR(B, A) ; \ - XOR(D, C) ; \ - XOR(B, C) ; \ - XOR(D, T) ; \ - ROTL_IMM(B, 1) ; \ - ROTL_IMM(D, 7) ; \ - ASSIGN(T, B) ; \ - SHL_IMM(T, 7) ; \ - XOR(A, B) ; \ - XOR(C, D) ; \ - XOR(A, D) ; \ - XOR(C, T) ; \ - ROTL_IMM(A, 5) ; \ - ROTL_IMM(C, 22) ; - -#define I_TRANSFORM(A, B, C, D, T) \ - ROTR_IMM(C, 22) ; \ - ROTR_IMM(A, 5) ; \ - ASSIGN(T, B) ; \ - SHL_IMM(T, 7) ; \ - XOR(A, B) ; \ - XOR(C, D) ; \ - XOR(A, D) ; \ - XOR(C, T) ; \ - ROTR_IMM(D, 7) ; \ - ROTR_IMM(B, 1) ; \ - SHL2_3(T, A) ; \ - XOR(B, C) ; \ - XOR(D, C) ; \ - XOR(B, A) ; \ - XOR(D, T) ; \ - ROTR_IMM(C, 3) ; \ - ROTR_IMM(A, 13) ; - -#define KEY_XOR(A, B, C, D, N) \ - XOR(A, ARRAY4(EDI, (4*N ))) ; \ - XOR(B, ARRAY4(EDI, (4*N+1))) ; \ - XOR(C, ARRAY4(EDI, (4*N+2))) ; \ - XOR(D, ARRAY4(EDI, (4*N+3))) ; - -/* -* Serpent Encryption -*/ -START_FUNCTION(botan_serpent_x86_32_encrypt) - SPILL_REGS() -#define PUSHED 4 - - ASSIGN(EBP, ARG(1)) /* input block */ - ASSIGN(EAX, ARRAY4(EBP, 0)) - ASSIGN(EBX, ARRAY4(EBP, 1)) - ASSIGN(ECX, ARRAY4(EBP, 2)) - ASSIGN(EDX, ARRAY4(EBP, 3)) - - ASSIGN(EDI, ARG(3)) /* round keys */ - ZEROIZE(EBP) - -#define E_ROUND(A, B, C, D, T, N, SBOX) \ - KEY_XOR(A, B, C, D, N) \ - SBOX(A, B, C, D, T) \ - TRANSFORM(A, B, C, D, T) - - - E_ROUND(EAX, EBX, ECX, EDX, EBP, 0, SBOX_E1) - E_ROUND(EAX, EBX, ECX, EDX, EBP, 1, SBOX_E2) - E_ROUND(EAX, EBX, ECX, EDX, EBP, 2, SBOX_E3) - E_ROUND(EAX, EBX, ECX, EDX, EBP, 3, SBOX_E4) - E_ROUND(EAX, EBX, ECX, EDX, EBP, 4, SBOX_E5) - E_ROUND(EAX, EBX, ECX, EDX, EBP, 5, SBOX_E6) - E_ROUND(EAX, EBX, ECX, EDX, EBP, 6, SBOX_E7) - E_ROUND(EAX, EBX, ECX, EDX, EBP, 7, SBOX_E8) - - E_ROUND(EAX, EBX, ECX, EDX, EBP, 8, SBOX_E1) - E_ROUND(EAX, EBX, ECX, EDX, EBP, 9, SBOX_E2) - E_ROUND(EAX, EBX, ECX, EDX, EBP, 10, SBOX_E3) - E_ROUND(EAX, EBX, ECX, EDX, EBP, 11, SBOX_E4) - E_ROUND(EAX, EBX, ECX, EDX, EBP, 12, SBOX_E5) - E_ROUND(EAX, EBX, ECX, EDX, EBP, 13, SBOX_E6) - E_ROUND(EAX, EBX, ECX, EDX, EBP, 14, SBOX_E7) - E_ROUND(EAX, EBX, ECX, EDX, EBP, 15, SBOX_E8) - - E_ROUND(EAX, EBX, ECX, EDX, EBP, 16, SBOX_E1) - E_ROUND(EAX, EBX, ECX, EDX, EBP, 17, SBOX_E2) - E_ROUND(EAX, EBX, ECX, EDX, EBP, 18, SBOX_E3) - E_ROUND(EAX, EBX, ECX, EDX, EBP, 19, SBOX_E4) - E_ROUND(EAX, EBX, ECX, EDX, EBP, 20, SBOX_E5) - E_ROUND(EAX, EBX, ECX, EDX, EBP, 21, SBOX_E6) - E_ROUND(EAX, EBX, ECX, EDX, EBP, 22, SBOX_E7) - E_ROUND(EAX, EBX, ECX, EDX, EBP, 23, SBOX_E8) - - E_ROUND(EAX, EBX, ECX, EDX, EBP, 24, SBOX_E1) - E_ROUND(EAX, EBX, ECX, EDX, EBP, 25, SBOX_E2) - E_ROUND(EAX, EBX, ECX, EDX, EBP, 26, SBOX_E3) - E_ROUND(EAX, EBX, ECX, EDX, EBP, 27, SBOX_E4) - E_ROUND(EAX, EBX, ECX, EDX, EBP, 28, SBOX_E5) - E_ROUND(EAX, EBX, ECX, EDX, EBP, 29, SBOX_E6) - E_ROUND(EAX, EBX, ECX, EDX, EBP, 30, SBOX_E7) - - KEY_XOR(EAX, EBX, ECX, EDX, 31) - SBOX_E8(EAX, EBX, ECX, EDX, EBP) - KEY_XOR(EAX, EBX, ECX, EDX, 32) - - ASSIGN(EBP, ARG(2)) /* output block */ - ASSIGN(ARRAY4(EBP, 0), EAX) - ASSIGN(ARRAY4(EBP, 1), EBX) - ASSIGN(ARRAY4(EBP, 2), ECX) - ASSIGN(ARRAY4(EBP, 3), EDX) - - RESTORE_REGS() -#undef PUSHED -END_FUNCTION(botan_serpent_x86_32_encrypt) - -/* -* Serpent Decryption -*/ -START_FUNCTION(botan_serpent_x86_32_decrypt) - SPILL_REGS() -#define PUSHED 4 - - ASSIGN(EBP, ARG(1)) /* input block */ - ASSIGN(EAX, ARRAY4(EBP, 0)) - ASSIGN(EBX, ARRAY4(EBP, 1)) - ASSIGN(ECX, ARRAY4(EBP, 2)) - ASSIGN(EDX, ARRAY4(EBP, 3)) - - ASSIGN(EDI, ARG(3)) /* round keys */ - - ZEROIZE(EBP) - -#define D_ROUND(A, B, C, D, T, N, SBOX) \ - I_TRANSFORM(A, B, C, D, T) \ - SBOX(A, B, C, D, T) \ - KEY_XOR(A, B, C, D, N) \ - - KEY_XOR(EAX, EBX, ECX, EDX, 32) - SBOX_D8(EAX, EBX, ECX, EDX, EBP) - KEY_XOR(EAX, EBX, ECX, EDX, 31) - - D_ROUND(EAX, EBX, ECX, EDX, EBP, 30, SBOX_D7) - D_ROUND(EAX, EBX, ECX, EDX, EBP, 29, SBOX_D6) - D_ROUND(EAX, EBX, ECX, EDX, EBP, 28, SBOX_D5) - D_ROUND(EAX, EBX, ECX, EDX, EBP, 27, SBOX_D4) - D_ROUND(EAX, EBX, ECX, EDX, EBP, 26, SBOX_D3) - D_ROUND(EAX, EBX, ECX, EDX, EBP, 25, SBOX_D2) - D_ROUND(EAX, EBX, ECX, EDX, EBP, 24, SBOX_D1) - - D_ROUND(EAX, EBX, ECX, EDX, EBP, 23, SBOX_D8) - D_ROUND(EAX, EBX, ECX, EDX, EBP, 22, SBOX_D7) - D_ROUND(EAX, EBX, ECX, EDX, EBP, 21, SBOX_D6) - D_ROUND(EAX, EBX, ECX, EDX, EBP, 20, SBOX_D5) - D_ROUND(EAX, EBX, ECX, EDX, EBP, 19, SBOX_D4) - D_ROUND(EAX, EBX, ECX, EDX, EBP, 18, SBOX_D3) - D_ROUND(EAX, EBX, ECX, EDX, EBP, 17, SBOX_D2) - D_ROUND(EAX, EBX, ECX, EDX, EBP, 16, SBOX_D1) - - D_ROUND(EAX, EBX, ECX, EDX, EBP, 15, SBOX_D8) - D_ROUND(EAX, EBX, ECX, EDX, EBP, 14, SBOX_D7) - D_ROUND(EAX, EBX, ECX, EDX, EBP, 13, SBOX_D6) - D_ROUND(EAX, EBX, ECX, EDX, EBP, 12, SBOX_D5) - D_ROUND(EAX, EBX, ECX, EDX, EBP, 11, SBOX_D4) - D_ROUND(EAX, EBX, ECX, EDX, EBP, 10, SBOX_D3) - D_ROUND(EAX, EBX, ECX, EDX, EBP, 9, SBOX_D2) - D_ROUND(EAX, EBX, ECX, EDX, EBP, 8, SBOX_D1) - - D_ROUND(EAX, EBX, ECX, EDX, EBP, 7, SBOX_D8) - D_ROUND(EAX, EBX, ECX, EDX, EBP, 6, SBOX_D7) - D_ROUND(EAX, EBX, ECX, EDX, EBP, 5, SBOX_D6) - D_ROUND(EAX, EBX, ECX, EDX, EBP, 4, SBOX_D5) - D_ROUND(EAX, EBX, ECX, EDX, EBP, 3, SBOX_D4) - D_ROUND(EAX, EBX, ECX, EDX, EBP, 2, SBOX_D3) - D_ROUND(EAX, EBX, ECX, EDX, EBP, 1, SBOX_D2) - D_ROUND(EAX, EBX, ECX, EDX, EBP, 0, SBOX_D1) - - ASSIGN(EBP, ARG(2)) /* output block */ - ASSIGN(ARRAY4(EBP, 0), EAX) - ASSIGN(ARRAY4(EBP, 1), EBX) - ASSIGN(ARRAY4(EBP, 2), ECX) - ASSIGN(ARRAY4(EBP, 3), EDX) - - RESTORE_REGS() -#undef PUSHED -END_FUNCTION(botan_serpent_x86_32_decrypt) - -/* -* Serpent Key Schedule -*/ -START_FUNCTION(botan_serpent_x86_32_key_schedule) - SPILL_REGS() -#define PUSHED 4 - - ASSIGN(EDI, ARG(1)) /* round keys */ - ASSIGN(ESI, IMM(8)) - ADD_IMM(EDI, 32) - -START_LOOP(.L_SERP_EXPANSION) - ASSIGN(EAX, ARRAY4(EDI, -1)) - ASSIGN(EBX, ARRAY4(EDI, -3)) - ASSIGN(ECX, ARRAY4(EDI, -5)) - ASSIGN(EDX, ARRAY4(EDI, -8)) - - ASSIGN(EBP, ESI) - SUB_IMM(EBP, 8) - XOR(EBP, IMM(0x9E3779B9)) - XOR(EAX, EBX) - XOR(ECX, EDX) - XOR(EAX, EBP) - XOR(EAX, ECX) - - ROTL_IMM(EAX, 11) - - ASSIGN(ARRAY4(EDI, 0), EAX) - - ADD_IMM(ESI, 1) - ADD_IMM(EDI, 4) -LOOP_UNTIL_EQ(ESI, 140, .L_SERP_EXPANSION) - - ASSIGN(EDI, ARG(1)) /* round keys */ - -#define LOAD_AND_SBOX(MSG, SBOX) \ - ASSIGN(EAX, ARRAY4(EDI, (4*MSG+ 8))) ; \ - ASSIGN(EBX, ARRAY4(EDI, (4*MSG+ 9))) ; \ - ASSIGN(ECX, ARRAY4(EDI, (4*MSG+10))) ; \ - ASSIGN(EDX, ARRAY4(EDI, (4*MSG+11))) ; \ - SBOX(EAX, EBX, ECX, EDX, EBP) ; \ - ASSIGN(ARRAY4(EDI, (4*MSG+ 8)), EAX) ; \ - ASSIGN(ARRAY4(EDI, (4*MSG+ 9)), EBX) ; \ - ASSIGN(ARRAY4(EDI, (4*MSG+10)), ECX) ; \ - ASSIGN(ARRAY4(EDI, (4*MSG+11)), EDX) - - LOAD_AND_SBOX( 0, SBOX_E4) - LOAD_AND_SBOX( 1, SBOX_E3) - LOAD_AND_SBOX( 2, SBOX_E2) - LOAD_AND_SBOX( 3, SBOX_E1) - - LOAD_AND_SBOX( 4, SBOX_E8) - LOAD_AND_SBOX( 5, SBOX_E7) - LOAD_AND_SBOX( 6, SBOX_E6) - LOAD_AND_SBOX( 7, SBOX_E5) - LOAD_AND_SBOX( 8, SBOX_E4) - LOAD_AND_SBOX( 9, SBOX_E3) - LOAD_AND_SBOX(10, SBOX_E2) - LOAD_AND_SBOX(11, SBOX_E1) - - LOAD_AND_SBOX(12, SBOX_E8) - LOAD_AND_SBOX(13, SBOX_E7) - LOAD_AND_SBOX(14, SBOX_E6) - LOAD_AND_SBOX(15, SBOX_E5) - LOAD_AND_SBOX(16, SBOX_E4) - LOAD_AND_SBOX(17, SBOX_E3) - LOAD_AND_SBOX(18, SBOX_E2) - LOAD_AND_SBOX(19, SBOX_E1) - - LOAD_AND_SBOX(20, SBOX_E8) - LOAD_AND_SBOX(21, SBOX_E7) - LOAD_AND_SBOX(22, SBOX_E6) - LOAD_AND_SBOX(23, SBOX_E5) - LOAD_AND_SBOX(24, SBOX_E4) - LOAD_AND_SBOX(25, SBOX_E3) - LOAD_AND_SBOX(26, SBOX_E2) - LOAD_AND_SBOX(27, SBOX_E1) - - LOAD_AND_SBOX(28, SBOX_E8) - LOAD_AND_SBOX(29, SBOX_E7) - LOAD_AND_SBOX(30, SBOX_E6) - LOAD_AND_SBOX(31, SBOX_E5) - LOAD_AND_SBOX(32, SBOX_E4) - - RESTORE_REGS() -#undef PUSHED -END_FUNCTION(botan_serpent_x86_32_key_schedule) diff --git a/src/lib/hash/md4_x86_32/info.txt b/src/lib/hash/md4_x86_32/info.txt deleted file mode 100644 index fa7eef6cb..000000000 --- a/src/lib/hash/md4_x86_32/info.txt +++ /dev/null @@ -1,12 +0,0 @@ -define MD4_X86_32 20131128 - -load_on asm_ok - -<arch> -x86_32 -</arch> - -<requires> -asm_x86_32 -md4 -</requires> diff --git a/src/lib/hash/md4_x86_32/md4_x86_32.cpp b/src/lib/hash/md4_x86_32/md4_x86_32.cpp deleted file mode 100644 index 28860a369..000000000 --- a/src/lib/hash/md4_x86_32/md4_x86_32.cpp +++ /dev/null @@ -1,37 +0,0 @@ -/* -* MD4 (x86-32) -* (C) 1999-2007 Jack Lloyd -* -* Botan is released under the Simplified BSD License (see license.txt) -*/ - -#include <botan/internal/hash_utils.h> -#include <botan/md4_x86_32.h> - -namespace Botan { - -BOTAN_REGISTER_NAMED_T_NOARGS(HashFunction, MD4_X86_32, "MD4", "x86-32"); - -/** -* MD4 compression function in x86-32 asm -* @param digest the current digest -* @param input the input block -* @param M the message buffer -*/ -extern "C" void botan_md4_x86_32_compress(u32bit digest[4], - const byte input[64], - u32bit M[16]); - -/* -* MD4 Compression Function -*/ -void MD4_X86_32::compress_n(const byte input[], size_t blocks) - { - for(size_t i = 0; i != blocks; ++i) - { - botan_md4_x86_32_compress(digest.data(), input, M.data()); - input += hash_block_size(); - } - } - -} diff --git a/src/lib/hash/md4_x86_32/md4_x86_32.h b/src/lib/hash/md4_x86_32/md4_x86_32.h deleted file mode 100644 index 1cb6c779d..000000000 --- a/src/lib/hash/md4_x86_32/md4_x86_32.h +++ /dev/null @@ -1,28 +0,0 @@ -/* -* MD4 (x86-32) -* (C) 1999-2007 Jack Lloyd -* -* Botan is released under the Simplified BSD License (see license.txt) -*/ - -#ifndef BOTAN_MD4_X86_32_H__ -#define BOTAN_MD4_X86_32_H__ - -#include <botan/md4.h> - -namespace Botan { - -/** -* MD4 using x86 assembly -*/ -class BOTAN_DLL MD4_X86_32 : public MD4 - { - public: - HashFunction* clone() const { return new MD4_X86_32; } - private: - void compress_n(const byte[], size_t blocks); - }; - -} - -#endif diff --git a/src/lib/hash/md4_x86_32/md4_x86_32_imp.S b/src/lib/hash/md4_x86_32/md4_x86_32_imp.S deleted file mode 100644 index 035b30801..000000000 --- a/src/lib/hash/md4_x86_32/md4_x86_32_imp.S +++ /dev/null @@ -1,137 +0,0 @@ -/* -* MD4 in x86-32 assembler -* (C) 1999-2007 Jack Lloyd -* -* Botan is released under the Simplified BSD License (see license.txt) -*/ - -#include <botan/internal/asm_x86_32.h> - -START_LISTING(md4_x86_32_imp.S) - -START_FUNCTION(botan_md4_x86_32_compress) - SPILL_REGS() - -#define PUSHED 4 - - ASSIGN(EBP, ARG(2)) /* input block */ - ASSIGN(EDI, ARG(3)) /* expanded words */ - - ZEROIZE(ESI) - -START_LOOP(.LOAD_INPUT) - ADD_IMM(ESI, 4) - - ASSIGN(EAX, ARRAY4(EBP, 0)) - ASSIGN(EBX, ARRAY4(EBP, 1)) - ASSIGN(ECX, ARRAY4(EBP, 2)) - ASSIGN(EDX, ARRAY4(EBP, 3)) - - ADD_IMM(EBP, 16) - - ASSIGN(ARRAY4_INDIRECT(EDI,ESI,-4), EAX) - ASSIGN(ARRAY4_INDIRECT(EDI,ESI,-3), EBX) - ASSIGN(ARRAY4_INDIRECT(EDI,ESI,-2), ECX) - ASSIGN(ARRAY4_INDIRECT(EDI,ESI,-1), EDX) -LOOP_UNTIL_EQ(ESI, 16, .LOAD_INPUT) - - ASSIGN(EBP, ARG(1)) - ASSIGN(EAX, ARRAY4(EBP, 0)) - ASSIGN(EBX, ARRAY4(EBP, 1)) - ASSIGN(ECX, ARRAY4(EBP, 2)) - ASSIGN(EDX, ARRAY4(EBP, 3)) - -#define MSG EDI -#define T1 ESI -#define T2 EBP - -#define FF(A, B, C, D, N, S) \ - ASSIGN(T1, ARRAY4(MSG, N)) ; \ - ASSIGN(T2, C) ; \ - XOR(T2, D) ; \ - AND(T2, B) ; \ - XOR(T2, D) ; \ - ADD(A, T1) ; \ - ADD(A, T2) ; \ - ROTL_IMM(A, S) ; - -#define GG(A, B, C, D, N, S) \ - ASSIGN(T1, ARRAY4(MSG, N)) ; \ - ASSIGN(T2, B) ; \ - OR(T2, C) ; \ - AND(T2, D) ; \ - ADD3_IMM(A, T1, 0x5A827999) ; \ - ASSIGN(T1, B) ; \ - AND(T1, C) ; \ - OR(T2, T1) ; \ - ADD(A, T2) ; \ - ROTL_IMM(A, S) ; - -#define HH(A, B, C, D, N, S) \ - ASSIGN(T1, ARRAY4(MSG, N)) ; \ - ASSIGN(T2, B) ; \ - XOR(T2, C) ; \ - XOR(T2, D) ; \ - ADD3_IMM(A, T1, 0x6ED9EBA1) ; \ - ADD(A, T2) ; \ - ROTL_IMM(A, S) ; - - FF(EAX,EBX,ECX,EDX, 0, 3); - FF(EDX,EAX,EBX,ECX, 1, 7); - FF(ECX,EDX,EAX,EBX, 2,11); - FF(EBX,ECX,EDX,EAX, 3,19); - FF(EAX,EBX,ECX,EDX, 4, 3); - FF(EDX,EAX,EBX,ECX, 5, 7); - FF(ECX,EDX,EAX,EBX, 6,11); - FF(EBX,ECX,EDX,EAX, 7,19); - FF(EAX,EBX,ECX,EDX, 8, 3); - FF(EDX,EAX,EBX,ECX, 9, 7); - FF(ECX,EDX,EAX,EBX,10,11); - FF(EBX,ECX,EDX,EAX,11,19); - FF(EAX,EBX,ECX,EDX,12, 3); - FF(EDX,EAX,EBX,ECX,13, 7); - FF(ECX,EDX,EAX,EBX,14,11); - FF(EBX,ECX,EDX,EAX,15,19); - - GG(EAX,EBX,ECX,EDX, 0, 3); - GG(EDX,EAX,EBX,ECX, 4, 5); - GG(ECX,EDX,EAX,EBX, 8, 9); - GG(EBX,ECX,EDX,EAX,12,13); - GG(EAX,EBX,ECX,EDX, 1, 3); - GG(EDX,EAX,EBX,ECX, 5, 5); - GG(ECX,EDX,EAX,EBX, 9, 9); - GG(EBX,ECX,EDX,EAX,13,13); - GG(EAX,EBX,ECX,EDX, 2, 3); - GG(EDX,EAX,EBX,ECX, 6, 5); - GG(ECX,EDX,EAX,EBX,10, 9); - GG(EBX,ECX,EDX,EAX,14,13); - GG(EAX,EBX,ECX,EDX, 3, 3); - GG(EDX,EAX,EBX,ECX, 7, 5); - GG(ECX,EDX,EAX,EBX,11, 9); - GG(EBX,ECX,EDX,EAX,15,13); - - HH(EAX,EBX,ECX,EDX, 0, 3); - HH(EDX,EAX,EBX,ECX, 8, 9); - HH(ECX,EDX,EAX,EBX, 4,11); - HH(EBX,ECX,EDX,EAX,12,15); - HH(EAX,EBX,ECX,EDX, 2, 3); - HH(EDX,EAX,EBX,ECX,10, 9); - HH(ECX,EDX,EAX,EBX, 6,11); - HH(EBX,ECX,EDX,EAX,14,15); - HH(EAX,EBX,ECX,EDX, 1, 3); - HH(EDX,EAX,EBX,ECX, 9, 9); - HH(ECX,EDX,EAX,EBX, 5,11); - HH(EBX,ECX,EDX,EAX,13,15); - HH(EAX,EBX,ECX,EDX, 3, 3); - HH(EDX,EAX,EBX,ECX,11, 9); - HH(ECX,EDX,EAX,EBX, 7,11); - HH(EBX,ECX,EDX,EAX,15,15); - - ASSIGN(EBP, ARG(1)) - ADD(ARRAY4(EBP, 0), EAX) - ADD(ARRAY4(EBP, 1), EBX) - ADD(ARRAY4(EBP, 2), ECX) - ADD(ARRAY4(EBP, 3), EDX) - - RESTORE_REGS() -END_FUNCTION(botan_md4_x86_32_compress) diff --git a/src/lib/hash/md5_x86_32/info.txt b/src/lib/hash/md5_x86_32/info.txt deleted file mode 100644 index 769ee8389..000000000 --- a/src/lib/hash/md5_x86_32/info.txt +++ /dev/null @@ -1,12 +0,0 @@ -define MD5_X86_32 20131128 - -load_on asm_ok - -<arch> -x86_32 -</arch> - -<requires> -asm_x86_32 -md5 -</requires> diff --git a/src/lib/hash/md5_x86_32/md5_x86_32.cpp b/src/lib/hash/md5_x86_32/md5_x86_32.cpp deleted file mode 100644 index 083e90900..000000000 --- a/src/lib/hash/md5_x86_32/md5_x86_32.cpp +++ /dev/null @@ -1,34 +0,0 @@ -/* -* MD5 (x86-32) -* (C) 1999-2007 Jack Lloyd -* -* Botan is released under the Simplified BSD License (see license.txt) -*/ - -#include <botan/internal/hash_utils.h> -#include <botan/md5_x86_32.h> - -namespace Botan { - -BOTAN_REGISTER_NAMED_T_NOARGS(HashFunction, MD5_X86_32, "MD5", "x86-32"); - -namespace { - -extern "C" -void botan_md5_x86_32_compress(u32bit[4], const byte[64], u32bit[16]); - -} - -/* -* MD5 Compression Function -*/ -void MD5_X86_32::compress_n(const byte input[], size_t blocks) - { - for(size_t i = 0; i != blocks; ++i) - { - botan_md5_x86_32_compress(digest.data(), input, M.data()); - input += hash_block_size(); - } - } - -} diff --git a/src/lib/hash/md5_x86_32/md5_x86_32.h b/src/lib/hash/md5_x86_32/md5_x86_32.h deleted file mode 100644 index 2f8873a2a..000000000 --- a/src/lib/hash/md5_x86_32/md5_x86_32.h +++ /dev/null @@ -1,28 +0,0 @@ -/* -* MD5 (x86-32) -* (C) 1999-2007 Jack Lloyd -* -* Botan is released under the Simplified BSD License (see license.txt) -*/ - -#ifndef BOTAN_MD5_X86_32_H__ -#define BOTAN_MD5_X86_32_H__ - -#include <botan/md5.h> - -namespace Botan { - -/** -* MD5 in x86 assembly -*/ -class BOTAN_DLL MD5_X86_32 : public MD5 - { - public: - HashFunction* clone() const { return new MD5_X86_32; } - private: - void compress_n(const byte[], size_t blocks); - }; - -} - -#endif diff --git a/src/lib/hash/md5_x86_32/md5_x86_32_imp.S b/src/lib/hash/md5_x86_32/md5_x86_32_imp.S deleted file mode 100644 index 23606e93a..000000000 --- a/src/lib/hash/md5_x86_32/md5_x86_32_imp.S +++ /dev/null @@ -1,166 +0,0 @@ -/* -* MD5 in x86-32 assembler -* (C) 1999-2007 Jack Lloyd -* -* Botan is released under the Simplified BSD License (see license.txt) -*/ - -#include <botan/internal/asm_x86_32.h> - -START_LISTING(md5_x86_32.S) - -START_FUNCTION(botan_md5_x86_32_compress) - SPILL_REGS() - -#define PUSHED 4 - - ASSIGN(EBP, ARG(2)) /* input block */ - ASSIGN(EDI, ARG(3)) /* expanded words */ - - ZEROIZE(ESI) - -START_LOOP(.LOAD_INPUT) - ADD_IMM(ESI, 4) - - ASSIGN(EAX, ARRAY4(EBP, 0)) - ASSIGN(EBX, ARRAY4(EBP, 1)) - ASSIGN(ECX, ARRAY4(EBP, 2)) - ASSIGN(EDX, ARRAY4(EBP, 3)) - - ADD_IMM(EBP, 16) - - ASSIGN(ARRAY4_INDIRECT(EDI,ESI,-4), EAX) - ASSIGN(ARRAY4_INDIRECT(EDI,ESI,-3), EBX) - ASSIGN(ARRAY4_INDIRECT(EDI,ESI,-2), ECX) - ASSIGN(ARRAY4_INDIRECT(EDI,ESI,-1), EDX) -LOOP_UNTIL_EQ(ESI, 16, .LOAD_INPUT) - - ASSIGN(EBP, ARG(1)) - ASSIGN(EAX, ARRAY4(EBP, 0)) - ASSIGN(EBX, ARRAY4(EBP, 1)) - ASSIGN(ECX, ARRAY4(EBP, 2)) - ASSIGN(EDX, ARRAY4(EBP, 3)) - -#define MSG EDI -#define T1 ESI -#define T2 EBP - -#define FF(A, B, C, D, N, S, MAGIC) \ - ASSIGN(T1, ARRAY4(MSG, N)) ; \ - ASSIGN(T2, C) ; \ - XOR(T2, D) ; \ - AND(T2, B) ; \ - XOR(T2, D) ; \ - ADD3_IMM(A, T1, MAGIC) ; \ - ADD(A, T2) ; \ - ROTL_IMM(A, S) ; \ - ADD(A, B) ; - -#define GG(A, B, C, D, N, S, MAGIC) \ - ASSIGN(T1, ARRAY4(MSG, N)) ; \ - ASSIGN(T2, B) ; \ - XOR(T2, C) ; \ - AND(T2, D) ; \ - XOR(T2, C) ; \ - ADD3_IMM(A, T1, MAGIC) ; \ - ADD(A, T2) ; \ - ROTL_IMM(A, S) ; \ - ADD(A, B) ; - -#define HH(A, B, C, D, N, S, MAGIC) \ - ASSIGN(T1, ARRAY4(MSG, N)) ; \ - ASSIGN(T2, B) ; \ - XOR(T2, C) ; \ - XOR(T2, D) ; \ - ADD3_IMM(A, T1, MAGIC) ; \ - ADD(A, T2) ; \ - ROTL_IMM(A, S) ; \ - ADD(A, B) ; - -#define II(A, B, C, D, N, S, MAGIC) \ - ASSIGN(T1, ARRAY4(MSG, N)) ; \ - ASSIGN(T2, D) ; \ - NOT(T2) ; \ - OR(T2, B) ; \ - XOR(T2, C) ; \ - ADD3_IMM(A, T1, MAGIC) ; \ - ADD(A, T2) ; \ - ROTL_IMM(A, S) ; \ - ADD(A, B) ; - - FF(EAX,EBX,ECX,EDX, 0, 7,0xD76AA478); - FF(EDX,EAX,EBX,ECX, 1,12,0xE8C7B756); - FF(ECX,EDX,EAX,EBX, 2,17,0x242070DB); - FF(EBX,ECX,EDX,EAX, 3,22,0xC1BDCEEE); - FF(EAX,EBX,ECX,EDX, 4, 7,0xF57C0FAF); - FF(EDX,EAX,EBX,ECX, 5,12,0x4787C62A); - FF(ECX,EDX,EAX,EBX, 6,17,0xA8304613); - FF(EBX,ECX,EDX,EAX, 7,22,0xFD469501); - FF(EAX,EBX,ECX,EDX, 8, 7,0x698098D8); - FF(EDX,EAX,EBX,ECX, 9,12,0x8B44F7AF); - FF(ECX,EDX,EAX,EBX,10,17,0xFFFF5BB1); - FF(EBX,ECX,EDX,EAX,11,22,0x895CD7BE); - FF(EAX,EBX,ECX,EDX,12, 7,0x6B901122); - FF(EDX,EAX,EBX,ECX,13,12,0xFD987193); - FF(ECX,EDX,EAX,EBX,14,17,0xA679438E); - FF(EBX,ECX,EDX,EAX,15,22,0x49B40821); - - GG(EAX,EBX,ECX,EDX, 1, 5,0xF61E2562); - GG(EDX,EAX,EBX,ECX, 6, 9,0xC040B340); - GG(ECX,EDX,EAX,EBX,11,14,0x265E5A51); - GG(EBX,ECX,EDX,EAX, 0,20,0xE9B6C7AA); - GG(EAX,EBX,ECX,EDX, 5, 5,0xD62F105D); - GG(EDX,EAX,EBX,ECX,10, 9,0x02441453); - GG(ECX,EDX,EAX,EBX,15,14,0xD8A1E681); - GG(EBX,ECX,EDX,EAX, 4,20,0xE7D3FBC8); - GG(EAX,EBX,ECX,EDX, 9, 5,0x21E1CDE6); - GG(EDX,EAX,EBX,ECX,14, 9,0xC33707D6); - GG(ECX,EDX,EAX,EBX, 3,14,0xF4D50D87); - GG(EBX,ECX,EDX,EAX, 8,20,0x455A14ED); - GG(EAX,EBX,ECX,EDX,13, 5,0xA9E3E905); - GG(EDX,EAX,EBX,ECX, 2, 9,0xFCEFA3F8); - GG(ECX,EDX,EAX,EBX, 7,14,0x676F02D9); - GG(EBX,ECX,EDX,EAX,12,20,0x8D2A4C8A); - - HH(EAX,EBX,ECX,EDX, 5, 4,0xFFFA3942); - HH(EDX,EAX,EBX,ECX, 8,11,0x8771F681); - HH(ECX,EDX,EAX,EBX,11,16,0x6D9D6122); - HH(EBX,ECX,EDX,EAX,14,23,0xFDE5380C); - HH(EAX,EBX,ECX,EDX, 1, 4,0xA4BEEA44); - HH(EDX,EAX,EBX,ECX, 4,11,0x4BDECFA9); - HH(ECX,EDX,EAX,EBX, 7,16,0xF6BB4B60); - HH(EBX,ECX,EDX,EAX,10,23,0xBEBFBC70); - HH(EAX,EBX,ECX,EDX,13, 4,0x289B7EC6); - HH(EDX,EAX,EBX,ECX, 0,11,0xEAA127FA); - HH(ECX,EDX,EAX,EBX, 3,16,0xD4EF3085); - HH(EBX,ECX,EDX,EAX, 6,23,0x04881D05); - HH(EAX,EBX,ECX,EDX, 9, 4,0xD9D4D039); - HH(EDX,EAX,EBX,ECX,12,11,0xE6DB99E5); - HH(ECX,EDX,EAX,EBX,15,16,0x1FA27CF8); - HH(EBX,ECX,EDX,EAX, 2,23,0xC4AC5665); - - II(EAX,EBX,ECX,EDX, 0, 6,0xF4292244); - II(EDX,EAX,EBX,ECX, 7,10,0x432AFF97); - II(ECX,EDX,EAX,EBX,14,15,0xAB9423A7); - II(EBX,ECX,EDX,EAX, 5,21,0xFC93A039); - II(EAX,EBX,ECX,EDX,12, 6,0x655B59C3); - II(EDX,EAX,EBX,ECX, 3,10,0x8F0CCC92); - II(ECX,EDX,EAX,EBX,10,15,0xFFEFF47D); - II(EBX,ECX,EDX,EAX, 1,21,0x85845DD1); - II(EAX,EBX,ECX,EDX, 8, 6,0x6FA87E4F); - II(EDX,EAX,EBX,ECX,15,10,0xFE2CE6E0); - II(ECX,EDX,EAX,EBX, 6,15,0xA3014314); - II(EBX,ECX,EDX,EAX,13,21,0x4E0811A1); - II(EAX,EBX,ECX,EDX, 4, 6,0xF7537E82); - II(EDX,EAX,EBX,ECX,11,10,0xBD3AF235); - II(ECX,EDX,EAX,EBX, 2,15,0x2AD7D2BB); - II(EBX,ECX,EDX,EAX, 9,21,0xEB86D391); - - ASSIGN(EBP, ARG(1)) - ADD(ARRAY4(EBP, 0), EAX) - ADD(ARRAY4(EBP, 1), EBX) - ADD(ARRAY4(EBP, 2), ECX) - ADD(ARRAY4(EBP, 3), EDX) - - RESTORE_REGS() -END_FUNCTION(botan_md5_x86_32_compress) diff --git a/src/lib/hash/sha1_x86_32/info.txt b/src/lib/hash/sha1_x86_32/info.txt deleted file mode 100644 index 51e3f6587..000000000 --- a/src/lib/hash/sha1_x86_32/info.txt +++ /dev/null @@ -1,12 +0,0 @@ -define SHA1_X86_32 20131128 - -load_on asm_ok - -<arch> -x86_32 -</arch> - -<requires> -asm_x86_32 -sha1 -</requires> diff --git a/src/lib/hash/sha1_x86_32/sha1_x86_32.cpp b/src/lib/hash/sha1_x86_32/sha1_x86_32.cpp deleted file mode 100644 index c5986221e..000000000 --- a/src/lib/hash/sha1_x86_32/sha1_x86_32.cpp +++ /dev/null @@ -1,34 +0,0 @@ -/* -* SHA-160 in x86-32 -* (C) 1999-2007 Jack Lloyd -* -* Botan is released under the Simplified BSD License (see license.txt) -*/ - -#include <botan/internal/hash_utils.h> -#include <botan/sha1_x86_32.h> - -namespace Botan { - -BOTAN_REGISTER_NAMED_T_NOARGS(HashFunction, SHA_160_X86_32, "SHA-160", "x86-32"); - -namespace { - -extern "C" -void botan_sha160_x86_32_compress(u32bit[5], const byte[64], u32bit[81]); - -} - -/* -* SHA-160 Compression Function -*/ -void SHA_160_X86_32::compress_n(const byte input[], size_t blocks) - { - for(size_t i = 0; i != blocks; ++i) - { - botan_sha160_x86_32_compress(digest.data(), input, W.data()); - input += hash_block_size(); - } - } - -} diff --git a/src/lib/hash/sha1_x86_32/sha1_x86_32.h b/src/lib/hash/sha1_x86_32/sha1_x86_32.h deleted file mode 100644 index 738000744..000000000 --- a/src/lib/hash/sha1_x86_32/sha1_x86_32.h +++ /dev/null @@ -1,31 +0,0 @@ -/* -* SHA-160 in x86-32 asm -* (C) 1999-2007 Jack Lloyd -* -* Botan is released under the Simplified BSD License (see license.txt) -*/ - -#ifndef BOTAN_SHA_160_X86_32_H__ -#define BOTAN_SHA_160_X86_32_H__ - -#include <botan/sha160.h> - -namespace Botan { - -/** -* SHA-160 in x86 assembly -*/ -class BOTAN_DLL SHA_160_X86_32 : public SHA_160 - { - public: - HashFunction* clone() const { return new SHA_160_X86_32; } - - // Note 81 instead of normal 80: x86-32 asm needs an extra temp - SHA_160_X86_32() : SHA_160(81) {} - private: - void compress_n(const byte[], size_t blocks); - }; - -} - -#endif diff --git a/src/lib/hash/sha1_x86_32/sha1_x86_32_imp.S b/src/lib/hash/sha1_x86_32/sha1_x86_32_imp.S deleted file mode 100644 index 6ab5ed78d..000000000 --- a/src/lib/hash/sha1_x86_32/sha1_x86_32_imp.S +++ /dev/null @@ -1,244 +0,0 @@ -/* -* SHA-1 in x86-32 asm -* (C) 1999-2007 Jack Lloyd -* -* Botan is released under the Simplified BSD License (see license.txt) -*/ - -#include <botan/internal/asm_x86_32.h> - -START_LISTING(sha1_x86_32_imp.S) - -START_FUNCTION(botan_sha160_x86_32_compress) - SPILL_REGS() - -#define PUSHED 4 - - ASSIGN(EDI, ARG(2)) - ASSIGN(EBP, ARG(3)) - - ZEROIZE(ESI) - -START_LOOP(.LOAD_INPUT) - ADD_IMM(ESI, 4) - - ASSIGN(EAX, ARRAY4(EDI, 0)) - ASSIGN(EBX, ARRAY4(EDI, 1)) - ASSIGN(ECX, ARRAY4(EDI, 2)) - ASSIGN(EDX, ARRAY4(EDI, 3)) - - ADD_IMM(EDI, 16) - - BSWAP(EAX) - BSWAP(EBX) - BSWAP(ECX) - BSWAP(EDX) - - ASSIGN(ARRAY4_INDIRECT(EBP,ESI,-4), EAX) - ASSIGN(ARRAY4_INDIRECT(EBP,ESI,-3), EBX) - ASSIGN(ARRAY4_INDIRECT(EBP,ESI,-2), ECX) - ASSIGN(ARRAY4_INDIRECT(EBP,ESI,-1), EDX) -LOOP_UNTIL_EQ(ESI, 16, .LOAD_INPUT) - - ADD2_IMM(EDI, EBP, 64) - -START_LOOP(.L_SHA_EXPANSION) - ADD_IMM(ESI, 4) - - ZEROIZE(EAX) - ASSIGN(EBX, ARRAY4(EDI, -1)) - ASSIGN(ECX, ARRAY4(EDI, -2)) - ASSIGN(EDX, ARRAY4(EDI, -3)) - - XOR(EAX, ARRAY4(EDI, -5)) - XOR(EBX, ARRAY4(EDI, -6)) - XOR(ECX, ARRAY4(EDI, -7)) - XOR(EDX, ARRAY4(EDI, -8)) - - XOR(EAX, ARRAY4(EDI, -11)) - XOR(EBX, ARRAY4(EDI, -12)) - XOR(ECX, ARRAY4(EDI, -13)) - XOR(EDX, ARRAY4(EDI, -14)) - - XOR(EAX, ARRAY4(EDI, -13)) - XOR(EBX, ARRAY4(EDI, -14)) - XOR(ECX, ARRAY4(EDI, -15)) - XOR(EDX, ARRAY4(EDI, -16)) - - ROTL_IMM(EDX, 1) - ROTL_IMM(ECX, 1) - ROTL_IMM(EBX, 1) - XOR(EAX, EDX) - ROTL_IMM(EAX, 1) - - ASSIGN(ARRAY4(EDI, 0), EDX) - ASSIGN(ARRAY4(EDI, 1), ECX) - ASSIGN(ARRAY4(EDI, 2), EBX) - ASSIGN(ARRAY4(EDI, 3), EAX) - - ADD_IMM(EDI, 16) -LOOP_UNTIL_EQ(ESI, 80, .L_SHA_EXPANSION) - -#define MAGIC1 0x5A827999 -#define MAGIC2 0x6ED9EBA1 -#define MAGIC3 0x8F1BBCDC -#define MAGIC4 0xCA62C1D6 - -#define MSG ESP -#define T2 EBP - -#define F1(A, B, C, D, E, F, N) \ - ASSIGN(T2, ARRAY4(MSG, N)) ; \ - ASSIGN(A, F) ; \ - ROTL_IMM(F, 5) ; \ - ADD(F, E) ; \ - ASSIGN(E, C) ; \ - XOR(E, D) ; \ - ADD3_IMM(F, T2, MAGIC1) ; \ - AND(E, B) ; \ - XOR(E, D) ; \ - ROTR_IMM(B, 2) ; \ - ADD(E, F) ; - -#define F2_4(A, B, C, D, E, F, N, MAGIC) \ - ASSIGN(T2, ARRAY4(MSG, N)) ; \ - ASSIGN(A, F) ; \ - ROTL_IMM(F, 5) ; \ - ADD(F, E) ; \ - ASSIGN(E, B) ; \ - XOR(E, C) ; \ - ADD3_IMM(F, T2, MAGIC) ; \ - XOR(E, D) ; \ - ROTR_IMM(B, 2) ; \ - ADD(E, F) ; - -#define F3(A, B, C, D, E, F, N) \ - ASSIGN(T2, ARRAY4(MSG, N)) ; \ - ASSIGN(A, F) ; \ - ROTL_IMM(F, 5) ; \ - ADD(F, E) ; \ - ASSIGN(E, B) ; \ - OR(E, C) ; \ - AND(E, D) ; \ - ADD3_IMM(F, T2, MAGIC3) ; \ - ASSIGN(T2, B) ; \ - AND(T2, C) ; \ - OR(E, T2) ; \ - ROTR_IMM(B, 2) ; \ - ADD(E, F) ; - -#define F2(A, B, C, D, E, F, MSG) \ - F2_4(A, B, C, D, E, F, MSG, MAGIC2) - -#define F4(A, B, C, D, E, F, MSG) \ - F2_4(A, B, C, D, E, F, MSG, MAGIC4) - - ASSIGN(EAX, ARG(1)) - ASSIGN(EDI, ARRAY4(EAX, 0)) - ASSIGN(EBX, ARRAY4(EAX, 1)) - ASSIGN(ECX, ARRAY4(EAX, 2)) - ASSIGN(EDX, ARRAY4(EAX, 3)) - ASSIGN(ESI, ARRAY4(EAX, 4)) - - ASSIGN(ARRAY4(EBP, 80), ESP) - ASSIGN(ESP, EBP) - - /* First Round */ - F1(EAX, EBX, ECX, EDX, ESI, EDI, 0) - F1(EDI, EAX, EBX, ECX, EDX, ESI, 1) - F1(ESI, EDI, EAX, EBX, ECX, EDX, 2) - F1(EDX, ESI, EDI, EAX, EBX, ECX, 3) - F1(ECX, EDX, ESI, EDI, EAX, EBX, 4) - F1(EBX, ECX, EDX, ESI, EDI, EAX, 5) - F1(EAX, EBX, ECX, EDX, ESI, EDI, 6) - F1(EDI, EAX, EBX, ECX, EDX, ESI, 7) - F1(ESI, EDI, EAX, EBX, ECX, EDX, 8) - F1(EDX, ESI, EDI, EAX, EBX, ECX, 9) - F1(ECX, EDX, ESI, EDI, EAX, EBX, 10) - F1(EBX, ECX, EDX, ESI, EDI, EAX, 11) - F1(EAX, EBX, ECX, EDX, ESI, EDI, 12) - F1(EDI, EAX, EBX, ECX, EDX, ESI, 13) - F1(ESI, EDI, EAX, EBX, ECX, EDX, 14) - F1(EDX, ESI, EDI, EAX, EBX, ECX, 15) - F1(ECX, EDX, ESI, EDI, EAX, EBX, 16) - F1(EBX, ECX, EDX, ESI, EDI, EAX, 17) - F1(EAX, EBX, ECX, EDX, ESI, EDI, 18) - F1(EDI, EAX, EBX, ECX, EDX, ESI, 19) - - /* Second Round */ - F2(ESI, EDI, EAX, EBX, ECX, EDX, 20) - F2(EDX, ESI, EDI, EAX, EBX, ECX, 21) - F2(ECX, EDX, ESI, EDI, EAX, EBX, 22) - F2(EBX, ECX, EDX, ESI, EDI, EAX, 23) - F2(EAX, EBX, ECX, EDX, ESI, EDI, 24) - F2(EDI, EAX, EBX, ECX, EDX, ESI, 25) - F2(ESI, EDI, EAX, EBX, ECX, EDX, 26) - F2(EDX, ESI, EDI, EAX, EBX, ECX, 27) - F2(ECX, EDX, ESI, EDI, EAX, EBX, 28) - F2(EBX, ECX, EDX, ESI, EDI, EAX, 29) - F2(EAX, EBX, ECX, EDX, ESI, EDI, 30) - F2(EDI, EAX, EBX, ECX, EDX, ESI, 31) - F2(ESI, EDI, EAX, EBX, ECX, EDX, 32) - F2(EDX, ESI, EDI, EAX, EBX, ECX, 33) - F2(ECX, EDX, ESI, EDI, EAX, EBX, 34) - F2(EBX, ECX, EDX, ESI, EDI, EAX, 35) - F2(EAX, EBX, ECX, EDX, ESI, EDI, 36) - F2(EDI, EAX, EBX, ECX, EDX, ESI, 37) - F2(ESI, EDI, EAX, EBX, ECX, EDX, 38) - F2(EDX, ESI, EDI, EAX, EBX, ECX, 39) - - /* Third Round */ - F3(ECX, EDX, ESI, EDI, EAX, EBX, 40) - F3(EBX, ECX, EDX, ESI, EDI, EAX, 41) - F3(EAX, EBX, ECX, EDX, ESI, EDI, 42) - F3(EDI, EAX, EBX, ECX, EDX, ESI, 43) - F3(ESI, EDI, EAX, EBX, ECX, EDX, 44) - F3(EDX, ESI, EDI, EAX, EBX, ECX, 45) - F3(ECX, EDX, ESI, EDI, EAX, EBX, 46) - F3(EBX, ECX, EDX, ESI, EDI, EAX, 47) - F3(EAX, EBX, ECX, EDX, ESI, EDI, 48) - F3(EDI, EAX, EBX, ECX, EDX, ESI, 49) - F3(ESI, EDI, EAX, EBX, ECX, EDX, 50) - F3(EDX, ESI, EDI, EAX, EBX, ECX, 51) - F3(ECX, EDX, ESI, EDI, EAX, EBX, 52) - F3(EBX, ECX, EDX, ESI, EDI, EAX, 53) - F3(EAX, EBX, ECX, EDX, ESI, EDI, 54) - F3(EDI, EAX, EBX, ECX, EDX, ESI, 55) - F3(ESI, EDI, EAX, EBX, ECX, EDX, 56) - F3(EDX, ESI, EDI, EAX, EBX, ECX, 57) - F3(ECX, EDX, ESI, EDI, EAX, EBX, 58) - F3(EBX, ECX, EDX, ESI, EDI, EAX, 59) - - /* Fourth Round */ - F4(EAX, EBX, ECX, EDX, ESI, EDI, 60) - F4(EDI, EAX, EBX, ECX, EDX, ESI, 61) - F4(ESI, EDI, EAX, EBX, ECX, EDX, 62) - F4(EDX, ESI, EDI, EAX, EBX, ECX, 63) - F4(ECX, EDX, ESI, EDI, EAX, EBX, 64) - F4(EBX, ECX, EDX, ESI, EDI, EAX, 65) - F4(EAX, EBX, ECX, EDX, ESI, EDI, 66) - F4(EDI, EAX, EBX, ECX, EDX, ESI, 67) - F4(ESI, EDI, EAX, EBX, ECX, EDX, 68) - F4(EDX, ESI, EDI, EAX, EBX, ECX, 69) - F4(ECX, EDX, ESI, EDI, EAX, EBX, 70) - F4(EBX, ECX, EDX, ESI, EDI, EAX, 71) - F4(EAX, EBX, ECX, EDX, ESI, EDI, 72) - F4(EDI, EAX, EBX, ECX, EDX, ESI, 73) - F4(ESI, EDI, EAX, EBX, ECX, EDX, 74) - F4(EDX, ESI, EDI, EAX, EBX, ECX, 75) - F4(ECX, EDX, ESI, EDI, EAX, EBX, 76) - F4(EBX, ECX, EDX, ESI, EDI, EAX, 77) - F4(EAX, EBX, ECX, EDX, ESI, EDI, 78) - F4(EDI, EAX, EBX, ECX, EDX, ESI, 79) - - ASSIGN(ESP, ARRAY4(ESP, 80)) - - ASSIGN(EBP, ARG(1)) - ADD(ARRAY4(EBP, 0), EDX) - ADD(ARRAY4(EBP, 1), EDI) - ADD(ARRAY4(EBP, 2), EAX) - ADD(ARRAY4(EBP, 3), EBX) - ADD(ARRAY4(EBP, 4), ECX) - - RESTORE_REGS() -END_FUNCTION(botan_sha160_x86_32_compress) diff --git a/src/lib/hash/sha1_x86_64/info.txt b/src/lib/hash/sha1_x86_64/info.txt deleted file mode 100644 index db7cdcb92..000000000 --- a/src/lib/hash/sha1_x86_64/info.txt +++ /dev/null @@ -1,12 +0,0 @@ -define SHA1_X86_64 20131128 - -load_on asm_ok - -<arch> -x86_64 -</arch> - -<requires> -asm_x86_64 -sha1 -</requires> diff --git a/src/lib/hash/sha1_x86_64/sha1_x86_64.cpp b/src/lib/hash/sha1_x86_64/sha1_x86_64.cpp deleted file mode 100644 index f2fbff1a6..000000000 --- a/src/lib/hash/sha1_x86_64/sha1_x86_64.cpp +++ /dev/null @@ -1,34 +0,0 @@ -/* -* SHA-160 -* (C) 1999-2007 Jack Lloyd -* -* Botan is released under the Simplified BSD License (see license.txt) -*/ - -#include <botan/internal/hash_utils.h> -#include <botan/sha1_x86_64.h> - -namespace Botan { - -BOTAN_REGISTER_NAMED_T_NOARGS(HashFunction, SHA_160_X86_64, "SHA-160", "x86-64"); - -namespace { - -extern "C" -void botan_sha160_x86_64_compress(u32bit[5], const byte[64], u32bit[80]); - -} - -/* -* SHA-160 Compression Function -*/ -void SHA_160_X86_64::compress_n(const byte input[], size_t blocks) - { - for(size_t i = 0; i != blocks; ++i) - { - botan_sha160_x86_64_compress(digest.data(), input, W.data()); - input += hash_block_size(); - } - } - -} diff --git a/src/lib/hash/sha1_x86_64/sha1_x86_64.h b/src/lib/hash/sha1_x86_64/sha1_x86_64.h deleted file mode 100644 index 10bb8bd16..000000000 --- a/src/lib/hash/sha1_x86_64/sha1_x86_64.h +++ /dev/null @@ -1,28 +0,0 @@ -/* -* SHA-160 (x86-64) -* (C) 1999-2007 Jack Lloyd -* -* Botan is released under the Simplified BSD License (see license.txt) -*/ - -#ifndef BOTAN_SHA_160_X86_64_H__ -#define BOTAN_SHA_160_X86_64_H__ - -#include <botan/sha160.h> - -namespace Botan { - -/** -* SHA-160 in x86-64 assembly -*/ -class BOTAN_DLL SHA_160_X86_64 : public SHA_160 - { - public: - HashFunction* clone() const { return new SHA_160_X86_64; } - private: - void compress_n(const byte[], size_t blocks); - }; - -} - -#endif diff --git a/src/lib/hash/sha1_x86_64/sha1_x86_64_imp.S b/src/lib/hash/sha1_x86_64/sha1_x86_64_imp.S deleted file mode 100644 index dd46a9e56..000000000 --- a/src/lib/hash/sha1_x86_64/sha1_x86_64_imp.S +++ /dev/null @@ -1,266 +0,0 @@ -/* -* SHA-1 in x86-64 assembler -* (C) 1999-2007 Jack Lloyd -* -* Botan is released under the Simplified BSD License (see license.txt) -*/ - -#include <botan/internal/asm_x86_64.h> - -START_LISTING(sha1_x86_64_imp.S) - -START_FUNCTION(botan_sha160_x86_64_compress) - -#define DIGEST_ARR %rdi -#define INPUT %rsi -#define W %rdx -#define LOOP_CTR %eax - -#define A %r8d -#define B %r9d -#define C %r10d -#define D %r11d -#define E %ecx - - ZEROIZE(LOOP_CTR) - -ALIGN; -.LOOP_LOAD_INPUT: - addl $8, %eax - - movq ARRAY8(INPUT, 0), %r8 - movq ARRAY8(INPUT, 1), %r9 - movq ARRAY8(INPUT, 2), %r10 - movq ARRAY8(INPUT, 3), %r11 - - bswap %r8 - bswap %r9 - bswap %r10 - bswap %r11 - - rolq $32, %r8 - rolq $32, %r9 - rolq $32, %r10 - rolq $32, %r11 - - movq %r8, ARRAY8(W, 0) - movq %r9, ARRAY8(W, 1) - movq %r10, ARRAY8(W, 2) - movq %r11, ARRAY8(W, 3) - - addq $32, W - addq $32, INPUT - - cmp IMM(16), LOOP_CTR - jne .LOOP_LOAD_INPUT - -/* -#define A %r8d -#define B %r9d -#define C %r10d -#define D %r11d -#define E %ecx -*/ - -ALIGN; -.LOOP_EXPANSION: - addl $4, LOOP_CTR - - ZEROIZE(A) - ASSIGN(B, ARRAY4(W, -1)) - ASSIGN(C, ARRAY4(W, -2)) - ASSIGN(D, ARRAY4(W, -3)) - - XOR(A, ARRAY4(W, -5)) - XOR(B, ARRAY4(W, -6)) - XOR(C, ARRAY4(W, -7)) - XOR(D, ARRAY4(W, -8)) - - XOR(A, ARRAY4(W, -11)) - XOR(B, ARRAY4(W, -12)) - XOR(C, ARRAY4(W, -13)) - XOR(D, ARRAY4(W, -14)) - - XOR(A, ARRAY4(W, -13)) - XOR(B, ARRAY4(W, -14)) - XOR(C, ARRAY4(W, -15)) - XOR(D, ARRAY4(W, -16)) - - ROTL_IMM(D, 1) - ROTL_IMM(C, 1) - ROTL_IMM(B, 1) - XOR(A, D) - ROTL_IMM(A, 1) - - ASSIGN(ARRAY4(W, 0), D) - ASSIGN(ARRAY4(W, 1), C) - ASSIGN(ARRAY4(W, 2), B) - ASSIGN(ARRAY4(W, 3), A) - - addq $16, W - cmp IMM(80), LOOP_CTR - jne .LOOP_EXPANSION - - subq $320, W - -/* -* Using negative values for SHA-1 constants > 2^31 to work around -* a bug in binutils not accepting large lea displacements. -* -0x70E44324 == 0x8F1BBCDC -* -0x359D3E2A == 0xCA62C1D6 -*/ -#define MAGIC1 0x5A827999 -#define MAGIC2 0x6ED9EBA1 -#define MAGIC3 -0x70E44324 -#define MAGIC4 -0x359D3E2A - -#define T %esi -#define T2 %eax - -#define F1(A, B, C, D, E, F, N) \ - ASSIGN(T2, ARRAY4(W, N)) ; \ - ASSIGN(A, F) ; \ - ROTL_IMM(F, 5) ; \ - ADD(F, E) ; \ - ASSIGN(E, C) ; \ - XOR(E, D) ; \ - ADD3_IMM(F, T2, MAGIC1) ; \ - AND(E, B) ; \ - XOR(E, D) ; \ - ROTR_IMM(B, 2) ; \ - ADD(E, F) ; - -#define F2_4(A, B, C, D, E, F, N, MAGIC) \ - ASSIGN(T2, ARRAY4(W, N)) ; \ - ASSIGN(A, F) ; \ - ROTL_IMM(F, 5) ; \ - ADD(F, E) ; \ - ASSIGN(E, B) ; \ - XOR(E, C) ; \ - ADD3_IMM(F, T2, MAGIC) ; \ - XOR(E, D) ; \ - ROTR_IMM(B, 2) ; \ - ADD(E, F) ; - -#define F3(A, B, C, D, E, F, N) \ - ASSIGN(T2, ARRAY4(W, N)) ; \ - ASSIGN(A, F) ; \ - ROTL_IMM(F, 5) ; \ - ADD(F, E) ; \ - ASSIGN(E, B) ; \ - OR(E, C) ; \ - AND(E, D) ; \ - ADD3_IMM(F, T2, MAGIC3) ; \ - ASSIGN(T2, B) ; \ - AND(T2, C) ; \ - OR(E, T2) ; \ - ROTR_IMM(B, 2) ; \ - ADD(E, F) ; - -#define F2(A, B, C, D, E, F, W) \ - F2_4(A, B, C, D, E, F, W, MAGIC2) - -#define F4(A, B, C, D, E, F, W) \ - F2_4(A, B, C, D, E, F, W, MAGIC4) - - ASSIGN(T, ARRAY4(DIGEST_ARR, 0)) - ASSIGN(B, ARRAY4(DIGEST_ARR, 1)) - ASSIGN(C, ARRAY4(DIGEST_ARR, 2)) - ASSIGN(D, ARRAY4(DIGEST_ARR, 3)) - ASSIGN(E, ARRAY4(DIGEST_ARR, 4)) - - /* First Round */ - F1(A, B, C, D, E, T, 0) - F1(T, A, B, C, D, E, 1) - F1(E, T, A, B, C, D, 2) - F1(D, E, T, A, B, C, 3) - F1(C, D, E, T, A, B, 4) - F1(B, C, D, E, T, A, 5) - F1(A, B, C, D, E, T, 6) - F1(T, A, B, C, D, E, 7) - F1(E, T, A, B, C, D, 8) - F1(D, E, T, A, B, C, 9) - F1(C, D, E, T, A, B, 10) - F1(B, C, D, E, T, A, 11) - F1(A, B, C, D, E, T, 12) - F1(T, A, B, C, D, E, 13) - F1(E, T, A, B, C, D, 14) - F1(D, E, T, A, B, C, 15) - F1(C, D, E, T, A, B, 16) - F1(B, C, D, E, T, A, 17) - F1(A, B, C, D, E, T, 18) - F1(T, A, B, C, D, E, 19) - - /* Second Round */ - F2(E, T, A, B, C, D, 20) - F2(D, E, T, A, B, C, 21) - F2(C, D, E, T, A, B, 22) - F2(B, C, D, E, T, A, 23) - F2(A, B, C, D, E, T, 24) - F2(T, A, B, C, D, E, 25) - F2(E, T, A, B, C, D, 26) - F2(D, E, T, A, B, C, 27) - F2(C, D, E, T, A, B, 28) - F2(B, C, D, E, T, A, 29) - F2(A, B, C, D, E, T, 30) - F2(T, A, B, C, D, E, 31) - F2(E, T, A, B, C, D, 32) - F2(D, E, T, A, B, C, 33) - F2(C, D, E, T, A, B, 34) - F2(B, C, D, E, T, A, 35) - F2(A, B, C, D, E, T, 36) - F2(T, A, B, C, D, E, 37) - F2(E, T, A, B, C, D, 38) - F2(D, E, T, A, B, C, 39) - - /* Third Round */ - F3(C, D, E, T, A, B, 40) - F3(B, C, D, E, T, A, 41) - F3(A, B, C, D, E, T, 42) - F3(T, A, B, C, D, E, 43) - F3(E, T, A, B, C, D, 44) - F3(D, E, T, A, B, C, 45) - F3(C, D, E, T, A, B, 46) - F3(B, C, D, E, T, A, 47) - F3(A, B, C, D, E, T, 48) - F3(T, A, B, C, D, E, 49) - F3(E, T, A, B, C, D, 50) - F3(D, E, T, A, B, C, 51) - F3(C, D, E, T, A, B, 52) - F3(B, C, D, E, T, A, 53) - F3(A, B, C, D, E, T, 54) - F3(T, A, B, C, D, E, 55) - F3(E, T, A, B, C, D, 56) - F3(D, E, T, A, B, C, 57) - F3(C, D, E, T, A, B, 58) - F3(B, C, D, E, T, A, 59) - - /* Fourth Round */ - F4(A, B, C, D, E, T, 60) - F4(T, A, B, C, D, E, 61) - F4(E, T, A, B, C, D, 62) - F4(D, E, T, A, B, C, 63) - F4(C, D, E, T, A, B, 64) - F4(B, C, D, E, T, A, 65) - F4(A, B, C, D, E, T, 66) - F4(T, A, B, C, D, E, 67) - F4(E, T, A, B, C, D, 68) - F4(D, E, T, A, B, C, 69) - F4(C, D, E, T, A, B, 70) - F4(B, C, D, E, T, A, 71) - F4(A, B, C, D, E, T, 72) - F4(T, A, B, C, D, E, 73) - F4(E, T, A, B, C, D, 74) - F4(D, E, T, A, B, C, 75) - F4(C, D, E, T, A, B, 76) - F4(B, C, D, E, T, A, 77) - F4(A, B, C, D, E, T, 78) - F4(T, A, B, C, D, E, 79) - - ADD(ARRAY4(DIGEST_ARR, 0), D) - ADD(ARRAY4(DIGEST_ARR, 1), T) - ADD(ARRAY4(DIGEST_ARR, 2), A) - ADD(ARRAY4(DIGEST_ARR, 3), B) - ADD(ARRAY4(DIGEST_ARR, 4), C) - -END_FUNCTION(botan_sha160_x86_64_compress) diff --git a/src/lib/utils/asm_x86_32/asm_x86_32.h b/src/lib/utils/asm_x86_32/asm_x86_32.h deleted file mode 100644 index 7149b8db5..000000000 --- a/src/lib/utils/asm_x86_32/asm_x86_32.h +++ /dev/null @@ -1,128 +0,0 @@ -/* -* Assembly Macros for 32-bit x86 -* (C) 1999-2008 Jack Lloyd -* -* Botan is released under the Simplified BSD License (see license.txt) -*/ - -#ifndef BOTAN_ASM_MACROS_X86_32_H__ -#define BOTAN_ASM_MACROS_X86_32_H__ - -/* -* General/Global Macros -*/ -#define ALIGN .p2align 4,,15 - -#define START_LISTING(FILENAME) \ - .file #FILENAME; \ - .text; \ - ALIGN; - -#if defined(__ELF__) -.section .note.GNU-stack,"",%progbits -#endif - -/* -* Function Definitions -*/ -#define START_FUNCTION(func_name) \ - ALIGN; \ - .global func_name; \ - .type func_name,@function; \ -func_name: - -#define END_FUNCTION(func_name) \ - ret - -/* -* Loop Control -*/ -#define START_LOOP(LABEL) \ - ALIGN; \ - LABEL##_LOOP: - -#define LOOP_UNTIL_EQ(REG, NUM, LABEL) \ - cmpl IMM(NUM), REG; \ - jne LABEL##_LOOP - -#define LOOP_UNTIL_LT(REG, NUM, LABEL) \ - cmpl IMM(NUM), REG; \ - jge LABEL##_LOOP - -/* - Conditional Jumps -*/ -#define JUMP_IF_ZERO(REG, LABEL) \ - cmpl IMM(0), REG; \ - jz LABEL - -#define JUMP_IF_LT(REG, NUM, LABEL) \ - cmpl IMM(NUM), REG; \ - jl LABEL - -/* -* Register Names -*/ -#define EAX %eax -#define EBX %ebx -#define ECX %ecx -#define EDX %edx -#define EBP %ebp -#define EDI %edi -#define ESI %esi -#define ESP %esp - -/* -* Memory Access Operations -*/ -#define ARRAY1(REG, NUM) (NUM)(REG) -#define ARRAY4(REG, NUM) 4*(NUM)(REG) -#define ARRAY4_INDIRECT(BASE, OFFSET, NUM) 4*(NUM)(BASE,OFFSET,4) -#define ARG(NUM) 4*(PUSHED) + ARRAY4(ESP, NUM) - -#define ASSIGN(TO, FROM) movl FROM, TO -#define ASSIGN_BYTE(TO, FROM) movzbl FROM, TO - -#define PUSH(REG) pushl REG -#define POP(REG) popl REG - -#define SPILL_REGS() \ - PUSH(EBP) ; \ - PUSH(EDI) ; \ - PUSH(ESI) ; \ - PUSH(EBX) - -#define RESTORE_REGS() \ - POP(EBX) ; \ - POP(ESI) ; \ - POP(EDI) ; \ - POP(EBP) - -/* -* ALU Operations -*/ -#define IMM(VAL) $VAL - -#define ADD(TO, FROM) addl FROM, TO -#define ADD_IMM(TO, NUM) ADD(TO, IMM(NUM)) -#define ADD_W_CARRY(TO1, TO2, FROM) addl FROM, TO1; adcl IMM(0), TO2; -#define SUB_IMM(TO, NUM) subl IMM(NUM), TO -#define ADD2_IMM(TO, FROM, NUM) leal NUM(FROM), TO -#define ADD3_IMM(TO, FROM, NUM) leal NUM(TO,FROM,1), TO -#define MUL(REG) mull REG - -#define SHL_IMM(REG, SHIFT) shll IMM(SHIFT), REG -#define SHR_IMM(REG, SHIFT) shrl IMM(SHIFT), REG -#define SHL2_3(TO, FROM) leal 0(,FROM,8), TO - -#define XOR(TO, FROM) xorl FROM, TO -#define AND(TO, FROM) andl FROM, TO -#define OR(TO, FROM) orl FROM, TO -#define NOT(REG) notl REG -#define ZEROIZE(REG) XOR(REG, REG) - -#define ROTL_IMM(REG, NUM) roll IMM(NUM), REG -#define ROTR_IMM(REG, NUM) rorl IMM(NUM), REG -#define BSWAP(REG) bswapl REG - -#endif diff --git a/src/lib/utils/asm_x86_32/info.txt b/src/lib/utils/asm_x86_32/info.txt deleted file mode 100644 index 8eeefe70e..000000000 --- a/src/lib/utils/asm_x86_32/info.txt +++ /dev/null @@ -1,26 +0,0 @@ -load_on dep - -<header:internal> -asm_x86_32.h -</header:internal> - -<arch> -x86_32 -</arch> - -# ELF systems -<os> -android -linux -freebsd -dragonfly -netbsd -openbsd -solaris -</os> - -<cc> -gcc -clang -icc -</cc> diff --git a/src/lib/utils/asm_x86_64/asm_x86_64.h b/src/lib/utils/asm_x86_64/asm_x86_64.h deleted file mode 100644 index eaf4388de..000000000 --- a/src/lib/utils/asm_x86_64/asm_x86_64.h +++ /dev/null @@ -1,127 +0,0 @@ -/* -* Assembly Macros for 64-bit x86 -* (C) 1999-2008 Jack Lloyd -* -* Botan is released under the Simplified BSD License (see license.txt) -*/ - -#ifndef BOTAN_ASM_MACROS_X86_64_H__ -#define BOTAN_ASM_MACROS_X86_64_H__ - -/* -* General/Global Macros -*/ -#define ALIGN .p2align 4,,15 - -#define START_LISTING(FILENAME) \ - .file #FILENAME; \ - .text; \ - ALIGN; - -#if defined(__ELF__) -.section .note.GNU-stack,"",%progbits -#endif - -/* -* Function Definitions -*/ -#define START_FUNCTION(func_name) \ - ALIGN; \ - .global func_name; \ - .type func_name,@function; \ -func_name: - -#define END_FUNCTION(func_name) \ - ret - -/* -* Conditional Jumps -*/ -#define JUMP_IF_ZERO(REG, LABEL) \ - cmp IMM(0), REG; \ - jz LABEL - -#define JUMP_IF_LT(REG, NUM, LABEL) \ - cmp IMM(NUM), REG; \ - jl LABEL - -/* -* Register Names -*/ -#define R0 %rax -#define R1 %rbx -#define R2 %rcx -#define R2_32 %ecx -#define R3 %rdx -#define R3_32 %edx -#define R4 %rsp -#define R5 %rbp -#define R6 %rsi -#define R6_32 %esi -#define R7 %rdi -#define R8 %r8 -#define R9 %r9 -#define R9_32 %r9d -#define R10 %r10 -#define R11 %r11 -#define R12 %r12 -#define R13 %r13 -#define R14 %r14 -#define R15 %r15 -#define R16 %r16 - -#define ARG_1 R7 -#define ARG_2 R6 -#define ARG_2_32 R6_32 -#define ARG_3 R3 -#define ARG_3_32 R3_32 -#define ARG_4 R2 -#define ARG_4_32 R2_32 -#define ARG_5 R8 -#define ARG_6 R9 -#define ARG_6_32 R9_32 - -#define TEMP_1 R10 -#define TEMP_2 R11 -#define TEMP_3 ARG_6 -#define TEMP_4 ARG_5 -#define TEMP_5 ARG_4 -#define TEMP_5_32 ARG_4_32 -#define TEMP_6 ARG_3 -#define TEMP_7 ARG_2 -#define TEMP_8 ARG_1 -#define TEMP_9 R0 - -/* -* Memory Access Operations -*/ -#define ARRAY8(REG, NUM) 8*(NUM)(REG) -#define ARRAY4(REG, NUM) 4*(NUM)(REG) - -#define ASSIGN(TO, FROM) mov FROM, TO - -/* -* ALU Operations -*/ -#define IMM(VAL) $VAL - -#define ADD(TO, FROM) add FROM, TO -#define ADD_LAST_CARRY(REG) adc IMM(0), REG -#define ADD_IMM(TO, NUM) ADD(TO, IMM(NUM)) -#define ADD_W_CARRY(TO1, TO2, FROM) add FROM, TO1; adc IMM(0), TO2; -#define SUB_IMM(TO, NUM) sub IMM(NUM), TO -#define MUL(REG) mul REG - -#define XOR(TO, FROM) xor FROM, TO -#define AND(TO, FROM) and FROM, TO -#define OR(TO, FROM) or FROM, TO -#define NOT(REG) not REG -#define ZEROIZE(REG) XOR(REG, REG) - -#define RETURN_VALUE_IS(V) ASSIGN(%rax, V) - -#define ROTL_IMM(REG, NUM) rol IMM(NUM), REG -#define ROTR_IMM(REG, NUM) ror IMM(NUM), REG -#define ADD3_IMM(TO, FROM, NUM) lea NUM(TO,FROM,1), TO - -#endif diff --git a/src/lib/utils/asm_x86_64/info.txt b/src/lib/utils/asm_x86_64/info.txt deleted file mode 100644 index 8e381486d..000000000 --- a/src/lib/utils/asm_x86_64/info.txt +++ /dev/null @@ -1,24 +0,0 @@ -load_on dep - -<header:internal> -asm_x86_64.h -</header:internal> - -<arch> -x86_64 -</arch> - -<cc> -clang -gcc -icc -</cc> - -# ELF systems -<os> -android -linux -netbsd -openbsd -solaris -</os> |