TEST_F(BlockStoreUtilsTest_CopyToExistingBlock, CopyDataBlock) {
auto block = blockStore->create(Data(SIZE));
block->write(dataFixture.data(), 0, SIZE);
auto block2 = blockStore->create(Data(SIZE));
copyTo(block2.get(), *block);
EXPECT_EQ(0, std::memcmp(dataFixture.data(), block2->data(), SIZE));
}
TEST_F(BlockStoreUtilsTest, FillWithZeroes) {
auto block = blockStore->create(Data(SIZE));
block->write(dataFixture.data(), 0, SIZE);
EXPECT_NE(0, std::memcmp(ZEROES.data(), block->data(), SIZE));
fillWithZeroes(block.get());
EXPECT_EQ(0, std::memcmp(ZEROES.data(), block->data(), SIZE));
}
TEST_F(ConcreteInnerEncryptorTest, DoesntDecryptWithWrongCipherName) {
auto encryptor = makeInnerEncryptor<Twofish128_CFB>();
InnerConfig encrypted = encryptor->encrypt(Data(0));
encrypted.cipherName = AES256_CFB::NAME;
auto decrypted = encryptor->decrypt(encrypted);
EXPECT_EQ(none, decrypted);
}
TEST_F(BlockStoreUtilsTest_CopyToNewBlock, OriginalBlockUnchanged) {
auto block = blockStore->create(Data(SIZE));
block->write(dataFixture.data(), 0, SIZE);
auto block2 = copyToNewBlock(blockStore.get(), *block);
EXPECT_EQ(SIZE, block->size());
EXPECT_EQ(0, std::memcmp(dataFixture.data(), block->data(), SIZE));
}
TEST_F(OnDiskBlockCreateTest, CreatingBlockCreatesFile) {
EXPECT_FALSE(bf::exists(file.path()));
auto block = OnDiskBlock::CreateOnDisk(dir.path(), key, Data(0));
EXPECT_TRUE(bf::exists(file.path()));
EXPECT_TRUE(bf::is_regular_file(file.path()));
}
TEST_F(CryConfigEncryptorFactoryTest, DoesntDecryptWithWrongPassword_EmptyData) {
auto encryptor = CryConfigEncryptorFactory::deriveKey("mypassword", SCrypt::TestSettings);
Data encrypted = encryptor->encrypt(Data(0), AES256_GCM::NAME);
auto loadedEncryptor = CryConfigEncryptorFactory::loadKey(encrypted, "wrongpassword").value();
auto decrypted = loadedEncryptor->decrypt(encrypted);
EXPECT_EQ(none, decrypted);
}
TEST_F(CryConfigEncryptorTest, EncryptionIsFixedSize) {
auto encryptor = makeEncryptor();
Data encrypted1 = encryptor->encrypt(DataFixture::generate(100), AES128_CFB::NAME);
Data encrypted2 = encryptor->encrypt(DataFixture::generate(200), Twofish256_GCM::NAME);
Data encrypted3 = encryptor->encrypt(Data(0), AES256_GCM::NAME);
EXPECT_EQ(encrypted1.size(), encrypted2.size());
EXPECT_EQ(encrypted1.size(), encrypted3.size());
}
TEST_F(ConcreteInnerEncryptorTest, EncryptionIsFixedSize) {
auto encryptor = makeInnerEncryptor<AES256_GCM>();
InnerConfig encrypted1 = encryptor->encrypt(DataFixture::generate(100));
InnerConfig encrypted2 = encryptor->encrypt(DataFixture::generate(200));
InnerConfig encrypted3 = encryptor->encrypt(Data(0));
EXPECT_EQ(encrypted1.encryptedConfig.size(), encrypted2.encryptedConfig.size());
EXPECT_EQ(encrypted1.encryptedConfig.size(), encrypted3.encryptedConfig.size());
}
TEST_F(CachingBlockStoreTest, PhysicalBlockSize_negativeboundaries) {
// This tests that a potential if/else in blockSizeFromPhysicalBlockSize that catches negative values has the
// correct boundary set. We test the highest value that is negative and the smallest value that is positive.
auto physicalSizeForVirtualSizeZero = baseBlockStore->load(CreateBlockReturnKey(Data(0))).value()->size();
if (physicalSizeForVirtualSizeZero > 0) {
EXPECT_EQ(0u, blockStore.blockSizeFromPhysicalBlockSize(physicalSizeForVirtualSizeZero - 1));
}
EXPECT_EQ(0u, blockStore.blockSizeFromPhysicalBlockSize(physicalSizeForVirtualSizeZero));
EXPECT_EQ(1u, blockStore.blockSizeFromPhysicalBlockSize(physicalSizeForVirtualSizeZero + 1));
}
TEST_F(CachingBlockStoreTest, PhysicalBlockSize_zerovirtual) {
auto key = CreateBlockReturnKey(Data(0));
auto base = baseBlockStore->load(key).value();
EXPECT_EQ(0u, blockStore.blockSizeFromPhysicalBlockSize(base->size()));
}
TEST_F(ConcreteInnerEncryptorTest, EncryptAndDecrypt_EmptyData) {
auto encryptor = makeInnerEncryptor<AES256_GCM>();
InnerConfig encrypted = encryptor->encrypt(Data(0));
Data decrypted = encryptor->decrypt(encrypted).value();
EXPECT_EQ(Data(0), decrypted);
}
DerivedKey<CryConfigEncryptor::MaxTotalKeySize> _derivedKey() {
auto salt = DataFixture::generate(128, 2);
auto keyConfig = DerivedKeyConfig(std::move(salt), 1024, 1, 2);
auto key = DataFixture::generateFixedSize<CryConfigEncryptor::MaxTotalKeySize>(3);
return DerivedKey<CryConfigEncryptor::MaxTotalKeySize>(std::move(keyConfig), std::move(key));
}
TEST_F(BlockStoreUtilsTest_CopyToExistingBlock, CopyEmptyBlock) {
auto block = blockStore->create(Data(0));
auto block2 = blockStore->create(Data(0));
copyTo(block2.get(), *block);
}
TEST_F(CryConfigEncryptorTest, EncryptAndDecrypt_EmptyData) {
auto encryptor = makeEncryptor();
Data encrypted = encryptor->encrypt(Data(0), AES256_GCM::NAME);
auto decrypted = encryptor->decrypt(encrypted).value();
EXPECT_EQ(Data(0), decrypted.data);
}
TEST_F(BlockStoreUtilsTest_CopyToNewBlock, CopyEmptyBlock) {
auto block = blockStore->create(Data(0));
auto block2 = copyToNewBlock(blockStore.get(), *block);
EXPECT_EQ(0u, block2->size());
}
TEST_F(OnDiskBlockCreateTest, CreatingExistingBlockReturnsNull) {
auto block1 = OnDiskBlock::CreateOnDisk(dir.path(), key, Data(0));
auto block2 = OnDiskBlock::CreateOnDisk(dir.path(), key, Data(0));
EXPECT_TRUE((bool)block1);
EXPECT_FALSE((bool)block2);
}
OnDiskBlockCreateSizeTest():
block(OnDiskBlock::CreateOnDisk(dir.path(), key, std::move(Data(GetParam()).FillWithZeroes())).value()),
ZEROES(block->size())
{
ZEROES.FillWithZeroes();
}
TEST_F(CachingBlockStoreTest, PhysicalBlockSize_positive) {
auto key = CreateBlockReturnKey(Data(10*1024));
auto base = baseBlockStore->load(key).value();
EXPECT_EQ(10*1024u, blockStore.blockSizeFromPhysicalBlockSize(base->size()));
}
blockstore::Key CreateBlockWriteFixtureToItAndReturnKey() {
auto block = blockStore->create(Data(data.size()));
block->write(data.data(), 0, data.size());
return block->key();
}
TEST_F(OuterConfigTest, SomeValues) {
Data serialized = OuterConfig{DerivedKeyConfig(salt(), N, r, p), DataFixture::generate(1024)}.serialize();
OuterConfig deserialized = OuterConfig::deserialize(serialized).value();
EXPECT_EQ(DerivedKeyConfig(salt(), N, r, p), deserialized.keyConfig);
EXPECT_EQ(DataFixture::generate(1024), deserialized.encryptedInnerConfig);
}
TEST_F(CryConfigEncryptorFactoryTest, DoesntDecryptInvalidData) {
auto loadedEncryptor = CryConfigEncryptorFactory::loadKey(Data(0), "mypassword");
EXPECT_EQ(none, loadedEncryptor);
}
TEST_F(OuterConfigTest, DataAndKeyConfigEmpty) {
Data serialized = OuterConfig{DerivedKeyConfig(Data(0), 0, 0, 0), Data(0)}.serialize();
OuterConfig deserialized = OuterConfig::deserialize(serialized).value();
EXPECT_EQ(DerivedKeyConfig(Data(0), 0, 0, 0), deserialized.keyConfig);
EXPECT_EQ(Data(0), deserialized.encryptedInnerConfig);
}
TEST_F(OuterConfigTest, DataAndKeyConfigEmpty) {
Data serialized = OuterConfig{Data(0), Data(0), false}.serialize();
OuterConfig deserialized = OuterConfig::deserialize(serialized).value();
EXPECT_EQ(Data(0), deserialized.kdfParameters);
EXPECT_EQ(Data(0), deserialized.encryptedInnerConfig);
}
