Improve readability
This commit is contained in:
parent
016d66c722
commit
4b7cb59e30
@ -33,9 +33,8 @@ public:
|
||||
};
|
||||
|
||||
|
||||
EvpCipherCtx AES256_CBC::init(Mode mode,
|
||||
const std::vector<unsigned char>& key,
|
||||
const std::vector<unsigned char>& iv) {
|
||||
EvpCipherCtx AES256_CBC::init(Mode mode, const raw_data& key,
|
||||
const raw_data& iv) {
|
||||
if (key.size() != kKeySize) {
|
||||
throw std::runtime_error("Wrong key size");
|
||||
}
|
||||
@ -60,11 +59,10 @@ EvpCipherCtx AES256_CBC::init(Mode mode,
|
||||
return ctx;
|
||||
}
|
||||
|
||||
size_t AES256_CBC::process_chunk(
|
||||
Mode mode, EvpCipherCtx& ctx,
|
||||
std::vector<unsigned char>::const_iterator begin,
|
||||
std::vector<unsigned char>::const_iterator end,
|
||||
std::vector<unsigned char>& output, size_t output_offset,
|
||||
size_t AES256_CBC::process_chunk(Mode mode, EvpCipherCtx& ctx,
|
||||
raw_data::const_iterator begin,
|
||||
raw_data::const_iterator end,
|
||||
raw_data& output, size_t output_offset,
|
||||
bool resize_in, bool resize_out) {
|
||||
auto chunk_size = end - begin;
|
||||
int len;
|
||||
@ -91,8 +89,7 @@ size_t AES256_CBC::process_chunk(
|
||||
}
|
||||
|
||||
size_t AES256_CBC::process_final(Mode mode, EvpCipherCtx& ctx,
|
||||
std::vector<unsigned char>& output,
|
||||
size_t output_offset,
|
||||
raw_data& output, size_t output_offset,
|
||||
bool resize_in, bool resize_out) {
|
||||
int len;
|
||||
if (resize_in) {
|
||||
@ -115,11 +112,10 @@ size_t AES256_CBC::process_final(Mode mode, EvpCipherCtx& ctx,
|
||||
return len;
|
||||
}
|
||||
|
||||
size_t AES256_CBC::process_all(
|
||||
Mode mode, EvpCipherCtx& ctx,
|
||||
std::vector<unsigned char>::const_iterator begin,
|
||||
std::vector<unsigned char>::const_iterator end,
|
||||
std::vector<unsigned char>& output, size_t output_offset,
|
||||
size_t AES256_CBC::process_all(Mode mode, EvpCipherCtx& ctx,
|
||||
raw_data::const_iterator begin,
|
||||
raw_data::const_iterator end,
|
||||
raw_data& output, size_t output_offset,
|
||||
bool resize_in, bool resize_out) {
|
||||
int len = process_chunk(mode, ctx, begin, end, output, output_offset,
|
||||
resize_in, false);
|
||||
@ -128,32 +124,27 @@ size_t AES256_CBC::process_all(
|
||||
return len;
|
||||
}
|
||||
|
||||
std::vector<unsigned char> AES256_CBC::process(
|
||||
const std::vector<unsigned char>& inputdata) {
|
||||
raw_data AES256_CBC::process(const raw_data& inputdata) {
|
||||
if (mode == Mode::kEncrypt)
|
||||
return encrypt(inputdata);
|
||||
else
|
||||
return decrypt(inputdata);
|
||||
}
|
||||
|
||||
std::vector<unsigned char> AES256_CBC::encrypt(
|
||||
const std::vector<unsigned char>& plaintext) {
|
||||
raw_data AES256_CBC::encrypt(const raw_data& plaintext) {
|
||||
return encrypt(encryption_key, horcrux::generate_random(kIvSize),
|
||||
plaintext);
|
||||
}
|
||||
std::vector<unsigned char> AES256_CBC::decrypt(
|
||||
const std::vector<unsigned char>& ciphertext) {
|
||||
raw_data AES256_CBC::decrypt(const raw_data& ciphertext) {
|
||||
return decrypt(encryption_key, ciphertext);
|
||||
}
|
||||
|
||||
std::vector<unsigned char> AES256_CBC::encrypt(
|
||||
const std::vector<unsigned char>& key,
|
||||
const std::vector<unsigned char>& iv,
|
||||
const std::vector<unsigned char>& input) {
|
||||
raw_data AES256_CBC::encrypt(const raw_data& key, const raw_data& iv,
|
||||
const raw_data& input) {
|
||||
auto ctx = init(Mode::kEncrypt, key, iv);
|
||||
|
||||
// Make sure ouput is large enough to contain IV + encrypted data + padding
|
||||
std::vector<unsigned char> output(input.size() + (2 * kIvSize));
|
||||
raw_data output(input.size() + (2 * kIvSize));
|
||||
std::copy(iv.begin(), iv.end(), output.begin());
|
||||
process_all(Mode::kEncrypt, ctx, input.begin(), input.end(), output,
|
||||
kIvSize);
|
||||
@ -162,12 +153,11 @@ std::vector<unsigned char> AES256_CBC::encrypt(
|
||||
|
||||
/*
|
||||
|
||||
int AES256_CBC::encrypt(const std::vector<unsigned char>& key,
|
||||
const std::vector<unsigned char>& iv,
|
||||
int AES256_CBC::encrypt(const raw_data& key, const raw_data& iv,
|
||||
std::istream input, const size_t input_len,
|
||||
std::ostream output, size_t& output_len) {
|
||||
auto inbuf = std::vector<unsigned char>(input_len);
|
||||
auto outbuf = std::vector<unsigned char>(input_len + 16);
|
||||
auto inbuf = raw_data(input_len);
|
||||
auto outbuf = raw_data(input_len + 16);
|
||||
input.read(reinterpret_cast<char*>(inbuf.data()), input_len);
|
||||
|
||||
encrypt(key, iv, inbuf, outbuf);
|
||||
@ -178,28 +168,21 @@ int AES256_CBC::encrypt(const std::vector<unsigned char>& key,
|
||||
}
|
||||
|
||||
*/
|
||||
std::vector<unsigned char> AES256_CBC::decrypt(
|
||||
const std::vector<unsigned char>& key,
|
||||
const std::vector<unsigned char>& ciphertext) {
|
||||
std::vector<unsigned char> iv(ciphertext.begin(),
|
||||
ciphertext.begin() + kIvSize);
|
||||
raw_data AES256_CBC::decrypt(const raw_data& key, const raw_data& ciphertext) {
|
||||
raw_data iv(ciphertext.begin(), ciphertext.begin() + kIvSize);
|
||||
return decrypt(key, iv, ciphertext.begin() + kIvSize, ciphertext.end());
|
||||
}
|
||||
|
||||
std::vector<unsigned char> AES256_CBC::decrypt(
|
||||
const std::vector<unsigned char>& key,
|
||||
const std::vector<unsigned char>& iv,
|
||||
const std::vector<unsigned char>& ciphertext) {
|
||||
raw_data AES256_CBC::decrypt(const raw_data& key, const raw_data& iv,
|
||||
const raw_data& ciphertext) {
|
||||
return decrypt(key, iv, ciphertext.begin(), ciphertext.end());
|
||||
}
|
||||
|
||||
std::vector<unsigned char> AES256_CBC::decrypt(
|
||||
const std::vector<unsigned char>& key,
|
||||
const std::vector<unsigned char>& iv,
|
||||
std::vector<unsigned char>::const_iterator begin,
|
||||
std::vector<unsigned char>::const_iterator end) {
|
||||
raw_data AES256_CBC::decrypt(const raw_data& key, const raw_data& iv,
|
||||
raw_data::const_iterator begin,
|
||||
raw_data::const_iterator end) {
|
||||
auto ctx = init(Mode::kDecrypt, key, iv);
|
||||
std::vector<unsigned char> output;
|
||||
raw_data output;
|
||||
process_all(Mode::kDecrypt, ctx, begin, end, output, 0);
|
||||
return output;
|
||||
}
|
||||
|
84
src/crypto.h
84
src/crypto.h
@ -25,7 +25,7 @@ public:
|
||||
/** @brief create Cipher
|
||||
* @param m Cipher mode (encrypt/decrypt)
|
||||
* @param key use provided key for encryption/decryption */
|
||||
Cipher(Mode m, const std::vector<unsigned char>& key) :
|
||||
Cipher(Mode m, const raw_data& key) :
|
||||
mode(m), encryption_key(key) {}
|
||||
|
||||
/** @brief default destructor */
|
||||
@ -33,7 +33,7 @@ public:
|
||||
|
||||
protected:
|
||||
/** @brief key used for encryption / decryption */
|
||||
std::vector<unsigned char> encryption_key;
|
||||
raw_data encryption_key;
|
||||
|
||||
public:
|
||||
/** @brief Cipher mode (encrypt or decrypt) */
|
||||
@ -42,7 +42,7 @@ public:
|
||||
/** @brief get Cipher encryption key
|
||||
* @return the encryption key
|
||||
*/
|
||||
const std::vector<unsigned char>& get_encryption_key() {
|
||||
const raw_data& get_encryption_key() {
|
||||
return encryption_key;
|
||||
}
|
||||
|
||||
@ -50,22 +50,22 @@ public:
|
||||
* @param inputdata buffer containing data to process
|
||||
* @return processed data
|
||||
*/
|
||||
virtual std::vector<unsigned char> process(
|
||||
const std::vector<unsigned char>& inputdata) = 0;
|
||||
virtual raw_data process(
|
||||
const raw_data& inputdata) = 0;
|
||||
|
||||
/** @brief encrypt the content of a buffer using Cipher key
|
||||
* @param plaintext the input buffer
|
||||
* @return encrypted data
|
||||
*/
|
||||
virtual std::vector<unsigned char> encrypt(
|
||||
const std::vector<unsigned char>& plaintext) = 0;
|
||||
virtual raw_data encrypt(
|
||||
const raw_data& plaintext) = 0;
|
||||
|
||||
/** @brief decrypt the content of a buffer using Cipher key
|
||||
* @param decrypt the input buffer
|
||||
* @return decrypted data
|
||||
*/
|
||||
virtual std::vector<unsigned char> decrypt(
|
||||
const std::vector<unsigned char>& ciphertext) = 0;
|
||||
virtual raw_data decrypt(
|
||||
const raw_data& ciphertext) = 0;
|
||||
};
|
||||
|
||||
// forward declaration
|
||||
@ -98,7 +98,7 @@ public:
|
||||
/** @brief Create cipher in decrypt mode using provided key
|
||||
* @param key 256 bit key
|
||||
*/
|
||||
explicit AES256_CBC(const std::vector<unsigned char>& key)
|
||||
explicit AES256_CBC(const raw_data& key)
|
||||
: Cipher(Mode::kDecrypt, key) {
|
||||
if (key.size() != kKeySize)
|
||||
throw std::invalid_argument("Invalid key size");
|
||||
@ -110,22 +110,22 @@ public:
|
||||
* @param inputdata buffer containing data to process
|
||||
* @return processed data
|
||||
*/
|
||||
std::vector<unsigned char> process(
|
||||
const std::vector<unsigned char>& inputdata) override;
|
||||
raw_data process(
|
||||
const raw_data& inputdata) override;
|
||||
|
||||
/** @brief encrypt the content of a buffer using Cipher key
|
||||
* @param plaintext the input buffer
|
||||
* @return encrypted data
|
||||
*/
|
||||
std::vector<unsigned char> encrypt(
|
||||
const std::vector<unsigned char>& plaintext) override;
|
||||
raw_data encrypt(
|
||||
const raw_data& plaintext) override;
|
||||
|
||||
/** @brief decrypt the content of a buffer using Cipher key
|
||||
* @param decrypt the input buffer
|
||||
* @return decrypted data
|
||||
*/
|
||||
std::vector<unsigned char> decrypt(
|
||||
const std::vector<unsigned char>& ciphertext) override;
|
||||
raw_data decrypt(
|
||||
const raw_data& ciphertext) override;
|
||||
|
||||
/** @brief Read the whole input and return a buffer with the encrypted data
|
||||
* @param key the encryption key
|
||||
@ -134,13 +134,13 @@ public:
|
||||
* @param input the input buffer
|
||||
* @return the encrypted data buffer
|
||||
*/
|
||||
std::vector<unsigned char> encrypt(const std::vector<unsigned char>& key,
|
||||
const std::vector<unsigned char>& iv,
|
||||
const std::vector<unsigned char>& input);
|
||||
raw_data encrypt(const raw_data& key,
|
||||
const raw_data& iv,
|
||||
const raw_data& input);
|
||||
|
||||
/*
|
||||
int encrypt(const std::vector<unsigned char>& key,
|
||||
const std::vector<unsigned char>& iv,
|
||||
int encrypt(const raw_data& key,
|
||||
const raw_data& iv,
|
||||
std::istream input, const size_t input_len,
|
||||
std::ostream output, size_t& output_len);
|
||||
|
||||
@ -151,9 +151,9 @@ public:
|
||||
* @param ciphertext the input buffer
|
||||
* @return the encrypted data buffer
|
||||
*/
|
||||
std::vector<unsigned char> decrypt(
|
||||
const std::vector<unsigned char>& key,
|
||||
const std::vector<unsigned char>& ciphertext);
|
||||
raw_data decrypt(
|
||||
const raw_data& key,
|
||||
const raw_data& ciphertext);
|
||||
|
||||
/** @brief Read the whole input and return a buffer with the decrypted data.
|
||||
* ciphertext does not contain the iv.
|
||||
@ -162,10 +162,10 @@ public:
|
||||
* @param ciphertext the input buffer
|
||||
* @return the encrypted data buffer
|
||||
*/
|
||||
std::vector<unsigned char> decrypt(
|
||||
const std::vector<unsigned char>& key,
|
||||
const std::vector<unsigned char>& iv,
|
||||
const std::vector<unsigned char>& ciphertext);
|
||||
raw_data decrypt(
|
||||
const raw_data& key,
|
||||
const raw_data& iv,
|
||||
const raw_data& ciphertext);
|
||||
|
||||
/** @brief Read some input from begin to end and return a buffer with the
|
||||
* decrypted data. Output data is finalized.
|
||||
@ -175,11 +175,11 @@ public:
|
||||
* @param end end of the input buffer
|
||||
* @return the encrypted data buffer
|
||||
*/
|
||||
std::vector<unsigned char> decrypt(
|
||||
const std::vector<unsigned char>& key,
|
||||
const std::vector<unsigned char>& iv,
|
||||
std::vector<unsigned char>::const_iterator begin,
|
||||
std::vector<unsigned char>::const_iterator end);
|
||||
raw_data decrypt(
|
||||
const raw_data& key,
|
||||
const raw_data& iv,
|
||||
raw_data::const_iterator begin,
|
||||
raw_data::const_iterator end);
|
||||
|
||||
private:
|
||||
/** @brief Create a Cipher context object needed for enc/dec operations
|
||||
@ -188,8 +188,8 @@ private:
|
||||
* @param the initialization vector
|
||||
* @return the Cipher context object
|
||||
*/
|
||||
EvpCipherCtx init(Mode mode, const std::vector<unsigned char>& key,
|
||||
const std::vector<unsigned char>& iv);
|
||||
EvpCipherCtx init(Mode mode, const raw_data& key,
|
||||
const raw_data& iv);
|
||||
|
||||
/** @brief process a chunk of input
|
||||
* @param mode encrypt or decrypt
|
||||
@ -204,9 +204,9 @@ private:
|
||||
* @param resize_out shrink the output buffer at the end
|
||||
*/
|
||||
size_t process_chunk(Mode mode, EvpCipherCtx& ctx,
|
||||
std::vector<unsigned char>::const_iterator begin,
|
||||
std::vector<unsigned char>::const_iterator end,
|
||||
std::vector<unsigned char>& output,
|
||||
raw_data::const_iterator begin,
|
||||
raw_data::const_iterator end,
|
||||
raw_data& output,
|
||||
size_t output_offset,
|
||||
bool resize_in = true, bool resize_out = true);
|
||||
|
||||
@ -222,7 +222,7 @@ private:
|
||||
* @param resize_out shrink the output buffer at the end
|
||||
*/
|
||||
size_t process_final(Mode mode, EvpCipherCtx& ctx,
|
||||
std::vector<unsigned char>& output,
|
||||
raw_data& output,
|
||||
size_t output_offset,
|
||||
bool resize_in = true, bool resize_out = true);
|
||||
|
||||
@ -239,9 +239,9 @@ private:
|
||||
* @param resize_out shrink the output buffer at the end
|
||||
*/
|
||||
size_t process_all(Mode mode, EvpCipherCtx& ctx,
|
||||
std::vector<unsigned char>::const_iterator begin,
|
||||
std::vector<unsigned char>::const_iterator end,
|
||||
std::vector<unsigned char>& output, size_t output_offset,
|
||||
raw_data::const_iterator begin,
|
||||
raw_data::const_iterator end,
|
||||
raw_data& output, size_t output_offset,
|
||||
bool resize_in = true, bool resize_out = true);
|
||||
};
|
||||
|
||||
|
12
src/io.cpp
12
src/io.cpp
@ -17,8 +17,8 @@ FsPlainInput::FsPlainInput(const std::string& path)
|
||||
file_stream = std::ifstream(file_path, std::ios::binary);
|
||||
}
|
||||
|
||||
std::vector<unsigned char> FsPlainInput::read() {
|
||||
std::vector<unsigned char> result(file_size);
|
||||
raw_data FsPlainInput::read() {
|
||||
raw_data result(file_size);
|
||||
file_stream.read(reinterpret_cast<char*>(result.data()), file_size);
|
||||
return result;
|
||||
}
|
||||
@ -40,8 +40,8 @@ FsCryptoInput::FsCryptoInput(const std::vector<std::string>& filenames) {
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<unsigned char> FsCryptoInput::read() {
|
||||
std::vector<unsigned char> result(total_size);
|
||||
raw_data FsCryptoInput::read() {
|
||||
raw_data result(total_size);
|
||||
size_t data_read{0};
|
||||
for (auto& f : file_paths) {
|
||||
std::ifstream ifstream(f.first);
|
||||
@ -58,7 +58,7 @@ FsPlainOutput::FsPlainOutput(const std::string& filename)
|
||||
throw std::invalid_argument("Output file is not a regular file");
|
||||
}
|
||||
}
|
||||
size_t FsPlainOutput::write(const std::vector<unsigned char>& to_write) {
|
||||
size_t FsPlainOutput::write(const raw_data& to_write) {
|
||||
std::ofstream out(file_path, std::ios::binary);
|
||||
out.write(reinterpret_cast<const char*>(to_write.data()), to_write.size());
|
||||
return to_write.size();
|
||||
@ -77,7 +77,7 @@ FsCryptoOutput::FsCryptoOutput(const std::string& folder, const int horcrux_num,
|
||||
}
|
||||
}
|
||||
|
||||
size_t FsCryptoOutput::write(const std::vector<unsigned char>& to_write) {
|
||||
size_t FsCryptoOutput::write(const raw_data& to_write) {
|
||||
size = to_write.size() / num;
|
||||
std::ofstream f;
|
||||
created_files.clear();
|
||||
|
13
src/io.h
13
src/io.h
@ -5,6 +5,7 @@
|
||||
#include <fstream>
|
||||
#include <vector>
|
||||
#include <utility>
|
||||
#include "utils.h"
|
||||
|
||||
namespace horcrux {
|
||||
|
||||
@ -15,7 +16,7 @@ public:
|
||||
virtual ~Input() = default;
|
||||
/** @brief Read from the input
|
||||
* @return new buffer containing all read data */
|
||||
virtual std::vector<unsigned char> read() = 0;
|
||||
virtual raw_data read() = 0;
|
||||
};
|
||||
|
||||
/** @brief Base Class for Output
|
||||
@ -26,7 +27,7 @@ public:
|
||||
/** @brief Write to the output
|
||||
* @param data to write
|
||||
* @return written data */
|
||||
virtual size_t write(const std::vector<unsigned char>& data) = 0;
|
||||
virtual size_t write(const raw_data& data) = 0;
|
||||
};
|
||||
|
||||
/** @brief Input that reads data from a regular file */
|
||||
@ -49,7 +50,7 @@ public:
|
||||
|
||||
/** @brief Read from the input
|
||||
* @return new buffer containing all read data */
|
||||
std::vector<unsigned char> read() override;
|
||||
raw_data read() override;
|
||||
};
|
||||
|
||||
/** @brief Input that reads scattered data from multiple files */
|
||||
@ -71,7 +72,7 @@ public:
|
||||
/** @brief Read from the input
|
||||
* @details basically concatenate the input files.
|
||||
* @return new buffer containing all read data */
|
||||
std::vector<unsigned char> read() override;
|
||||
raw_data read() override;
|
||||
};
|
||||
|
||||
/** @brief Output that writes to a single regular file */
|
||||
@ -91,7 +92,7 @@ public:
|
||||
/** @brief Write to the output
|
||||
* @param data to write
|
||||
* @return written data */
|
||||
size_t write(const std::vector<unsigned char>& to_write) override;
|
||||
size_t write(const raw_data& to_write) override;
|
||||
};
|
||||
|
||||
/** @brief Output that splits the data in equal size chunks and writes them to
|
||||
@ -128,7 +129,7 @@ public:
|
||||
/** @brief Write to the output
|
||||
* @param data to write
|
||||
* @return written data */
|
||||
size_t write(const std::vector<unsigned char>& to_write) override;
|
||||
size_t write(const raw_data& to_write) override;
|
||||
};
|
||||
}; // namespace horcrux
|
||||
#endif // HORCRUX_SRC_IO_H
|
||||
|
@ -4,7 +4,7 @@
|
||||
#include <boost/archive/iterators/base64_from_binary.hpp>
|
||||
#include <boost/archive/iterators/transform_width.hpp>
|
||||
|
||||
std::string horcrux::to_base64(const std::vector<unsigned char>& binary) {
|
||||
std::string horcrux::to_base64(const raw_data& binary) {
|
||||
using namespace boost::archive::iterators;
|
||||
using It = base64_from_binary<transform_width<
|
||||
std::vector<unsigned char>::const_iterator, 6, 8>>;
|
||||
@ -13,7 +13,7 @@ std::string horcrux::to_base64(const std::vector<unsigned char>& binary) {
|
||||
return base64.append((3 - binary.size() % 3) % 3, '=');
|
||||
}
|
||||
|
||||
std::vector<unsigned char> horcrux::from_base64(const std::string& base64) {
|
||||
horcrux::raw_data horcrux::from_base64(const std::string& base64) {
|
||||
using namespace boost::archive::iterators;
|
||||
using It = transform_width<binary_from_base64<std::string::const_iterator>,
|
||||
8, 6>;
|
||||
@ -30,8 +30,8 @@ std::vector<unsigned char> horcrux::from_base64(const std::string& base64) {
|
||||
return binary;
|
||||
}
|
||||
|
||||
std::vector<unsigned char> horcrux::generate_random(const size_t size) {
|
||||
std::vector<unsigned char> res(size);
|
||||
horcrux::raw_data horcrux::generate_random(const size_t size) {
|
||||
horcrux::raw_data res(size);
|
||||
if (!RAND_bytes(res.data(), size)) {
|
||||
throw std::exception();
|
||||
}
|
||||
|
@ -6,9 +6,11 @@
|
||||
|
||||
namespace horcrux {
|
||||
|
||||
std::string to_base64(const std::vector<unsigned char>& binary);
|
||||
std::vector<unsigned char> from_base64(const std::string& base64);
|
||||
std::vector<unsigned char> generate_random(const size_t size);
|
||||
typedef std::vector<unsigned char> raw_data;
|
||||
|
||||
std::string to_base64(const raw_data& binary);
|
||||
raw_data from_base64(const std::string& base64);
|
||||
raw_data generate_random(const size_t size);
|
||||
|
||||
}
|
||||
#endif // HORCRUX_SRC_UTILS_H
|
||||
|
@ -6,9 +6,9 @@
|
||||
|
||||
using namespace horcrux;
|
||||
TEST(CryptoTest, encrypt1){
|
||||
const std::vector<unsigned char> plaintext(test1_str.begin(), test1_str.end());
|
||||
const std::vector<unsigned char> key(test1_key.begin(), test1_key.end());
|
||||
const std::vector<unsigned char> iv(test1_iv.begin(), test1_iv.end());
|
||||
const raw_data plaintext(test1_str.begin(), test1_str.end());
|
||||
const raw_data key(test1_key.begin(), test1_key.end());
|
||||
const raw_data iv(test1_iv.begin(), test1_iv.end());
|
||||
|
||||
AES256_CBC a;
|
||||
auto output = a.encrypt(key, iv, plaintext);
|
||||
@ -19,11 +19,11 @@ TEST(CryptoTest, encrypt1){
|
||||
}
|
||||
|
||||
TEST(CryptoTest, encrypt2){
|
||||
const std::vector<unsigned char> plaintext(test1_str.begin(), test1_str.end());
|
||||
const raw_data plaintext(test1_str.begin(), test1_str.end());
|
||||
//size_t output_len = plaintext.size() + 16;
|
||||
//std::vector<unsigned char> output(output_len);
|
||||
const std::vector<unsigned char> key(test1_key.begin(), test1_key.end());
|
||||
const std::vector<unsigned char> iv(test1_iv.begin(), test1_iv.end());
|
||||
//raw_data output(output_len);
|
||||
const raw_data key(test1_key.begin(), test1_key.end());
|
||||
const raw_data iv(test1_iv.begin(), test1_iv.end());
|
||||
|
||||
AES256_CBC a;
|
||||
auto output = a.encrypt(key, iv, plaintext);
|
||||
@ -35,11 +35,11 @@ TEST(CryptoTest, encrypt2){
|
||||
}
|
||||
|
||||
TEST(CryptoTest, encrypt3){
|
||||
const std::vector<unsigned char> plaintext(test1_str.begin(), test1_str.end());
|
||||
const raw_data plaintext(test1_str.begin(), test1_str.end());
|
||||
//size_t output_len = plaintext.size() + 16;
|
||||
//std::vector<unsigned char> output(output_len);
|
||||
const std::vector<unsigned char> key(test1_key.begin(), test1_key.end());
|
||||
const std::vector<unsigned char> iv(test1_iv.begin(), test1_iv.end());
|
||||
//raw_data output(output_len);
|
||||
const raw_data key(test1_key.begin(), test1_key.end());
|
||||
const raw_data iv(test1_iv.begin(), test1_iv.end());
|
||||
|
||||
AES256_CBC a(key);
|
||||
auto output = a.encrypt(plaintext);
|
||||
@ -50,9 +50,9 @@ TEST(CryptoTest, encrypt3){
|
||||
}
|
||||
|
||||
TEST(CryptoTest, decrypt1){
|
||||
const std::vector<unsigned char> plaintext(test1_str.begin(), test1_str.end());
|
||||
const std::vector<unsigned char> key(test1_key.begin(), test1_key.end());
|
||||
const std::vector<unsigned char> iv(test1_iv.begin(), test1_iv.end());
|
||||
const raw_data plaintext(test1_str.begin(), test1_str.end());
|
||||
const raw_data key(test1_key.begin(), test1_key.end());
|
||||
const raw_data iv(test1_iv.begin(), test1_iv.end());
|
||||
|
||||
AES256_CBC a;
|
||||
auto output = a.decrypt(key, iv, test1_enc);
|
||||
@ -60,12 +60,12 @@ TEST(CryptoTest, decrypt1){
|
||||
EXPECT_EQ(plaintext, output);
|
||||
}
|
||||
TEST(CryptoTest, decrypt2){
|
||||
const std::vector<unsigned char> plaintext(test1_str.begin(), test1_str.end());
|
||||
const raw_data plaintext(test1_str.begin(), test1_str.end());
|
||||
size_t output_len = test1_enc.size();
|
||||
const std::vector<unsigned char> key(test1_key.begin(), test1_key.end());
|
||||
const std::vector<unsigned char> iv(test1_iv.begin(), test1_iv.end());
|
||||
const raw_data key(test1_key.begin(), test1_key.end());
|
||||
const raw_data iv(test1_iv.begin(), test1_iv.end());
|
||||
// constructs encrypted input (iv + encrypted_data)
|
||||
auto input = std::vector<unsigned char>(iv);
|
||||
auto input = raw_data(iv);
|
||||
input.insert(input.end(),test1_enc.begin(), test1_enc.end());
|
||||
|
||||
AES256_CBC a;
|
||||
@ -74,12 +74,12 @@ TEST(CryptoTest, decrypt2){
|
||||
EXPECT_EQ(plaintext, output);
|
||||
}
|
||||
TEST(CryptoTest, decrypt3){
|
||||
const std::vector<unsigned char> plaintext(test1_str.begin(), test1_str.end());
|
||||
const raw_data plaintext(test1_str.begin(), test1_str.end());
|
||||
size_t output_len = test1_enc.size();
|
||||
const std::vector<unsigned char> key(test1_key.begin(), test1_key.end());
|
||||
const std::vector<unsigned char> iv(test1_iv.begin(), test1_iv.end());
|
||||
const raw_data key(test1_key.begin(), test1_key.end());
|
||||
const raw_data iv(test1_iv.begin(), test1_iv.end());
|
||||
// constructs encrypted input (iv + encrypted_data)
|
||||
auto input = std::vector<unsigned char>(iv);
|
||||
auto input = raw_data(iv);
|
||||
input.insert(input.end(),test1_enc.begin(), test1_enc.end());
|
||||
|
||||
AES256_CBC a(key);
|
||||
@ -88,7 +88,7 @@ TEST(CryptoTest, decrypt3){
|
||||
EXPECT_EQ(plaintext, output);
|
||||
}
|
||||
TEST(CryptoTest, endToEnd){
|
||||
const std::vector<unsigned char> plaintext(test1_str.begin(), test1_str.end());
|
||||
const raw_data plaintext(test1_str.begin(), test1_str.end());
|
||||
AES256_CBC a;
|
||||
auto crypto = a.encrypt(plaintext);
|
||||
EXPECT_GT(crypto.size(), plaintext.size());
|
||||
|
@ -2,11 +2,11 @@
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
/* Utility functions */
|
||||
std::vector<unsigned char> generic_read_file(const std::string& filename) {
|
||||
horcrux::raw_data generic_read_file(const std::string& filename) {
|
||||
auto ifstream = std::ifstream{filename, std::ios::binary};
|
||||
auto path = std::filesystem::path{filename};
|
||||
auto size = std::filesystem::file_size(path);
|
||||
std::vector<unsigned char> buf(size);
|
||||
horcrux::raw_data buf(size);
|
||||
ifstream.read(reinterpret_cast<char*>(buf.data()), size);
|
||||
return buf;
|
||||
}
|
||||
|
@ -4,6 +4,7 @@
|
||||
#include <algorithm>
|
||||
#include "io.h"
|
||||
#include "crypto.h"
|
||||
#include "utils.h"
|
||||
|
||||
/* IO Test utils */
|
||||
#ifndef TEST_WORK_DIR
|
||||
@ -16,7 +17,7 @@ const std::string empty{TEST_WORK_DIR "/empty"};
|
||||
const std::string text{TEST_WORK_DIR "/test.txt"};
|
||||
const std::string image{TEST_WORK_DIR "/mangoni.jpg"};
|
||||
|
||||
std::vector<unsigned char> generic_read_file(const std::string& filename);
|
||||
horcrux::raw_data generic_read_file(const std::string& filename);
|
||||
|
||||
std::vector<std::string> get_created_filenames(const horcrux::FsCryptoOutput& out);
|
||||
|
||||
@ -34,7 +35,7 @@ echo "ditemi perche' se la mucca fa mu il merlo non fa me" |
|
||||
const std::string test1_str = "ditemi perche' se la mucca fa mu il merlo non fa me";
|
||||
const std::string test1_key = "0123456789ABCDEF0123456789ABCDEF";
|
||||
const std::string test1_iv = "0123456789ABCDEF";
|
||||
const std::vector<unsigned char> test1_enc {
|
||||
const horcrux::raw_data test1_enc {
|
||||
0x4c, 0x17, 0x6e, 0x6d, 0xd2, 0x83, 0x51, 0x52, 0xfc, 0x5d, 0xbe, 0x0f,
|
||||
0x1b, 0xcf, 0x86, 0xef, 0x73, 0x91, 0x58, 0xc4, 0xdd, 0x1b, 0x09, 0x3d,
|
||||
0x77, 0xe0, 0x78, 0x5d, 0x21, 0xfe, 0x59, 0x9c, 0xb2, 0x12, 0xa6, 0x81,
|
||||
|
@ -16,10 +16,10 @@ const std::string test4_str = "mi e' entrata una bruschetta nell'occhio";
|
||||
const std::string test4_base64 = "bWkgZScgZW50cmF0YSB1bmEgYnJ1c2NoZXR0YSBuZWxsJ29jY2hpbw==";
|
||||
|
||||
TEST(utilTests, to_base64Test){
|
||||
EXPECT_EQ(test1_base64, horcrux::to_base64(std::vector<unsigned char>(test1_str.begin(), test1_str.end())));
|
||||
EXPECT_EQ(test2_base64, horcrux::to_base64(std::vector<unsigned char>(test2_str.begin(), test2_str.end())));
|
||||
EXPECT_EQ(test3_base64, horcrux::to_base64(std::vector<unsigned char>(test3_str.begin(), test3_str.end())));
|
||||
EXPECT_EQ(test4_base64, horcrux::to_base64(std::vector<unsigned char>(test4_str.begin(), test4_str.end())));
|
||||
EXPECT_EQ(test1_base64, horcrux::to_base64(horcrux::raw_data(test1_str.begin(), test1_str.end())));
|
||||
EXPECT_EQ(test2_base64, horcrux::to_base64(horcrux::raw_data(test2_str.begin(), test2_str.end())));
|
||||
EXPECT_EQ(test3_base64, horcrux::to_base64(horcrux::raw_data(test3_str.begin(), test3_str.end())));
|
||||
EXPECT_EQ(test4_base64, horcrux::to_base64(horcrux::raw_data(test4_str.begin(), test4_str.end())));
|
||||
}
|
||||
|
||||
TEST(utilTests, from_base64Test){
|
||||
|
Loading…
Reference in New Issue
Block a user