/*
* 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;
}
/*
* Write data from a pipe into an ostream
*/
std::ostream& operator<<(std::ostream& stream, Pipe& pipe)
{
secure_vector<uint8_t> buffer(DEFAULT_BUFFERSIZE);
while(stream.good() && pipe.remaining())
{
const size_t got = pipe.read(buffer.data(), buffer.size());
stream.write(cast_uint8_ptr_to_char(buffer.data()), got);
}
if(!stream.good())
throw Stream_IO_Error("Pipe output operator (iostream) has failed");
return stream;
}
std::set<std::string> Encrypted_PSK_Database::list_names() const
{
const std::set<std::string> encrypted_names = kv_get_all();
std::set<std::string> names;
for(std::string enc_name : encrypted_names)
{
try
{
const secure_vector<uint8_t> raw_name = base64_decode(enc_name);
const secure_vector<uint8_t> name_bits =
nist_key_unwrap_padded(raw_name.data(), raw_name.size(), *m_cipher);
std::string pt_name(cast_uint8_ptr_to_char(name_bits.data()), name_bits.size());
names.insert(pt_name);
}
catch(Integrity_Failure&)
{
}
}
return names;
}
