105 lines
3.3 KiB
C++
105 lines
3.3 KiB
C++
#pragma once
|
|
#ifndef MESSMER_BLOCKSTORE_TEST_IMPLEMENTATIONS_ENCRYPTED_TESTUTILS_FAKEAUTHENTICATEDCIPHER_H_
|
|
#define MESSMER_BLOCKSTORE_TEST_IMPLEMENTATIONS_ENCRYPTED_TESTUTILS_FAKEAUTHENTICATEDCIPHER_H_
|
|
|
|
#include "../../../../implementations/encrypted/ciphers/Cipher.h"
|
|
#include <messmer/cpp-utils/data/FixedSizeData.h>
|
|
#include <messmer/cpp-utils/random/Random.h>
|
|
|
|
struct FakeKey {
|
|
static FakeKey FromBinary(const void *data) {
|
|
return FakeKey{*(uint8_t*)data};
|
|
}
|
|
static constexpr unsigned int BINARY_LENGTH = 1;
|
|
|
|
uint8_t value;
|
|
};
|
|
|
|
// This is a fake cipher that uses an indeterministic caesar chiffre and a 4-byte parity for a simple authentication mechanism
|
|
class FakeAuthenticatedCipher {
|
|
public:
|
|
BOOST_CONCEPT_ASSERT((blockstore::encrypted::CipherConcept<FakeAuthenticatedCipher>));
|
|
|
|
using EncryptionKey = FakeKey;
|
|
|
|
static EncryptionKey CreateKey(cpputils::RandomGenerator &randomGenerator) {
|
|
auto data = randomGenerator.getFixedSize<1>();
|
|
return FakeKey{*((uint8_t*)data.data())};
|
|
}
|
|
|
|
static EncryptionKey Key1() {
|
|
return FakeKey{5};
|
|
}
|
|
static EncryptionKey Key2() {
|
|
return FakeKey{63};
|
|
}
|
|
|
|
static constexpr unsigned int ciphertextSize(unsigned int plaintextBlockSize) {
|
|
return plaintextBlockSize + 5;
|
|
}
|
|
|
|
static constexpr unsigned int plaintextSize(unsigned int ciphertextBlockSize) {
|
|
return ciphertextBlockSize - 5;
|
|
}
|
|
|
|
static cpputils::Data encrypt(const byte *plaintext, unsigned int plaintextSize, const EncryptionKey &encKey) {
|
|
cpputils::Data result(ciphertextSize(plaintextSize));
|
|
|
|
//Add a random IV
|
|
uint8_t iv = rand();
|
|
std::memcpy(result.data(), &iv, 1);
|
|
|
|
//Use caesar chiffre on plaintext
|
|
_caesar((byte*)result.data() + 1, plaintext, plaintextSize, encKey.value + iv);
|
|
|
|
//Add parity information
|
|
int32_t parity = _parity((byte*)result.data(), plaintextSize + 1);
|
|
std::memcpy((byte*)result.data() + plaintextSize + 1, &parity, 4);
|
|
|
|
return result;
|
|
}
|
|
|
|
static boost::optional<cpputils::Data> decrypt(const byte *ciphertext, unsigned int ciphertextSize, const EncryptionKey &encKey) {
|
|
//We need at least 5 bytes (iv + parity)
|
|
if (ciphertextSize < 5) {
|
|
return boost::none;
|
|
}
|
|
|
|
//Check parity
|
|
int32_t expectedParity = _parity(ciphertext, plaintextSize(ciphertextSize) + 1);
|
|
int32_t actualParity = *(int32_t*)(ciphertext + plaintextSize(ciphertextSize) + 1);
|
|
if (expectedParity != actualParity) {
|
|
return boost::none;
|
|
}
|
|
|
|
//Decrypt caesar chiffre from ciphertext
|
|
int32_t iv = *(int32_t*)ciphertext;
|
|
cpputils::Data result(plaintextSize(ciphertextSize));
|
|
_caesar((byte*)result.data(), ciphertext + 1, plaintextSize(ciphertextSize), -(encKey.value+iv));
|
|
return std::move(result);
|
|
}
|
|
|
|
private:
|
|
static int32_t _parity(const byte *data, unsigned int size) {
|
|
int32_t parity = 34343435; // some init value
|
|
int32_t *intData = (int32_t*)data;
|
|
unsigned int intSize = size / sizeof(int32_t);
|
|
for (unsigned int i = 0; i < intSize; ++i) {
|
|
parity += intData[i];
|
|
}
|
|
unsigned int remainingBytes = size - 4 * intSize;
|
|
for (unsigned int i = 0; i < remainingBytes; ++i) {
|
|
parity += (data[4*intSize + i] << (24 - 8*i));
|
|
}
|
|
return parity;
|
|
}
|
|
|
|
static void _caesar(byte *dst, const byte *src, unsigned int size, uint8_t key) {
|
|
for (unsigned int i = 0; i < size; ++i) {
|
|
dst[i] = src[i] + key;
|
|
}
|
|
}
|
|
};
|
|
|
|
#endif
|