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.

23 files changed, 200 insertions, 200 deletions

diff --git a/src/lib/prov/openssl/openssl_block.cpp b/src/lib/prov/openssl/openssl_block.cpp
index cb98be70d..842730af7 100644
--- a/src/lib/prov/openssl/openssl_block.cpp
+++ b/src/lib/prov/openssl/openssl_block.cpp
@@ -34,19 +34,19 @@ class OpenSSL_BlockCipher : public BlockCipher
 
       Key_Length_Specification key_spec() const override { return m_cipher_key_spec; }
 
-      void encrypt_n(const byte in[], byte out[], size_t blocks) const override
+      void encrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const override
          {
          int out_len = 0;
          EVP_EncryptUpdate(&m_encrypt, out, &out_len, in, blocks * m_block_sz);
          }
 
-      void decrypt_n(const byte in[], byte out[], size_t blocks) const override
+      void decrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const override
          {
          int out_len = 0;
          EVP_DecryptUpdate(&m_decrypt, out, &out_len, in, blocks * m_block_sz);
          }
 
-      void key_schedule(const byte key[], size_t key_len) override;
+      void key_schedule(const uint8_t key[], size_t key_len) override;
 
       size_t m_block_sz;
       Key_Length_Specification m_cipher_key_spec;
@@ -104,9 +104,9 @@ OpenSSL_BlockCipher::~OpenSSL_BlockCipher()
 /*
 * Set the key
 */
-void OpenSSL_BlockCipher::key_schedule(const byte key[], size_t length)
+void OpenSSL_BlockCipher::key_schedule(const uint8_t key[], size_t length)
    {
-   secure_vector<byte> full_key(key, key + length);
+   secure_vector<uint8_t> full_key(key, key + length);
 
    if(m_cipher_name == "TripleDES" && length == 16)
       {
diff --git a/src/lib/prov/openssl/openssl_ec.cpp b/src/lib/prov/openssl/openssl_ec.cpp
index 5fe7865a1..84f3a1ca0 100644
--- a/src/lib/prov/openssl/openssl_ec.cpp
+++ b/src/lib/prov/openssl/openssl_ec.cpp
@@ -43,7 +43,7 @@ namespace Botan {
 
 namespace {
 
-secure_vector<byte> PKCS8_for_openssl(const EC_PrivateKey& ec)
+secure_vector<uint8_t> PKCS8_for_openssl(const EC_PrivateKey& ec)
    {
    const PointGFp& pub_key = ec.public_point();
    const BigInt& priv_key = ec.private_value();
@@ -123,8 +123,8 @@ class OpenSSL_ECDSA_Verification_Operation : public PK_Ops::Verification_with_EM
 
          ::EC_KEY_set_group(m_ossl_ec.get(), grp.get());
 
-         const secure_vector<byte> enc = EC2OSP(ecdsa.public_point(), PointGFp::UNCOMPRESSED);
-         const byte* enc_ptr = enc.data();
+         const secure_vector<uint8_t> enc = EC2OSP(ecdsa.public_point(), PointGFp::UNCOMPRESSED);
+         const uint8_t* enc_ptr = enc.data();
          EC_KEY* key_ptr = m_ossl_ec.get();
          if(!::o2i_ECPublicKey(&key_ptr, &enc_ptr, enc.size()))
             throw OpenSSL_Error("o2i_ECPublicKey");
@@ -137,8 +137,8 @@ class OpenSSL_ECDSA_Verification_Operation : public PK_Ops::Verification_with_EM
 
       bool with_recovery() const override { return false; }
 
-      bool verify(const byte msg[], size_t msg_len,
-                  const byte sig_bytes[], size_t sig_len) override
+      bool verify(const uint8_t msg[], size_t msg_len,
+                  const uint8_t sig_bytes[], size_t sig_len) override
          {
          const size_t order_bytes = (m_order_bits + 7) / 8;
          if(sig_len != 2 * order_bytes)
@@ -168,8 +168,8 @@ class OpenSSL_ECDSA_Signing_Operation : public PK_Ops::Signature_with_EMSA
          PK_Ops::Signature_with_EMSA(emsa),
          m_ossl_ec(nullptr, ::EC_KEY_free)
          {
-         const secure_vector<byte> der = PKCS8_for_openssl(ecdsa);
-         const byte* der_ptr = der.data();
+         const secure_vector<uint8_t> der = PKCS8_for_openssl(ecdsa);
+         const uint8_t* der_ptr = der.data();
          m_ossl_ec.reset(d2i_ECPrivateKey(nullptr, &der_ptr, der.size()));
          if(!m_ossl_ec)
             throw OpenSSL_Error("d2i_ECPrivateKey");
@@ -178,7 +178,7 @@ class OpenSSL_ECDSA_Signing_Operation : public PK_Ops::Signature_with_EMSA
          m_order_bits = ::EC_GROUP_get_degree(group);
          }
 
-      secure_vector<byte> raw_sign(const byte msg[], size_t msg_len,
+      secure_vector<uint8_t> raw_sign(const uint8_t msg[], size_t msg_len,
                                    RandomNumberGenerator&) override
          {
          std::unique_ptr<ECDSA_SIG, std::function<void (ECDSA_SIG*)>> sig(nullptr, ECDSA_SIG_free);
@@ -190,7 +190,7 @@ class OpenSSL_ECDSA_Signing_Operation : public PK_Ops::Signature_with_EMSA
          const size_t order_bytes = (m_order_bits + 7) / 8;
          const size_t r_bytes = BN_num_bytes(sig->r);
          const size_t s_bytes = BN_num_bytes(sig->s);
-         secure_vector<byte> sigval(2*order_bytes);
+         secure_vector<uint8_t> sigval(2*order_bytes);
          BN_bn2bin(sig->r, &sigval[order_bytes - r_bytes]);
          BN_bn2bin(sig->s, &sigval[2*order_bytes - s_bytes]);
          return sigval;
@@ -240,18 +240,18 @@ class OpenSSL_ECDH_KA_Operation : public PK_Ops::Key_Agreement_with_KDF
       OpenSSL_ECDH_KA_Operation(const ECDH_PrivateKey& ecdh, const std::string& kdf) :
          PK_Ops::Key_Agreement_with_KDF(kdf), m_ossl_ec(::EC_KEY_new(), ::EC_KEY_free)
          {
-         const secure_vector<byte> der = PKCS8_for_openssl(ecdh);
-         const byte* der_ptr = der.data();
+         const secure_vector<uint8_t> der = PKCS8_for_openssl(ecdh);
+         const uint8_t* der_ptr = der.data();
          m_ossl_ec.reset(d2i_ECPrivateKey(nullptr, &der_ptr, der.size()));
          if(!m_ossl_ec)
             throw OpenSSL_Error("d2i_ECPrivateKey");
          }
 
-      secure_vector<byte> raw_agree(const byte w[], size_t w_len) override
+      secure_vector<uint8_t> raw_agree(const uint8_t w[], size_t w_len) override
          {
          const EC_GROUP* group = ::EC_KEY_get0_group(m_ossl_ec.get());
          const size_t out_len = (::EC_GROUP_get_degree(group) + 7) / 8;
-         secure_vector<byte> out(out_len);
+         secure_vector<uint8_t> out(out_len);
          EC_POINT* pub_key = ::EC_POINT_new(group);
 
          if(!pub_key)
diff --git a/src/lib/prov/openssl/openssl_hash.cpp b/src/lib/prov/openssl/openssl_hash.cpp
index 8e36866a1..19a12d938 100644
--- a/src/lib/prov/openssl/openssl_hash.cpp
+++ b/src/lib/prov/openssl/openssl_hash.cpp
@@ -54,12 +54,12 @@ class OpenSSL_HashFunction : public HashFunction
          }
 
    private:
-      void add_data(const byte input[], size_t length) override
+      void add_data(const uint8_t input[], size_t length) override
          {
          EVP_DigestUpdate(&m_md, input, length);
          }
 
-      void final_result(byte output[]) override
+      void final_result(uint8_t output[]) override
          {
          EVP_DigestFinal_ex(&m_md, output, nullptr);
          const EVP_MD* algo = EVP_MD_CTX_md(&m_md);
diff --git a/src/lib/prov/openssl/openssl_rc4.cpp b/src/lib/prov/openssl/openssl_rc4.cpp
index c8ba32235..9cca7fdd1 100644
--- a/src/lib/prov/openssl/openssl_rc4.cpp
+++ b/src/lib/prov/openssl/openssl_rc4.cpp
@@ -48,26 +48,26 @@ class OpenSSL_RC4 : public StreamCipher
       explicit OpenSSL_RC4(size_t skip = 0) : m_skip(skip) { clear(); }
       ~OpenSSL_RC4() { clear(); }
 
-      void set_iv(const byte*, size_t len) override
+      void set_iv(const uint8_t*, size_t len) override
          {
          if(len > 0)
             throw Exception("RC4 does not support an IV");
          }
 
-      void seek(u64bit) override
+      void seek(uint64_t) override
          {
          throw Exception("RC4 does not support seeking");
          }
    private:
-      void cipher(const byte in[], byte out[], size_t length) override
+      void cipher(const uint8_t in[], uint8_t out[], size_t length) override
          {
          ::RC4(&m_rc4, length, in, out);
          }
 
-      void key_schedule(const byte key[], size_t length) override
+      void key_schedule(const uint8_t key[], size_t length) override
          {
          ::RC4_set_key(&m_rc4, length, key);
-         byte d = 0;
+         uint8_t d = 0;
          for(size_t i = 0; i != m_skip; ++i)
             ::RC4(&m_rc4, 1, &d, &d);
          }
diff --git a/src/lib/prov/openssl/openssl_rsa.cpp b/src/lib/prov/openssl/openssl_rsa.cpp
index aef9c95d8..e7a562cf5 100644
--- a/src/lib/prov/openssl/openssl_rsa.cpp
+++ b/src/lib/prov/openssl/openssl_rsa.cpp
@@ -44,8 +44,8 @@ class OpenSSL_RSA_Encryption_Operation : public PK_Ops::Encryption
       OpenSSL_RSA_Encryption_Operation(const RSA_PublicKey& rsa, int pad, size_t pad_overhead) :
          m_openssl_rsa(nullptr, ::RSA_free), m_padding(pad)
          {
-         const std::vector<byte> der = rsa.public_key_bits();
-         const byte* der_ptr = der.data();
+         const std::vector<uint8_t> der = rsa.public_key_bits();
+         const uint8_t* der_ptr = der.data();
          m_openssl_rsa.reset(::d2i_RSAPublicKey(nullptr, &der_ptr, der.size()));
          if(!m_openssl_rsa)
             throw OpenSSL_Error("d2i_RSAPublicKey");
@@ -55,7 +55,7 @@ class OpenSSL_RSA_Encryption_Operation : public PK_Ops::Encryption
 
       size_t max_input_bits() const override { return m_bits; };
 
-      secure_vector<byte> encrypt(const byte msg[], size_t msg_len,
+      secure_vector<uint8_t> encrypt(const uint8_t msg[], size_t msg_len,
                                   RandomNumberGenerator&) override
          {
          const size_t mod_sz = n_size();
@@ -63,9 +63,9 @@ class OpenSSL_RSA_Encryption_Operation : public PK_Ops::Encryption
          if(msg_len > mod_sz)
             throw Invalid_Argument("Input too large for RSA key");
 
-         secure_vector<byte> outbuf(mod_sz);
+         secure_vector<uint8_t> outbuf(mod_sz);
 
-         secure_vector<byte> inbuf;
+         secure_vector<uint8_t> inbuf;
 
          if(m_padding == RSA_NO_PADDING)
             {
@@ -99,17 +99,17 @@ class OpenSSL_RSA_Decryption_Operation : public PK_Ops::Decryption
       OpenSSL_RSA_Decryption_Operation(const RSA_PrivateKey& rsa, int pad) :
          m_openssl_rsa(nullptr, ::RSA_free), m_padding(pad)
          {
-         const secure_vector<byte> der = rsa.private_key_bits();
-         const byte* der_ptr = der.data();
+         const secure_vector<uint8_t> der = rsa.private_key_bits();
+         const uint8_t* der_ptr = der.data();
          m_openssl_rsa.reset(d2i_RSAPrivateKey(nullptr, &der_ptr, der.size()));
          if(!m_openssl_rsa)
             throw OpenSSL_Error("d2i_RSAPrivateKey");
          }
 
-      secure_vector<byte> decrypt(byte& valid_mask,
-                                  const byte msg[], size_t msg_len) override
+      secure_vector<uint8_t> decrypt(uint8_t& valid_mask,
+                                  const uint8_t msg[], size_t msg_len) override
          {
-         secure_vector<byte> buf(::RSA_size(m_openssl_rsa.get()));
+         secure_vector<uint8_t> buf(::RSA_size(m_openssl_rsa.get()));
          int rc = ::RSA_private_decrypt(msg_len, msg, buf.data(), m_openssl_rsa.get(), m_padding);
          if(rc < 0 || static_cast<size_t>(rc) > buf.size())
             {
@@ -143,8 +143,8 @@ class OpenSSL_RSA_Verification_Operation : public PK_Ops::Verification_with_EMSA
          PK_Ops::Verification_with_EMSA(emsa),
          m_openssl_rsa(nullptr, ::RSA_free)
          {
-         const std::vector<byte> der = rsa.public_key_bits();
-         const byte* der_ptr = der.data();
+         const std::vector<uint8_t> der = rsa.public_key_bits();
+         const uint8_t* der_ptr = der.data();
          m_openssl_rsa.reset(::d2i_RSAPublicKey(nullptr, &der_ptr, der.size()));
          }
 
@@ -152,17 +152,17 @@ class OpenSSL_RSA_Verification_Operation : public PK_Ops::Verification_with_EMSA
 
       bool with_recovery() const override { return true; }
 
-      secure_vector<byte> verify_mr(const byte msg[], size_t msg_len) override
+      secure_vector<uint8_t> verify_mr(const uint8_t msg[], size_t msg_len) override
          {
          const size_t mod_sz = ::RSA_size(m_openssl_rsa.get());
 
          if(msg_len > mod_sz)
             throw Invalid_Argument("OpenSSL RSA verify input too large");
 
-         secure_vector<byte> inbuf(mod_sz);
+         secure_vector<uint8_t> inbuf(mod_sz);
          copy_mem(&inbuf[mod_sz - msg_len], msg, msg_len);
 
-         secure_vector<byte> outbuf(mod_sz);
+         secure_vector<uint8_t> outbuf(mod_sz);
 
          int rc = ::RSA_public_decrypt(inbuf.size(), inbuf.data(), outbuf.data(),
                                        m_openssl_rsa.get(), RSA_NO_PADDING);
@@ -183,14 +183,14 @@ class OpenSSL_RSA_Signing_Operation : public PK_Ops::Signature_with_EMSA
          PK_Ops::Signature_with_EMSA(emsa),
          m_openssl_rsa(nullptr, ::RSA_free)
          {
-         const secure_vector<byte> der = rsa.private_key_bits();
-         const byte* der_ptr = der.data();
+         const secure_vector<uint8_t> der = rsa.private_key_bits();
+         const uint8_t* der_ptr = der.data();
          m_openssl_rsa.reset(d2i_RSAPrivateKey(nullptr, &der_ptr, der.size()));
          if(!m_openssl_rsa)
             throw OpenSSL_Error("d2i_RSAPrivateKey");
          }
 
-      secure_vector<byte> raw_sign(const byte msg[], size_t msg_len,
+      secure_vector<uint8_t> raw_sign(const uint8_t msg[], size_t msg_len,
                                    RandomNumberGenerator&) override
          {
          const size_t mod_sz = ::RSA_size(m_openssl_rsa.get());
@@ -198,10 +198,10 @@ class OpenSSL_RSA_Signing_Operation : public PK_Ops::Signature_with_EMSA
          if(msg_len > mod_sz)
             throw Invalid_Argument("OpenSSL RSA sign input too large");
 
-         secure_vector<byte> inbuf(mod_sz);
+         secure_vector<uint8_t> inbuf(mod_sz);
          copy_mem(&inbuf[mod_sz - msg_len], msg, msg_len);
 
-         secure_vector<byte> outbuf(mod_sz);
+         secure_vector<uint8_t> outbuf(mod_sz);
 
          int rc = ::RSA_private_encrypt(inbuf.size(), inbuf.data(), outbuf.data(),
                                         m_openssl_rsa.get(), RSA_NO_PADDING);
diff --git a/src/lib/prov/pkcs11/p11.h b/src/lib/prov/pkcs11/p11.h
index 72abcd611..efc887e11 100644
--- a/src/lib/prov/pkcs11/p11.h
+++ b/src/lib/prov/pkcs11/p11.h
@@ -58,7 +58,7 @@ static_assert(CRYPTOKI_VERSION_MAJOR == 2 && CRYPTOKI_VERSION_MINOR == 40,
 namespace Botan {
 namespace PKCS11 {
 
-using secure_string = secure_vector<byte>;
+using secure_string = secure_vector<uint8_t>;
 
 enum class AttributeType : CK_ATTRIBUTE_TYPE
    {
@@ -1149,7 +1149,7 @@ class BOTAN_DLL LowLevel
       */
       template<typename TAlloc>
       bool C_InitToken(SlotId slot_id,
-                       const std::vector<byte, TAlloc>& so_pin,
+                       const std::vector<uint8_t, TAlloc>& so_pin,
                        const std::string& label,
                        ReturnValue* return_value = ThrowException) const
          {
@@ -1159,7 +1159,7 @@ class BOTAN_DLL LowLevel
             padded_label.insert(padded_label.end(), 32 - label.size(), ' ');
             }
 
-         return C_InitToken(slot_id, reinterpret_cast< Utf8Char* >(const_cast< byte* >(so_pin.data())),
+         return C_InitToken(slot_id, reinterpret_cast< Utf8Char* >(const_cast< uint8_t* >(so_pin.data())),
                             so_pin.size(), reinterpret_cast< Utf8Char* >(const_cast< char* >(padded_label.c_str())), return_value);
          }
 
@@ -1201,10 +1201,10 @@ class BOTAN_DLL LowLevel
       */
       template<typename TAlloc>
       bool C_InitPIN(SessionHandle session,
-                     const std::vector<byte, TAlloc>& pin,
+                     const std::vector<uint8_t, TAlloc>& pin,
                      ReturnValue* return_value = ThrowException) const
          {
-         return C_InitPIN(session, reinterpret_cast< Utf8Char* >(const_cast< byte* >(pin.data())), pin.size(), return_value);
+         return C_InitPIN(session, reinterpret_cast< Utf8Char* >(const_cast< uint8_t* >(pin.data())), pin.size(), return_value);
          }
 
       /**
@@ -1250,13 +1250,13 @@ class BOTAN_DLL LowLevel
       */
       template<typename TAlloc>
       bool C_SetPIN(SessionHandle session,
-                    const std::vector<byte, TAlloc>& old_pin,
-                    const std::vector<byte, TAlloc>& new_pin,
+                    const std::vector<uint8_t, TAlloc>& old_pin,
+                    const std::vector<uint8_t, TAlloc>& new_pin,
                     ReturnValue* return_value = ThrowException) const
          {
          return C_SetPIN(session,
-                         reinterpret_cast< Utf8Char* >(const_cast< byte* >(old_pin.data())), old_pin.size(),
-                         reinterpret_cast< Utf8Char* >(const_cast< byte* >(new_pin.data())), new_pin.size(),
+                         reinterpret_cast< Utf8Char* >(const_cast< uint8_t* >(old_pin.data())), old_pin.size(),
+                         reinterpret_cast< Utf8Char* >(const_cast< uint8_t* >(new_pin.data())), new_pin.size(),
                          return_value);
          }
 
@@ -1423,10 +1423,10 @@ class BOTAN_DLL LowLevel
       template<typename TAlloc>
       bool C_Login(SessionHandle session,
                    UserType user_type,
-                   const std::vector<byte, TAlloc>& pin,
+                   const std::vector<uint8_t, TAlloc>& pin,
                    ReturnValue* return_value = ThrowException) const
          {
-         return C_Login(session, user_type, reinterpret_cast< Utf8Char* >(const_cast< byte* >(pin.data())), pin.size(),
+         return C_Login(session, user_type, reinterpret_cast< Utf8Char* >(const_cast< uint8_t* >(pin.data())), pin.size(),
                         return_value);
          }
 
@@ -1576,7 +1576,7 @@ class BOTAN_DLL LowLevel
       template<typename TAlloc>
       bool C_GetAttributeValue(SessionHandle session,
                                ObjectHandle object,
-                               std::map<AttributeType, std::vector<byte, TAlloc>>& attribute_values,
+                               std::map<AttributeType, std::vector<uint8_t, TAlloc>>& attribute_values,
                                ReturnValue* return_value = ThrowException) const
          {
          std::vector<Attribute> getter_template;
@@ -1599,7 +1599,7 @@ class BOTAN_DLL LowLevel
             {
             entry.second.clear();
             entry.second.resize(getter_template.at(i).ulValueLen);
-            getter_template.at(i).pValue = const_cast< byte* >(entry.second.data());
+            getter_template.at(i).pValue = const_cast< uint8_t* >(entry.second.data());
             i++;
             }
 
@@ -1651,7 +1651,7 @@ class BOTAN_DLL LowLevel
       template<typename TAlloc>
       bool C_SetAttributeValue(SessionHandle session,
                                ObjectHandle object,
-                               std::map<AttributeType, std::vector<byte, TAlloc>>& attribute_values,
+                               std::map<AttributeType, std::vector<uint8_t, TAlloc>>& attribute_values,
                                ReturnValue* return_value = ThrowException) const
          {
          std::vector<Attribute> setter_template;
@@ -1788,8 +1788,8 @@ class BOTAN_DLL LowLevel
       */
       template<typename TAllocA, typename TAllocB>
       bool C_Encrypt(SessionHandle session,
-                     const std::vector<byte, TAllocA>& plaintext_data,
-                     std::vector<byte, TAllocB>& encrypted_data,
+                     const std::vector<uint8_t, TAllocA>& plaintext_data,
+                     std::vector<uint8_t, TAllocB>& encrypted_data,
                      ReturnValue* return_value = ThrowException) const
          {
          Ulong encrypted_size = 0;
@@ -1915,8 +1915,8 @@ class BOTAN_DLL LowLevel
       */
       template<typename TAllocA, typename TAllocB>
       bool C_Decrypt(SessionHandle session,
-                     const std::vector<byte, TAllocA>& encrypted_data,
-                     std::vector<byte, TAllocB>& decrypted_data,
+                     const std::vector<uint8_t, TAllocA>& encrypted_data,
+                     std::vector<uint8_t, TAllocB>& decrypted_data,
                      ReturnValue* return_value = ThrowException) const
          {
          Ulong decrypted_size = 0;
@@ -2064,7 +2064,7 @@ class BOTAN_DLL LowLevel
       * C_DigestFinal finishes a multiple-part message-digesting operation.
       * @param session the session's handle
       * @param digest_ptr gets the message digest
-      * @param digest_len_ptr gets byte count of digest
+      * @param digest_len_ptr gets uint8_t count of digest
       * @param return_value default value (`ThrowException`): throw exception on error.
       * if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown.
       * At least the following PKCS#11 return values may be returned:
@@ -2147,8 +2147,8 @@ class BOTAN_DLL LowLevel
       */
       template<typename TAllocA, typename TAllocB>
       bool C_Sign(SessionHandle session,
-                  const std::vector<byte, TAllocA>& data,
-                  std::vector<byte, TAllocB>& signature,
+                  const std::vector<uint8_t, TAllocA>& data,
+                  std::vector<uint8_t, TAllocB>& signature,
                   ReturnValue* return_value = ThrowException) const
          {
          Ulong signature_size = 0;
@@ -2197,7 +2197,7 @@ class BOTAN_DLL LowLevel
       */
       template<typename TAlloc>
       bool C_SignUpdate(SessionHandle session,
-                        const std::vector<byte, TAlloc>& part,
+                        const std::vector<uint8_t, TAlloc>& part,
                         ReturnValue* return_value = ThrowException) const
          {
          return C_SignUpdate(session, const_cast<Byte*>(part.data()), part.size(), return_value);
@@ -2241,7 +2241,7 @@ class BOTAN_DLL LowLevel
       */
       template<typename TAlloc>
       bool C_SignFinal(SessionHandle session,
-                       std::vector<byte, TAlloc>& signature,
+                       std::vector<uint8_t, TAlloc>& signature,
                        ReturnValue* return_value = ThrowException) const
          {
          Ulong signature_size = 0;
@@ -2368,8 +2368,8 @@ class BOTAN_DLL LowLevel
       */
       template<typename TAllocA, typename TAllocB>
       bool C_Verify(SessionHandle session,
-                    const std::vector<byte, TAllocA>& data,
-                    std::vector<byte, TAllocB>& signature,
+                    const std::vector<uint8_t, TAllocA>& data,
+                    std::vector<uint8_t, TAllocB>& signature,
                     ReturnValue* return_value = ThrowException) const
          {
          return C_Verify(session, const_cast<Byte*>(data.data()), data.size(), signature.data(), signature.size(), return_value);
@@ -2411,7 +2411,7 @@ class BOTAN_DLL LowLevel
       */
       template<typename TAlloc>
       bool C_VerifyUpdate(SessionHandle session,
-                          std::vector<byte, TAlloc> part,
+                          std::vector<uint8_t, TAlloc> part,
                           ReturnValue* return_value = ThrowException) const
          {
          return C_VerifyUpdate(session, part.data(), part.size(), return_value);
diff --git a/src/lib/prov/pkcs11/p11_ecc_key.cpp b/src/lib/prov/pkcs11/p11_ecc_key.cpp
index 527daceaf..9366594a6 100644
--- a/src/lib/prov/pkcs11/p11_ecc_key.cpp
+++ b/src/lib/prov/pkcs11/p11_ecc_key.cpp
@@ -17,22 +17,22 @@ namespace Botan {
 namespace PKCS11 {
 namespace {
 /// Converts a DER-encoded ANSI X9.62 ECPoint to PointGFp
-PointGFp decode_public_point(const secure_vector<byte>& ec_point_data, const CurveGFp& curve)
+PointGFp decode_public_point(const secure_vector<uint8_t>& ec_point_data, const CurveGFp& curve)
    {
-   secure_vector<byte> ec_point;
+   secure_vector<uint8_t> ec_point;
    BER_Decoder(ec_point_data).decode(ec_point, OCTET_STRING);
    return OS2ECP(ec_point, curve);
    }
 }
 
-EC_PublicKeyGenerationProperties::EC_PublicKeyGenerationProperties(const std::vector<byte>& ec_params)
+EC_PublicKeyGenerationProperties::EC_PublicKeyGenerationProperties(const std::vector<uint8_t>& ec_params)
    : PublicKeyProperties(KeyType::Ec), m_ec_params(ec_params)
    {
    add_binary(AttributeType::EcParams, m_ec_params);
    }
 
-EC_PublicKeyImportProperties::EC_PublicKeyImportProperties(const std::vector<byte>& ec_params,
-      const std::vector<byte>& ec_point)
+EC_PublicKeyImportProperties::EC_PublicKeyImportProperties(const std::vector<uint8_t>& ec_params,
+      const std::vector<uint8_t>& ec_point)
    : PublicKeyProperties(KeyType::Ec), m_ec_params(ec_params), m_ec_point(ec_point)
    {
    add_binary(AttributeType::EcParams, m_ec_params);
@@ -42,7 +42,7 @@ EC_PublicKeyImportProperties::EC_PublicKeyImportProperties(const std::vector<byt
 PKCS11_EC_PublicKey::PKCS11_EC_PublicKey(Session& session, ObjectHandle handle)
    : Object(session, handle)
    {
-   secure_vector<byte> ec_parameters = get_attribute_value(AttributeType::EcParams);
+   secure_vector<uint8_t> ec_parameters = get_attribute_value(AttributeType::EcParams);
    m_domain_params = EC_Group(unlock(ec_parameters));
    m_public_key = decode_public_point(get_attribute_value(AttributeType::EcPoint), m_domain_params.get_curve());
    m_domain_encoding = EC_DOMPAR_ENC_EXPLICIT;
@@ -53,13 +53,13 @@ PKCS11_EC_PublicKey::PKCS11_EC_PublicKey(Session& session, const EC_PublicKeyImp
    {
    m_domain_params = EC_Group(props.ec_params());
 
-   secure_vector<byte> ec_point;
+   secure_vector<uint8_t> ec_point;
    BER_Decoder(props.ec_point()).decode(ec_point, OCTET_STRING);
    m_public_key = OS2ECP(ec_point, m_domain_params.get_curve());
    m_domain_encoding = EC_DOMPAR_ENC_EXPLICIT;
    }
 
-EC_PrivateKeyImportProperties::EC_PrivateKeyImportProperties(const std::vector<byte>& ec_params, const BigInt& value)
+EC_PrivateKeyImportProperties::EC_PrivateKeyImportProperties(const std::vector<uint8_t>& ec_params, const BigInt& value)
    : PrivateKeyProperties(KeyType::Ec), m_ec_params(ec_params), m_value(value)
    {
    add_binary(AttributeType::EcParams, m_ec_params);
@@ -69,7 +69,7 @@ EC_PrivateKeyImportProperties::EC_PrivateKeyImportProperties(const std::vector<b
 PKCS11_EC_PrivateKey::PKCS11_EC_PrivateKey(Session& session, ObjectHandle handle)
    : Object(session, handle), m_domain_params(), m_public_key()
    {
-   secure_vector<byte> ec_parameters = get_attribute_value(AttributeType::EcParams);
+   secure_vector<uint8_t> ec_parameters = get_attribute_value(AttributeType::EcParams);
    m_domain_params = EC_Group(unlock(ec_parameters));
    }
 
@@ -79,7 +79,7 @@ PKCS11_EC_PrivateKey::PKCS11_EC_PrivateKey(Session& session, const EC_PrivateKey
    m_domain_params = EC_Group(props.ec_params());
    }
 
-PKCS11_EC_PrivateKey::PKCS11_EC_PrivateKey(Session& session, const std::vector<byte>& ec_params,
+PKCS11_EC_PrivateKey::PKCS11_EC_PrivateKey(Session& session, const std::vector<uint8_t>& ec_params,
       const EC_PrivateKeyGenerationProperties& props)
    : Object(session)
    {
@@ -106,7 +106,7 @@ size_t PKCS11_EC_PrivateKey::key_length() const
    return m_domain_params.get_order().bits();
    }
 
-std::vector<byte> PKCS11_EC_PrivateKey::public_key_bits() const
+std::vector<uint8_t> PKCS11_EC_PrivateKey::public_key_bits() const
    {
    return unlock(EC2OSP(public_point(), PointGFp::COMPRESSED));
    }
diff --git a/src/lib/prov/pkcs11/p11_ecc_key.h b/src/lib/prov/pkcs11/p11_ecc_key.h
index 69e612c33..6762d448e 100644
--- a/src/lib/prov/pkcs11/p11_ecc_key.h
+++ b/src/lib/prov/pkcs11/p11_ecc_key.h
@@ -30,16 +30,16 @@ class BOTAN_DLL EC_PublicKeyGenerationProperties final : public PublicKeyPropert
    {
    public:
       /// @param ec_params DER-encoding of an ANSI X9.62 Parameters value
-      EC_PublicKeyGenerationProperties(const std::vector<byte>& ec_params);
+      EC_PublicKeyGenerationProperties(const std::vector<uint8_t>& ec_params);
 
       /// @return the DER-encoding of the ec parameters according to ANSI X9.62
-      inline const std::vector<byte>& ec_params() const
+      inline const std::vector<uint8_t>& ec_params() const
          {
          return m_ec_params;
          }
 
    private:
-      const std::vector<byte> m_ec_params;
+      const std::vector<uint8_t> m_ec_params;
    };
 
 /// Properties for importing a PKCS#11 EC public key
@@ -50,23 +50,23 @@ class BOTAN_DLL EC_PublicKeyImportProperties final : public PublicKeyProperties
       * @param ec_params DER-encoding of an ANSI X9.62 Parameters value
       * @param ec_point DER-encoding of ANSI X9.62 ECPoint value Q
       */
-      EC_PublicKeyImportProperties(const std::vector<byte>& ec_params, const std::vector<byte>& ec_point);
+      EC_PublicKeyImportProperties(const std::vector<uint8_t>& ec_params, const std::vector<uint8_t>& ec_point);
 
       /// @return the DER-encoding of the ec parameters according to ANSI X9.62
-      inline const std::vector<byte>& ec_params() const
+      inline const std::vector<uint8_t>& ec_params() const
          {
          return m_ec_params;
          }
 
       /// @return the DER-encoding of the ec public point according to ANSI X9.62
-      inline const std::vector<byte>& ec_point() const
+      inline const std::vector<uint8_t>& ec_point() const
          {
          return m_ec_point;
          }
 
    private:
-      const std::vector<byte> m_ec_params;
-      const std::vector<byte> m_ec_point;
+      const std::vector<uint8_t> m_ec_params;
+      const std::vector<uint8_t> m_ec_point;
    };
 
 /// Represents a PKCS#11 EC public key
@@ -108,10 +108,10 @@ class BOTAN_DLL EC_PrivateKeyImportProperties final : public PrivateKeyPropertie
       * @param ec_params DER-encoding of an ANSI X9.62 Parameters value
       * @param value ANSI X9.62 private value d
       */
-      EC_PrivateKeyImportProperties(const std::vector<byte>& ec_params, const BigInt& value);
+      EC_PrivateKeyImportProperties(const std::vector<uint8_t>& ec_params, const BigInt& value);
 
       /// @return the DER-encoding of the ec parameters according to ANSI X9.62
-      inline const std::vector<byte>& ec_params() const
+      inline const std::vector<uint8_t>& ec_params() const
          {
          return m_ec_params;
          }
@@ -123,7 +123,7 @@ class BOTAN_DLL EC_PrivateKeyImportProperties final : public PrivateKeyPropertie
          }
 
    private:
-      const std::vector<byte> m_ec_params;
+      const std::vector<uint8_t> m_ec_params;
       const BigInt m_value;
    };
 
@@ -157,7 +157,7 @@ class BOTAN_DLL PKCS11_EC_PrivateKey : public virtual Private_Key,
       * @param props the attributes of the private key
       * @note no persistent public key object will be created
       */
-      PKCS11_EC_PrivateKey(Session& session, const std::vector<byte>& ec_params,
+      PKCS11_EC_PrivateKey(Session& session, const std::vector<uint8_t>& ec_params,
                            const EC_PrivateKeyGenerationProperties& props);
 
       /// @returns the domain of the EC private key
@@ -201,7 +201,7 @@ class BOTAN_DLL PKCS11_EC_PrivateKey : public virtual Private_Key,
 
       // Private_Key methods
 
-      std::vector<byte> public_key_bits() const override;
+      std::vector<uint8_t> public_key_bits() const override;
 
       std::size_t key_length() const override;
 
diff --git a/src/lib/prov/pkcs11/p11_ecdh.cpp b/src/lib/prov/pkcs11/p11_ecdh.cpp
index 50aa964d5..088b93894 100644
--- a/src/lib/prov/pkcs11/p11_ecdh.cpp
+++ b/src/lib/prov/pkcs11/p11_ecdh.cpp
@@ -33,7 +33,7 @@ ECDH_PrivateKey PKCS11_ECDH_PrivateKey::export_key() const
    return ECDH_PrivateKey(rng, domain(), BigInt::decode(priv_key));
    }
 
-secure_vector<byte> PKCS11_ECDH_PrivateKey::private_key_bits() const
+secure_vector<uint8_t> PKCS11_ECDH_PrivateKey::private_key_bits() const
    {
    return export_key().private_key_bits();
    }
@@ -49,10 +49,10 @@ class PKCS11_ECDH_KA_Operation : public PK_Ops::Key_Agreement
 
       /// The encoding in V2.20 was not specified and resulted in different implementations choosing different encodings.
       /// Applications relying only on a V2.20 encoding (e.g. the DER variant) other than the one specified now (raw) may not work with all V2.30 compliant tokens.
-      secure_vector<byte> agree(size_t key_len, const byte other_key[], size_t other_key_len, const byte salt[],
+      secure_vector<uint8_t> agree(size_t key_len, const uint8_t other_key[], size_t other_key_len, const uint8_t salt[],
                                 size_t salt_len) override
          {
-         std::vector<byte> der_encoded_other_key;
+         std::vector<uint8_t> der_encoded_other_key;
          if(m_key.point_encoding() == PublicPointEncoding::Der)
             {
             der_encoded_other_key = DER_Encoder().encode(other_key, other_key_len, OCTET_STRING).get_contents_unlocked();
@@ -79,7 +79,7 @@ class PKCS11_ECDH_KA_Operation : public PK_Ops::Key_Agreement
                                      attributes.count(), &secret_handle);
 
          Object secret_object(m_key.session(), secret_handle);
-         secure_vector<byte> secret = secret_object.get_attribute_value(AttributeType::Value);
+         secure_vector<uint8_t> secret = secret_object.get_attribute_value(AttributeType::Value);
          if(secret.size() < key_len)
             {
             throw PKCS11_Error("ECDH key derivation secret length is too short");
diff --git a/src/lib/prov/pkcs11/p11_ecdh.h b/src/lib/prov/pkcs11/p11_ecdh.h
index 7fc21ad46..c8e4017ba 100644
--- a/src/lib/prov/pkcs11/p11_ecdh.h
+++ b/src/lib/prov/pkcs11/p11_ecdh.h
@@ -83,7 +83,7 @@ class BOTAN_DLL PKCS11_ECDH_PrivateKey final : public virtual PKCS11_EC_PrivateK
       * @param props the attributes of the private key
       * @note no persistent public key object will be created
       */
-      PKCS11_ECDH_PrivateKey(Session& session, const std::vector<byte>& ec_params,
+      PKCS11_ECDH_PrivateKey(Session& session, const std::vector<uint8_t>& ec_params,
                              const EC_PrivateKeyGenerationProperties& props)
          : PKCS11_EC_PrivateKey(session, ec_params, props)
          {}
@@ -93,7 +93,7 @@ class BOTAN_DLL PKCS11_ECDH_PrivateKey final : public virtual PKCS11_EC_PrivateK
          return "ECDH";
          }
 
-      inline std::vector<byte> public_value() const override
+      inline std::vector<uint8_t> public_value() const override
          {
          return unlock(EC2OSP(public_point(), PointGFp::UNCOMPRESSED));
          }
@@ -101,7 +101,7 @@ class BOTAN_DLL PKCS11_ECDH_PrivateKey final : public virtual PKCS11_EC_PrivateK
       /// @return the exported ECDH private key
       ECDH_PrivateKey export_key() const;
 
-      secure_vector<byte> private_key_bits() const override;
+      secure_vector<uint8_t> private_key_bits() const override;
 
       std::unique_ptr<PK_Ops::Key_Agreement>
          create_key_agreement_op(RandomNumberGenerator& rng,
diff --git a/src/lib/prov/pkcs11/p11_ecdsa.cpp b/src/lib/prov/pkcs11/p11_ecdsa.cpp
index cbdd4d007..5be66caaf 100644
--- a/src/lib/prov/pkcs11/p11_ecdsa.cpp
+++ b/src/lib/prov/pkcs11/p11_ecdsa.cpp
@@ -47,7 +47,7 @@ ECDSA_PrivateKey PKCS11_ECDSA_PrivateKey::export_key() const
    return ECDSA_PrivateKey(rng, domain(), BigInt::decode(priv_key));
    }
 
-secure_vector<byte> PKCS11_ECDSA_PrivateKey::private_key_bits() const
+secure_vector<uint8_t> PKCS11_ECDSA_PrivateKey::private_key_bits() const
    {
    return export_key().private_key_bits();
    }
@@ -61,14 +61,14 @@ class PKCS11_ECDSA_Signature_Operation : public PK_Ops::Signature
          : PK_Ops::Signature(), m_key(key), m_order(key.domain().get_order()), m_mechanism(MechanismWrapper::create_ecdsa_mechanism(emsa))
          {}
 
-      void update(const byte msg[], size_t msg_len) override
+      void update(const uint8_t msg[], size_t msg_len) override
          {
          if(!m_initialized)
             {
             // first call to update: initialize and cache message because we can not determine yet whether a single- or multiple-part operation will be performed
             m_key.module()->C_SignInit(m_key.session().handle(), m_mechanism.data(), m_key.handle());
             m_initialized = true;
-            m_first_message = secure_vector<byte>(msg, msg + msg_len);
+            m_first_message = secure_vector<uint8_t>(msg, msg + msg_len);
             return;
             }
 
@@ -82,9 +82,9 @@ class PKCS11_ECDSA_Signature_Operation : public PK_Ops::Signature
          m_key.module()->C_SignUpdate(m_key.session().handle(), const_cast<Byte*>(msg), msg_len);
          }
 
-      secure_vector<byte> sign(RandomNumberGenerator&) override
+      secure_vector<uint8_t> sign(RandomNumberGenerator&) override
          {
-         secure_vector<byte> signature;
+         secure_vector<uint8_t> signature;
          if(!m_first_message.empty())
             {
             // single call to update: perform single-part operation
@@ -104,7 +104,7 @@ class PKCS11_ECDSA_Signature_Operation : public PK_Ops::Signature
       const PKCS11_EC_PrivateKey& m_key;
       const BigInt& m_order;
       MechanismWrapper m_mechanism;
-      secure_vector<byte> m_first_message;
+      secure_vector<uint8_t> m_first_message;
       bool m_initialized = false;
    };
 
@@ -116,14 +116,14 @@ class PKCS11_ECDSA_Verification_Operation : public PK_Ops::Verification
          : PK_Ops::Verification(), m_key(key), m_order(key.domain().get_order()), m_mechanism(MechanismWrapper::create_ecdsa_mechanism(emsa))
          {}
 
-      void update(const byte msg[], size_t msg_len) override
+      void update(const uint8_t msg[], size_t msg_len) override
          {
          if(!m_initialized)
             {
             // first call to update: initialize and cache message because we can not determine yet whether a single- or multiple-part operation will be performed
             m_key.module()->C_VerifyInit(m_key.session().handle(), m_mechanism.data(), m_key.handle());
             m_initialized = true;
-            m_first_message = secure_vector<byte>(msg, msg + msg_len);
+            m_first_message = secure_vector<uint8_t>(msg, msg + msg_len);
             return;
             }
 
@@ -137,7 +137,7 @@ class PKCS11_ECDSA_Verification_Operation : public PK_Ops::Verification
          m_key.module()->C_VerifyUpdate(m_key.session().handle(), const_cast<Byte*>(msg), msg_len);
          }
 
-      bool is_valid_signature(const byte sig[], size_t sig_len) override
+      bool is_valid_signature(const uint8_t sig[], size_t sig_len) override
          {
          ReturnValue return_value = ReturnValue::SignatureInvalid;
          if(!m_first_message.empty())
@@ -164,7 +164,7 @@ class PKCS11_ECDSA_Verification_Operation : public PK_Ops::Verification
       const PKCS11_EC_PublicKey& m_key;
       const BigInt& m_order;
       MechanismWrapper m_mechanism;
-      secure_vector<byte> m_first_message;
+      secure_vector<uint8_t> m_first_message;
       bool m_initialized = false;
    };
 
diff --git a/src/lib/prov/pkcs11/p11_ecdsa.h b/src/lib/prov/pkcs11/p11_ecdsa.h
index 73ee900db..c1ac0d557 100644
--- a/src/lib/prov/pkcs11/p11_ecdsa.h
+++ b/src/lib/prov/pkcs11/p11_ecdsa.h
@@ -85,7 +85,7 @@ class BOTAN_DLL PKCS11_ECDSA_PrivateKey final : public PKCS11_EC_PrivateKey
       * @param props the attributes of the private key
       * @note no persistent public key object will be created
       */
-      PKCS11_ECDSA_PrivateKey(Session& session, const std::vector<byte>& ec_params,
+      PKCS11_ECDSA_PrivateKey(Session& session, const std::vector<uint8_t>& ec_params,
                               const EC_PrivateKeyGenerationProperties& props)
          : PKCS11_EC_PrivateKey(session, ec_params, props)
          {}
@@ -98,7 +98,7 @@ class BOTAN_DLL PKCS11_ECDSA_PrivateKey final : public PKCS11_EC_PrivateKey
       /// @return the exported ECDSA private key
       ECDSA_PrivateKey export_key() const;
 
-      secure_vector<byte> private_key_bits() const override;
+      secure_vector<uint8_t> private_key_bits() const override;
 
       bool check_key(RandomNumberGenerator&, bool) const override;
 
diff --git a/src/lib/prov/pkcs11/p11_mechanism.h b/src/lib/prov/pkcs11/p11_mechanism.h
index dde5e5b07..be48c9a14 100644
--- a/src/lib/prov/pkcs11/p11_mechanism.h
+++ b/src/lib/prov/pkcs11/p11_mechanism.h
@@ -63,9 +63,9 @@ class MechanismWrapper final
       * @param salt the salt
       * @param salt_len size of the salt in bytes
       */
-      inline void set_ecdh_salt(const byte salt[], size_t salt_len)
+      inline void set_ecdh_salt(const uint8_t salt[], size_t salt_len)
          {
-         m_parameters->ecdh_params.pSharedData = const_cast<byte*>(salt);
+         m_parameters->ecdh_params.pSharedData = const_cast<uint8_t*>(salt);
          m_parameters->ecdh_params.ulSharedDataLen = salt_len;
          }
 
@@ -74,9 +74,9 @@ class MechanismWrapper final
       * @param other_key key of the other party
       * @param other_key_len size of the key of the other party in bytes
       */
-      inline void set_ecdh_other_key(const byte other_key[], size_t other_key_len)
+      inline void set_ecdh_other_key(const uint8_t other_key[], size_t other_key_len)
          {
-         m_parameters->ecdh_params.pPublicData = const_cast<byte*>(other_key);
+         m_parameters->ecdh_params.pPublicData = const_cast<uint8_t*>(other_key);
          m_parameters->ecdh_params.ulPublicDataLen = other_key_len;
          }
 
diff --git a/src/lib/prov/pkcs11/p11_object.cpp b/src/lib/prov/pkcs11/p11_object.cpp
index ef7477284..872fdf8b7 100644
--- a/src/lib/prov/pkcs11/p11_object.cpp
+++ b/src/lib/prov/pkcs11/p11_object.cpp
@@ -22,28 +22,28 @@ AttributeContainer::AttributeContainer(ObjectClass object_class)
 void AttributeContainer::add_class(ObjectClass object_class)
    {
    m_numerics.push_back(static_cast< uint64_t >(object_class));
-   add_attribute(AttributeType::Class, reinterpret_cast< byte* >(&m_numerics.back()), sizeof(ObjectClass));
+   add_attribute(AttributeType::Class, reinterpret_cast< uint8_t* >(&m_numerics.back()), sizeof(ObjectClass));
    }
 
 void AttributeContainer::add_string(AttributeType attribute, const std::string& value)
    {
    m_strings.push_back(value);
-   add_attribute(attribute, reinterpret_cast< const byte* >(m_strings.back().data()), value.size());
+   add_attribute(attribute, reinterpret_cast< const uint8_t* >(m_strings.back().data()), value.size());
    }
 
-void AttributeContainer::add_binary(AttributeType attribute, const byte* value, size_t length)
+void AttributeContainer::add_binary(AttributeType attribute, const uint8_t* value, size_t length)
    {
-   m_vectors.push_back(secure_vector<byte>(value, value + length));
-   add_attribute(attribute, reinterpret_cast< const byte* >(m_vectors.back().data()), length);
+   m_vectors.push_back(secure_vector<uint8_t>(value, value + length));
+   add_attribute(attribute, reinterpret_cast< const uint8_t* >(m_vectors.back().data()), length);
    }
 
 void AttributeContainer::add_bool(AttributeType attribute, bool value)
    {
    m_numerics.push_back(value ? True : False);
-   add_attribute(attribute, reinterpret_cast< byte* >(&m_numerics.back()), sizeof(Bbool));
+   add_attribute(attribute, reinterpret_cast< uint8_t* >(&m_numerics.back()), sizeof(Bbool));
    }
 
-void AttributeContainer::add_attribute(AttributeType attribute, const byte* value, uint32_t size)
+void AttributeContainer::add_attribute(AttributeType attribute, const uint8_t* value, uint32_t size)
    {
    bool exists = false;
    // check if the attribute has been added already
@@ -63,12 +63,12 @@ void AttributeContainer::add_attribute(AttributeType attribute, const byte* valu
             }), m_numerics.end());
 
          m_vectors.erase(std::remove_if(m_vectors.begin(),
-                                        m_vectors.end(), [ &existing_attribute ](const secure_vector<byte>& data)
+                                        m_vectors.end(), [ &existing_attribute ](const secure_vector<uint8_t>& data)
             {
             return data.data() == existing_attribute.pValue;
             }), m_vectors.end());
 
-         existing_attribute.pValue = const_cast< byte* >(value);
+         existing_attribute.pValue = const_cast< uint8_t* >(value);
          existing_attribute.ulValueLen = size;
          exists = true;
          break;
@@ -77,7 +77,7 @@ void AttributeContainer::add_attribute(AttributeType attribute, const byte* valu
 
    if(!exists)
       {
-      m_attributes.push_back(Attribute{ static_cast< CK_ATTRIBUTE_TYPE >(attribute), const_cast< byte* >(value), size });
+      m_attributes.push_back(Attribute{ static_cast< CK_ATTRIBUTE_TYPE >(attribute), const_cast< uint8_t* >(value), size });
       }
    }
 
@@ -188,16 +188,16 @@ Object::Object(Session& session, const ObjectProperties& obj_props)
    m_session.get().module()->C_CreateObject(m_session.get().handle(), obj_props.data(), obj_props.count(), &m_handle);
    }
 
-secure_vector<byte> Object::get_attribute_value(AttributeType attribute) const
+secure_vector<uint8_t> Object::get_attribute_value(AttributeType attribute) const
    {
-   std::map<AttributeType, secure_vector<byte>> attribute_map = { { attribute, secure_vector<byte>() } };
+   std::map<AttributeType, secure_vector<uint8_t>> attribute_map = { { attribute, secure_vector<uint8_t>() } };
    module()->C_GetAttributeValue(m_session.get().handle(), m_handle, attribute_map);
    return attribute_map.at(attribute);
    }
 
-void Object::set_attribute_value(AttributeType attribute, const secure_vector<byte>& value) const
+void Object::set_attribute_value(AttributeType attribute, const secure_vector<uint8_t>& value) const
    {
-   std::map<AttributeType, secure_vector<byte>> attribute_map = { { attribute, value } };
+   std::map<AttributeType, secure_vector<uint8_t>> attribute_map = { { attribute, value } };
    module()->C_SetAttributeValue(m_session.get().handle(), m_handle, attribute_map);
    }
 
diff --git a/src/lib/prov/pkcs11/p11_object.h b/src/lib/prov/pkcs11/p11_object.h
index cae1969a2..e7ab05f0d 100644
--- a/src/lib/prov/pkcs11/p11_object.h
+++ b/src/lib/prov/pkcs11/p11_object.h
@@ -83,7 +83,7 @@ class BOTAN_DLL AttributeContainer
       * @param value binary attribute value to add
       * @param length size of the binary attribute value in bytes
       */
-      void add_binary(AttributeType attribute, const byte* value, size_t length);
+      void add_binary(AttributeType attribute, const uint8_t* value, size_t length);
 
       /**
       * Add a binary attribute (e.g. CKA_ID / AttributeType::Id).
@@ -91,7 +91,7 @@ class BOTAN_DLL AttributeContainer
       * @param binary binary attribute value to add
       */
       template<typename TAlloc>
-      void add_binary(AttributeType attribute, const std::vector<byte, TAlloc>& binary)
+      void add_binary(AttributeType attribute, const std::vector<uint8_t, TAlloc>& binary)
          {
          add_binary(attribute, binary.data(), binary.size());
          }
@@ -113,18 +113,18 @@ class BOTAN_DLL AttributeContainer
          {
          static_assert(std::is_integral<T>::value, "Numeric value required.");
          m_numerics.push_back(static_cast< uint64_t >(value));
-         add_attribute(attribute, reinterpret_cast< byte* >(&m_numerics.back()), sizeof(T));
+         add_attribute(attribute, reinterpret_cast< uint8_t* >(&m_numerics.back()), sizeof(T));
          }
 
    protected:
       /// Add an attribute with the given value and size to the attribute collection `m_attributes`
-      void add_attribute(AttributeType attribute, const byte* value, uint32_t size);
+      void add_attribute(AttributeType attribute, const uint8_t* value, uint32_t size);
 
    private:
       std::vector<Attribute> m_attributes;
       std::list<uint64_t> m_numerics;
       std::list<std::string> m_strings;
-      std::list<secure_vector<byte>> m_vectors;
+      std::list<secure_vector<uint8_t>> m_vectors;
    };
 
 /// Manages calls to C_FindObjects* functions (C_FindObjectsInit -> C_FindObjects -> C_FindObjectsFinal)
@@ -249,13 +249,13 @@ class BOTAN_DLL DataObjectProperties : public StorageObjectProperties
          }
 
       /// @param object_id DER-encoding of the object identifier indicating the data object type
-      inline void set_object_id(const std::vector<byte>& object_id)
+      inline void set_object_id(const std::vector<uint8_t>& object_id)
          {
          add_binary(AttributeType::ObjectId, object_id);
          }
 
       /// @param value value of the object
-      inline void set_value(const secure_vector<byte>& value)
+      inline void set_value(const secure_vector<uint8_t>& value)
          {
          add_binary(AttributeType::Value, value);
          }
@@ -284,7 +284,7 @@ class BOTAN_DLL CertificateProperties : public StorageObjectProperties
       * @param checksum the value of this attribute is derived from the certificate by taking the
       * first three bytes of the SHA - 1 hash of the certificate object's `CKA_VALUE` attribute
       */
-      inline void set_check_value(const std::vector<byte>& checksum)
+      inline void set_check_value(const std::vector<uint8_t>& checksum)
          {
          add_binary(AttributeType::CheckValue, checksum);
          }
@@ -292,17 +292,17 @@ class BOTAN_DLL CertificateProperties : public StorageObjectProperties
       /// @param date start date for the certificate
       inline void set_start_date(Date date)
          {
-         add_binary(AttributeType::StartDate, reinterpret_cast<byte*>(&date), sizeof(Date));
+         add_binary(AttributeType::StartDate, reinterpret_cast<uint8_t*>(&date), sizeof(Date));
          }
 
       /// @param date end date for the certificate
       inline void set_end_date(Date date)
          {
-         add_binary(AttributeType::EndDate, reinterpret_cast<byte*>(&date), sizeof(Date));
+         add_binary(AttributeType::EndDate, reinterpret_cast<uint8_t*>(&date), sizeof(Date));
          }
 
       /// @param pubkey_info DER-encoding of the SubjectPublicKeyInfo for the public key contained in this certificate
-      inline void set_public_key_info(const std::vector<byte>& pubkey_info)
+      inline void set_public_key_info(const std::vector<uint8_t>& pubkey_info)
          {
          add_binary(AttributeType::PublicKeyInfo, pubkey_info);
          }
@@ -328,7 +328,7 @@ class BOTAN_DLL KeyProperties : public StorageObjectProperties
       KeyProperties(ObjectClass object_class, KeyType key_type);
 
       /// @param id key identifier for key
-      inline void set_id(const std::vector<byte>& id)
+      inline void set_id(const std::vector<uint8_t>& id)
          {
          add_binary(AttributeType::Id, id);
          }
@@ -336,13 +336,13 @@ class BOTAN_DLL KeyProperties : public StorageObjectProperties
       /// @param date start date for the key
       inline void set_start_date(Date date)
          {
-         add_binary(AttributeType::StartDate, reinterpret_cast<byte*>(&date), sizeof(Date));
+         add_binary(AttributeType::StartDate, reinterpret_cast<uint8_t*>(&date), sizeof(Date));
          }
 
       /// @param date end date for the key
       inline void set_end_date(Date date)
          {
-         add_binary(AttributeType::EndDate, reinterpret_cast<byte*>(&date), sizeof(Date));
+         add_binary(AttributeType::EndDate, reinterpret_cast<uint8_t*>(&date), sizeof(Date));
          }
 
       /// @param value true if key supports key derivation (i.e., if other keys can be derived from this one)
@@ -378,7 +378,7 @@ class BOTAN_DLL PublicKeyProperties : public KeyProperties
       PublicKeyProperties(KeyType key_type);
 
       /// @param subject DER-encoding of the key subject name
-      inline void set_subject(const std::vector<byte>& subject)
+      inline void set_subject(const std::vector<uint8_t>& subject)
          {
          add_binary(AttributeType::Subject, subject);
          }
@@ -428,7 +428,7 @@ class BOTAN_DLL PublicKeyProperties : public KeyProperties
          }
 
       /// @param pubkey_info DER-encoding of the SubjectPublicKeyInfo for this public	key
-      inline void set_public_key_info(const std::vector<byte>& pubkey_info)
+      inline void set_public_key_info(const std::vector<uint8_t>& pubkey_info)
          {
          add_binary(AttributeType::PublicKeyInfo, pubkey_info);
          }
@@ -442,7 +442,7 @@ class BOTAN_DLL PrivateKeyProperties : public KeyProperties
       PrivateKeyProperties(KeyType key_type);
 
       /// @param subject DER-encoding of the key subject name
-      inline void set_subject(const std::vector<byte>& subject)
+      inline void set_subject(const std::vector<uint8_t>& subject)
          {
          add_binary(AttributeType::Subject, subject);
          }
@@ -507,7 +507,7 @@ class BOTAN_DLL PrivateKeyProperties : public KeyProperties
          }
 
       /// @param pubkey_info DER-encoding of the SubjectPublicKeyInfo for this public	key
-      inline void set_public_key_info(const std::vector<byte>& pubkey_info)
+      inline void set_public_key_info(const std::vector<uint8_t>& pubkey_info)
          {
          add_binary(AttributeType::PublicKeyInfo, pubkey_info);
          }
@@ -590,7 +590,7 @@ class BOTAN_DLL SecretKeyProperties : public KeyProperties
          }
 
       /// @param checksum the key check value of this key
-      inline void set_check_value(const std::vector<byte>& checksum)
+      inline void set_check_value(const std::vector<uint8_t>& checksum)
          {
          add_binary(AttributeType::CheckValue, checksum);
          }
@@ -668,21 +668,21 @@ class BOTAN_DLL Object
 
       /// Searches for all objects of the given type using the id (`CKA_ID`)
       template<typename T>
-      static std::vector<T> search(Session& session, const std::vector<byte>& id);
+      static std::vector<T> search(Session& session, const std::vector<uint8_t>& id);
 
       /// Searches for all objects of the given type using the label (`CKA_LABEL`) and id (`CKA_ID`)
       template<typename T>
-      static std::vector<T> search(Session& session, const std::string& label, const std::vector<byte>& id);
+      static std::vector<T> search(Session& session, const std::string& label, const std::vector<uint8_t>& id);
 
       /// Searches for all objects of the given type
       template<typename T>
       static std::vector<T> search(Session& session);
 
       /// @returns the value of the given attribute (using `C_GetAttributeValue`)
-      secure_vector<byte> get_attribute_value(AttributeType attribute) const;
+      secure_vector<uint8_t> get_attribute_value(AttributeType attribute) const;
 
       /// Sets the given value for the attribute (using `C_SetAttributeValue`)
-      void set_attribute_value(AttributeType attribute, const secure_vector<byte>& value) const;
+      void set_attribute_value(AttributeType attribute, const secure_vector<uint8_t>& value) const;
 
       /// Destroys the object
       void destroy() const;
@@ -742,7 +742,7 @@ std::vector<T> Object::search(Session& session, const std::string& label)
    }
 
 template<typename T>
-std::vector<T> Object::search(Session& session, const std::vector<byte>& id)
+std::vector<T> Object::search(Session& session, const std::vector<uint8_t>& id)
    {
    AttributeContainer search_template(T::Class);
    search_template.add_binary(AttributeType::Id, id);
@@ -750,7 +750,7 @@ std::vector<T> Object::search(Session& session, const std::vector<byte>& id)
    }
 
 template<typename T>
-std::vector<T> Object::search(Session& session, const std::string& label, const std::vector<byte>& id)
+std::vector<T> Object::search(Session& session, const std::string& label, const std::vector<uint8_t>& id)
    {
    AttributeContainer search_template(T::Class);
    search_template.add_string(AttributeType::Label, label);
diff --git a/src/lib/prov/pkcs11/p11_randomgenerator.cpp b/src/lib/prov/pkcs11/p11_randomgenerator.cpp
index eaf9933c6..957a33cae 100644
--- a/src/lib/prov/pkcs11/p11_randomgenerator.cpp
+++ b/src/lib/prov/pkcs11/p11_randomgenerator.cpp
@@ -16,14 +16,14 @@ PKCS11_RNG::PKCS11_RNG(Session& session)
    : m_session(session)
    {}
 
-void PKCS11_RNG::randomize(Botan::byte output[], std::size_t length)
+void PKCS11_RNG::randomize(uint8_t output[], std::size_t length)
    {
    module()->C_GenerateRandom(m_session.get().handle(), output, length);
    }
 
-void PKCS11_RNG::add_entropy(const Botan::byte in[], std::size_t length)
+void PKCS11_RNG::add_entropy(const uint8_t in[], std::size_t length)
    {
-   module()->C_SeedRandom(m_session.get().handle(), const_cast<Botan::byte*>(in), length);
+   module()->C_SeedRandom(m_session.get().handle(), const_cast<uint8_t*>(in), length);
    }
 
 }
diff --git a/src/lib/prov/pkcs11/p11_randomgenerator.h b/src/lib/prov/pkcs11/p11_randomgenerator.h
index a291c89f3..6a29f8040 100644
--- a/src/lib/prov/pkcs11/p11_randomgenerator.h
+++ b/src/lib/prov/pkcs11/p11_randomgenerator.h
@@ -55,10 +55,10 @@ class BOTAN_DLL PKCS11_RNG final : public Hardware_RNG
          }
 
       /// Calls `C_GenerateRandom` to generate random data
-      void randomize(Botan::byte output[], std::size_t length) override;
+      void randomize(uint8_t output[], std::size_t length) override;
 
       /// Calls `C_SeedRandom` to add entropy to the random generation function of the token/middleware
-      void add_entropy(const Botan::byte in[], std::size_t length) override;
+      void add_entropy(const uint8_t in[], std::size_t length) override;
 
    private:
       const std::reference_wrapper<Session> m_session;
diff --git a/src/lib/prov/pkcs11/p11_rsa.cpp b/src/lib/prov/pkcs11/p11_rsa.cpp
index 1edbde83b..3bb7b7534 100644
--- a/src/lib/prov/pkcs11/p11_rsa.cpp
+++ b/src/lib/prov/pkcs11/p11_rsa.cpp
@@ -101,7 +101,7 @@ RSA_PrivateKey PKCS11_RSA_PrivateKey::export_key() const
                          , BigInt::decode(n));
    }
 
-secure_vector<byte> PKCS11_RSA_PrivateKey::private_key_bits() const
+secure_vector<uint8_t> PKCS11_RSA_PrivateKey::private_key_bits() const
    {
    return export_key().private_key_bits();
    }
@@ -127,12 +127,12 @@ class PKCS11_RSA_Decryption_Operation final : public PK_Ops::Decryption
          m_bits = m_key.get_n().bits() - 1;
          }
 
-      secure_vector<byte> decrypt(byte& valid_mask, const byte ciphertext[], size_t ciphertext_len) override
+      secure_vector<uint8_t> decrypt(uint8_t& valid_mask, const uint8_t ciphertext[], size_t ciphertext_len) override
          {
          valid_mask = 0;
          m_key.module()->C_DecryptInit(m_key.session().handle(), m_mechanism.data(), m_key.handle());
 
-         std::vector<byte> encrypted_data(ciphertext, ciphertext + ciphertext_len);
+         std::vector<uint8_t> encrypted_data(ciphertext, ciphertext + ciphertext_len);
 
          // blind for RSA/RAW decryption
          if(! m_mechanism.padding_size())
@@ -140,7 +140,7 @@ class PKCS11_RSA_Decryption_Operation final : public PK_Ops::Decryption
             encrypted_data = BigInt::encode(m_blinder.blind(BigInt::decode(encrypted_data)));
             }
 
-         secure_vector<byte> decrypted_data;
+         secure_vector<uint8_t> decrypted_data;
          m_key.module()->C_Decrypt(m_key.session().handle(), encrypted_data, decrypted_data);
 
          // Unblind for RSA/RAW decryption
@@ -178,12 +178,12 @@ class PKCS11_RSA_Encryption_Operation : public PK_Ops::Encryption
          return m_bits;
          }
 
-      secure_vector<byte> encrypt(const byte msg[], size_t msg_len, RandomNumberGenerator&) override
+      secure_vector<uint8_t> encrypt(const uint8_t msg[], size_t msg_len, RandomNumberGenerator&) override
          {
          m_key.module()->C_EncryptInit(m_key.session().handle(), m_mechanism.data(), m_key.handle());
 
-         secure_vector<byte> encrytped_data;
-         m_key.module()->C_Encrypt(m_key.session().handle(), secure_vector<byte>(msg, msg + msg_len), encrytped_data);
+         secure_vector<uint8_t> encrytped_data;
+         m_key.module()->C_Encrypt(m_key.session().handle(), secure_vector<uint8_t>(msg, msg + msg_len), encrytped_data);
          return encrytped_data;
          }
 
@@ -202,14 +202,14 @@ class PKCS11_RSA_Signature_Operation : public PK_Ops::Signature
          : m_key(key), m_mechanism(MechanismWrapper::create_rsa_sign_mechanism(padding))
          {}
 
-      void update(const byte msg[], size_t msg_len) override
+      void update(const uint8_t msg[], size_t msg_len) override
          {
          if(!m_initialized)
             {
             // first call to update: initialize and cache message because we can not determine yet whether a single- or multiple-part operation will be performed
             m_key.module()->C_SignInit(m_key.session().handle(), m_mechanism.data(), m_key.handle());
             m_initialized = true;
-            m_first_message = secure_vector<byte>(msg, msg + msg_len);
+            m_first_message = secure_vector<uint8_t>(msg, msg + msg_len);
             return;
             }
 
@@ -223,9 +223,9 @@ class PKCS11_RSA_Signature_Operation : public PK_Ops::Signature
          m_key.module()->C_SignUpdate(m_key.session().handle(), const_cast< Byte* >(msg), msg_len);
          }
 
-      secure_vector<byte> sign(RandomNumberGenerator&) override
+      secure_vector<uint8_t> sign(RandomNumberGenerator&) override
          {
-         secure_vector<byte> signature;
+         secure_vector<uint8_t> signature;
          if(!m_first_message.empty())
             {
             // single call to update: perform single-part operation
@@ -244,7 +244,7 @@ class PKCS11_RSA_Signature_Operation : public PK_Ops::Signature
    private:
       const PKCS11_RSA_PrivateKey& m_key;
       bool m_initialized = false;
-      secure_vector<byte> m_first_message;
+      secure_vector<uint8_t> m_first_message;
       MechanismWrapper m_mechanism;
    };
 
@@ -257,14 +257,14 @@ class PKCS11_RSA_Verification_Operation : public PK_Ops::Verification
          : m_key(key), m_mechanism(MechanismWrapper::create_rsa_sign_mechanism(padding))
          {}
 
-      void update(const byte msg[], size_t msg_len) override
+      void update(const uint8_t msg[], size_t msg_len) override
          {
          if(!m_initialized)
             {
             // first call to update: initialize and cache message because we can not determine yet whether a single- or multiple-part operation will be performed
             m_key.module()->C_VerifyInit(m_key.session().handle(), m_mechanism.data(), m_key.handle());
             m_initialized = true;
-            m_first_message = secure_vector<byte>(msg, msg + msg_len);
+            m_first_message = secure_vector<uint8_t>(msg, msg + msg_len);
             return;
             }
 
@@ -278,7 +278,7 @@ class PKCS11_RSA_Verification_Operation : public PK_Ops::Verification
          m_key.module()->C_VerifyUpdate(m_key.session().handle(), const_cast< Byte* >(msg), msg_len);
          }
 
-      bool is_valid_signature(const byte sig[], size_t sig_len) override
+      bool is_valid_signature(const uint8_t sig[], size_t sig_len) override
          {
          ReturnValue return_value = ReturnValue::SignatureInvalid;
          if(!m_first_message.empty())
@@ -304,7 +304,7 @@ class PKCS11_RSA_Verification_Operation : public PK_Ops::Verification
    private:
       const PKCS11_RSA_PublicKey& m_key;
       bool m_initialized = false;
-      secure_vector<byte> m_first_message;
+      secure_vector<uint8_t> m_first_message;
       MechanismWrapper m_mechanism;
    };
 
diff --git a/src/lib/prov/pkcs11/p11_rsa.h b/src/lib/prov/pkcs11/p11_rsa.h
index 13b9d9dc1..1a6fd4890 100644
--- a/src/lib/prov/pkcs11/p11_rsa.h
+++ b/src/lib/prov/pkcs11/p11_rsa.h
@@ -200,7 +200,7 @@ class BOTAN_DLL PKCS11_RSA_PrivateKey final : public Private_Key,
       /// @return the exported RSA private key
       RSA_PrivateKey export_key() const;
 
-      secure_vector<byte> private_key_bits() const override;
+      secure_vector<uint8_t> private_key_bits() const override;
 
       std::unique_ptr<PK_Ops::Decryption>
          create_decryption_op(RandomNumberGenerator& rng,
diff --git a/src/lib/prov/pkcs11/p11_x509.cpp b/src/lib/prov/pkcs11/p11_x509.cpp
index 76b120368..5c6accdf0 100644
--- a/src/lib/prov/pkcs11/p11_x509.cpp
+++ b/src/lib/prov/pkcs11/p11_x509.cpp
@@ -13,7 +13,7 @@
 namespace Botan {
 namespace PKCS11 {
 
-X509_CertificateProperties::X509_CertificateProperties(const std::vector<byte>& subject, const std::vector<byte>& value)
+X509_CertificateProperties::X509_CertificateProperties(const std::vector<uint8_t>& subject, const std::vector<uint8_t>& value)
    : CertificateProperties(CertificateType::X509), m_subject(subject), m_value(value)
    {
    add_binary(AttributeType::Subject, m_subject);
diff --git a/src/lib/prov/pkcs11/p11_x509.h b/src/lib/prov/pkcs11/p11_x509.h
index f0e025ff4..db83286cc 100644
--- a/src/lib/prov/pkcs11/p11_x509.h
+++ b/src/lib/prov/pkcs11/p11_x509.h
@@ -31,34 +31,34 @@ class BOTAN_DLL X509_CertificateProperties final : public CertificateProperties
       * @param subject DER-encoding of the certificate subject name
       * @param value BER-encoding of the certificate
       */
-      X509_CertificateProperties(const std::vector<byte>& subject, const std::vector<byte>& value);
+      X509_CertificateProperties(const std::vector<uint8_t>& subject, const std::vector<uint8_t>& value);
 
       /// @param id key identifier for public/private key pair
-      inline void set_id(const std::vector<byte>& id)
+      inline void set_id(const std::vector<uint8_t>& id)
          {
          add_binary(AttributeType::Id, id);
          }
 
       /// @param issuer DER-encoding of the certificate issuer name
-      inline void set_issuer(const std::vector<byte>& issuer)
+      inline void set_issuer(const std::vector<uint8_t>& issuer)
          {
          add_binary(AttributeType::Issuer, issuer);
          }
 
       /// @param serial DER-encoding of the certificate serial number
-      inline void set_serial(const std::vector<byte>& serial)
+      inline void set_serial(const std::vector<uint8_t>& serial)
          {
          add_binary(AttributeType::SerialNumber, serial);
          }
 
       /// @param hash hash value of the subject public key
-      inline void set_subject_pubkey_hash(const std::vector<byte>& hash)
+      inline void set_subject_pubkey_hash(const std::vector<uint8_t>& hash)
          {
          add_binary(AttributeType::HashOfSubjectPublicKey, hash);
          }
 
       /// @param hash hash value of the issuer public key
-      inline void set_issuer_pubkey_hash(const std::vector<byte>& hash)
+      inline void set_issuer_pubkey_hash(const std::vector<uint8_t>& hash)
          {
          add_binary(AttributeType::HashOfIssuerPublicKey, hash);
          }
@@ -70,20 +70,20 @@ class BOTAN_DLL X509_CertificateProperties final : public CertificateProperties
          }
 
       /// @return the subject
-      inline const std::vector<byte>& subject() const
+      inline const std::vector<uint8_t>& subject() const
          {
          return m_subject;
          }
 
       /// @return the BER-encoding of the certificate
-      inline const std::vector<byte>& value() const
+      inline const std::vector<uint8_t>& value() const
          {
          return m_value;
          }
 
    private:
-      const std::vector<byte> m_subject;
-      const std::vector<byte> m_value;
+      const std::vector<uint8_t> m_subject;
+      const std::vector<uint8_t> m_value;
    };
 
 /// Represents a PKCS#11 X509 certificate
diff --git a/src/lib/prov/tpm/tpm.cpp b/src/lib/prov/tpm/tpm.cpp
index e1f214952..8e3fce968 100644
--- a/src/lib/prov/tpm/tpm.cpp
+++ b/src/lib/prov/tpm/tpm.cpp
@@ -59,7 +59,7 @@ TSS_FLAG bit_flag(size_t bits)
 #if 0
 bool is_srk_uuid(const UUID& uuid)
    {
-   static const byte srk[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 };
+   static const uint8_t srk[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 };
    const std::vector<uint8_t>& b = uuid.binary_value();
    return (b.size() == 16 && same_mem(b.data(), srk, 16));
    }
@@ -349,7 +349,7 @@ AlgorithmIdentifier TPM_PrivateKey::algorithm_identifier() const
                               AlgorithmIdentifier::USE_NULL_PARAM);
    }
 
-std::vector<byte> TPM_PrivateKey::public_key_bits() const
+std::vector<uint8_t> TPM_PrivateKey::public_key_bits() const
    {
    return DER_Encoder()
       .start_cons(SEQUENCE)
@@ -359,7 +359,7 @@ std::vector<byte> TPM_PrivateKey::public_key_bits() const
       .get_contents_unlocked();
    }
 
-secure_vector<byte> TPM_PrivateKey::private_key_bits() const
+secure_vector<uint8_t> TPM_PrivateKey::private_key_bits() const
    {
    throw TPM_Error("Private key export not supported for TPM keys");
    }
@@ -394,12 +394,12 @@ class TPM_Signing_Operation : public PK_Ops::Signature
          {
          }
 
-      void update(const byte msg[], size_t msg_len) override
+      void update(const uint8_t msg[], size_t msg_len) override
          {
          m_hash->update(msg, msg_len);
          }
 
-      secure_vector<byte> sign(RandomNumberGenerator&) override
+      secure_vector<uint8_t> sign(RandomNumberGenerator&) override
          {
          /*
          * v1.2 TPMs will only sign with PKCS #1 v1.5 padding. SHA-1 is built
@@ -408,7 +408,7 @@ class TPM_Signing_Operation : public PK_Ops::Signature
          * 01FFFF... prefix. Even when using SHA-1 we compute the hash locally
          * since it is going to be much faster than pushing data over the LPC bus.
          */
-         secure_vector<byte> msg_hash = m_hash->final();
+         secure_vector<uint8_t> msg_hash = m_hash->final();
 
          std::vector<uint8_t> id_and_msg;
          id_and_msg.reserve(m_hash_id.size() + msg_hash.size());
diff --git a/src/lib/prov/tpm/tpm.h b/src/lib/prov/tpm/tpm.h
index de0fa364f..178206b8f 100644
--- a/src/lib/prov/tpm/tpm.h
+++ b/src/lib/prov/tpm/tpm.h
@@ -77,12 +77,12 @@ class BOTAN_DLL TPM_RNG : public Hardware_RNG
    public:
       TPM_RNG(TPM_Context& ctx) : m_ctx(ctx) {}
 
-      void add_entropy(const byte in[], size_t in_len) override
+      void add_entropy(const uint8_t in[], size_t in_len) override
          {
          m_ctx.stir_random(in, in_len);
          }
 
-      void randomize(byte out[], size_t out_len) override
+      void randomize(uint8_t out[], size_t out_len) override
          {
          m_ctx.gen_random(out, out_len);
          }
@@ -154,9 +154,9 @@ class BOTAN_DLL TPM_PrivateKey : public Private_Key
 
       AlgorithmIdentifier algorithm_identifier() const override;
 
-      std::vector<byte> public_key_bits() const override;
+      std::vector<uint8_t> public_key_bits() const override;
 
-      secure_vector<byte> private_key_bits() const override;
+      secure_vector<uint8_t> private_key_bits() const override;
 
       bool check_key(RandomNumberGenerator& rng, bool) const override;