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); }