2 files changed, 28 insertions, 28 deletions

diff --git a/src/rng/randpool/randpool.cpp b/src/rng/randpool/randpool.cpp
index d75885a76..51354db12 100644
--- a/src/rng/randpool/randpool.cpp
+++ b/src/rng/randpool/randpool.cpp
@@ -29,7 +29,7 @@ enum RANDPOOL_PRF_TAG {
 /*
 * Generate a buffer of random bytes
 */
-void Randpool::randomize(byte out[], u32bit length)
+void Randpool::randomize(byte out[], size_t length)
    {
    if(!is_seeded())
       throw PRNG_Unseeded(name());
@@ -37,8 +37,8 @@ void Randpool::randomize(byte out[], u32bit length)
    update_buffer();
    while(length)
       {
-      const u32bit copied = std::min(length, buffer.size());
-      copy_mem(out, buffer.begin(), copied);
+      const size_t copied = std::min<size_t>(length, buffer.size());
+      copy_mem(out, &buffer[0], copied);
       out += copied;
       length -= copied;
       update_buffer();
@@ -50,15 +50,15 @@ void Randpool::randomize(byte out[], u32bit length)
 */
 void Randpool::update_buffer()
    {
-   for(u32bit i = 0; i != counter.size(); ++i)
+   for(size_t i = 0; i != counter.size(); ++i)
       if(++counter[i])
          break;
 
    mac->update(static_cast<byte>(GEN_OUTPUT));
-   mac->update(counter, counter.size());
+   mac->update(counter);
    SecureVector<byte> mac_val = mac->final();
 
-   for(u32bit i = 0; i != mac_val.size(); ++i)
+   for(size_t i = 0; i != mac_val.size(); ++i)
       buffer[i % buffer.size()] ^= mac_val[i];
    cipher->encrypt(buffer);
 
@@ -71,22 +71,22 @@ void Randpool::update_buffer()
 */
 void Randpool::mix_pool()
    {
-   const u32bit BLOCK_SIZE = cipher->BLOCK_SIZE;
+   const size_t BLOCK_SIZE = cipher->block_size();
 
    mac->update(static_cast<byte>(MAC_KEY));
-   mac->update(pool, pool.size());
+   mac->update(pool);
    mac->set_key(mac->final());
 
    mac->update(static_cast<byte>(CIPHER_KEY));
-   mac->update(pool, pool.size());
+   mac->update(pool);
    cipher->set_key(mac->final());
 
    xor_buf(pool, buffer, BLOCK_SIZE);
    cipher->encrypt(pool);
-   for(u32bit i = 1; i != POOL_BLOCKS; ++i)
+   for(size_t i = 1; i != POOL_BLOCKS; ++i)
       {
-      const byte* previous_block = pool + BLOCK_SIZE*(i-1);
-      byte* this_block = pool + BLOCK_SIZE*i;
+      const byte* previous_block = &pool[BLOCK_SIZE*(i-1)];
+      byte* this_block = &pool[BLOCK_SIZE*i];
       xor_buf(this_block, previous_block, BLOCK_SIZE);
       cipher->encrypt(this_block);
       }
@@ -97,13 +97,13 @@ void Randpool::mix_pool()
 /*
 * Reseed the internal state
 */
-void Randpool::reseed(u32bit poll_bits)
+void Randpool::reseed(size_t poll_bits)
    {
    Entropy_Accumulator_BufferedComputation accum(*mac, poll_bits);
 
    if(!entropy_sources.empty())
       {
-      u32bit poll_attempt = 0;
+      size_t poll_attempt = 0;
 
       while(!accum.polling_goal_achieved() && poll_attempt < poll_bits)
          {
@@ -124,7 +124,7 @@ void Randpool::reseed(u32bit poll_bits)
 /*
 * Add user-supplied entropy
 */
-void Randpool::add_entropy(const byte input[], u32bit length)
+void Randpool::add_entropy(const byte input[], size_t length)
    {
    SecureVector<byte> mac_val = mac->process(input, length);
    xor_buf(pool, mac_val, mac_val.size());
@@ -149,9 +149,9 @@ void Randpool::clear()
    {
    cipher->clear();
    mac->clear();
-   pool.clear();
-   buffer.clear();
-   counter.clear();
+   zeroise(pool);
+   zeroise(buffer);
+   zeroise(counter);
    seeded = false;
    }
 
@@ -168,15 +168,15 @@ std::string Randpool::name() const
 */
 Randpool::Randpool(BlockCipher* cipher_in,
                    MessageAuthenticationCode* mac_in,
-                   u32bit pool_blocks,
-                   u32bit iter_before_reseed) :
+                   size_t pool_blocks,
+                   size_t iter_before_reseed) :
    ITERATIONS_BEFORE_RESEED(iter_before_reseed),
    POOL_BLOCKS(pool_blocks),
    cipher(cipher_in),
    mac(mac_in)
    {
-   const u32bit BLOCK_SIZE = cipher->BLOCK_SIZE;
-   const u32bit OUTPUT_LENGTH = mac->OUTPUT_LENGTH;
+   const size_t BLOCK_SIZE = cipher->block_size();
+   const size_t OUTPUT_LENGTH = mac->output_length();
 
    if(OUTPUT_LENGTH < BLOCK_SIZE ||
       !cipher->valid_keylength(OUTPUT_LENGTH) ||
diff --git a/src/rng/randpool/randpool.h b/src/rng/randpool/randpool.h
index 471bb791a..ed224221c 100644
--- a/src/rng/randpool/randpool.h
+++ b/src/rng/randpool/randpool.h
@@ -21,14 +21,14 @@ namespace Botan {
 class BOTAN_DLL Randpool : public RandomNumberGenerator
    {
    public:
-      void randomize(byte[], u32bit);
+      void randomize(byte[], size_t);
       bool is_seeded() const { return seeded; }
       void clear();
       std::string name() const;
 
-      void reseed(u32bit bits_to_collect);
+      void reseed(size_t bits_to_collect);
       void add_entropy_source(EntropySource* es);
-      void add_entropy(const byte input[], u32bit length);
+      void add_entropy(const byte input[], size_t length);
 
       /**
       * @param cipher a block cipher to use
@@ -39,15 +39,15 @@ class BOTAN_DLL Randpool : public RandomNumberGenerator
       */
       Randpool(BlockCipher* cipher,
                MessageAuthenticationCode* mac,
-               u32bit pool_blocks = 32,
-               u32bit iterations_before_reseed = 128);
+               size_t pool_blocks = 32,
+               size_t iterations_before_reseed = 128);
 
       ~Randpool();
    private:
       void update_buffer();
       void mix_pool();
 
-      u32bit ITERATIONS_BEFORE_RESEED, POOL_BLOCKS;
+      size_t ITERATIONS_BEFORE_RESEED, POOL_BLOCKS;
       BlockCipher* cipher;
       MessageAuthenticationCode* mac;