/*

* BigInt Encoding/Decoding

* (C) 1999-2010,2012,2019 Jack Lloyd

*

* Botan is released under the Simplified BSD License (see license.txt)

*/

#include <botan/bigint.h>

#include <botan/divide.h>

#include <botan/charset.h>

#include <botan/hex.h>

namespace Botan {

std::string BigInt::to_dec_string() const

   {

   BigInt copy = *this;

   copy.set_sign(Positive);

   uint8_t remainder;

   std::vector<uint8_t> digits;

   while(copy > 0)

      {

      ct_divide_u8(copy, 10, copy, remainder);

      digits.push_back(remainder);

      }

   std::string s;

   for(auto i = digits.rbegin(); i != digits.rend(); ++i)

      {

      s.push_back(Charset::digit2char(*i));

      }

   if(s.empty())

      s += "0";

   return s;

   }

std::string BigInt::to_hex_string() const

   {

   const std::vector<uint8_t> bits = BigInt::encode(*this);

   if(bits.empty())

      return "00";

   else

      return hex_encode(bits);

   }

/*

* Encode a BigInt

*/

void BigInt::encode(uint8_t output[], const BigInt& n, Base base)

   {

   secure_vector<uint8_t> enc = n.encode_locked(base);

   copy_mem(output, enc.data(), enc.size());

   }

namespace {

std::vector<uint8_t> str_to_vector(const std::string& s)

   {

   std::vector<uint8_t> v(s.size());

   std::memcpy(v.data(), s.data(), s.size());

   return v;

   }

secure_vector<uint8_t> str_to_lvector(const std::string& s)

   {

   secure_vector<uint8_t> v(s.size());

   std::memcpy(v.data(), s.data(), s.size());

   return v;

   }

}

/*

* Encode a BigInt

*/

std::vector<uint8_t> BigInt::encode(const BigInt& n, Base base)

   {

   if(base == Binary)

      return BigInt::encode(n);

   else if(base == Hexadecimal)

      return str_to_vector(n.to_hex_string());

   else if(base == Decimal)

      return str_to_vector(n.to_dec_string());

   else

      throw Invalid_Argument("Unknown BigInt encoding base");

   }

/*

* Encode a BigInt

*/

secure_vector<uint8_t> BigInt::encode_locked(const BigInt& n, Base base)

   {

   if(base == Binary)

      return BigInt::encode_locked(n);

   else if(base == Hexadecimal)

      return str_to_lvector(n.to_hex_string());

   else if(base == Decimal)

      return str_to_lvector(n.to_dec_string());

   else

      throw Invalid_Argument("Unknown BigInt encoding base");

   }

/*

* Encode a BigInt, with leading 0s if needed

*/

secure_vector<uint8_t> BigInt::encode_1363(const BigInt& n, size_t bytes)

   {

   if(n.bytes() > bytes)

      throw Encoding_Error("encode_1363: n is too large to encode properly");

   secure_vector<uint8_t> output(bytes);

   n.binary_encode(output.data(), output.size());

   return output;

   }

//static

void BigInt::encode_1363(uint8_t output[], size_t bytes, const BigInt& n)

   {

   if(n.bytes() > bytes)

      throw Encoding_Error("encode_1363: n is too large to encode properly");

   n.binary_encode(output, bytes);

   }

/*

* Encode two BigInt, with leading 0s if needed, and concatenate

*/

secure_vector<uint8_t> BigInt::encode_fixed_length_int_pair(const BigInt& n1, const BigInt& n2, size_t bytes)

   {

   if(n1.bytes() > bytes || n2.bytes() > bytes)

      throw Encoding_Error("encode_fixed_length_int_pair: values too large to encode properly");

   secure_vector<uint8_t> output(2 * bytes);

   n1.binary_encode(output.data()        , bytes);

   n2.binary_encode(output.data() + bytes, bytes);

   return output;

   }

/*

* Decode a BigInt

*/

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<uint8_t> binary;

      if(length % 2)

         {

         // Handle lack of leading 0

         const char buf0_with_leading_0[2] =

            { '0', static_cast<char>(buf[0]) };

         binary = hex_decode_locked(buf0_with_leading_0, 2);

         binary += hex_decode_locked(cast_uint8_ptr_to_char(&buf[1]),

                                     length - 1,

                                     false);

         }

      else

         binary = hex_decode_locked(cast_uint8_ptr_to_char(buf),

                                    length, false);

      r.binary_decode(binary.data(), binary.size());

      }

   else if(base == Decimal)

      {

      for(size_t i = 0; i != length; ++i)

         {

         if(Charset::is_space(buf[i]))

            continue;

         if(!Charset::is_digit(buf[i]))

            throw Invalid_Argument("BigInt::decode: "

                                   "Invalid character in decimal input");

         const uint8_t x = Charset::char2digit(buf[i]);

         if(x >= 10)

            throw Invalid_Argument("BigInt: Invalid decimal string");

         r *= 10;

         r += x;

         }

      }

   else

      throw Invalid_Argument("Unknown BigInt decoding method");

   return r;

   }

}