propagate from branch 'net.randombit.botan' (head af0e75a6f88cf5c3e0c53f949ae83242dedc5786)

            to branch 'net.randombit.botan.c++0x' (head 5543a042e04c7ff88a110c7271918488b13342f1)

3 files changed, 33 insertions, 13 deletions

diff --git a/src/cert/cvc/cvc_self.cpp b/src/cert/cvc/cvc_self.cpp
index 0052651c9..dae8f1804 100644
--- a/src/cert/cvc/cvc_self.cpp
+++ b/src/cert/cvc/cvc_self.cpp
@@ -80,7 +80,7 @@ EAC1_1_CVC create_self_signed_cert(Private_Key const& key,
    ASN1_Chr chr(opt.car.value());
 
    AlgorithmIdentifier sig_algo;
-   std::string padding_and_hash(eac_cvc_emsa + "(" + opt.hash_alg + ")");
+   std::string padding_and_hash("EMSA1_BSI(" + opt.hash_alg + ")");
    sig_algo.oid = OIDS::lookup(priv_key->algo_name() + "/" + padding_and_hash);
    sig_algo = AlgorithmIdentifier(sig_algo.oid, AlgorithmIdentifier::USE_NULL_PARAM);
 
@@ -111,7 +111,7 @@ EAC1_1_Req create_cvc_req(Private_Key const& key,
       throw Invalid_Argument("CVC_EAC::create_self_signed_cert(): unsupported key type");
       }
    AlgorithmIdentifier sig_algo;
-   std::string padding_and_hash(eac_cvc_emsa + "(" + hash_alg + ")");
+   std::string padding_and_hash("EMSA1_BSI(" + hash_alg + ")");
    sig_algo.oid = OIDS::lookup(priv_key->algo_name() + "/" + padding_and_hash);
    sig_algo = AlgorithmIdentifier(sig_algo.oid, AlgorithmIdentifier::USE_NULL_PARAM);
 
diff --git a/src/cert/cvc/eac_obj.h b/src/cert/cvc/eac_obj.h
index f822442bc..74d7460dd 100644
--- a/src/cert/cvc/eac_obj.h
+++ b/src/cert/cvc/eac_obj.h
@@ -23,8 +23,6 @@
 
 namespace Botan {
 
-const std::string eac_cvc_emsa("EMSA1_BSI");
-
 /*
 * TR03110 v1.1 EAC CV Certificate
 */
diff --git a/src/filters/modes/xts/xts.cpp b/src/filters/modes/xts/xts.cpp
index cfea0b34b..68eb0c482 100644
--- a/src/filters/modes/xts/xts.cpp
+++ b/src/filters/modes/xts/xts.cpp
@@ -176,6 +176,18 @@ void XTS_Encryption::buffered_final(const byte input[], u32bit length)
       }
    else
       { // steal ciphertext
+
+      u32bit leftover_blocks =
+         ((length / cipher->BLOCK_SIZE) - 1) * cipher->BLOCK_SIZE;
+
+      buffered_block(input, leftover_blocks);
+
+      input += leftover_blocks;
+      length -= leftover_blocks;
+
+      if(length >= 2*cipher->BLOCK_SIZE)
+         throw std::runtime_error("Die vampire die");
+
       SecureVector<byte> temp(input, length);
 
       xor_buf(temp, tweak, cipher->BLOCK_SIZE);
@@ -201,7 +213,8 @@ void XTS_Encryption::buffered_final(const byte input[], u32bit length)
 * XTS_Decryption constructor
 */
 XTS_Decryption::XTS_Decryption(BlockCipher* ciph) :
-   Buffered_Filter(BOTAN_PARALLEL_BLOCKS_XTS * ciph->BLOCK_SIZE, 1)
+   Buffered_Filter(BOTAN_PARALLEL_BLOCKS_XTS * ciph->BLOCK_SIZE,
+                   ciph->BLOCK_SIZE + 1)
    {
    cipher = ciph;
    cipher2 = ciph->clone();
@@ -214,7 +227,8 @@ XTS_Decryption::XTS_Decryption(BlockCipher* ciph) :
 XTS_Decryption::XTS_Decryption(BlockCipher* ciph,
                                const SymmetricKey& key,
                                const InitializationVector& iv) :
-   Buffered_Filter(BOTAN_PARALLEL_BLOCKS_XTS * ciph->BLOCK_SIZE, 1)
+   Buffered_Filter(BOTAN_PARALLEL_BLOCKS_XTS * ciph->BLOCK_SIZE,
+                   ciph->BLOCK_SIZE + 1)
    {
    cipher = ciph;
    cipher2 = ciph->clone();
@@ -320,18 +334,26 @@ void XTS_Decryption::buffered_block(const byte input[], u32bit input_length)
       }
    }
 
-void XTS_Decryption::buffered_final(const byte input[], u32bit input_length)
+void XTS_Decryption::buffered_final(const byte input[], u32bit length)
    {
-   if(input_length <= cipher->BLOCK_SIZE)
+   if(length <= cipher->BLOCK_SIZE)
       throw Decoding_Error("XTS_Decryption: insufficient data to decrypt");
 
-   if(input_length % cipher->BLOCK_SIZE == 0)
+   if(length % cipher->BLOCK_SIZE == 0)
       {
-      buffered_block(input, input_length);
+      buffered_block(input, length);
       }
    else
       {
-      SecureVector<byte> temp(input, input_length);
+      u32bit leftover_blocks =
+         ((length / cipher->BLOCK_SIZE) - 1) * cipher->BLOCK_SIZE;
+
+      buffered_block(input, leftover_blocks);
+
+      input += leftover_blocks;
+      length -= leftover_blocks;
+
+      SecureVector<byte> temp(input, length);
       SecureVector<byte> tweak_copy(&tweak[0], cipher->BLOCK_SIZE);
 
       poly_double(tweak_copy, cipher->BLOCK_SIZE);
@@ -340,14 +362,14 @@ void XTS_Decryption::buffered_final(const byte input[], u32bit input_length)
       cipher->decrypt(temp);
       xor_buf(temp, tweak_copy, cipher->BLOCK_SIZE);
 
-      for(u32bit i = 0; i != input_length - cipher->BLOCK_SIZE; ++i)
+      for(u32bit i = 0; i != length - cipher->BLOCK_SIZE; ++i)
          std::swap(temp[i], temp[i + cipher->BLOCK_SIZE]);
 
       xor_buf(temp, tweak, cipher->BLOCK_SIZE);
       cipher->decrypt(temp);
       xor_buf(temp, tweak, cipher->BLOCK_SIZE);
 
-      send(temp, input_length);
+      send(temp, length);
       }
 
    buffer_reset();