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.

24 files changed, 216 insertions, 216 deletions

diff --git a/src/lib/math/bigint/big_code.cpp b/src/lib/math/bigint/big_code.cpp
index c8687715d..f7ab53291 100644
--- a/src/lib/math/bigint/big_code.cpp
+++ b/src/lib/math/bigint/big_code.cpp
@@ -15,7 +15,7 @@ namespace Botan {
 /*
 * Encode a BigInt
 */
-void BigInt::encode(byte output[], const BigInt& n, Base base)
+void BigInt::encode(uint8_t output[], const BigInt& n, Base base)
    {
    if(base == Binary)
       {
@@ -23,7 +23,7 @@ void BigInt::encode(byte output[], const BigInt& n, Base base)
       }
    else if(base == Hexadecimal)
       {
-      secure_vector<byte> binary(n.encoded_size(Binary));
+      secure_vector<uint8_t> binary(n.encoded_size(Binary));
       n.binary_encode(binary.data());
 
       hex_encode(reinterpret_cast<char*>(output),
@@ -39,7 +39,7 @@ void BigInt::encode(byte output[], const BigInt& n, Base base)
          {
          divide(copy, 10, copy, remainder);
          output[output_size - 1 - j] =
-            Charset::digit2char(static_cast<byte>(remainder.word_at(0)));
+            Charset::digit2char(static_cast<uint8_t>(remainder.word_at(0)));
          if(copy.is_zero())
             break;
          }
@@ -51,9 +51,9 @@ void BigInt::encode(byte output[], const BigInt& n, Base base)
 /*
 * Encode a BigInt
 */
-std::vector<byte> BigInt::encode(const BigInt& n, Base base)
+std::vector<uint8_t> BigInt::encode(const BigInt& n, Base base)
    {
-   std::vector<byte> output(n.encoded_size(base));
+   std::vector<uint8_t> output(n.encoded_size(base));
    encode(output.data(), n, base);
    if(base != Binary)
       for(size_t j = 0; j != output.size(); ++j)
@@ -65,9 +65,9 @@ std::vector<byte> BigInt::encode(const BigInt& n, Base base)
 /*
 * Encode a BigInt
 */
-secure_vector<byte> BigInt::encode_locked(const BigInt& n, Base base)
+secure_vector<uint8_t> BigInt::encode_locked(const BigInt& n, Base base)
    {
-   secure_vector<byte> output(n.encoded_size(base));
+   secure_vector<uint8_t> output(n.encoded_size(base));
    encode(output.data(), n, base);
    if(base != Binary)
       for(size_t j = 0; j != output.size(); ++j)
@@ -79,15 +79,15 @@ secure_vector<byte> BigInt::encode_locked(const BigInt& n, Base base)
 /*
 * Encode a BigInt, with leading 0s if needed
 */
-secure_vector<byte> BigInt::encode_1363(const BigInt& n, size_t bytes)
+secure_vector<uint8_t> BigInt::encode_1363(const BigInt& n, size_t bytes)
    {
-   secure_vector<byte> output(bytes);
+   secure_vector<uint8_t> output(bytes);
    BigInt::encode_1363(output.data(), output.size(), n);
    return output;
    }
 
 //static
-void BigInt::encode_1363(byte output[], size_t bytes, const BigInt& n)
+void BigInt::encode_1363(uint8_t output[], size_t bytes, const BigInt& n)
    {
    const size_t n_bytes = n.bytes();
    if(n_bytes > bytes)
@@ -100,9 +100,9 @@ void BigInt::encode_1363(byte output[], size_t bytes, const BigInt& n)
 /*
 * Encode two BigInt, with leading 0s if needed, and concatenate
 */
-secure_vector<byte> BigInt::encode_fixed_length_int_pair(const BigInt& n1, const BigInt& n2, size_t bytes)
+secure_vector<uint8_t> BigInt::encode_fixed_length_int_pair(const BigInt& n1, const BigInt& n2, size_t bytes)
    {
-   secure_vector<byte> output(2 * bytes);
+   secure_vector<uint8_t> output(2 * bytes);
    BigInt::encode_1363(output.data(), bytes, n1);
    BigInt::encode_1363(output.data() + bytes, bytes, n2);
    return output;
@@ -111,14 +111,14 @@ secure_vector<byte> BigInt::encode_fixed_length_int_pair(const BigInt& n1, const
 /*
 * Decode a BigInt
 */
-BigInt BigInt::decode(const byte buf[], size_t length, Base base)
+BigInt BigInt::decode(const uint8_t buf[], size_t length, Base base)
    {
    BigInt r;
    if(base == Binary)
       r.binary_decode(buf, length);
    else if(base == Hexadecimal)
       {
-      secure_vector<byte> binary;
+      secure_vector<uint8_t> binary;
 
       if(length % 2)
          {
@@ -149,7 +149,7 @@ BigInt BigInt::decode(const byte buf[], size_t length, Base base)
             throw Invalid_Argument("BigInt::decode: "
                                    "Invalid character in decimal input");
 
-         const byte x = Charset::char2digit(buf[i]);
+         const uint8_t x = Charset::char2digit(buf[i]);
 
          if(x >= 10)
             throw Invalid_Argument("BigInt: Invalid decimal string");
diff --git a/src/lib/math/bigint/big_io.cpp b/src/lib/math/bigint/big_io.cpp
index 779f8ccb7..088b1daf7 100644
--- a/src/lib/math/bigint/big_io.cpp
+++ b/src/lib/math/bigint/big_io.cpp
@@ -27,7 +27,7 @@ std::ostream& operator<<(std::ostream& stream, const BigInt& n)
       {
       if(n < 0)
          stream.write("-", 1);
-      const std::vector<byte> buffer = BigInt::encode(n, base);
+      const std::vector<uint8_t> buffer = BigInt::encode(n, base);
       size_t skip = 0;
       while(skip < buffer.size() && buffer[skip] == '0')
          ++skip;
diff --git a/src/lib/math/bigint/big_ops2.cpp b/src/lib/math/bigint/big_ops2.cpp
index 6e234f036..48d547af0 100644
--- a/src/lib/math/bigint/big_ops2.cpp
+++ b/src/lib/math/bigint/big_ops2.cpp
@@ -27,7 +27,7 @@ BigInt& BigInt::operator+=(const BigInt& y)
       bigint_add2(mutable_data(), reg_size - 1, y.data(), y_sw);
    else
       {
-      s32bit relative_size = bigint_cmp(data(), x_sw, y.data(), y_sw);
+      int32_t relative_size = bigint_cmp(data(), x_sw, y.data(), y_sw);
 
       if(relative_size < 0)
          {
@@ -55,7 +55,7 @@ BigInt& BigInt::operator-=(const BigInt& y)
    {
    const size_t x_sw = sig_words(), y_sw = y.sig_words();
 
-   s32bit relative_size = bigint_cmp(data(), x_sw, y.data(), y_sw);
+   int32_t relative_size = bigint_cmp(data(), x_sw, y.data(), y_sw);
 
    const size_t reg_size = std::max(x_sw, y_sw) + 1;
    grow_to(reg_size);
diff --git a/src/lib/math/bigint/big_ops3.cpp b/src/lib/math/bigint/big_ops3.cpp
index 24927b4fc..a864fa96c 100644
--- a/src/lib/math/bigint/big_ops3.cpp
+++ b/src/lib/math/bigint/big_ops3.cpp
@@ -27,7 +27,7 @@ BigInt operator+(const BigInt& x, const BigInt& y)
       bigint_add3(z.mutable_data(), x.data(), x_sw, y.data(), y_sw);
    else
       {
-      s32bit relative_size = bigint_cmp(x.data(), x_sw, y.data(), y_sw);
+      int32_t relative_size = bigint_cmp(x.data(), x_sw, y.data(), y_sw);
 
       if(relative_size < 0)
          {
@@ -50,7 +50,7 @@ BigInt operator-(const BigInt& x, const BigInt& y)
    {
    const size_t x_sw = x.sig_words(), y_sw = y.sig_words();
 
-   s32bit relative_size = bigint_cmp(x.data(), x_sw, y.data(), y_sw);
+   int32_t relative_size = bigint_cmp(x.data(), x_sw, y.data(), y_sw);
 
    BigInt z(BigInt::Positive, std::max(x_sw, y_sw) + 1);
 
diff --git a/src/lib/math/bigint/big_rand.cpp b/src/lib/math/bigint/big_rand.cpp
index 73f3cf070..506e9776a 100644
--- a/src/lib/math/bigint/big_rand.cpp
+++ b/src/lib/math/bigint/big_rand.cpp
@@ -25,7 +25,7 @@ void BigInt::randomize(RandomNumberGenerator& rng,
       }
    else
       {
-      secure_vector<byte> array = rng.random_vec(round_up(bitsize, 8) / 8);
+      secure_vector<uint8_t> array = rng.random_vec(round_up(bitsize, 8) / 8);
 
       // Always cut unwanted bits
       if(bitsize % 8)
diff --git a/src/lib/math/bigint/bigint.cpp b/src/lib/math/bigint/bigint.cpp
index 2acfabb99..a91a685e0 100644
--- a/src/lib/math/bigint/bigint.cpp
+++ b/src/lib/math/bigint/bigint.cpp
@@ -17,12 +17,12 @@ namespace Botan {
 /*
 * Construct a BigInt from a regular number
 */
-BigInt::BigInt(u64bit n)
+BigInt::BigInt(uint64_t n)
    {
    if(n == 0)
       return;
 
-   const size_t limbs_needed = sizeof(u64bit) / sizeof(word);
+   const size_t limbs_needed = sizeof(uint64_t) / sizeof(word);
 
    m_reg.resize(4*limbs_needed);
    for(size_t i = 0; i != limbs_needed; ++i)
@@ -69,7 +69,7 @@ BigInt::BigInt(const std::string& str)
       base = Hexadecimal;
       }
 
-   *this = decode(reinterpret_cast<const byte*>(str.data()) + markers,
+   *this = decode(reinterpret_cast<const uint8_t*>(str.data()) + markers,
                   str.length() - markers, base);
 
    if(negative) set_sign(Negative);
@@ -79,7 +79,7 @@ BigInt::BigInt(const std::string& str)
 /*
 * Construct a BigInt from an encoded BigInt
 */
-BigInt::BigInt(const byte input[], size_t length, Base base)
+BigInt::BigInt(const uint8_t input[], size_t length, Base base)
    {
    *this = decode(input, length, base);
    }
@@ -95,7 +95,7 @@ BigInt::BigInt(RandomNumberGenerator& rng, size_t bits, bool set_high_bit)
 /*
 * Comparison Function
 */
-s32bit BigInt::cmp(const BigInt& other, bool check_signs) const
+int32_t BigInt::cmp(const BigInt& other, bool check_signs) const
    {
    if(check_signs)
       {
@@ -117,35 +117,35 @@ s32bit BigInt::cmp(const BigInt& other, bool check_signs) const
 /*
 * Return bits {offset...offset+length}
 */
-u32bit BigInt::get_substring(size_t offset, size_t length) const
+uint32_t BigInt::get_substring(size_t offset, size_t length) const
    {
    if(length > 32)
       throw Invalid_Argument("BigInt::get_substring: Substring size too big");
 
-   u64bit piece = 0;
+   uint64_t piece = 0;
    for(size_t i = 0; i != 8; ++i)
       {
-      const byte part = byte_at((offset / 8) + (7-i));
+      const uint8_t part = byte_at((offset / 8) + (7-i));
       piece = (piece << 8) | part;
       }
 
-   const u64bit mask = (static_cast<u64bit>(1) << length) - 1;
+   const uint64_t mask = (static_cast<uint64_t>(1) << length) - 1;
    const size_t shift = (offset % 8);
 
-   return static_cast<u32bit>((piece >> shift) & mask);
+   return static_cast<uint32_t>((piece >> shift) & mask);
    }
 
 /*
-* Convert this number to a u32bit, if possible
+* Convert this number to a uint32_t, if possible
 */
-u32bit BigInt::to_u32bit() const
+uint32_t BigInt::to_u32bit() const
    {
    if(is_negative())
       throw Encoding_Error("BigInt::to_u32bit: Number is negative");
    if(bits() > 32)
       throw Encoding_Error("BigInt::to_u32bit: Number is too big to convert");
 
-   u32bit out = 0;
+   uint32_t out = 0;
    for(size_t i = 0; i != 4; ++i)
       out = (out << 8) | byte_at(3-i);
    return out;
@@ -267,7 +267,7 @@ void BigInt::grow_to(size_t n)
 /*
 * Encode this number into bytes
 */
-void BigInt::binary_encode(byte output[]) const
+void BigInt::binary_encode(uint8_t output[]) const
    {
    const size_t sig_bytes = bytes();
    for(size_t i = 0; i != sig_bytes; ++i)
@@ -277,7 +277,7 @@ void BigInt::binary_encode(byte output[]) const
 /*
 * Set this number to the value in buf
 */
-void BigInt::binary_decode(const byte buf[], size_t length)
+void BigInt::binary_decode(const uint8_t buf[], size_t length)
    {
    const size_t WORD_BYTES = sizeof(word);
 
diff --git a/src/lib/math/bigint/bigint.h b/src/lib/math/bigint/bigint.h
index a61bee39c..42fe60e41 100644
--- a/src/lib/math/bigint/bigint.h
+++ b/src/lib/math/bigint/bigint.h
@@ -48,7 +48,7 @@ class BOTAN_DLL BigInt
      * Create BigInt from 64 bit integer
      * @param n initial value of this BigInt
      */
-     BigInt(u64bit n);
+     BigInt(uint64_t n);
 
      /**
      * Copy Constructor
@@ -71,7 +71,7 @@ class BOTAN_DLL BigInt
      * @param length size of buf
      * @param base is the number base of the integer in buf
      */
-     BigInt(const byte buf[], size_t length, Base base = Binary);
+     BigInt(const uint8_t buf[], size_t length, Base base = Binary);
 
      /**
      * \brief Create a random BigInt of the specified size
@@ -223,7 +223,7 @@ class BOTAN_DLL BigInt
      * @result if (this<n) return -1, if (this>n) return 1, if both
      * values are identical return 0 [like Perl's <=> operator]
      */
-     s32bit cmp(const BigInt& n, bool check_signs = true) const;
+     int32_t cmp(const BigInt& n, bool check_signs = true) const;
 
      /**
      * Test if the integer has an even value
@@ -308,20 +308,20 @@ class BOTAN_DLL BigInt
      * @result the integer extracted from the register starting at
      * offset with specified length
      */
-     u32bit get_substring(size_t offset, size_t length) const;
+     uint32_t get_substring(size_t offset, size_t length) const;
 
      /**
-     * Convert this value into a u32bit, if it is in the range
+     * Convert this value into a uint32_t, if it is in the range
      * [0 ... 2**32-1], or otherwise throw an exception.
-     * @result the value as a u32bit if conversion is possible
+     * @result the value as a uint32_t if conversion is possible
      */
-     u32bit to_u32bit() const;
+     uint32_t to_u32bit() const;
 
      /**
      * @param n the offset to get a byte from
      * @result byte at offset n
      */
-     byte byte_at(size_t n) const
+     uint8_t byte_at(size_t n) const
         {
         return get_byte(sizeof(word) - (n % sizeof(word)) - 1,
                         word_at(n / sizeof(word)));
@@ -450,20 +450,20 @@ class BOTAN_DLL BigInt
      * Store BigInt-value in a given byte array
      * @param buf destination byte array for the integer value
      */
-     void binary_encode(byte buf[]) const;
+     void binary_encode(uint8_t buf[]) const;
 
      /**
      * Read integer value from a byte array with given size
      * @param buf byte array buffer containing the integer
      * @param length size of buf
      */
-     void binary_decode(const byte buf[], size_t length);
+     void binary_decode(const uint8_t buf[], size_t length);
 
      /**
-     * Read integer value from a byte array (secure_vector<byte>)
+     * Read integer value from a byte array (secure_vector<uint8_t>)
      * @param buf the array to load from
      */
-     void binary_decode(const secure_vector<byte>& buf)
+     void binary_decode(const secure_vector<uint8_t>& buf)
         {
         binary_decode(buf.data(), buf.size());
         }
@@ -502,7 +502,7 @@ class BOTAN_DLL BigInt
      * @param base number-base of resulting byte array representation
      * @result secure_vector of bytes containing the integer with given base
      */
-     static std::vector<byte> encode(const BigInt& n, Base base = Binary);
+     static std::vector<uint8_t> encode(const BigInt& n, Base base = Binary);
 
      /**
      * Encode the integer value from a BigInt to a secure_vector of bytes
@@ -510,7 +510,7 @@ class BOTAN_DLL BigInt
      * @param base number-base of resulting byte array representation
      * @result secure_vector of bytes containing the integer with given base
      */
-     static secure_vector<byte> encode_locked(const BigInt& n,
+     static secure_vector<uint8_t> encode_locked(const BigInt& n,
                                               Base base = Binary);
 
      /**
@@ -520,7 +520,7 @@ class BOTAN_DLL BigInt
      * @param n the BigInt to use as integer source
      * @param base number-base of resulting byte array representation
      */
-     static void encode(byte buf[], const BigInt& n, Base base = Binary);
+     static void encode(uint8_t buf[], const BigInt& n, Base base = Binary);
 
      /**
      * Create a BigInt from an integer in a byte array
@@ -529,7 +529,7 @@ class BOTAN_DLL BigInt
      * @param base number-base of the integer in buf
      * @result BigInt representing the integer in the byte array
      */
-     static BigInt decode(const byte buf[], size_t length,
+     static BigInt decode(const uint8_t buf[], size_t length,
                           Base base = Binary);
 
      /**
@@ -538,7 +538,7 @@ class BOTAN_DLL BigInt
      * @param base number-base of the integer in buf
      * @result BigInt representing the integer in the byte array
      */
-     static BigInt decode(const secure_vector<byte>& buf,
+     static BigInt decode(const secure_vector<uint8_t>& buf,
                           Base base = Binary)
         {
         return BigInt::decode(buf.data(), buf.size(), base);
@@ -550,7 +550,7 @@ class BOTAN_DLL BigInt
      * @param base number-base of the integer in buf
      * @result BigInt representing the integer in the byte array
      */
-     static BigInt decode(const std::vector<byte>& buf,
+     static BigInt decode(const std::vector<uint8_t>& buf,
                           Base base = Binary)
         {
         return BigInt::decode(buf.data(), buf.size(), base);
@@ -559,21 +559,21 @@ class BOTAN_DLL BigInt
      /**
      * Encode a BigInt to a byte array according to IEEE 1363
      * @param n the BigInt to encode
-     * @param bytes the length of the resulting secure_vector<byte>
-     * @result a secure_vector<byte> containing the encoded BigInt
+     * @param bytes the length of the resulting secure_vector<uint8_t>
+     * @result a secure_vector<uint8_t> containing the encoded BigInt
      */
-     static secure_vector<byte> encode_1363(const BigInt& n, size_t bytes);
+     static secure_vector<uint8_t> encode_1363(const BigInt& n, size_t bytes);
 
-     static void encode_1363(byte out[], size_t bytes, const BigInt& n);
+     static void encode_1363(uint8_t out[], size_t bytes, const BigInt& n);
 
      /**
      * Encode two BigInt to a byte array according to IEEE 1363
      * @param n1 the first BigInt to encode
      * @param n2 the second BigInt to encode
      * @param bytes the length of the encoding of each single BigInt
-     * @result a secure_vector<byte> containing the concatenation of the two encoded BigInt
+     * @result a secure_vector<uint8_t> containing the concatenation of the two encoded BigInt
      */
-     static secure_vector<byte> encode_fixed_length_int_pair(const BigInt& n1, const BigInt& n2, size_t bytes);
+     static secure_vector<uint8_t> encode_fixed_length_int_pair(const BigInt& n1, const BigInt& n2, size_t bytes);
 
    private:
       secure_vector<word> m_reg;
diff --git a/src/lib/math/bigint/divide.cpp b/src/lib/math/bigint/divide.cpp
index ec4ba3f9f..13696d6d3 100644
--- a/src/lib/math/bigint/divide.cpp
+++ b/src/lib/math/bigint/divide.cpp
@@ -69,7 +69,7 @@ void divide(const BigInt& x, const BigInt& y_arg, BigInt& q, BigInt& r)
    r.set_sign(BigInt::Positive);
    y.set_sign(BigInt::Positive);
 
-   s32bit compare = r.cmp(y);
+   int32_t compare = r.cmp(y);
 
    if(compare == 0)
       {
diff --git a/src/lib/math/ec_gfp/curve_nistp.cpp b/src/lib/math/ec_gfp/curve_nistp.cpp
index 176409dbf..fb94a81d2 100644
--- a/src/lib/math/ec_gfp/curve_nistp.cpp
+++ b/src/lib/math/ec_gfp/curve_nistp.cpp
@@ -89,12 +89,12 @@ namespace {
 * Treating this MPI as a sequence of 32-bit words in big-endian
 * order, return word i (or 0 if out of range)
 */
-inline u32bit get_u32bit(const BigInt& x, size_t i)
+inline uint32_t get_uint32_t(const BigInt& x, size_t i)
    {
 #if (BOTAN_MP_WORD_BITS == 32)
    return x.word_at(i);
 #elif (BOTAN_MP_WORD_BITS == 64)
-   return static_cast<u32bit>(x.word_at(i/2) >> ((i % 2)*32));
+   return static_cast<uint32_t>(x.word_at(i/2) >> ((i % 2)*32));
 #else
   #error "Not implemented"
 #endif
@@ -105,9 +105,9 @@ inline u32bit get_u32bit(const BigInt& x, size_t i)
 * order, set word i to the value x
 */
 template<typename T>
-inline void set_u32bit(BigInt& x, size_t i, T v_in)
+inline void set_uint32_t(BigInt& x, size_t i, T v_in)
    {
-   const u32bit v = static_cast<u32bit>(v_in);
+   const uint32_t v = static_cast<uint32_t>(v_in);
 #if (BOTAN_MP_WORD_BITS == 32)
    x.set_word_at(i, v);
 #elif (BOTAN_MP_WORD_BITS == 64)
@@ -129,56 +129,56 @@ const BigInt& prime_p192()
 
 void redc_p192(BigInt& x, secure_vector<word>& ws)
    {
-   const u32bit X6 = get_u32bit(x, 6);
-   const u32bit X7 = get_u32bit(x, 7);
-   const u32bit X8 = get_u32bit(x, 8);
-   const u32bit X9 = get_u32bit(x, 9);
-   const u32bit X10 = get_u32bit(x, 10);
-   const u32bit X11 = get_u32bit(x, 11);
+   const uint32_t X6 = get_uint32_t(x, 6);
+   const uint32_t X7 = get_uint32_t(x, 7);
+   const uint32_t X8 = get_uint32_t(x, 8);
+   const uint32_t X9 = get_uint32_t(x, 9);
+   const uint32_t X10 = get_uint32_t(x, 10);
+   const uint32_t X11 = get_uint32_t(x, 11);
 
    x.mask_bits(192);
 
-   u64bit S = 0;
+   uint64_t S = 0;
 
-   S += get_u32bit(x, 0);
+   S += get_uint32_t(x, 0);
    S += X6;
    S += X10;
-   set_u32bit(x, 0, S);
+   set_uint32_t(x, 0, S);
    S >>= 32;
 
-   S += get_u32bit(x, 1);
+   S += get_uint32_t(x, 1);
    S += X7;
    S += X11;
-   set_u32bit(x, 1, S);
+   set_uint32_t(x, 1, S);
    S >>= 32;
 
-   S += get_u32bit(x, 2);
+   S += get_uint32_t(x, 2);
    S += X6;
    S += X8;
    S += X10;
-   set_u32bit(x, 2, S);
+   set_uint32_t(x, 2, S);
    S >>= 32;
 
-   S += get_u32bit(x, 3);
+   S += get_uint32_t(x, 3);
    S += X7;
    S += X9;
    S += X11;
-   set_u32bit(x, 3, S);
+   set_uint32_t(x, 3, S);
    S >>= 32;
 
-   S += get_u32bit(x, 4);
+   S += get_uint32_t(x, 4);
    S += X8;
    S += X10;
-   set_u32bit(x, 4, S);
+   set_uint32_t(x, 4, S);
    S >>= 32;
 
-   S += get_u32bit(x, 5);
+   S += get_uint32_t(x, 5);
    S += X9;
    S += X11;
-   set_u32bit(x, 5, S);
+   set_uint32_t(x, 5, S);
    S >>= 32;
 
-   set_u32bit(x, 6, S);
+   set_uint32_t(x, 6, S);
 
    // No underflow possible
 
@@ -193,13 +193,13 @@ const BigInt& prime_p224()
 
 void redc_p224(BigInt& x, secure_vector<word>& ws)
    {
-   const u32bit X7 = get_u32bit(x, 7);
-   const u32bit X8 = get_u32bit(x, 8);
-   const u32bit X9 = get_u32bit(x, 9);
-   const u32bit X10 = get_u32bit(x, 10);
-   const u32bit X11 = get_u32bit(x, 11);
-   const u32bit X12 = get_u32bit(x, 12);
-   const u32bit X13 = get_u32bit(x, 13);
+   const uint32_t X7 = get_uint32_t(x, 7);
+   const uint32_t X8 = get_uint32_t(x, 8);
+   const uint32_t X9 = get_uint32_t(x, 9);
+   const uint32_t X10 = get_uint32_t(x, 10);
+   const uint32_t X11 = get_uint32_t(x, 11);
+   const uint32_t X12 = get_uint32_t(x, 12);
+   const uint32_t X13 = get_uint32_t(x, 13);
 
    x.mask_bits(224);
 
@@ -207,56 +207,56 @@ void redc_p224(BigInt& x, secure_vector<word>& ws)
 
    int64_t S = 0;
 
-   S += get_u32bit(x, 0);
+   S += get_uint32_t(x, 0);
    S += 1;
    S -= X7;
    S -= X11;
-   set_u32bit(x, 0, S);
+   set_uint32_t(x, 0, S);
    S >>= 32;
 
-   S += get_u32bit(x, 1);
+   S += get_uint32_t(x, 1);
    S -= X8;
    S -= X12;
-   set_u32bit(x, 1, S);
+   set_uint32_t(x, 1, S);
    S >>= 32;
 
-   S += get_u32bit(x, 2);
+   S += get_uint32_t(x, 2);
    S -= X9;
    S -= X13;
-   set_u32bit(x, 2, S);
+   set_uint32_t(x, 2, S);
    S >>= 32;
 
-   S += get_u32bit(x, 3);
+   S += get_uint32_t(x, 3);
    S += 0xFFFFFFFF;
    S += X7;
    S += X11;
    S -= X10;
-   set_u32bit(x, 3, S);
+   set_uint32_t(x, 3, S);
    S >>= 32;
 
-   S += get_u32bit(x, 4);
+   S += get_uint32_t(x, 4);
    S += 0xFFFFFFFF;
    S += X8;
    S += X12;
    S -= X11;
-   set_u32bit(x, 4, S);
+   set_uint32_t(x, 4, S);
    S >>= 32;
 
-   S += get_u32bit(x, 5);
+   S += get_uint32_t(x, 5);
    S += 0xFFFFFFFF;
    S += X9;
    S += X13;
    S -= X12;
-   set_u32bit(x, 5, S);
+   set_uint32_t(x, 5, S);
    S >>= 32;
 
-   S += get_u32bit(x, 6);
+   S += get_uint32_t(x, 6);
    S += 0xFFFFFFFF;
    S += X10;
    S -= X13;
-   set_u32bit(x, 6, S);
+   set_uint32_t(x, 6, S);
    S >>= 32;
-   set_u32bit(x, 7, S);
+   set_uint32_t(x, 7, S);
 
    BOTAN_ASSERT_EQUAL(S >> 32, 0, "No underflow");
 
@@ -271,14 +271,14 @@ const BigInt& prime_p256()
 
 void redc_p256(BigInt& x, secure_vector<word>& ws)
    {
-   const u32bit X8 = get_u32bit(x, 8);
-   const u32bit X9 = get_u32bit(x, 9);
-   const u32bit X10 = get_u32bit(x, 10);
-   const u32bit X11 = get_u32bit(x, 11);
-   const u32bit X12 = get_u32bit(x, 12);
-   const u32bit X13 = get_u32bit(x, 13);
-   const u32bit X14 = get_u32bit(x, 14);
-   const u32bit X15 = get_u32bit(x, 15);
+   const uint32_t X8 = get_uint32_t(x, 8);
+   const uint32_t X9 = get_uint32_t(x, 9);
+   const uint32_t X10 = get_uint32_t(x, 10);
+   const uint32_t X11 = get_uint32_t(x, 11);
+   const uint32_t X12 = get_uint32_t(x, 12);
+   const uint32_t X13 = get_uint32_t(x, 13);
+   const uint32_t X14 = get_uint32_t(x, 14);
+   const uint32_t X15 = get_uint32_t(x, 15);
 
    x.mask_bits(256);
 
@@ -286,7 +286,7 @@ void redc_p256(BigInt& x, secure_vector<word>& ws)
 
    // Adds 6 * P-256 to prevent underflow
 
-   S = get_u32bit(x, 0);
+   S = get_uint32_t(x, 0);
    S += 0xFFFFFFFA;
    S += X8;
    S += X9;
@@ -294,10 +294,10 @@ void redc_p256(BigInt& x, secure_vector<word>& ws)
    S -= X12;
    S -= X13;
    S -= X14;
-   set_u32bit(x, 0, S);
+   set_uint32_t(x, 0, S);
    S >>= 32;
 
-   S += get_u32bit(x, 1);
+   S += get_uint32_t(x, 1);
    S += 0xFFFFFFFF;
    S += X9;
    S += X10;
@@ -305,20 +305,20 @@ void redc_p256(BigInt& x, secure_vector<word>& ws)
    S -= X13;
    S -= X14;
    S -= X15;
-   set_u32bit(x, 1, S);
+   set_uint32_t(x, 1, S);
    S >>= 32;
 
-   S += get_u32bit(x, 2);
+   S += get_uint32_t(x, 2);
    S += 0xFFFFFFFF;
    S += X10;
    S += X11;
    S -= X13;
    S -= X14;
    S -= X15;
-   set_u32bit(x, 2, S);
+   set_uint32_t(x, 2, S);
    S >>= 32;
 
-   S += get_u32bit(x, 3);
+   S += get_uint32_t(x, 3);
    S += 5;
    S += X11;
    S += X11;
@@ -328,10 +328,10 @@ void redc_p256(BigInt& x, secure_vector<word>& ws)
    S -= X15;
    S -= X8;
    S -= X9;
-   set_u32bit(x, 3, S);
+   set_uint32_t(x, 3, S);
    S >>= 32;
 
-   S += get_u32bit(x, 4);
+   S += get_uint32_t(x, 4);
    S += X12;
    S += X12;
    S += X13;
@@ -339,10 +339,10 @@ void redc_p256(BigInt& x, secure_vector<word>& ws)
    S += X14;
    S -= X9;
    S -= X10;
-   set_u32bit(x, 4, S);
+   set_uint32_t(x, 4, S);
    S >>= 32;
 
-   S += get_u32bit(x, 5);
+   S += get_uint32_t(x, 5);
    S += X13;
    S += X13;
    S += X14;
@@ -350,10 +350,10 @@ void redc_p256(BigInt& x, secure_vector<word>& ws)
    S += X15;
    S -= X10;
    S -= X11;
-   set_u32bit(x, 5, S);
+   set_uint32_t(x, 5, S);
    S >>= 32;
 
-   S += get_u32bit(x, 6);
+   S += get_uint32_t(x, 6);
    S += 6;
    S += X14;
    S += X14;
@@ -363,10 +363,10 @@ void redc_p256(BigInt& x, secure_vector<word>& ws)
    S += X13;
    S -= X8;
    S -= X9;
-   set_u32bit(x, 6, S);
+   set_uint32_t(x, 6, S);
    S >>= 32;
 
-   S += get_u32bit(x, 7);
+   S += get_uint32_t(x, 7);
    S += 0xFFFFFFFA;
    S += X15;
    S += X15;
@@ -376,11 +376,11 @@ void redc_p256(BigInt& x, secure_vector<word>& ws)
    S -= X11;
    S -= X12;
    S -= X13;
-   set_u32bit(x, 7, S);
+   set_uint32_t(x, 7, S);
    S >>= 32;
 
    S += 5;
-   set_u32bit(x, 8, S);
+   set_uint32_t(x, 8, S);
 
    BOTAN_ASSERT_EQUAL(S >> 32, 0, "No underflow");
 
@@ -414,51 +414,51 @@ const BigInt& prime_p384()
 
 void redc_p384(BigInt& x, secure_vector<word>& ws)
    {
-   const u32bit X12 = get_u32bit(x, 12);
-   const u32bit X13 = get_u32bit(x, 13);
-   const u32bit X14 = get_u32bit(x, 14);
-   const u32bit X15 = get_u32bit(x, 15);
-   const u32bit X16 = get_u32bit(x, 16);
-   const u32bit X17 = get_u32bit(x, 17);
-   const u32bit X18 = get_u32bit(x, 18);
-   const u32bit X19 = get_u32bit(x, 19);
-   const u32bit X20 = get_u32bit(x, 20);
-   const u32bit X21 = get_u32bit(x, 21);
-   const u32bit X22 = get_u32bit(x, 22);
-   const u32bit X23 = get_u32bit(x, 23);
+   const uint32_t X12 = get_uint32_t(x, 12);
+   const uint32_t X13 = get_uint32_t(x, 13);
+   const uint32_t X14 = get_uint32_t(x, 14);
+   const uint32_t X15 = get_uint32_t(x, 15);
+   const uint32_t X16 = get_uint32_t(x, 16);
+   const uint32_t X17 = get_uint32_t(x, 17);
+   const uint32_t X18 = get_uint32_t(x, 18);
+   const uint32_t X19 = get_uint32_t(x, 19);
+   const uint32_t X20 = get_uint32_t(x, 20);
+   const uint32_t X21 = get_uint32_t(x, 21);
+   const uint32_t X22 = get_uint32_t(x, 22);
+   const uint32_t X23 = get_uint32_t(x, 23);
 
    x.mask_bits(384);
 
    int64_t S = 0;
 
    // One copy of P-384 is added to prevent underflow
-   S = get_u32bit(x, 0);
+   S = get_uint32_t(x, 0);
    S += 0xFFFFFFFF;
    S += X12;
    S += X21;
    S += X20;
    S -= X23;
-   set_u32bit(x, 0, S);
+   set_uint32_t(x, 0, S);
    S >>= 32;
 
-   S += get_u32bit(x, 1);
+   S += get_uint32_t(x, 1);
    S += X13;
    S += X22;
    S += X23;
    S -= X12;
    S -= X20;
-   set_u32bit(x, 1, S);
+   set_uint32_t(x, 1, S);
    S >>= 32;
 
-   S += get_u32bit(x, 2);
+   S += get_uint32_t(x, 2);
    S += X14;
    S += X23;
    S -= X13;
    S -= X21;
-   set_u32bit(x, 2, S);
+   set_uint32_t(x, 2, S);
    S >>= 32;
 
-   S += get_u32bit(x, 3);
+   S += get_uint32_t(x, 3);
    S += 0xFFFFFFFF;
    S += X15;
    S += X12;
@@ -467,10 +467,10 @@ void redc_p384(BigInt& x, secure_vector<word>& ws)
    S -= X14;
    S -= X22;
    S -= X23;
-   set_u32bit(x, 3, S);
+   set_uint32_t(x, 3, S);
    S >>= 32;
 
-   S += get_u32bit(x, 4);
+   S += get_uint32_t(x, 4);
    S += 0xFFFFFFFE;
    S += X21;
    S += X21;
@@ -482,10 +482,10 @@ void redc_p384(BigInt& x, secure_vector<word>& ws)
    S -= X15;
    S -= X23;
    S -= X23;
-   set_u32bit(x, 4, S);
+   set_uint32_t(x, 4, S);
    S >>= 32;
 
-   S += get_u32bit(x, 5);
+   S += get_uint32_t(x, 5);
    S += 0xFFFFFFFF;
    S += X22;
    S += X22;
@@ -495,10 +495,10 @@ void redc_p384(BigInt& x, secure_vector<word>& ws)
    S += X21;
    S += X23;
    S -= X16;
-   set_u32bit(x, 5, S);
+   set_uint32_t(x, 5, S);
    S >>= 32;
 
-   S += get_u32bit(x, 6);
+   S += get_uint32_t(x, 6);
    S += 0xFFFFFFFF;
    S += X23;
    S += X23;
@@ -507,56 +507,56 @@ void redc_p384(BigInt& x, secure_vector<word>& ws)
    S += X14;
    S += X22;
    S -= X17;
-   set_u32bit(x, 6, S);
+   set_uint32_t(x, 6, S);
    S >>= 32;
 
-   S += get_u32bit(x, 7);
+   S += get_uint32_t(x, 7);
    S += 0xFFFFFFFF;
    S += X19;
    S += X16;
    S += X15;
    S += X23;
    S -= X18;
-   set_u32bit(x, 7, S);
+   set_uint32_t(x, 7, S);
    S >>= 32;
 
-   S += get_u32bit(x, 8);
+   S += get_uint32_t(x, 8);
    S += 0xFFFFFFFF;
    S += X20;
    S += X17;
    S += X16;
    S -= X19;
-   set_u32bit(x, 8, S);
+   set_uint32_t(x, 8, S);
    S >>= 32;
 
-   S += get_u32bit(x, 9);
+   S += get_uint32_t(x, 9);
    S += 0xFFFFFFFF;
    S += X21;
    S += X18;
    S += X17;
    S -= X20;
-   set_u32bit(x, 9, S);
+   set_uint32_t(x, 9, S);
    S >>= 32;
 
-   S += get_u32bit(x, 10);
+   S += get_uint32_t(x, 10);
    S += 0xFFFFFFFF;
    S += X22;
    S += X19;
    S += X18;
    S -= X21;
-   set_u32bit(x, 10, S);
+   set_uint32_t(x, 10, S);
    S >>= 32;
 
-   S += get_u32bit(x, 11);
+   S += get_uint32_t(x, 11);
    S += 0xFFFFFFFF;
    S += X23;
    S += X20;
    S += X19;
    S -= X22;
-   set_u32bit(x, 11, S);
+   set_uint32_t(x, 11, S);
    S >>= 32;
    BOTAN_ASSERT_EQUAL(S >> 32, 0, "No underflow");
-   set_u32bit(x, 12, S);
+   set_uint32_t(x, 12, S);
 
    #if 0
    if(S >= 2)
diff --git a/src/lib/math/ec_gfp/point_gfp.cpp b/src/lib/math/ec_gfp/point_gfp.cpp
index f15911db0..bb446566e 100644
--- a/src/lib/math/ec_gfp/point_gfp.cpp
+++ b/src/lib/math/ec_gfp/point_gfp.cpp
@@ -406,7 +406,7 @@ PointGFp Blinded_Point_Multiply::blinded_multiply(const BigInt& scalar_in,
    if(windows > 0)
       {
       windows--;
-      const u32bit nibble = scalar.get_substring(windows*m_h, m_h);
+      const uint32_t nibble = scalar.get_substring(windows*m_h, m_h);
       R.add(m_U[nibble], m_ws);
 
       /*
@@ -421,7 +421,7 @@ PointGFp Blinded_Point_Multiply::blinded_multiply(const BigInt& scalar_in,
          for(size_t i = 0; i != m_h; ++i)
             R.mult2(m_ws);
 
-         const u32bit inner_nibble = scalar.get_substring((windows-1)*m_h, m_h);
+         const uint32_t inner_nibble = scalar.get_substring((windows-1)*m_h, m_h);
          R.add(m_U[inner_nibble], m_ws);
          windows--;
          }
@@ -513,22 +513,22 @@ bool PointGFp::operator==(const PointGFp& other) const
    }
 
 // encoding and decoding
-secure_vector<byte> EC2OSP(const PointGFp& point, byte format)
+secure_vector<uint8_t> EC2OSP(const PointGFp& point, uint8_t format)
    {
    if(point.is_zero())
-      return secure_vector<byte>(1); // single 0 byte
+      return secure_vector<uint8_t>(1); // single 0 byte
 
    const size_t p_bytes = point.get_curve().get_p().bytes();
 
    BigInt x = point.get_affine_x();
    BigInt y = point.get_affine_y();
 
-   secure_vector<byte> bX = BigInt::encode_1363(x, p_bytes);
-   secure_vector<byte> bY = BigInt::encode_1363(y, p_bytes);
+   secure_vector<uint8_t> bX = BigInt::encode_1363(x, p_bytes);
+   secure_vector<uint8_t> bY = BigInt::encode_1363(y, p_bytes);
 
    if(format == PointGFp::UNCOMPRESSED)
       {
-      secure_vector<byte> result;
+      secure_vector<uint8_t> result;
       result.push_back(0x04);
 
       result += bX;
@@ -538,8 +538,8 @@ secure_vector<byte> EC2OSP(const PointGFp& point, byte format)
       }
    else if(format == PointGFp::COMPRESSED)
       {
-      secure_vector<byte> result;
-      result.push_back(0x02 | static_cast<byte>(y.get_bit(0)));
+      secure_vector<uint8_t> result;
+      result.push_back(0x02 | static_cast<uint8_t>(y.get_bit(0)));
 
       result += bX;
 
@@ -547,8 +547,8 @@ secure_vector<byte> EC2OSP(const PointGFp& point, byte format)
       }
    else if(format == PointGFp::HYBRID)
       {
-      secure_vector<byte> result;
-      result.push_back(0x06 | static_cast<byte>(y.get_bit(0)));
+      secure_vector<uint8_t> result;
+      result.push_back(0x06 | static_cast<uint8_t>(y.get_bit(0)));
 
       result += bX;
       result += bY;
@@ -587,13 +587,13 @@ BigInt decompress_point(bool yMod2,
 
 }
 
-PointGFp OS2ECP(const byte data[], size_t data_len,
+PointGFp OS2ECP(const uint8_t data[], size_t data_len,
                 const CurveGFp& curve)
    {
    if(data_len <= 1)
       return PointGFp(curve); // return zero
 
-   const byte pc = data[0];
+   const uint8_t pc = data[0];
 
    BigInt x, y;
 
diff --git a/src/lib/math/ec_gfp/point_gfp.h b/src/lib/math/ec_gfp/point_gfp.h
index c64963683..6f4c7e5f9 100644
--- a/src/lib/math/ec_gfp/point_gfp.h
+++ b/src/lib/math/ec_gfp/point_gfp.h
@@ -274,13 +274,13 @@ inline PointGFp operator*(const PointGFp& point, const BigInt& scalar)
    }
 
 // encoding and decoding
-secure_vector<byte> BOTAN_DLL EC2OSP(const PointGFp& point, byte format);
+secure_vector<uint8_t> BOTAN_DLL EC2OSP(const PointGFp& point, uint8_t format);
 
-PointGFp BOTAN_DLL OS2ECP(const byte data[], size_t data_len,
+PointGFp BOTAN_DLL OS2ECP(const uint8_t data[], size_t data_len,
                           const CurveGFp& curve);
 
 template<typename Alloc>
-PointGFp OS2ECP(const std::vector<byte, Alloc>& data, const CurveGFp& curve)
+PointGFp OS2ECP(const std::vector<uint8_t, Alloc>& data, const CurveGFp& curve)
    { return OS2ECP(data.data(), data.size(), curve); }
 
 /**
diff --git a/src/lib/math/mp/mp_core.cpp b/src/lib/math/mp/mp_core.cpp
index 2a0b08f67..ff4efd945 100644
--- a/src/lib/math/mp/mp_core.cpp
+++ b/src/lib/math/mp/mp_core.cpp
@@ -375,7 +375,7 @@ void bigint_shr2(word y[], const word x[], size_t x_size,
 /*
 * Compare two MP integers
 */
-s32bit bigint_cmp(const word x[], size_t x_size,
+int32_t bigint_cmp(const word x[], size_t x_size,
                   const word y[], size_t y_size)
    {
    if(x_size < y_size) { return (-bigint_cmp(y, y_size, x, x_size)); }
diff --git a/src/lib/math/mp/mp_core.h b/src/lib/math/mp/mp_core.h
index c4ce005ba..a22d3b6ad 100644
--- a/src/lib/math/mp/mp_core.h
+++ b/src/lib/math/mp/mp_core.h
@@ -150,7 +150,7 @@ void bigint_monty_sqr(BigInt& z, const BigInt& x,
 /**
 * Compare x and y
 */
-s32bit bigint_cmp(const word x[], size_t x_size,
+int32_t bigint_cmp(const word x[], size_t x_size,
                   const word y[], size_t y_size);
 
 /**
diff --git a/src/lib/math/mp/mp_karat.cpp b/src/lib/math/mp/mp_karat.cpp
index 62a52b88c..994100c9b 100644
--- a/src/lib/math/mp/mp_karat.cpp
+++ b/src/lib/math/mp/mp_karat.cpp
@@ -75,8 +75,8 @@ void karatsuba_mul(word z[], const word x[], const word y[], size_t N,
    word* z0 = z;
    word* z1 = z + N;
 
-   const s32bit cmp0 = bigint_cmp(x0, N2, x1, N2);
-   const s32bit cmp1 = bigint_cmp(y1, N2, y0, N2);
+   const int32_t cmp0 = bigint_cmp(x0, N2, x1, N2);
+   const int32_t cmp1 = bigint_cmp(y1, N2, y0, N2);
 
    clear_mem(workspace, 2*N);
 
@@ -143,7 +143,7 @@ void karatsuba_sqr(word z[], const word x[], size_t N, word workspace[])
    word* z0 = z;
    word* z1 = z + N;
 
-   const s32bit cmp = bigint_cmp(x0, N2, x1, N2);
+   const int32_t cmp = bigint_cmp(x0, N2, x1, N2);
 
    clear_mem(workspace, 2*N);
 
diff --git a/src/lib/math/mp/mp_madd.h b/src/lib/math/mp/mp_madd.h
index 0567622d9..2fa1d88ce 100644
--- a/src/lib/math/mp/mp_madd.h
+++ b/src/lib/math/mp/mp_madd.h
@@ -15,13 +15,13 @@
 namespace Botan {
 
 #if (BOTAN_MP_WORD_BITS == 8)
-  typedef u16bit dword;
+  typedef uint16_t dword;
   #define BOTAN_HAS_MP_DWORD
 #elif (BOTAN_MP_WORD_BITS == 16)
-  typedef u32bit dword;
+  typedef uint32_t dword;
   #define BOTAN_HAS_MP_DWORD
 #elif (BOTAN_MP_WORD_BITS == 32)
-  typedef u64bit dword;
+  typedef uint64_t dword;
   #define BOTAN_HAS_MP_DWORD
 #elif (BOTAN_MP_WORD_BITS == 64)
   #if defined(BOTAN_TARGET_HAS_NATIVE_UINT128)
diff --git a/src/lib/math/mp/mp_types.h b/src/lib/math/mp/mp_types.h
index 69dc911fd..0b5c5055e 100644
--- a/src/lib/math/mp/mp_types.h
+++ b/src/lib/math/mp/mp_types.h
@@ -13,13 +13,13 @@
 namespace Botan {
 
 #if (BOTAN_MP_WORD_BITS == 8)
-  typedef byte word;
+  typedef uint8_t word;
 #elif (BOTAN_MP_WORD_BITS == 16)
-  typedef u16bit word;
+  typedef uint16_t word;
 #elif (BOTAN_MP_WORD_BITS == 32)
-  typedef u32bit word;
+  typedef uint32_t word;
 #elif (BOTAN_MP_WORD_BITS == 64)
-  typedef u64bit word;
+  typedef uint64_t word;
 #else
   #error BOTAN_MP_WORD_BITS must be 8, 16, 32, or 64
 #endif
diff --git a/src/lib/math/numbertheory/dsa_gen.cpp b/src/lib/math/numbertheory/dsa_gen.cpp
index 29d1fe9bc..a01810025 100644
--- a/src/lib/math/numbertheory/dsa_gen.cpp
+++ b/src/lib/math/numbertheory/dsa_gen.cpp
@@ -39,7 +39,7 @@ bool fips186_3_valid_size(size_t pbits, size_t qbits)
 bool generate_dsa_primes(RandomNumberGenerator& rng,
                          BigInt& p, BigInt& q,
                          size_t pbits, size_t qbits,
-                         const std::vector<byte>& seed_c)
+                         const std::vector<uint8_t>& seed_c)
    {
    if(!fips186_3_valid_size(pbits, qbits))
       throw Invalid_Argument(
@@ -59,9 +59,9 @@ bool generate_dsa_primes(RandomNumberGenerator& rng,
    class Seed
       {
       public:
-         explicit Seed(const std::vector<byte>& s) : m_seed(s) {}
+         explicit Seed(const std::vector<uint8_t>& s) : m_seed(s) {}
 
-         operator std::vector<byte>& () { return m_seed; }
+         operator std::vector<uint8_t>& () { return m_seed; }
 
          Seed& operator++()
             {
@@ -71,7 +71,7 @@ bool generate_dsa_primes(RandomNumberGenerator& rng,
             return (*this);
             }
       private:
-         std::vector<byte> m_seed;
+         std::vector<uint8_t> m_seed;
       };
 
    Seed seed(seed_c);
@@ -87,7 +87,7 @@ bool generate_dsa_primes(RandomNumberGenerator& rng,
                 b = (pbits-1) % (HASH_SIZE * 8);
 
    BigInt X;
-   std::vector<byte> V(HASH_SIZE * (n+1));
+   std::vector<uint8_t> V(HASH_SIZE * (n+1));
 
    for(size_t j = 0; j != 4*pbits; ++j)
       {
@@ -113,13 +113,13 @@ bool generate_dsa_primes(RandomNumberGenerator& rng,
 /*
 * Generate DSA Primes
 */
-std::vector<byte> generate_dsa_primes(RandomNumberGenerator& rng,
+std::vector<uint8_t> generate_dsa_primes(RandomNumberGenerator& rng,
                                       BigInt& p, BigInt& q,
                                       size_t pbits, size_t qbits)
    {
    while(true)
       {
-      std::vector<byte> seed(qbits / 8);
+      std::vector<uint8_t> seed(qbits / 8);
       rng.randomize(seed.data(), seed.size());
 
       if(generate_dsa_primes(rng, p, q, pbits, qbits, seed))
diff --git a/src/lib/math/numbertheory/jacobi.cpp b/src/lib/math/numbertheory/jacobi.cpp
index 0077fb10e..d3e8d7557 100644
--- a/src/lib/math/numbertheory/jacobi.cpp
+++ b/src/lib/math/numbertheory/jacobi.cpp
@@ -12,7 +12,7 @@ namespace Botan {
 /*
 * Calculate the Jacobi symbol
 */
-s32bit jacobi(const BigInt& a, const BigInt& n)
+int32_t jacobi(const BigInt& a, const BigInt& n)
    {
    if(a.is_negative())
       throw Invalid_Argument("jacobi: first argument must be non-negative");
@@ -20,7 +20,7 @@ s32bit jacobi(const BigInt& a, const BigInt& n)
       throw Invalid_Argument("jacobi: second argument must be odd and > 1");
 
    BigInt x = a, y = n;
-   s32bit J = 1;
+   int32_t J = 1;
 
    while(y > 1)
       {
diff --git a/src/lib/math/numbertheory/make_prm.cpp b/src/lib/math/numbertheory/make_prm.cpp
index acd187063..9443bb9a1 100644
--- a/src/lib/math/numbertheory/make_prm.cpp
+++ b/src/lib/math/numbertheory/make_prm.cpp
@@ -63,10 +63,10 @@ BigInt random_prime(RandomNumberGenerator& rng,
          p += (modulo - p % modulo) + equiv;
 
       const size_t sieve_size = std::min(bits / 2, PRIME_TABLE_SIZE);
-      secure_vector<u16bit> sieve(sieve_size);
+      secure_vector<uint16_t> sieve(sieve_size);
 
       for(size_t j = 0; j != sieve.size(); ++j)
-         sieve[j] = static_cast<u16bit>(p % PRIMES[j]);
+         sieve[j] = static_cast<uint16_t>(p % PRIMES[j]);
 
       size_t counter = 0;
       while(true)
diff --git a/src/lib/math/numbertheory/numthry.cpp b/src/lib/math/numbertheory/numthry.cpp
index 71dbf6aba..4e8a5d8cc 100644
--- a/src/lib/math/numbertheory/numthry.cpp
+++ b/src/lib/math/numbertheory/numthry.cpp
@@ -449,7 +449,7 @@ bool is_prime(const BigInt& n, RandomNumberGenerator& rng,
    // Fast path testing for small numbers (<= 65521)
    if(n <= PRIMES[PRIME_TABLE_SIZE-1])
       {
-      const u16bit num = static_cast<u16bit>(n.word_at(0));
+      const uint16_t num = static_cast<uint16_t>(n.word_at(0));
 
       return std::binary_search(PRIMES, PRIMES + PRIME_TABLE_SIZE, num);
       }
diff --git a/src/lib/math/numbertheory/numthry.h b/src/lib/math/numbertheory/numthry.h
index 172c56a34..6d6991c15 100644
--- a/src/lib/math/numbertheory/numthry.h
+++ b/src/lib/math/numbertheory/numthry.h
@@ -116,7 +116,7 @@ BigInt BOTAN_DLL normalized_montgomery_inverse(const BigInt& a, const BigInt& b)
 * @param n is an odd integer > 1
 * @return (n / m)
 */
-s32bit BOTAN_DLL jacobi(const BigInt& a,
+int32_t BOTAN_DLL jacobi(const BigInt& a,
                         const BigInt& n);
 
 /**
@@ -210,7 +210,7 @@ BigInt BOTAN_DLL random_safe_prime(RandomNumberGenerator& rng,
 * @param qbits how long q will be in bits
 * @return random seed used to generate this parameter set
 */
-std::vector<byte> BOTAN_DLL
+std::vector<uint8_t> BOTAN_DLL
 generate_dsa_primes(RandomNumberGenerator& rng,
                     BigInt& p_out, BigInt& q_out,
                     size_t pbits, size_t qbits);
@@ -230,7 +230,7 @@ bool BOTAN_DLL
 generate_dsa_primes(RandomNumberGenerator& rng,
                     BigInt& p_out, BigInt& q_out,
                     size_t pbits, size_t qbits,
-                    const std::vector<byte>& seed);
+                    const std::vector<uint8_t>& seed);
 
 /**
 * The size of the PRIMES[] array
@@ -240,7 +240,7 @@ const size_t PRIME_TABLE_SIZE = 6541;
 /**
 * A const array of all primes less than 65535
 */
-extern const u16bit BOTAN_DLL PRIMES[];
+extern const uint16_t BOTAN_DLL PRIMES[];
 
 }
 
diff --git a/src/lib/math/numbertheory/powm_fw.cpp b/src/lib/math/numbertheory/powm_fw.cpp
index 7d69a2602..770f345c6 100644
--- a/src/lib/math/numbertheory/powm_fw.cpp
+++ b/src/lib/math/numbertheory/powm_fw.cpp
@@ -48,7 +48,7 @@ BigInt Fixed_Window_Exponentiator::execute() const
       for(size_t j = 0; j != m_window_bits; ++j)
          x = m_reducer.square(x);
 
-      const u32bit nibble = m_exp.get_substring(m_window_bits*(i-1), m_window_bits);
+      const uint32_t nibble = m_exp.get_substring(m_window_bits*(i-1), m_window_bits);
 
       x = m_reducer.multiply(x, m_g[nibble]);
       }
diff --git a/src/lib/math/numbertheory/powm_mnt.cpp b/src/lib/math/numbertheory/powm_mnt.cpp
index 546a2739a..ba7fddef2 100644
--- a/src/lib/math/numbertheory/powm_mnt.cpp
+++ b/src/lib/math/numbertheory/powm_mnt.cpp
@@ -86,7 +86,7 @@ BigInt Montgomery_Exponentiator::execute() const
          x = z;
          }
 
-      const u32bit nibble = m_exp.get_substring(m_window_bits*(i-1), m_window_bits);
+      const uint32_t nibble = m_exp.get_substring(m_window_bits*(i-1), m_window_bits);
 
       const BigInt& y = m_g[nibble];
 
diff --git a/src/lib/math/numbertheory/primes.cpp b/src/lib/math/numbertheory/primes.cpp
index 50229ad15..4a3eb46f2 100644
--- a/src/lib/math/numbertheory/primes.cpp
+++ b/src/lib/math/numbertheory/primes.cpp
@@ -9,7 +9,7 @@
 
 namespace Botan {
 
-const u16bit PRIMES[PRIME_TABLE_SIZE+1] = {
+const uint16_t PRIMES[PRIME_TABLE_SIZE+1] = {
     3,     5,     7,    11,    13,    17,    19,    23,    29,    31,    37,
    41,    43,    47,    53,    59,    61,    67,    71,    73,    79,    83,
    89,    97,   101,   103,   107,   109,   113,   127,   131,   137,   139,