Convert to using standard uintN_t integer types

Renames a couple of functions for somewhat better name consistency,
eg make_u32bit becomes make_uint32. The old typedefs remain for now
since probably lots of application code uses them.

25 files changed, 216 insertions, 216 deletions

diff --git a/src/lib/pk_pad/eme.cpp b/src/lib/pk_pad/eme.cpp
index eab9862af..85efe1615 100644
--- a/src/lib/pk_pad/eme.cpp
+++ b/src/lib/pk_pad/eme.cpp
@@ -56,7 +56,7 @@ EME* get_eme(const std::string& algo_spec)
 /*
 * Encode a message
 */
-secure_vector<byte> EME::encode(const byte msg[], size_t msg_len,
+secure_vector<uint8_t> EME::encode(const uint8_t msg[], size_t msg_len,
                                 size_t key_bits,
                                 RandomNumberGenerator& rng) const
    {
@@ -66,7 +66,7 @@ secure_vector<byte> EME::encode(const byte msg[], size_t msg_len,
 /*
 * Encode a message
 */
-secure_vector<byte> EME::encode(const secure_vector<byte>& msg,
+secure_vector<uint8_t> EME::encode(const secure_vector<uint8_t>& msg,
                                 size_t key_bits,
                                 RandomNumberGenerator& rng) const
    {
diff --git a/src/lib/pk_pad/eme.h b/src/lib/pk_pad/eme.h
index a5ad27b4e..e9b4386ab 100644
--- a/src/lib/pk_pad/eme.h
+++ b/src/lib/pk_pad/eme.h
@@ -36,7 +36,7 @@ class BOTAN_DLL EME
       * @param rng a random number generator
       * @return encoded plaintext
       */
-      secure_vector<byte> encode(const byte in[],
+      secure_vector<uint8_t> encode(const uint8_t in[],
                                  size_t in_length,
                                  size_t key_length,
                                  RandomNumberGenerator& rng) const;
@@ -48,7 +48,7 @@ class BOTAN_DLL EME
       * @param rng a random number generator
       * @return encoded plaintext
       */
-      secure_vector<byte> encode(const secure_vector<byte>& in,
+      secure_vector<uint8_t> encode(const secure_vector<uint8_t>& in,
                                  size_t key_length,
                                  RandomNumberGenerator& rng) const;
 
@@ -60,8 +60,8 @@ class BOTAN_DLL EME
       * @return bytes of out[] written to along with
       *         validity mask (0xFF if valid, else 0x00)
       */
-      virtual secure_vector<byte> unpad(byte& valid_mask,
-                                        const byte in[],
+      virtual secure_vector<uint8_t> unpad(uint8_t& valid_mask,
+                                        const uint8_t in[],
                                         size_t in_len) const = 0;
 
       /**
@@ -72,7 +72,7 @@ class BOTAN_DLL EME
       * @param rng a random number generator
       * @return encoded plaintext
       */
-      virtual secure_vector<byte> pad(const byte in[],
+      virtual secure_vector<uint8_t> pad(const uint8_t in[],
                                       size_t in_length,
                                       size_t key_length,
                                       RandomNumberGenerator& rng) const = 0;
diff --git a/src/lib/pk_pad/eme_oaep/oaep.cpp b/src/lib/pk_pad/eme_oaep/oaep.cpp
index f58254fdd..ef2fb81bb 100644
--- a/src/lib/pk_pad/eme_oaep/oaep.cpp
+++ b/src/lib/pk_pad/eme_oaep/oaep.cpp
@@ -14,7 +14,7 @@ namespace Botan {
 /*
 * OAEP Pad Operation
 */
-secure_vector<byte> OAEP::pad(const byte in[], size_t in_length,
+secure_vector<uint8_t> OAEP::pad(const uint8_t in[], size_t in_length,
                              size_t key_length,
                              RandomNumberGenerator& rng) const
    {
@@ -25,7 +25,7 @@ secure_vector<byte> OAEP::pad(const byte in[], size_t in_length,
       throw Invalid_Argument("OAEP: Input is too large");
       }
 
-   secure_vector<byte> out(key_length);
+   secure_vector<uint8_t> out(key_length);
 
    rng.randomize(out.data(), m_Phash.size());
 
@@ -47,8 +47,8 @@ secure_vector<byte> OAEP::pad(const byte in[], size_t in_length,
 /*
 * OAEP Unpad Operation
 */
-secure_vector<byte> OAEP::unpad(byte& valid_mask,
-                                const byte in[], size_t in_length) const
+secure_vector<uint8_t> OAEP::unpad(uint8_t& valid_mask,
+                                const uint8_t in[], size_t in_length) const
    {
    /*
    Must be careful about error messages here; if an attacker can
@@ -70,9 +70,9 @@ secure_vector<byte> OAEP::unpad(byte& valid_mask,
    Therefore, the first byte can always be skipped safely.
    */
 
-   byte skip_first = CT::is_zero<byte>(in[0]) & 0x01;
+   uint8_t skip_first = CT::is_zero<uint8_t>(in[0]) & 0x01;
    
-   secure_vector<byte> input(in + skip_first, in + in_length);
+   secure_vector<uint8_t> input(in + skip_first, in + in_length);
 
    CT::poison(input.data(), input.size());
 
@@ -87,26 +87,26 @@ secure_vector<byte> OAEP::unpad(byte& valid_mask,
              &input[hlen], input.size() - hlen);
 
    size_t delim_idx = 2 * hlen;
-   byte waiting_for_delim = 0xFF;
-   byte bad_input = 0;
+   uint8_t waiting_for_delim = 0xFF;
+   uint8_t bad_input = 0;
 
    for(size_t i = delim_idx; i < input.size(); ++i)
       {
-      const byte zero_m = CT::is_zero<byte>(input[i]);
-      const byte one_m = CT::is_equal<byte>(input[i], 1);
+      const uint8_t zero_m = CT::is_zero<uint8_t>(input[i]);
+      const uint8_t one_m = CT::is_equal<uint8_t>(input[i], 1);
 
-      const byte add_m = waiting_for_delim & zero_m;
+      const uint8_t add_m = waiting_for_delim & zero_m;
 
       bad_input |= waiting_for_delim & ~(zero_m | one_m);
 
-      delim_idx += CT::select<byte>(add_m, 1, 0);
+      delim_idx += CT::select<uint8_t>(add_m, 1, 0);
 
       waiting_for_delim &= zero_m;
       }
 
    // If we never saw any non-zero byte, then it's not valid input
    bad_input |= waiting_for_delim;
-   bad_input |= CT::is_equal<byte>(same_mem(&input[hlen], m_Phash.data(), hlen), false);
+   bad_input |= CT::is_equal<uint8_t>(same_mem(&input[hlen], m_Phash.data(), hlen), false);
 
    CT::unpoison(input.data(), input.size());
    CT::unpoison(&bad_input, 1);
@@ -114,7 +114,7 @@ secure_vector<byte> OAEP::unpad(byte& valid_mask,
 
    valid_mask = ~bad_input;
 
-   secure_vector<byte> output(input.begin() + delim_idx + 1, input.end());
+   secure_vector<uint8_t> output(input.begin() + delim_idx + 1, input.end());
    CT::cond_zero_mem(bad_input, output.data(), output.size());
 
    return output;
diff --git a/src/lib/pk_pad/eme_oaep/oaep.h b/src/lib/pk_pad/eme_oaep/oaep.h
index 3e476f6a3..9cd213eab 100644
--- a/src/lib/pk_pad/eme_oaep/oaep.h
+++ b/src/lib/pk_pad/eme_oaep/oaep.h
@@ -27,16 +27,16 @@ class BOTAN_DLL OAEP final : public EME
       */
       OAEP(HashFunction* hash, const std::string& P = "");
    private:
-      secure_vector<byte> pad(const byte in[],
+      secure_vector<uint8_t> pad(const uint8_t in[],
                               size_t in_length,
                               size_t key_length,
                               RandomNumberGenerator& rng) const override;
 
-      secure_vector<byte> unpad(byte& valid_mask,
-                                const byte in[],
+      secure_vector<uint8_t> unpad(uint8_t& valid_mask,
+                                const uint8_t in[],
                                 size_t in_len) const override;
 
-      secure_vector<byte> m_Phash;
+      secure_vector<uint8_t> m_Phash;
       std::unique_ptr<HashFunction> m_hash;
    };
 
diff --git a/src/lib/pk_pad/eme_pkcs1/eme_pkcs.cpp b/src/lib/pk_pad/eme_pkcs1/eme_pkcs.cpp
index 2b5ee4ba0..5d4f950f5 100644
--- a/src/lib/pk_pad/eme_pkcs1/eme_pkcs.cpp
+++ b/src/lib/pk_pad/eme_pkcs1/eme_pkcs.cpp
@@ -13,7 +13,7 @@ namespace Botan {
 /*
 * PKCS1 Pad Operation
 */
-secure_vector<byte> EME_PKCS1v15::pad(const byte in[], size_t inlen,
+secure_vector<uint8_t> EME_PKCS1v15::pad(const uint8_t in[], size_t inlen,
                                      size_t key_length,
                                      RandomNumberGenerator& rng) const
    {
@@ -24,7 +24,7 @@ secure_vector<byte> EME_PKCS1v15::pad(const byte in[], size_t inlen,
       throw Invalid_Argument("PKCS1: Input is too large");
       }
 
-   secure_vector<byte> out(key_length);
+   secure_vector<uint8_t> out(key_length);
 
    out[0] = 0x02;
    rng.randomize(out.data() + 1, (key_length - inlen - 2));
@@ -45,31 +45,31 @@ secure_vector<byte> EME_PKCS1v15::pad(const byte in[], size_t inlen,
 /*
 * PKCS1 Unpad Operation
 */
-secure_vector<byte> EME_PKCS1v15::unpad(byte& valid_mask,
-                                        const byte in[], size_t inlen) const
+secure_vector<uint8_t> EME_PKCS1v15::unpad(uint8_t& valid_mask,
+                                        const uint8_t in[], size_t inlen) const
    {
    if(inlen < 2)
       {
       valid_mask = false;
-      return secure_vector<byte>();
+      return secure_vector<uint8_t>();
       }
 
    CT::poison(in, inlen);
 
-   byte bad_input_m = 0;
-   byte seen_zero_m = 0;
+   uint8_t bad_input_m = 0;
+   uint8_t seen_zero_m = 0;
    size_t delim_idx = 0;
 
-   bad_input_m |= ~CT::is_equal<byte>(in[0], 0);
-   bad_input_m |= ~CT::is_equal<byte>(in[1], 2);
+   bad_input_m |= ~CT::is_equal<uint8_t>(in[0], 0);
+   bad_input_m |= ~CT::is_equal<uint8_t>(in[1], 2);
 
    for(size_t i = 2; i < inlen; ++i)
       {
-      const byte is_zero_m = CT::is_zero<byte>(in[i]);
+      const uint8_t is_zero_m = CT::is_zero<uint8_t>(in[i]);
 
-      delim_idx += CT::select<byte>(~seen_zero_m, 1, 0);
+      delim_idx += CT::select<uint8_t>(~seen_zero_m, 1, 0);
 
-      bad_input_m |= is_zero_m & CT::expand_mask<byte>(i < 10);
+      bad_input_m |= is_zero_m & CT::expand_mask<uint8_t>(i < 10);
       seen_zero_m |= is_zero_m;
       }
 
@@ -80,7 +80,7 @@ secure_vector<byte> EME_PKCS1v15::unpad(byte& valid_mask,
    CT::unpoison(bad_input_m);
    CT::unpoison(delim_idx);
 
-   secure_vector<byte> output(&in[delim_idx + 2], &in[inlen]);
+   secure_vector<uint8_t> output(&in[delim_idx + 2], &in[inlen]);
    CT::cond_zero_mem(bad_input_m, output.data(), output.size());
    valid_mask = ~bad_input_m;
    return output;
diff --git a/src/lib/pk_pad/eme_pkcs1/eme_pkcs.h b/src/lib/pk_pad/eme_pkcs1/eme_pkcs.h
index 006b39997..9e06403ac 100644
--- a/src/lib/pk_pad/eme_pkcs1/eme_pkcs.h
+++ b/src/lib/pk_pad/eme_pkcs1/eme_pkcs.h
@@ -20,11 +20,11 @@ class BOTAN_DLL EME_PKCS1v15 final : public EME
    public:
       size_t maximum_input_size(size_t) const override;
    private:
-      secure_vector<byte> pad(const byte[], size_t, size_t,
+      secure_vector<uint8_t> pad(const uint8_t[], size_t, size_t,
                              RandomNumberGenerator&) const override;
 
-      secure_vector<byte> unpad(byte& valid_mask,
-                                const byte in[],
+      secure_vector<uint8_t> unpad(uint8_t& valid_mask,
+                                const uint8_t in[],
                                 size_t in_len) const override;
    };
 
diff --git a/src/lib/pk_pad/eme_raw/eme_raw.cpp b/src/lib/pk_pad/eme_raw/eme_raw.cpp
index 84fd6f545..066e7afd8 100644
--- a/src/lib/pk_pad/eme_raw/eme_raw.cpp
+++ b/src/lib/pk_pad/eme_raw/eme_raw.cpp
@@ -10,15 +10,15 @@
 
 namespace Botan {
 
-secure_vector<byte> EME_Raw::pad(const byte in[], size_t in_length,
+secure_vector<uint8_t> EME_Raw::pad(const uint8_t in[], size_t in_length,
                                  size_t,
                                  RandomNumberGenerator&) const
    {
-   return secure_vector<byte>(in, in + in_length);
+   return secure_vector<uint8_t>(in, in + in_length);
    }
 
-secure_vector<byte> EME_Raw::unpad(byte& valid_mask,
-                                   const byte in[], size_t in_length) const
+secure_vector<uint8_t> EME_Raw::unpad(uint8_t& valid_mask,
+                                   const uint8_t in[], size_t in_length) const
    {
    valid_mask = 0xFF;
    return CT::strip_leading_zeros(in, in_length);
diff --git a/src/lib/pk_pad/eme_raw/eme_raw.h b/src/lib/pk_pad/eme_raw/eme_raw.h
index fa30c684e..ec698f759 100644
--- a/src/lib/pk_pad/eme_raw/eme_raw.h
+++ b/src/lib/pk_pad/eme_raw/eme_raw.h
@@ -18,11 +18,11 @@ class BOTAN_DLL EME_Raw final : public EME
 
       EME_Raw() {}
    private:
-      secure_vector<byte> pad(const byte[], size_t, size_t,
+      secure_vector<uint8_t> pad(const uint8_t[], size_t, size_t,
                              RandomNumberGenerator&) const override;
 
-      secure_vector<byte> unpad(byte& valid_mask,
-                                const byte in[],
+      secure_vector<uint8_t> unpad(uint8_t& valid_mask,
+                                const uint8_t in[],
                                 size_t in_len) const override;
    };
 
diff --git a/src/lib/pk_pad/emsa.h b/src/lib/pk_pad/emsa.h
index bc930ae22..4b932fd78 100644
--- a/src/lib/pk_pad/emsa.h
+++ b/src/lib/pk_pad/emsa.h
@@ -26,12 +26,12 @@ class BOTAN_DLL EMSA
       * @param input some data
       * @param length length of input in bytes
       */
-      virtual void update(const byte input[], size_t length) = 0;
+      virtual void update(const uint8_t input[], size_t length) = 0;
 
       /**
       * @return raw hash
       */
-      virtual secure_vector<byte> raw_data() = 0;
+      virtual secure_vector<uint8_t> raw_data() = 0;
 
       /**
       * Return the encoding of a message
@@ -40,7 +40,7 @@ class BOTAN_DLL EMSA
       * @param rng a random number generator
       * @return encoded signature
       */
-      virtual secure_vector<byte> encoding_of(const secure_vector<byte>& msg,
+      virtual secure_vector<uint8_t> encoding_of(const secure_vector<uint8_t>& msg,
                                              size_t output_bits,
                                              RandomNumberGenerator& rng) = 0;
 
@@ -51,8 +51,8 @@ class BOTAN_DLL EMSA
       * @param key_bits the size of the key in bits
       * @return true if coded is a valid encoding of raw, otherwise false
       */
-      virtual bool verify(const secure_vector<byte>& coded,
-                          const secure_vector<byte>& raw,
+      virtual bool verify(const secure_vector<uint8_t>& coded,
+                          const secure_vector<uint8_t>& raw,
                           size_t key_bits) = 0;
 
       virtual ~EMSA();
diff --git a/src/lib/pk_pad/emsa1/emsa1.cpp b/src/lib/pk_pad/emsa1/emsa1.cpp
index 11130920f..82c3b86a7 100644
--- a/src/lib/pk_pad/emsa1/emsa1.cpp
+++ b/src/lib/pk_pad/emsa1/emsa1.cpp
@@ -11,7 +11,7 @@ namespace Botan {
 
 namespace {
 
-secure_vector<byte> emsa1_encoding(const secure_vector<byte>& msg,
+secure_vector<uint8_t> emsa1_encoding(const secure_vector<uint8_t>& msg,
                                   size_t output_bits)
    {
    if(8*msg.size() <= output_bits)
@@ -20,17 +20,17 @@ secure_vector<byte> emsa1_encoding(const secure_vector<byte>& msg,
    size_t shift = 8*msg.size() - output_bits;
 
    size_t byte_shift = shift / 8, bit_shift = shift % 8;
-   secure_vector<byte> digest(msg.size() - byte_shift);
+   secure_vector<uint8_t> digest(msg.size() - byte_shift);
 
    for(size_t j = 0; j != msg.size() - byte_shift; ++j)
       digest[j] = msg[j];
 
    if(bit_shift)
       {
-      byte carry = 0;
+      uint8_t carry = 0;
       for(size_t j = 0; j != digest.size(); ++j)
          {
-         byte temp = digest[j];
+         uint8_t temp = digest[j];
          digest[j] = (temp >> bit_shift) | carry;
          carry = (temp << (8 - bit_shift));
          }
@@ -45,17 +45,17 @@ EMSA* EMSA1::clone()
    return new EMSA1(m_hash->clone());
    }
 
-void EMSA1::update(const byte input[], size_t length)
+void EMSA1::update(const uint8_t input[], size_t length)
    {
    m_hash->update(input, length);
    }
 
-secure_vector<byte> EMSA1::raw_data()
+secure_vector<uint8_t> EMSA1::raw_data()
    {
    return m_hash->final();
    }
 
-secure_vector<byte> EMSA1::encoding_of(const secure_vector<byte>& msg,
+secure_vector<uint8_t> EMSA1::encoding_of(const secure_vector<uint8_t>& msg,
                                        size_t output_bits,
                                        RandomNumberGenerator&)
    {
@@ -64,8 +64,8 @@ secure_vector<byte> EMSA1::encoding_of(const secure_vector<byte>& msg,
    return emsa1_encoding(msg, output_bits);
    }
 
-bool EMSA1::verify(const secure_vector<byte>& input,
-                   const secure_vector<byte>& raw,
+bool EMSA1::verify(const secure_vector<uint8_t>& input,
+                   const secure_vector<uint8_t>& raw,
                    size_t key_bits)
    {
    try {
@@ -73,7 +73,7 @@ bool EMSA1::verify(const secure_vector<byte>& input,
          throw Encoding_Error("EMSA1::encoding_of: Invalid size for input");
 
       // Call emsa1_encoding to handle any required bit shifting
-      const secure_vector<byte> our_coding = emsa1_encoding(raw, key_bits);
+      const secure_vector<uint8_t> our_coding = emsa1_encoding(raw, key_bits);
 
       if(our_coding.size() < input.size())
          return false;
diff --git a/src/lib/pk_pad/emsa1/emsa1.h b/src/lib/pk_pad/emsa1/emsa1.h
index 5a4b4b372..6d7b2bca8 100644
--- a/src/lib/pk_pad/emsa1/emsa1.h
+++ b/src/lib/pk_pad/emsa1/emsa1.h
@@ -33,15 +33,15 @@ class BOTAN_DLL EMSA1 : public EMSA
       std::unique_ptr<HashFunction> m_hash;
 
    private:
-      void update(const byte[], size_t) override;
-      secure_vector<byte> raw_data() override;
+      void update(const uint8_t[], size_t) override;
+      secure_vector<uint8_t> raw_data() override;
 
-      secure_vector<byte> encoding_of(const secure_vector<byte>& msg,
+      secure_vector<uint8_t> encoding_of(const secure_vector<uint8_t>& msg,
                                       size_t output_bits,
                                       RandomNumberGenerator& rng) override;
 
-      bool verify(const secure_vector<byte>& coded,
-                  const secure_vector<byte>& raw,
+      bool verify(const secure_vector<uint8_t>& coded,
+                  const secure_vector<uint8_t>& raw,
                   size_t key_bits) override;
 
    };
diff --git a/src/lib/pk_pad/emsa_pkcs1/emsa_pkcs1.cpp b/src/lib/pk_pad/emsa_pkcs1/emsa_pkcs1.cpp
index b3f74930b..c4cdc6f35 100644
--- a/src/lib/pk_pad/emsa_pkcs1/emsa_pkcs1.cpp
+++ b/src/lib/pk_pad/emsa_pkcs1/emsa_pkcs1.cpp
@@ -12,16 +12,16 @@ namespace Botan {
 
 namespace {
 
-secure_vector<byte> emsa3_encoding(const secure_vector<byte>& msg,
+secure_vector<uint8_t> emsa3_encoding(const secure_vector<uint8_t>& msg,
                                    size_t output_bits,
-                                   const byte hash_id[],
+                                   const uint8_t hash_id[],
                                    size_t hash_id_length)
    {
    size_t output_length = output_bits / 8;
    if(output_length < hash_id_length + msg.size() + 10)
       throw Encoding_Error("emsa3_encoding: Output length is too small");
 
-   secure_vector<byte> T(output_length);
+   secure_vector<uint8_t> T(output_length);
    const size_t P_LENGTH = output_length - msg.size() - hash_id_length - 2;
 
    T[0] = 0x01;
@@ -34,18 +34,18 @@ secure_vector<byte> emsa3_encoding(const secure_vector<byte>& msg,
 
 }
 
-void EMSA_PKCS1v15::update(const byte input[], size_t length)
+void EMSA_PKCS1v15::update(const uint8_t input[], size_t length)
    {
    m_hash->update(input, length);
    }
 
-secure_vector<byte> EMSA_PKCS1v15::raw_data()
+secure_vector<uint8_t> EMSA_PKCS1v15::raw_data()
    {
    return m_hash->final();
    }
 
-secure_vector<byte>
-EMSA_PKCS1v15::encoding_of(const secure_vector<byte>& msg,
+secure_vector<uint8_t>
+EMSA_PKCS1v15::encoding_of(const secure_vector<uint8_t>& msg,
                            size_t output_bits,
                            RandomNumberGenerator&)
    {
@@ -56,8 +56,8 @@ EMSA_PKCS1v15::encoding_of(const secure_vector<byte>& msg,
                          m_hash_id.data(), m_hash_id.size());
    }
 
-bool EMSA_PKCS1v15::verify(const secure_vector<byte>& coded,
-                           const secure_vector<byte>& raw,
+bool EMSA_PKCS1v15::verify(const secure_vector<uint8_t>& coded,
+                           const secure_vector<uint8_t>& raw,
                            size_t key_bits)
    {
    if(raw.size() != m_hash->output_length())
@@ -79,28 +79,28 @@ EMSA_PKCS1v15::EMSA_PKCS1v15(HashFunction* hash) : m_hash(hash)
    m_hash_id = pkcs_hash_id(m_hash->name());
    }
 
-void EMSA_PKCS1v15_Raw::update(const byte input[], size_t length)
+void EMSA_PKCS1v15_Raw::update(const uint8_t input[], size_t length)
    {
    m_message += std::make_pair(input, length);
    }
 
-secure_vector<byte> EMSA_PKCS1v15_Raw::raw_data()
+secure_vector<uint8_t> EMSA_PKCS1v15_Raw::raw_data()
    {
-   secure_vector<byte> ret;
+   secure_vector<uint8_t> ret;
    std::swap(ret, m_message);
    return ret;
    }
 
-secure_vector<byte>
-EMSA_PKCS1v15_Raw::encoding_of(const secure_vector<byte>& msg,
+secure_vector<uint8_t>
+EMSA_PKCS1v15_Raw::encoding_of(const secure_vector<uint8_t>& msg,
                                size_t output_bits,
                                RandomNumberGenerator&)
    {
    return emsa3_encoding(msg, output_bits, nullptr, 0);
    }
 
-bool EMSA_PKCS1v15_Raw::verify(const secure_vector<byte>& coded,
-                               const secure_vector<byte>& raw,
+bool EMSA_PKCS1v15_Raw::verify(const secure_vector<uint8_t>& coded,
+                               const secure_vector<uint8_t>& raw,
                                size_t key_bits)
    {
    try
diff --git a/src/lib/pk_pad/emsa_pkcs1/emsa_pkcs1.h b/src/lib/pk_pad/emsa_pkcs1/emsa_pkcs1.h
index 65daaf7ce..95ccafa4d 100644
--- a/src/lib/pk_pad/emsa_pkcs1/emsa_pkcs1.h
+++ b/src/lib/pk_pad/emsa_pkcs1/emsa_pkcs1.h
@@ -28,18 +28,18 @@ class BOTAN_DLL EMSA_PKCS1v15 final : public EMSA
 
       EMSA* clone() override { return new EMSA_PKCS1v15(m_hash->clone()); }
 
-      void update(const byte[], size_t) override;
+      void update(const uint8_t[], size_t) override;
 
-      secure_vector<byte> raw_data() override;
+      secure_vector<uint8_t> raw_data() override;
 
-      secure_vector<byte> encoding_of(const secure_vector<byte>&, size_t,
+      secure_vector<uint8_t> encoding_of(const secure_vector<uint8_t>&, size_t,
                                      RandomNumberGenerator& rng) override;
 
-      bool verify(const secure_vector<byte>&, const secure_vector<byte>&,
+      bool verify(const secure_vector<uint8_t>&, const secure_vector<uint8_t>&,
                   size_t) override;
    private:
       std::unique_ptr<HashFunction> m_hash;
-      std::vector<byte> m_hash_id;
+      std::vector<uint8_t> m_hash_id;
    };
 
 /**
@@ -52,18 +52,18 @@ class BOTAN_DLL EMSA_PKCS1v15_Raw final : public EMSA
    public:
       EMSA* clone() override { return new EMSA_PKCS1v15_Raw(); }
 
-      void update(const byte[], size_t) override;
+      void update(const uint8_t[], size_t) override;
 
-      secure_vector<byte> raw_data() override;
+      secure_vector<uint8_t> raw_data() override;
 
-      secure_vector<byte> encoding_of(const secure_vector<byte>&, size_t,
+      secure_vector<uint8_t> encoding_of(const secure_vector<uint8_t>&, size_t,
                                      RandomNumberGenerator& rng) override;
 
-      bool verify(const secure_vector<byte>&, const secure_vector<byte>&,
+      bool verify(const secure_vector<uint8_t>&, const secure_vector<uint8_t>&,
                   size_t) override;
 
    private:
-      secure_vector<byte> m_message;
+      secure_vector<uint8_t> m_message;
    };
 
 }
diff --git a/src/lib/pk_pad/emsa_pssr/pssr.cpp b/src/lib/pk_pad/emsa_pssr/pssr.cpp
index a41e79e78..5f76b5a6f 100644
--- a/src/lib/pk_pad/emsa_pssr/pssr.cpp
+++ b/src/lib/pk_pad/emsa_pssr/pssr.cpp
@@ -14,7 +14,7 @@ namespace Botan {
 /*
 * PSSR Update Operation
 */
-void PSSR::update(const byte input[], size_t length)
+void PSSR::update(const uint8_t input[], size_t length)
    {
    m_hash->update(input, length);
    }
@@ -22,7 +22,7 @@ void PSSR::update(const byte input[], size_t length)
 /*
 * Return the raw (unencoded) data
 */
-secure_vector<byte> PSSR::raw_data()
+secure_vector<uint8_t> PSSR::raw_data()
    {
    return m_hash->final();
    }
@@ -30,7 +30,7 @@ secure_vector<byte> PSSR::raw_data()
 /*
 * PSSR Encode Operation
 */
-secure_vector<byte> PSSR::encoding_of(const secure_vector<byte>& msg,
+secure_vector<uint8_t> PSSR::encoding_of(const secure_vector<uint8_t>& msg,
                                       size_t output_bits,
                                       RandomNumberGenerator& rng)
    {
@@ -43,15 +43,15 @@ secure_vector<byte> PSSR::encoding_of(const secure_vector<byte>& msg,
 
    const size_t output_length = (output_bits + 7) / 8;
 
-   secure_vector<byte> salt = rng.random_vec(m_SALT_SIZE);
+   secure_vector<uint8_t> salt = rng.random_vec(m_SALT_SIZE);
 
    for(size_t j = 0; j != 8; ++j)
       m_hash->update(0);
    m_hash->update(msg);
    m_hash->update(salt);
-   secure_vector<byte> H = m_hash->final();
+   secure_vector<uint8_t> H = m_hash->final();
 
-   secure_vector<byte> EM(output_length);
+   secure_vector<uint8_t> EM(output_length);
 
    EM[output_length - HASH_SIZE - m_SALT_SIZE - 2] = 0x01;
    buffer_insert(EM, output_length - 1 - HASH_SIZE - m_SALT_SIZE, salt);
@@ -66,8 +66,8 @@ secure_vector<byte> PSSR::encoding_of(const secure_vector<byte>& msg,
 /*
 * PSSR Decode/Verify Operation
 */
-bool PSSR::verify(const secure_vector<byte>& const_coded,
-                   const secure_vector<byte>& raw, size_t key_bits)
+bool PSSR::verify(const secure_vector<uint8_t>& const_coded,
+                   const secure_vector<uint8_t>& raw, size_t key_bits)
    {
    const size_t HASH_SIZE = m_hash->output_length();
    const size_t KEY_BYTES = (key_bits + 7) / 8;
@@ -84,10 +84,10 @@ bool PSSR::verify(const secure_vector<byte>& const_coded,
    if(const_coded[const_coded.size()-1] != 0xBC)
       return false;
 
-   secure_vector<byte> coded = const_coded;
+   secure_vector<uint8_t> coded = const_coded;
    if(coded.size() < KEY_BYTES)
       {
-      secure_vector<byte> temp(KEY_BYTES);
+      secure_vector<uint8_t> temp(KEY_BYTES);
       buffer_insert(temp, KEY_BYTES - coded.size(), coded);
       coded = temp;
       }
@@ -96,10 +96,10 @@ bool PSSR::verify(const secure_vector<byte>& const_coded,
    if(TOP_BITS > 8 - high_bit(coded[0]))
       return false;
 
-   byte* DB = coded.data();
+   uint8_t* DB = coded.data();
    const size_t DB_size = coded.size() - HASH_SIZE - 1;
 
-   const byte* H = &coded[DB_size];
+   const uint8_t* H = &coded[DB_size];
    const size_t H_size = HASH_SIZE;
 
    mgf1_mask(*m_hash, H, H_size, DB, DB_size);
@@ -120,7 +120,7 @@ bool PSSR::verify(const secure_vector<byte>& const_coded,
       m_hash->update(0);
    m_hash->update(raw);
    m_hash->update(&DB[salt_offset], DB_size - salt_offset);
-   secure_vector<byte> H2 = m_hash->final();
+   secure_vector<uint8_t> H2 = m_hash->final();
 
    return same_mem(H, H2.data(), HASH_SIZE);
    }
diff --git a/src/lib/pk_pad/emsa_pssr/pssr.h b/src/lib/pk_pad/emsa_pssr/pssr.h
index bf465eadf..0ed47c466 100644
--- a/src/lib/pk_pad/emsa_pssr/pssr.h
+++ b/src/lib/pk_pad/emsa_pssr/pssr.h
@@ -33,16 +33,16 @@ class BOTAN_DLL PSSR final : public EMSA
 
       EMSA* clone() override { return new PSSR(m_hash->clone(), m_SALT_SIZE); }
    private:
-      void update(const byte input[], size_t length) override;
+      void update(const uint8_t input[], size_t length) override;
 
-      secure_vector<byte> raw_data() override;
+      secure_vector<uint8_t> raw_data() override;
 
-      secure_vector<byte> encoding_of(const secure_vector<byte>& msg,
+      secure_vector<uint8_t> encoding_of(const secure_vector<uint8_t>& msg,
                                       size_t output_bits,
                                       RandomNumberGenerator& rng) override;
 
-      bool verify(const secure_vector<byte>& coded,
-                  const secure_vector<byte>& raw,
+      bool verify(const secure_vector<uint8_t>& coded,
+                  const secure_vector<uint8_t>& raw,
                   size_t key_bits) override;
 
       size_t m_SALT_SIZE;
diff --git a/src/lib/pk_pad/emsa_raw/emsa_raw.cpp b/src/lib/pk_pad/emsa_raw/emsa_raw.cpp
index 8d3bbdbc3..d15012a0d 100644
--- a/src/lib/pk_pad/emsa_raw/emsa_raw.cpp
+++ b/src/lib/pk_pad/emsa_raw/emsa_raw.cpp
@@ -12,7 +12,7 @@ namespace Botan {
 /*
 * EMSA-Raw Encode Operation
 */
-void EMSA_Raw::update(const byte input[], size_t length)
+void EMSA_Raw::update(const uint8_t input[], size_t length)
    {
    m_message += std::make_pair(input, length);
    }
@@ -20,9 +20,9 @@ void EMSA_Raw::update(const byte input[], size_t length)
 /*
 * Return the raw (unencoded) data
 */
-secure_vector<byte> EMSA_Raw::raw_data()
+secure_vector<uint8_t> EMSA_Raw::raw_data()
    {
-   secure_vector<byte> output;
+   secure_vector<uint8_t> output;
    std::swap(m_message, output);
    return output;
    }
@@ -30,7 +30,7 @@ secure_vector<byte> EMSA_Raw::raw_data()
 /*
 * EMSA-Raw Encode Operation
 */
-secure_vector<byte> EMSA_Raw::encoding_of(const secure_vector<byte>& msg,
+secure_vector<uint8_t> EMSA_Raw::encoding_of(const secure_vector<uint8_t>& msg,
                                          size_t,
                                          RandomNumberGenerator&)
    {
@@ -40,8 +40,8 @@ secure_vector<byte> EMSA_Raw::encoding_of(const secure_vector<byte>& msg,
 /*
 * EMSA-Raw Verify Operation
 */
-bool EMSA_Raw::verify(const secure_vector<byte>& coded,
-                      const secure_vector<byte>& raw,
+bool EMSA_Raw::verify(const secure_vector<uint8_t>& coded,
+                      const secure_vector<uint8_t>& raw,
                       size_t)
    {
    if(coded.size() == raw.size())
diff --git a/src/lib/pk_pad/emsa_raw/emsa_raw.h b/src/lib/pk_pad/emsa_raw/emsa_raw.h
index cc2d5d63a..288969257 100644
--- a/src/lib/pk_pad/emsa_raw/emsa_raw.h
+++ b/src/lib/pk_pad/emsa_raw/emsa_raw.h
@@ -22,15 +22,15 @@ class BOTAN_DLL EMSA_Raw final : public EMSA
       EMSA* clone() override { return new EMSA_Raw(); }
 
    private:
-      void update(const byte[], size_t) override;
-      secure_vector<byte> raw_data() override;
+      void update(const uint8_t[], size_t) override;
+      secure_vector<uint8_t> raw_data() override;
 
-      secure_vector<byte> encoding_of(const secure_vector<byte>&, size_t,
+      secure_vector<uint8_t> encoding_of(const secure_vector<uint8_t>&, size_t,
                                      RandomNumberGenerator&) override;
-      bool verify(const secure_vector<byte>&, const secure_vector<byte>&,
+      bool verify(const secure_vector<uint8_t>&, const secure_vector<uint8_t>&,
                   size_t) override;
 
-      secure_vector<byte> m_message;
+      secure_vector<uint8_t> m_message;
    };
 
 }
diff --git a/src/lib/pk_pad/emsa_x931/emsa_x931.cpp b/src/lib/pk_pad/emsa_x931/emsa_x931.cpp
index 2feedee1c..8d90bd245 100644
--- a/src/lib/pk_pad/emsa_x931/emsa_x931.cpp
+++ b/src/lib/pk_pad/emsa_x931/emsa_x931.cpp
@@ -12,10 +12,10 @@ namespace Botan {
 
 namespace {
 
-secure_vector<byte> emsa2_encoding(const secure_vector<byte>& msg,
+secure_vector<uint8_t> emsa2_encoding(const secure_vector<uint8_t>& msg,
                                    size_t output_bits,
-                                   const secure_vector<byte>& empty_hash,
-                                   byte hash_id)
+                                   const secure_vector<uint8_t>& empty_hash,
+                                   uint8_t hash_id)
    {
    const size_t HASH_SIZE = empty_hash.size();
 
@@ -28,7 +28,7 @@ secure_vector<byte> emsa2_encoding(const secure_vector<byte>& msg,
 
    const bool empty_input = (msg == empty_hash);
 
-   secure_vector<byte> output(output_length);
+   secure_vector<uint8_t> output(output_length);
 
    output[0] = (empty_input ? 0x4B : 0x6B);
    output[output_length - 3 - HASH_SIZE] = 0xBA;
@@ -42,12 +42,12 @@ secure_vector<byte> emsa2_encoding(const secure_vector<byte>& msg,
 
 }
 
-void EMSA_X931::update(const byte input[], size_t length)
+void EMSA_X931::update(const uint8_t input[], size_t length)
    {
    m_hash->update(input, length);
    }
 
-secure_vector<byte> EMSA_X931::raw_data()
+secure_vector<uint8_t> EMSA_X931::raw_data()
    {
    return m_hash->final();
    }
@@ -55,7 +55,7 @@ secure_vector<byte> EMSA_X931::raw_data()
 /*
 * EMSA_X931 Encode Operation
 */
-secure_vector<byte> EMSA_X931::encoding_of(const secure_vector<byte>& msg,
+secure_vector<uint8_t> EMSA_X931::encoding_of(const secure_vector<uint8_t>& msg,
                                       size_t output_bits,
                                       RandomNumberGenerator&)
    {
@@ -65,8 +65,8 @@ secure_vector<byte> EMSA_X931::encoding_of(const secure_vector<byte>& msg,
 /*
 * EMSA_X931 Verify Operation
 */
-bool EMSA_X931::verify(const secure_vector<byte>& coded,
-                   const secure_vector<byte>& raw,
+bool EMSA_X931::verify(const secure_vector<uint8_t>& coded,
+                   const secure_vector<uint8_t>& raw,
                    size_t key_bits)
    {
    try
diff --git a/src/lib/pk_pad/emsa_x931/emsa_x931.h b/src/lib/pk_pad/emsa_x931/emsa_x931.h
index fe5866002..ec48d01de 100644
--- a/src/lib/pk_pad/emsa_x931/emsa_x931.h
+++ b/src/lib/pk_pad/emsa_x931/emsa_x931.h
@@ -28,18 +28,18 @@ class BOTAN_DLL EMSA_X931 final : public EMSA
 
       EMSA* clone() override { return new EMSA_X931(m_hash->clone()); }
    private:
-      void update(const byte[], size_t) override;
-      secure_vector<byte> raw_data() override;
+      void update(const uint8_t[], size_t) override;
+      secure_vector<uint8_t> raw_data() override;
 
-      secure_vector<byte> encoding_of(const secure_vector<byte>&, size_t,
+      secure_vector<uint8_t> encoding_of(const secure_vector<uint8_t>&, size_t,
                                      RandomNumberGenerator& rng) override;
 
-      bool verify(const secure_vector<byte>&, const secure_vector<byte>&,
+      bool verify(const secure_vector<uint8_t>&, const secure_vector<uint8_t>&,
                   size_t) override;
 
-      secure_vector<byte> m_empty_hash;
+      secure_vector<uint8_t> m_empty_hash;
       std::unique_ptr<HashFunction> m_hash;
-      byte m_hash_id;
+      uint8_t m_hash_id;
    };
 
 }
diff --git a/src/lib/pk_pad/hash_id/hash_id.cpp b/src/lib/pk_pad/hash_id/hash_id.cpp
index 2af0f6878..70b7470c4 100644
--- a/src/lib/pk_pad/hash_id/hash_id.cpp
+++ b/src/lib/pk_pad/hash_id/hash_id.cpp
@@ -12,39 +12,39 @@ namespace Botan {
 
 namespace {
 
-const byte MD5_PKCS_ID[] = {
+const uint8_t MD5_PKCS_ID[] = {
 0x30, 0x20, 0x30, 0x0C, 0x06, 0x08, 0x2A, 0x86, 0x48, 0x86,
 0xF7, 0x0D, 0x02, 0x05, 0x05, 0x00, 0x04, 0x10 };
 
-const byte RIPEMD_160_PKCS_ID[] = {
+const uint8_t RIPEMD_160_PKCS_ID[] = {
 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2B, 0x24, 0x03, 0x02,
 0x01, 0x05, 0x00, 0x04, 0x14 };
 
-const byte SHA_160_PKCS_ID[] = {
+const uint8_t SHA_160_PKCS_ID[] = {
 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2B, 0x0E, 0x03, 0x02,
 0x1A, 0x05, 0x00, 0x04, 0x14 };
 
-const byte SHA_224_PKCS_ID[] = {
+const uint8_t SHA_224_PKCS_ID[] = {
 0x30, 0x2D, 0x30, 0x0D, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01,
 0x65, 0x03, 0x04, 0x02, 0x04, 0x05, 0x00, 0x04, 0x1C };
 
-const byte SHA_256_PKCS_ID[] = {
+const uint8_t SHA_256_PKCS_ID[] = {
 0x30, 0x31, 0x30, 0x0D, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01,
 0x65, 0x03, 0x04, 0x02, 0x01, 0x05, 0x00, 0x04, 0x20 };
 
-const byte SHA_384_PKCS_ID[] = {
+const uint8_t SHA_384_PKCS_ID[] = {
 0x30, 0x41, 0x30, 0x0D, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01,
 0x65, 0x03, 0x04, 0x02, 0x02, 0x05, 0x00, 0x04, 0x30 };
 
-const byte SHA_512_PKCS_ID[] = {
+const uint8_t SHA_512_PKCS_ID[] = {
 0x30, 0x51, 0x30, 0x0D, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01,
 0x65, 0x03, 0x04, 0x02, 0x03, 0x05, 0x00, 0x04, 0x40 };
 
-const byte SHA_512_256_PKCS_ID[] = {
+const uint8_t SHA_512_256_PKCS_ID[] = {
 0x30, 0x31, 0x30, 0x0D, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01,
 0x65, 0x03, 0x04, 0x02, 0x06, 0x05, 0x00, 0x04, 0x20 };
 
-const byte TIGER_PKCS_ID[] = {
+const uint8_t TIGER_PKCS_ID[] = {
 0x30, 0x29, 0x30, 0x0D, 0x06, 0x09, 0x2B, 0x06, 0x01, 0x04,
 0x01, 0xDA, 0x47, 0x0C, 0x02, 0x05, 0x00, 0x04, 0x18 };
 
@@ -53,46 +53,46 @@ const byte TIGER_PKCS_ID[] = {
 /*
 * HashID as specified by PKCS
 */
-std::vector<byte> pkcs_hash_id(const std::string& name)
+std::vector<uint8_t> pkcs_hash_id(const std::string& name)
    {
    // Special case for SSL/TLS RSA signatures
    if(name == "Parallel(MD5,SHA-160)")
-      return std::vector<byte>();
+      return std::vector<uint8_t>();
 
    if(name == "MD5")
-      return std::vector<byte>(MD5_PKCS_ID,
+      return std::vector<uint8_t>(MD5_PKCS_ID,
                                MD5_PKCS_ID + sizeof(MD5_PKCS_ID));
 
    if(name == "RIPEMD-160")
-      return std::vector<byte>(RIPEMD_160_PKCS_ID,
+      return std::vector<uint8_t>(RIPEMD_160_PKCS_ID,
                                RIPEMD_160_PKCS_ID + sizeof(RIPEMD_160_PKCS_ID));
 
    if(name == "SHA-160")
-      return std::vector<byte>(SHA_160_PKCS_ID,
+      return std::vector<uint8_t>(SHA_160_PKCS_ID,
                                SHA_160_PKCS_ID + sizeof(SHA_160_PKCS_ID));
 
    if(name == "SHA-224")
-      return std::vector<byte>(SHA_224_PKCS_ID,
+      return std::vector<uint8_t>(SHA_224_PKCS_ID,
                                SHA_224_PKCS_ID + sizeof(SHA_224_PKCS_ID));
 
    if(name == "SHA-256")
-      return std::vector<byte>(SHA_256_PKCS_ID,
+      return std::vector<uint8_t>(SHA_256_PKCS_ID,
                                SHA_256_PKCS_ID + sizeof(SHA_256_PKCS_ID));
 
    if(name == "SHA-384")
-      return std::vector<byte>(SHA_384_PKCS_ID,
+      return std::vector<uint8_t>(SHA_384_PKCS_ID,
                                SHA_384_PKCS_ID + sizeof(SHA_384_PKCS_ID));
 
    if(name == "SHA-512")
-      return std::vector<byte>(SHA_512_PKCS_ID,
+      return std::vector<uint8_t>(SHA_512_PKCS_ID,
                                SHA_512_PKCS_ID + sizeof(SHA_512_PKCS_ID));
 
    if(name == "SHA-512-256")
-      return std::vector<byte>(SHA_512_256_PKCS_ID,
+      return std::vector<uint8_t>(SHA_512_256_PKCS_ID,
                                SHA_512_256_PKCS_ID + sizeof(SHA_512_256_PKCS_ID));
 
    if(name == "Tiger(24,3)")
-      return std::vector<byte>(TIGER_PKCS_ID,
+      return std::vector<uint8_t>(TIGER_PKCS_ID,
                                TIGER_PKCS_ID + sizeof(TIGER_PKCS_ID));
 
    throw Invalid_Argument("No PKCS #1 identifier for " + name);
@@ -101,7 +101,7 @@ std::vector<byte> pkcs_hash_id(const std::string& name)
 /*
 * HashID as specified by IEEE 1363/X9.31
 */
-byte ieee1363_hash_id(const std::string& name)
+uint8_t ieee1363_hash_id(const std::string& name)
    {
    if(name == "SHA-160")    return 0x33;
 
diff --git a/src/lib/pk_pad/hash_id/hash_id.h b/src/lib/pk_pad/hash_id/hash_id.h
index 5eab8bc2b..4e5492bd0 100644
--- a/src/lib/pk_pad/hash_id/hash_id.h
+++ b/src/lib/pk_pad/hash_id/hash_id.h
@@ -17,17 +17,17 @@ namespace Botan {
 * Return the PKCS #1 hash identifier
 * @see RFC 3447 section 9.2
 * @param hash_name the name of the hash function
-* @return byte sequence identifying the hash
+* @return uint8_t sequence identifying the hash
 * @throw Invalid_Argument if the hash has no known PKCS #1 hash id
 */
-BOTAN_DLL std::vector<byte> pkcs_hash_id(const std::string& hash_name);
+BOTAN_DLL std::vector<uint8_t> pkcs_hash_id(const std::string& hash_name);
 
 /**
 * Return the IEEE 1363 hash identifier
 * @param hash_name the name of the hash function
-* @return byte code identifying the hash, or 0 if not known
+* @return uint8_t code identifying the hash, or 0 if not known
 */
-BOTAN_DLL byte ieee1363_hash_id(const std::string& hash_name);
+BOTAN_DLL uint8_t ieee1363_hash_id(const std::string& hash_name);
 
 }
 
diff --git a/src/lib/pk_pad/iso9796/iso9796.cpp b/src/lib/pk_pad/iso9796/iso9796.cpp
index db79661e3..f123a7e15 100644
--- a/src/lib/pk_pad/iso9796/iso9796.cpp
+++ b/src/lib/pk_pad/iso9796/iso9796.cpp
@@ -14,7 +14,7 @@ namespace Botan {
 
 namespace {
 
-secure_vector<byte> iso9796_encoding(const secure_vector<byte>& msg,
+secure_vector<uint8_t> iso9796_encoding(const secure_vector<uint8_t>& msg,
                                      size_t output_bits, std::unique_ptr<HashFunction>& hash, size_t SALT_SIZE, bool implicit, RandomNumberGenerator& rng)
    {
    const size_t output_length = (output_bits + 7) / 8;
@@ -37,12 +37,12 @@ secure_vector<byte> iso9796_encoding(const secure_vector<byte>& msg,
                            - HASH_SIZE - SALT_SIZE - tLength - 1;
 
    //msg1 is the recoverable and msg2 the unrecoverable message part.
-   secure_vector<byte> msg1;
-   secure_vector<byte> msg2;
+   secure_vector<uint8_t> msg1;
+   secure_vector<uint8_t> msg2;
    if(msg.size() > capacity)
       {
-      msg1 = secure_vector<byte> (msg.begin(), msg.begin() + capacity);
-      msg2 = secure_vector<byte> (msg.begin() + capacity, msg.end());
+      msg1 = secure_vector<uint8_t> (msg.begin(), msg.begin() + capacity);
+      msg2 = secure_vector<uint8_t> (msg.begin() + capacity, msg.end());
       hash->update(msg2);
       }
    else
@@ -53,14 +53,14 @@ secure_vector<byte> iso9796_encoding(const secure_vector<byte>& msg,
 
    //compute H(C||msg1 ||H(msg2)||S)
    uint64_t msgLength = msg1.size();
-   secure_vector<byte> salt = rng.random_vec(SALT_SIZE);
+   secure_vector<uint8_t> salt = rng.random_vec(SALT_SIZE);
    hash->update_be(msgLength * 8);
    hash->update(msg1);
    hash->update(msg2);
    hash->update(salt);
-   secure_vector<byte> H = hash->final();
+   secure_vector<uint8_t> H = hash->final();
 
-   secure_vector<byte> EM(output_length);
+   secure_vector<uint8_t> EM(output_length);
 
    //compute message offset.
    size_t offset = output_length - HASH_SIZE - SALT_SIZE - tLength
@@ -78,7 +78,7 @@ secure_vector<byte> iso9796_encoding(const secure_vector<byte>& msg,
    //set implicit/ISO trailer
    if(!implicit)
       {
-      byte hash_id = ieee1363_hash_id(hash->name());
+      uint8_t hash_id = ieee1363_hash_id(hash->name());
       if(!hash_id)
          {
          throw Encoding_Error("ISO9796-2::encoding_of: no hash identifier for " + hash->name());
@@ -97,8 +97,8 @@ secure_vector<byte> iso9796_encoding(const secure_vector<byte>& msg,
    return EM;
    }
 
-bool iso9796_verification(const secure_vector<byte>& const_coded,
-                          const secure_vector<byte>& raw, size_t key_bits, std::unique_ptr<HashFunction>& hash, size_t SALT_SIZE)
+bool iso9796_verification(const secure_vector<uint8_t>& const_coded,
+                          const secure_vector<uint8_t>& raw, size_t key_bits, std::unique_ptr<HashFunction>& hash, size_t SALT_SIZE)
    {
    const size_t HASH_SIZE = hash->output_length();
    const size_t KEY_BYTES = (key_bits + 7) / 8;
@@ -115,7 +115,7 @@ bool iso9796_verification(const secure_vector<byte>& const_coded,
       }
    else
       {
-      byte hash_id = ieee1363_hash_id(hash->name());
+      uint8_t hash_id = ieee1363_hash_id(hash->name());
       if((!const_coded[const_coded.size() - 2]) || (const_coded[const_coded.size() - 2] != hash_id) ||
             (const_coded[const_coded.size() - 1] != 0xCC))
          {
@@ -124,13 +124,13 @@ bool iso9796_verification(const secure_vector<byte>& const_coded,
       tLength = 2;
       }
 
-   secure_vector<byte> coded = const_coded;
+   secure_vector<uint8_t> coded = const_coded;
 
    //remove mask
-   byte* DB = coded.data();
+   uint8_t* DB = coded.data();
    const size_t DB_size = coded.size() - HASH_SIZE - tLength;
 
-   const byte* H = &coded[DB_size];
+   const uint8_t* H = &coded[DB_size];
 
    mgf1_mask(*hash, H, HASH_SIZE, DB, DB_size);
    //clear the leftmost bit (confer bouncy castle)
@@ -150,20 +150,20 @@ bool iso9796_verification(const secure_vector<byte>& const_coded,
       {
       return false;
       }
-   secure_vector<byte> msg1(coded.begin() + msg1_offset,
+   secure_vector<uint8_t> msg1(coded.begin() + msg1_offset,
                             coded.end() - tLength - HASH_SIZE - SALT_SIZE);
-   secure_vector<byte> salt(coded.begin() + msg1_offset + msg1.size(),
+   secure_vector<uint8_t> salt(coded.begin() + msg1_offset + msg1.size(),
                             coded.end() - tLength - HASH_SIZE);
 
    //compute H2(C||msg1||H(msg2)||S*). * indicates a recovered value
    const size_t capacity = (key_bits - 2 + 7) / 8 - HASH_SIZE
                            - SALT_SIZE - tLength - 1;
-   secure_vector<byte> msg1raw;
-   secure_vector<byte> msg2;
+   secure_vector<uint8_t> msg1raw;
+   secure_vector<uint8_t> msg2;
    if(raw.size() > capacity)
       {
-      msg1raw = secure_vector<byte> (raw.begin(), raw.begin() + capacity);
-      msg2 = secure_vector<byte> (raw.begin() + capacity, raw.end());
+      msg1raw = secure_vector<uint8_t> (raw.begin(), raw.begin() + capacity);
+      msg2 = secure_vector<uint8_t> (raw.begin() + capacity, raw.end());
       hash->update(msg2);
       }
    else
@@ -177,7 +177,7 @@ bool iso9796_verification(const secure_vector<byte>& const_coded,
    hash->update(msg1raw);
    hash->update(msg2);
    hash->update(salt);
-   secure_vector<byte> H3 = hash->final();
+   secure_vector<uint8_t> H3 = hash->final();
 
    //compute H3(C*||msg1*||H(msg2)||S*) * indicates a recovered value
    uint64_t msgLength = msg1.size();
@@ -185,7 +185,7 @@ bool iso9796_verification(const secure_vector<byte>& const_coded,
    hash->update(msg1);
    hash->update(msg2);
    hash->update(salt);
-   secure_vector<byte> H2 = hash->final();
+   secure_vector<uint8_t> H2 = hash->final();
 
    //check if H3 == H2
    return same_mem(H3.data(), H2.data(), HASH_SIZE);
@@ -196,7 +196,7 @@ bool iso9796_verification(const secure_vector<byte>& const_coded,
  *  ISO-9796-2 signature scheme 2
  *  DS 2 is probabilistic
  */
-void ISO_9796_DS2::update(const byte input[], size_t length)
+void ISO_9796_DS2::update(const uint8_t input[], size_t length)
    {
    //need to buffer message completely, before digest
    m_msg_buffer.insert(m_msg_buffer.end(), input, input+length);
@@ -205,9 +205,9 @@ void ISO_9796_DS2::update(const byte input[], size_t length)
 /*
  * Return the raw (unencoded) data
  */
-secure_vector<byte> ISO_9796_DS2::raw_data()
+secure_vector<uint8_t> ISO_9796_DS2::raw_data()
    {
-   secure_vector<byte> retbuffer = m_msg_buffer;
+   secure_vector<uint8_t> retbuffer = m_msg_buffer;
    m_msg_buffer.clear();
    return retbuffer;
    }
@@ -215,7 +215,7 @@ secure_vector<byte> ISO_9796_DS2::raw_data()
 /*
  *  ISO-9796-2 scheme 2 encode operation
  */
-secure_vector<byte> ISO_9796_DS2::encoding_of(const secure_vector<byte>& msg,
+secure_vector<uint8_t> ISO_9796_DS2::encoding_of(const secure_vector<uint8_t>& msg,
       size_t output_bits, RandomNumberGenerator& rng)
    {
    return iso9796_encoding(msg, output_bits, m_hash, m_SALT_SIZE, m_implicit, rng);
@@ -224,8 +224,8 @@ secure_vector<byte> ISO_9796_DS2::encoding_of(const secure_vector<byte>& msg,
 /*
  * ISO-9796-2 scheme 2 verify operation
  */
-bool ISO_9796_DS2::verify(const secure_vector<byte>& const_coded,
-                          const secure_vector<byte>& raw, size_t key_bits)
+bool ISO_9796_DS2::verify(const secure_vector<uint8_t>& const_coded,
+                          const secure_vector<uint8_t>& raw, size_t key_bits)
    {
    return iso9796_verification(const_coded,raw,key_bits,m_hash,m_SALT_SIZE);
    }
@@ -234,7 +234,7 @@ bool ISO_9796_DS2::verify(const secure_vector<byte>& const_coded,
  *  ISO-9796-2 signature scheme 3
  *  DS 3 is deterministic and equals DS2 without salt
  */
-void ISO_9796_DS3::update(const byte input[], size_t length)
+void ISO_9796_DS3::update(const uint8_t input[], size_t length)
    {
    //need to buffer message completely, before digest
    m_msg_buffer.insert(m_msg_buffer.end(), input, input+length);
@@ -243,9 +243,9 @@ void ISO_9796_DS3::update(const byte input[], size_t length)
 /*
  * Return the raw (unencoded) data
  */
-secure_vector<byte> ISO_9796_DS3::raw_data()
+secure_vector<uint8_t> ISO_9796_DS3::raw_data()
    {
-   secure_vector<byte> retbuffer = m_msg_buffer;
+   secure_vector<uint8_t> retbuffer = m_msg_buffer;
    m_msg_buffer.clear();
    return retbuffer;
    }
@@ -253,7 +253,7 @@ secure_vector<byte> ISO_9796_DS3::raw_data()
 /*
  *  ISO-9796-2 scheme 3 encode operation
  */
-secure_vector<byte> ISO_9796_DS3::encoding_of(const secure_vector<byte>& msg,
+secure_vector<uint8_t> ISO_9796_DS3::encoding_of(const secure_vector<uint8_t>& msg,
       size_t output_bits, RandomNumberGenerator& rng)
    {
    return iso9796_encoding(msg, output_bits, m_hash, 0, m_implicit, rng);
@@ -262,8 +262,8 @@ secure_vector<byte> ISO_9796_DS3::encoding_of(const secure_vector<byte>& msg,
 /*
  * ISO-9796-2 scheme 3 verify operation
  */
-bool ISO_9796_DS3::verify(const secure_vector<byte>& const_coded,
-                          const secure_vector<byte>& raw, size_t key_bits)
+bool ISO_9796_DS3::verify(const secure_vector<uint8_t>& const_coded,
+                          const secure_vector<uint8_t>& raw, size_t key_bits)
    {
    return iso9796_verification(const_coded, raw, key_bits, m_hash, 0);
    }
diff --git a/src/lib/pk_pad/iso9796/iso9796.h b/src/lib/pk_pad/iso9796/iso9796.h
index da3fff055..81e008e47 100644
--- a/src/lib/pk_pad/iso9796/iso9796.h
+++ b/src/lib/pk_pad/iso9796/iso9796.h
@@ -37,22 +37,22 @@ class BOTAN_DLL ISO_9796_DS2 final : public EMSA
       EMSA* clone() override
          {return new ISO_9796_DS2(m_hash->clone(), m_implicit, m_SALT_SIZE);}
    private:
-      void update(const byte input[], size_t length) override;
+      void update(const uint8_t input[], size_t length) override;
 
-      secure_vector<byte> raw_data() override;
+      secure_vector<uint8_t> raw_data() override;
 
-      secure_vector<byte> encoding_of(const secure_vector<byte>& msg,
+      secure_vector<uint8_t> encoding_of(const secure_vector<uint8_t>& msg,
                                       size_t output_bits,
                                       RandomNumberGenerator& rng) override;
 
-      bool verify(const secure_vector<byte>& coded,
-                  const secure_vector<byte>& raw,
+      bool verify(const secure_vector<uint8_t>& coded,
+                  const secure_vector<uint8_t>& raw,
                   size_t key_bits) override;
 
       std::unique_ptr<HashFunction> m_hash;
       bool m_implicit;
       size_t m_SALT_SIZE;
-      secure_vector<byte> m_msg_buffer;
+      secure_vector<uint8_t> m_msg_buffer;
    };
 
 /**
@@ -71,21 +71,21 @@ class BOTAN_DLL ISO_9796_DS3 final : public EMSA
       EMSA* clone() override
          {return new ISO_9796_DS3(m_hash->clone(), m_implicit);}
    private:
-      void update(const byte input[], size_t length) override;
+      void update(const uint8_t input[], size_t length) override;
 
-      secure_vector<byte> raw_data() override;
+      secure_vector<uint8_t> raw_data() override;
 
-      secure_vector<byte> encoding_of(const secure_vector<byte>& msg,
+      secure_vector<uint8_t> encoding_of(const secure_vector<uint8_t>& msg,
                                       size_t output_bits,
                                       RandomNumberGenerator& rng) override;
 
-      bool verify(const secure_vector<byte>& coded,
-                  const secure_vector<byte>& raw,
+      bool verify(const secure_vector<uint8_t>& coded,
+                  const secure_vector<uint8_t>& raw,
                   size_t key_bits) override;
 
       std::unique_ptr<HashFunction> m_hash;
       bool m_implicit;
-      secure_vector<byte> m_msg_buffer;
+      secure_vector<uint8_t> m_msg_buffer;
    };
 
 }
diff --git a/src/lib/pk_pad/mgf1/mgf1.cpp b/src/lib/pk_pad/mgf1/mgf1.cpp
index 34bc4a9a9..8903ac6f0 100644
--- a/src/lib/pk_pad/mgf1/mgf1.cpp
+++ b/src/lib/pk_pad/mgf1/mgf1.cpp
@@ -12,16 +12,16 @@
 namespace Botan {
 
 void mgf1_mask(HashFunction& hash,
-               const byte in[], size_t in_len,
-               byte out[], size_t out_len)
+               const uint8_t in[], size_t in_len,
+               uint8_t out[], size_t out_len)
    {
-   u32bit counter = 0;
+   uint32_t counter = 0;
 
    while(out_len)
       {
       hash.update(in, in_len);
       hash.update_be(counter);
-      secure_vector<byte> buffer = hash.final();
+      secure_vector<uint8_t> buffer = hash.final();
 
       size_t xored = std::min<size_t>(buffer.size(), out_len);
       xor_buf(out, buffer.data(), xored);
diff --git a/src/lib/pk_pad/mgf1/mgf1.h b/src/lib/pk_pad/mgf1/mgf1.h
index 034b0328e..27160bd9a 100644
--- a/src/lib/pk_pad/mgf1/mgf1.h
+++ b/src/lib/pk_pad/mgf1/mgf1.h
@@ -21,8 +21,8 @@ namespace Botan {
 * @param out_len size of the output buffer in bytes
 */
 void BOTAN_DLL mgf1_mask(HashFunction& hash,
-                         const byte in[], size_t in_len,
-                         byte out[], size_t out_len);
+                         const uint8_t in[], size_t in_len,
+                         uint8_t out[], size_t out_len);
 
 }