propagate from branch 'net.randombit.botan.1_8' (head 6e8c18515725a70923b34118951252723dd4c29a)

            to branch 'net.randombit.botan' (head 77ba4ea5a4be36d6d029bcc852b2271edff0d679)

5 files changed, 142 insertions, 126 deletions

diff --git a/src/block/cast/cast128.cpp b/src/block/cast/cast128.cpp
index 046638ab9..887dcf994 100644
--- a/src/block/cast/cast128.cpp
+++ b/src/block/cast/cast128.cpp
@@ -48,57 +48,69 @@ inline void R3(u32bit& L, u32bit R, u32bit MK, u32bit RK)
 /*
 * CAST-128 Encryption
 */
-void CAST_128::enc(const byte in[], byte out[]) const
+void CAST_128::encrypt_n(const byte in[], byte out[], u32bit blocks) const
    {
-   u32bit L = load_be<u32bit>(in, 0);
-   u32bit R = load_be<u32bit>(in, 1);
-
-   R1(L, R, MK[ 0], RK[ 0]);
-   R2(R, L, MK[ 1], RK[ 1]);
-   R3(L, R, MK[ 2], RK[ 2]);
-   R1(R, L, MK[ 3], RK[ 3]);
-   R2(L, R, MK[ 4], RK[ 4]);
-   R3(R, L, MK[ 5], RK[ 5]);
-   R1(L, R, MK[ 6], RK[ 6]);
-   R2(R, L, MK[ 7], RK[ 7]);
-   R3(L, R, MK[ 8], RK[ 8]);
-   R1(R, L, MK[ 9], RK[ 9]);
-   R2(L, R, MK[10], RK[10]);
-   R3(R, L, MK[11], RK[11]);
-   R1(L, R, MK[12], RK[12]);
-   R2(R, L, MK[13], RK[13]);
-   R3(L, R, MK[14], RK[14]);
-   R1(R, L, MK[15], RK[15]);
-
-   store_be(out, R, L);
+   for(u32bit i = 0; i != blocks; ++i)
+      {
+      u32bit L = load_be<u32bit>(in, 0);
+      u32bit R = load_be<u32bit>(in, 1);
+
+      R1(L, R, MK[ 0], RK[ 0]);
+      R2(R, L, MK[ 1], RK[ 1]);
+      R3(L, R, MK[ 2], RK[ 2]);
+      R1(R, L, MK[ 3], RK[ 3]);
+      R2(L, R, MK[ 4], RK[ 4]);
+      R3(R, L, MK[ 5], RK[ 5]);
+      R1(L, R, MK[ 6], RK[ 6]);
+      R2(R, L, MK[ 7], RK[ 7]);
+      R3(L, R, MK[ 8], RK[ 8]);
+      R1(R, L, MK[ 9], RK[ 9]);
+      R2(L, R, MK[10], RK[10]);
+      R3(R, L, MK[11], RK[11]);
+      R1(L, R, MK[12], RK[12]);
+      R2(R, L, MK[13], RK[13]);
+      R3(L, R, MK[14], RK[14]);
+      R1(R, L, MK[15], RK[15]);
+
+      store_be(out, R, L);
+
+      in += BLOCK_SIZE;
+      out += BLOCK_SIZE;
+      }
    }
 
 /*
 * CAST-128 Decryption
 */
-void CAST_128::dec(const byte in[], byte out[]) const
+void CAST_128::decrypt_n(const byte in[], byte out[], u32bit blocks) const
    {
-   u32bit L = load_be<u32bit>(in, 0);
-   u32bit R = load_be<u32bit>(in, 1);
-
-   R1(L, R, MK[15], RK[15]);
-   R3(R, L, MK[14], RK[14]);
-   R2(L, R, MK[13], RK[13]);
-   R1(R, L, MK[12], RK[12]);
-   R3(L, R, MK[11], RK[11]);
-   R2(R, L, MK[10], RK[10]);
-   R1(L, R, MK[ 9], RK[ 9]);
-   R3(R, L, MK[ 8], RK[ 8]);
-   R2(L, R, MK[ 7], RK[ 7]);
-   R1(R, L, MK[ 6], RK[ 6]);
-   R3(L, R, MK[ 5], RK[ 5]);
-   R2(R, L, MK[ 4], RK[ 4]);
-   R1(L, R, MK[ 3], RK[ 3]);
-   R3(R, L, MK[ 2], RK[ 2]);
-   R2(L, R, MK[ 1], RK[ 1]);
-   R1(R, L, MK[ 0], RK[ 0]);
-
-   store_be(out, R, L);
+   for(u32bit i = 0; i != blocks; ++i)
+      {
+      u32bit L = load_be<u32bit>(in, 0);
+      u32bit R = load_be<u32bit>(in, 1);
+
+      R1(L, R, MK[15], RK[15]);
+      R3(R, L, MK[14], RK[14]);
+      R2(L, R, MK[13], RK[13]);
+      R1(R, L, MK[12], RK[12]);
+      R3(L, R, MK[11], RK[11]);
+      R2(R, L, MK[10], RK[10]);
+      R1(L, R, MK[ 9], RK[ 9]);
+      R3(R, L, MK[ 8], RK[ 8]);
+      R2(L, R, MK[ 7], RK[ 7]);
+      R1(R, L, MK[ 6], RK[ 6]);
+      R3(L, R, MK[ 5], RK[ 5]);
+      R2(R, L, MK[ 4], RK[ 4]);
+      R1(L, R, MK[ 3], RK[ 3]);
+      R3(R, L, MK[ 2], RK[ 2]);
+      R2(L, R, MK[ 1], RK[ 1]);
+      R1(R, L, MK[ 0], RK[ 0]);
+
+      store_be(out, R, L);
+
+      in += BLOCK_SIZE;
+      out += BLOCK_SIZE;
+      }
    }
 
 /*
diff --git a/src/block/cast/cast128.h b/src/block/cast/cast128.h
index 680481482..caffb97ea 100644
--- a/src/block/cast/cast128.h
+++ b/src/block/cast/cast128.h
@@ -18,13 +18,15 @@ namespace Botan {
 class BOTAN_DLL CAST_128 : public BlockCipher
    {
    public:
-      void clear() throw() { MK.clear(); RK.clear(); }
+      void encrypt_n(const byte in[], byte out[], u32bit blocks) const;
+      void decrypt_n(const byte in[], byte out[], u32bit blocks) const;
+
+      void clear() { MK.clear(); RK.clear(); }
       std::string name() const { return "CAST-128"; }
       BlockCipher* clone() const { return new CAST_128; }
+
       CAST_128() : BlockCipher(8, 11, 16) {}
    private:
-      void enc(const byte[], byte[]) const;
-      void dec(const byte[], byte[]) const;
       void key_schedule(const byte[], u32bit);
 
       static void key_schedule(u32bit[16], u32bit[4]);
diff --git a/src/block/cast/cast256.cpp b/src/block/cast/cast256.cpp
index 22ff876fa..7a4a4e805 100644
--- a/src/block/cast/cast256.cpp
+++ b/src/block/cast/cast256.cpp
@@ -48,77 +48,89 @@ void round3(u32bit& out, u32bit in, u32bit mask, u32bit rot)
 /*
 * CAST-256 Encryption
 */
-void CAST_256::enc(const byte in[], byte out[]) const
+void CAST_256::encrypt_n(const byte in[], byte out[], u32bit blocks) const
    {
-   u32bit A = load_be<u32bit>(in, 0);
-   u32bit B = load_be<u32bit>(in, 1);
-   u32bit C = load_be<u32bit>(in, 2);
-   u32bit D = load_be<u32bit>(in, 3);
-
-   round1(C, D, MK[ 0], RK[ 0]); round2(B, C, MK[ 1], RK[ 1]);
-   round3(A, B, MK[ 2], RK[ 2]); round1(D, A, MK[ 3], RK[ 3]);
-   round1(C, D, MK[ 4], RK[ 4]); round2(B, C, MK[ 5], RK[ 5]);
-   round3(A, B, MK[ 6], RK[ 6]); round1(D, A, MK[ 7], RK[ 7]);
-   round1(C, D, MK[ 8], RK[ 8]); round2(B, C, MK[ 9], RK[ 9]);
-   round3(A, B, MK[10], RK[10]); round1(D, A, MK[11], RK[11]);
-   round1(C, D, MK[12], RK[12]); round2(B, C, MK[13], RK[13]);
-   round3(A, B, MK[14], RK[14]); round1(D, A, MK[15], RK[15]);
-   round1(C, D, MK[16], RK[16]); round2(B, C, MK[17], RK[17]);
-   round3(A, B, MK[18], RK[18]); round1(D, A, MK[19], RK[19]);
-   round1(C, D, MK[20], RK[20]); round2(B, C, MK[21], RK[21]);
-   round3(A, B, MK[22], RK[22]); round1(D, A, MK[23], RK[23]);
-   round1(D, A, MK[27], RK[27]); round3(A, B, MK[26], RK[26]);
-   round2(B, C, MK[25], RK[25]); round1(C, D, MK[24], RK[24]);
-   round1(D, A, MK[31], RK[31]); round3(A, B, MK[30], RK[30]);
-   round2(B, C, MK[29], RK[29]); round1(C, D, MK[28], RK[28]);
-   round1(D, A, MK[35], RK[35]); round3(A, B, MK[34], RK[34]);
-   round2(B, C, MK[33], RK[33]); round1(C, D, MK[32], RK[32]);
-   round1(D, A, MK[39], RK[39]); round3(A, B, MK[38], RK[38]);
-   round2(B, C, MK[37], RK[37]); round1(C, D, MK[36], RK[36]);
-   round1(D, A, MK[43], RK[43]); round3(A, B, MK[42], RK[42]);
-   round2(B, C, MK[41], RK[41]); round1(C, D, MK[40], RK[40]);
-   round1(D, A, MK[47], RK[47]); round3(A, B, MK[46], RK[46]);
-   round2(B, C, MK[45], RK[45]); round1(C, D, MK[44], RK[44]);
-
-   store_be(out, A, B, C, D);
+   for(u32bit i = 0; i != blocks; ++i)
+      {
+      u32bit A = load_be<u32bit>(in, 0);
+      u32bit B = load_be<u32bit>(in, 1);
+      u32bit C = load_be<u32bit>(in, 2);
+      u32bit D = load_be<u32bit>(in, 3);
+
+      round1(C, D, MK[ 0], RK[ 0]); round2(B, C, MK[ 1], RK[ 1]);
+      round3(A, B, MK[ 2], RK[ 2]); round1(D, A, MK[ 3], RK[ 3]);
+      round1(C, D, MK[ 4], RK[ 4]); round2(B, C, MK[ 5], RK[ 5]);
+      round3(A, B, MK[ 6], RK[ 6]); round1(D, A, MK[ 7], RK[ 7]);
+      round1(C, D, MK[ 8], RK[ 8]); round2(B, C, MK[ 9], RK[ 9]);
+      round3(A, B, MK[10], RK[10]); round1(D, A, MK[11], RK[11]);
+      round1(C, D, MK[12], RK[12]); round2(B, C, MK[13], RK[13]);
+      round3(A, B, MK[14], RK[14]); round1(D, A, MK[15], RK[15]);
+      round1(C, D, MK[16], RK[16]); round2(B, C, MK[17], RK[17]);
+      round3(A, B, MK[18], RK[18]); round1(D, A, MK[19], RK[19]);
+      round1(C, D, MK[20], RK[20]); round2(B, C, MK[21], RK[21]);
+      round3(A, B, MK[22], RK[22]); round1(D, A, MK[23], RK[23]);
+      round1(D, A, MK[27], RK[27]); round3(A, B, MK[26], RK[26]);
+      round2(B, C, MK[25], RK[25]); round1(C, D, MK[24], RK[24]);
+      round1(D, A, MK[31], RK[31]); round3(A, B, MK[30], RK[30]);
+      round2(B, C, MK[29], RK[29]); round1(C, D, MK[28], RK[28]);
+      round1(D, A, MK[35], RK[35]); round3(A, B, MK[34], RK[34]);
+      round2(B, C, MK[33], RK[33]); round1(C, D, MK[32], RK[32]);
+      round1(D, A, MK[39], RK[39]); round3(A, B, MK[38], RK[38]);
+      round2(B, C, MK[37], RK[37]); round1(C, D, MK[36], RK[36]);
+      round1(D, A, MK[43], RK[43]); round3(A, B, MK[42], RK[42]);
+      round2(B, C, MK[41], RK[41]); round1(C, D, MK[40], RK[40]);
+      round1(D, A, MK[47], RK[47]); round3(A, B, MK[46], RK[46]);
+      round2(B, C, MK[45], RK[45]); round1(C, D, MK[44], RK[44]);
+
+      store_be(out, A, B, C, D);
+
+      in += BLOCK_SIZE;
+      out += BLOCK_SIZE;
+      }
    }
 
 /*
 * CAST-256 Decryption
 */
-void CAST_256::dec(const byte in[], byte out[]) const
+void CAST_256::decrypt_n(const byte in[], byte out[], u32bit blocks) const
    {
-   u32bit A = load_be<u32bit>(in, 0);
-   u32bit B = load_be<u32bit>(in, 1);
-   u32bit C = load_be<u32bit>(in, 2);
-   u32bit D = load_be<u32bit>(in, 3);
-
-   round1(C, D, MK[44], RK[44]); round2(B, C, MK[45], RK[45]);
-   round3(A, B, MK[46], RK[46]); round1(D, A, MK[47], RK[47]);
-   round1(C, D, MK[40], RK[40]); round2(B, C, MK[41], RK[41]);
-   round3(A, B, MK[42], RK[42]); round1(D, A, MK[43], RK[43]);
-   round1(C, D, MK[36], RK[36]); round2(B, C, MK[37], RK[37]);
-   round3(A, B, MK[38], RK[38]); round1(D, A, MK[39], RK[39]);
-   round1(C, D, MK[32], RK[32]); round2(B, C, MK[33], RK[33]);
-   round3(A, B, MK[34], RK[34]); round1(D, A, MK[35], RK[35]);
-   round1(C, D, MK[28], RK[28]); round2(B, C, MK[29], RK[29]);
-   round3(A, B, MK[30], RK[30]); round1(D, A, MK[31], RK[31]);
-   round1(C, D, MK[24], RK[24]); round2(B, C, MK[25], RK[25]);
-   round3(A, B, MK[26], RK[26]); round1(D, A, MK[27], RK[27]);
-   round1(D, A, MK[23], RK[23]); round3(A, B, MK[22], RK[22]);
-   round2(B, C, MK[21], RK[21]); round1(C, D, MK[20], RK[20]);
-   round1(D, A, MK[19], RK[19]); round3(A, B, MK[18], RK[18]);
-   round2(B, C, MK[17], RK[17]); round1(C, D, MK[16], RK[16]);
-   round1(D, A, MK[15], RK[15]); round3(A, B, MK[14], RK[14]);
-   round2(B, C, MK[13], RK[13]); round1(C, D, MK[12], RK[12]);
-   round1(D, A, MK[11], RK[11]); round3(A, B, MK[10], RK[10]);
-   round2(B, C, MK[ 9], RK[ 9]); round1(C, D, MK[ 8], RK[ 8]);
-   round1(D, A, MK[ 7], RK[ 7]); round3(A, B, MK[ 6], RK[ 6]);
-   round2(B, C, MK[ 5], RK[ 5]); round1(C, D, MK[ 4], RK[ 4]);
-   round1(D, A, MK[ 3], RK[ 3]); round3(A, B, MK[ 2], RK[ 2]);
-   round2(B, C, MK[ 1], RK[ 1]); round1(C, D, MK[ 0], RK[ 0]);
-
-   store_be(out, A, B, C, D);
+   for(u32bit i = 0; i != blocks; ++i)
+      {
+      u32bit A = load_be<u32bit>(in, 0);
+      u32bit B = load_be<u32bit>(in, 1);
+      u32bit C = load_be<u32bit>(in, 2);
+      u32bit D = load_be<u32bit>(in, 3);
+
+      round1(C, D, MK[44], RK[44]); round2(B, C, MK[45], RK[45]);
+      round3(A, B, MK[46], RK[46]); round1(D, A, MK[47], RK[47]);
+      round1(C, D, MK[40], RK[40]); round2(B, C, MK[41], RK[41]);
+      round3(A, B, MK[42], RK[42]); round1(D, A, MK[43], RK[43]);
+      round1(C, D, MK[36], RK[36]); round2(B, C, MK[37], RK[37]);
+      round3(A, B, MK[38], RK[38]); round1(D, A, MK[39], RK[39]);
+      round1(C, D, MK[32], RK[32]); round2(B, C, MK[33], RK[33]);
+      round3(A, B, MK[34], RK[34]); round1(D, A, MK[35], RK[35]);
+      round1(C, D, MK[28], RK[28]); round2(B, C, MK[29], RK[29]);
+      round3(A, B, MK[30], RK[30]); round1(D, A, MK[31], RK[31]);
+      round1(C, D, MK[24], RK[24]); round2(B, C, MK[25], RK[25]);
+      round3(A, B, MK[26], RK[26]); round1(D, A, MK[27], RK[27]);
+      round1(D, A, MK[23], RK[23]); round3(A, B, MK[22], RK[22]);
+      round2(B, C, MK[21], RK[21]); round1(C, D, MK[20], RK[20]);
+      round1(D, A, MK[19], RK[19]); round3(A, B, MK[18], RK[18]);
+      round2(B, C, MK[17], RK[17]); round1(C, D, MK[16], RK[16]);
+      round1(D, A, MK[15], RK[15]); round3(A, B, MK[14], RK[14]);
+      round2(B, C, MK[13], RK[13]); round1(C, D, MK[12], RK[12]);
+      round1(D, A, MK[11], RK[11]); round3(A, B, MK[10], RK[10]);
+      round2(B, C, MK[ 9], RK[ 9]); round1(C, D, MK[ 8], RK[ 8]);
+      round1(D, A, MK[ 7], RK[ 7]); round3(A, B, MK[ 6], RK[ 6]);
+      round2(B, C, MK[ 5], RK[ 5]); round1(C, D, MK[ 4], RK[ 4]);
+      round1(D, A, MK[ 3], RK[ 3]); round3(A, B, MK[ 2], RK[ 2]);
+      round2(B, C, MK[ 1], RK[ 1]); round1(C, D, MK[ 0], RK[ 0]);
+
+      store_be(out, A, B, C, D);
+
+      in += BLOCK_SIZE;
+      out += BLOCK_SIZE;
+      }
    }
 
 /*
diff --git a/src/block/cast/cast256.h b/src/block/cast/cast256.h
index cd48edd5e..0db3682ba 100644
--- a/src/block/cast/cast256.h
+++ b/src/block/cast/cast256.h
@@ -18,13 +18,15 @@ namespace Botan {
 class BOTAN_DLL CAST_256 : public BlockCipher
    {
    public:
-      void clear() throw() { MK.clear(); RK.clear(); }
+      void encrypt_n(const byte in[], byte out[], u32bit blocks) const;
+      void decrypt_n(const byte in[], byte out[], u32bit blocks) const;
+
+      void clear() { MK.clear(); RK.clear(); }
       std::string name() const { return "CAST-256"; }
       BlockCipher* clone() const { return new CAST_256; }
+
       CAST_256() : BlockCipher(16, 4, 32, 4) {}
    private:
-      void enc(const byte[], byte[]) const;
-      void dec(const byte[], byte[]) const;
       void key_schedule(const byte[], u32bit);
 
       static const u32bit KEY_MASK[192];
diff --git a/src/block/cast/info.txt b/src/block/cast/info.txt
index 73d3f900f..faba491c2 100644
--- a/src/block/cast/info.txt
+++ b/src/block/cast/info.txt
@@ -1,13 +1 @@
-realname "CAST"
-
 define CAST
-
-load_on auto
-
-<add>
-cast128.cpp
-cast128.h
-cast256.cpp
-cast256.h
-cast_tab.cpp
-</add>