auto key = from_hex_string("2B7E151628AED2A6ABF7158809CF4F3C");
auto i_vec = from_hex_string("000102030405060708090A0B0C0D0E0F");
auto plan_vec = from_hex_string("6B");
AES_KEY aes_enc_ctx;
AES_set_encrypt_key(key.data(), 128, &aes_enc_ctx);
std::vector<unsigned char> cipher_vec(16);
AES_cbc_encrypt(plan_vec.data(), cipher_vec.data(), 1, &aes_enc_ctx, i_vec.data(), AES_ENCRYPT);
std::cout << "plan : " << to_hex_string(plan_vec) << std::endl;
std::cout << "cipher : " << to_hex_string(cipher_vec) << std::endl;
std::cout << "ivec : " << to_hex_string(i_vec) << std::endl;
AES_KEY aes_dec_ctx;
AES_set_decrypt_key(key.data(), 128, &aes_dec_ctx);
std::vector<unsigned char> decrypt_vec(16);
i_vec = from_hex_string("000102030405060708090A0B0C0D0E0F");
AES_cbc_encrypt(cipher_vec.data(), decrypt_vec.data(), 16, &aes_dec_ctx, i_vec.data(), AES_DECRYPT);
std::cout << "decrypt: " << to_hex_string(decrypt_vec) << std::endl;
result from_hex_string(boost::string_ref in, uint16_t &out) {
return chunk_size::decode(in, out);
}
TEST_CASE("from_hex_string", "[syntax]")
{
result HEXSTRING_INVALID = result::invalid;
result HEXSTRING_OK = result::ok;
result HEXSTRING_OVERFLOW = result::overflow;
uint16_t out;
// HEXSTRING_INVALID
CHECK(from_hex_string("", out) == HEXSTRING_INVALID);
CHECK(from_hex_string("-0", out) == HEXSTRING_INVALID);
CHECK(from_hex_string("-1", out) == HEXSTRING_INVALID);
CHECK(from_hex_string("g", out) == HEXSTRING_INVALID);
CHECK(from_hex_string("z", out) == HEXSTRING_INVALID);
CHECK(from_hex_string("$", out) == HEXSTRING_INVALID);
CHECK(from_hex_string("#", out) == HEXSTRING_INVALID);
CHECK(from_hex_string("0g", out) == HEXSTRING_INVALID);
CHECK(from_hex_string("0$", out) == HEXSTRING_INVALID);
CHECK(from_hex_string("2z", out) == HEXSTRING_INVALID);
// HEXSTRING_OVERFLOW
CHECK(from_hex_string("10000", out) == HEXSTRING_OVERFLOW);
CHECK(from_hex_string("010000", out) == HEXSTRING_OVERFLOW);
CHECK(from_hex_string("0000010000", out) == HEXSTRING_OVERFLOW);
bool chunk_header::parse_char(char c)
{
static const size_t MAX_SIZE_DIGITS(16); // enough for a 64 bit number
// Ensure that the overall header length is within limits
if (++length_ > max_line_length_)
state_ = CHUNK_ERROR_LENGTH;
switch (state_)
{
case CHUNK_SIZE_LS:
// Ignore leading whitespace
if (is_space_or_tab(c))
{
// but only upto to a limit!
if (++ws_count_ > max_whitespace_)
{
state_ = CHUNK_ERROR_WS;
return false;
}
else
break;
}
else
state_ = CHUNK_SIZE;
// intentional fall-through
case CHUNK_SIZE:
if (std::isxdigit (c))
{
hex_size_.push_back(c);
// limit the length of the hex string
if (hex_size_.size() > MAX_SIZE_DIGITS)
{
state_ = CHUNK_ERROR_SIZE;
return false;
}
}
else
{
if (is_end_of_line(c) || (';' == c))
{
size_ = from_hex_string(hex_size_);
size_read_ = true;
if (size_ > max_chunk_size_)
{
state_ = CHUNK_ERROR_SIZE;
return false;
}
if (';' == c)
{
ws_count_ = 0;
state_ = CHUNK_EXTENSION_LS;
}
else
{
if ('\r' == c)
state_ = CHUNK_LF;
else // ('\n' == c)
{
if (strict_crlf_)
return false;
else
state_ = CHUNK_VALID;
}
}
}
else
return false;
}
break;
case CHUNK_EXTENSION_LS:
// Ignore leading whitespace
if (is_space_or_tab(c))
{
// but only upto to a limit!
if (++ws_count_ > max_whitespace_)
return false;
else
break;
}
else
state_ = CHUNK_EXTENSION;
// intentional fall-through
case CHUNK_EXTENSION:
if (!is_end_of_line(c))
extension_.push_back(c);
else if ('\r' == c)
state_ = CHUNK_LF;
else // ('\n' == c)
{
if (strict_crlf_)
{
state_ = CHUNK_ERROR_CRLF;
return false;
}
else
state_ = CHUNK_VALID;
}
break;
case CHUNK_LF:
if ('\n' == c)
state_ = CHUNK_VALID;
else
return false;
break;
default:
return false;
}
return true;
}
