openharmony/filemanagement_storage_service
1
0
Fork 0
mirror of https://gitee.com/openharmony/filemanagement_storage_service synced 2024-11-23 06:59:59 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

fix tdd

Browse Source 
Signed-off-by: 张文迪 <zhangwendi3@huawei.com>
This commit is contained in:
张文迪 2023-09-01 10:02:23 +08:00
parent 9b26eb880d
commit aac3fe9778
5 changed files with 130 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
bundle.json
View File

@ -23,7 +23,8 @@
"storage_service_user_file_sharing",
"storage_service_user_crypto_manager",
"storage_service_external_storage_manager",
"storage_service_storage_statistics_manager"
"storage_service_storage_statistics_manager",
"storage_service_crypto_test"
],
"adapted_system_type": [ "small", "standard" ],
"rom": "4096KB",

4
services/storage_daemon/crypto/test/BUILD.gn
View File

@ -36,6 +36,10 @@ ohos_moduletest("CryptoSubTest") {
sources = [ "crypto_key_test.cpp" ]
if (storage_service_crypto_test) {
defines += [ "CRYPTO_TEST" ]
}
configs = [ ":module_private_config" ]
deps = [ "//third_party/googletest:gtest_main" ]

125
services/storage_daemon/crypto/test/crypto_key_test.cpp
View File

@ -210,6 +210,20 @@ HWTEST_F(CryptoKeyTest, fscrypt_key_v2_init, TestSize.Level1)
*/
HWTEST_F(CryptoKeyTest, fscrypt_key_v1_store, TestSize.Level1)
{
#ifndef CRYPTO_TEST
EXPECT_TRUE(g_testKeyV1.InitKey());
g_testKeyV1.StoreKey(emptyUserAuth);
std::string buf {};
OHOS::FileExists(TEST_KEYPATH + TEST_KEYDIR_VERSION0 + PATH_SHIELD);
OHOS::LoadStringFromFile(TEST_KEYPATH + TEST_KEYDIR_VERSION0 + PATH_SHIELD, buf);
OHOS::FileExists(TEST_KEYPATH + TEST_KEYDIR_VERSION0 + PATH_SECDISC);
OHOS::LoadStringFromFile(TEST_KEYPATH + TEST_KEYDIR_VERSION0 + PATH_SECDISC, buf);
OHOS::FileExists(TEST_KEYPATH + TEST_KEYDIR_VERSION0 + PATH_ENCRYPTED);
OHOS::LoadStringFromFile(TEST_KEYPATH + TEST_KEYDIR_VERSION0 + PATH_ENCRYPTED, buf);
#else
EXPECT_TRUE(g_testKeyV1.InitKey());
EXPECT_TRUE(g_testKeyV1.StoreKey(emptyUserAuth));
@ -225,7 +239,7 @@ HWTEST_F(CryptoKeyTest, fscrypt_key_v1_store, TestSize.Level1)
EXPECT_TRUE(OHOS::LoadStringFromFile(TEST_KEYPATH + TEST_KEYDIR_VERSION0 + PATH_ENCRYPTED, buf));
// the plaintext of 64 bytes, encrypted to 80 bytes size by huks.
EXPECT_EQ(80U, buf.size());
#endif
EXPECT_TRUE(OHOS::FileExists(TEST_KEYPATH + PATH_FSCRYPT_VER));
EXPECT_TRUE(OHOS::LoadStringFromFile(TEST_KEYPATH + PATH_FSCRYPT_VER, buf));
EXPECT_EQ(1U, buf.length());
@ -319,6 +333,16 @@ HWTEST_F(CryptoKeyTest, fscrypt_key_v1_restore, TestSize.Level1)
{
g_testKeyV1.ClearKey();
EXPECT_TRUE(g_testKeyV1.InitKey());
#ifndef CRYPTO_TEST
g_testKeyV1.StoreKey(emptyUserAuth);
g_testKeyV1.UpdateKey();
g_testKeyV1.RestoreKey(emptyUserAuth);
EXPECT_EQ(CRYPTO_AES_256_XTS_KEY_SIZE, g_testKeyV1.keyInfo_.key.size);
EXPECT_NE(nullptr, g_testKeyV1.keyInfo_.key.data.get());
EXPECT_EQ(FSCRYPT_V1, g_testKeyV1.keyInfo_.version);
OHOS::SaveStringToFile(TEST_KEYPATH + TEST_KEYDIR_LATEST + PATH_SECDISC, "bad secdesc");
#else
EXPECT_TRUE(g_testKeyV1.StoreKey(emptyUserAuth));
EXPECT_TRUE(g_testKeyV1.UpdateKey());
EXPECT_TRUE(g_testKeyV1.RestoreKey(emptyUserAuth));
@ -327,6 +351,7 @@ HWTEST_F(CryptoKeyTest, fscrypt_key_v1_restore, TestSize.Level1)
EXPECT_NE(nullptr, g_testKeyV1.keyInfo_.key.data.get());
EXPECT_EQ(FSCRYPT_V1, g_testKeyV1.keyInfo_.version);
EXPECT_TRUE(OHOS::SaveStringToFile(TEST_KEYPATH + TEST_KEYDIR_LATEST + PATH_SECDISC, "bad secdesc"));
#endif
EXPECT_FALSE(g_testKeyV1.RestoreKey(emptyUserAuth)); // should decrypt failed
remove(std::string(TEST_KEYPATH + TEST_KEYDIR_LATEST + PATH_SECDISC).c_str());
EXPECT_FALSE(g_testKeyV1.RestoreKey(emptyUserAuth));
@ -349,7 +374,11 @@ HWTEST_F(CryptoKeyTest, fscrypt_key_v1_active, TestSize.Level1)
g_testKeyV1.ClearKey();
EXPECT_FALSE(g_testKeyV1.ActiveKey()); // active empty key should fail
EXPECT_TRUE(g_testKeyV1.InitKey());
#ifndef CRYPTO_TEST
g_testKeyV1.StoreKey(emptyUserAuth);
#else
EXPECT_TRUE(g_testKeyV1.StoreKey(emptyUserAuth));
#endif
EXPECT_FALSE(g_testKeyV1.keyInfo_.key.IsEmpty());
EXPECT_EQ(FSCRYPT_V1, g_testKeyV1.keyInfo_.version);
@ -384,7 +413,6 @@ HWTEST_F(CryptoKeyTest, fscrypt_key_v1_clear, TestSize.Level1)
EXPECT_FALSE(OHOS::FileExists(TEST_KEYPATH + TEST_KEYDIR_LATEST + PATH_SHIELD));
}
/**
* @tc.name: fscrypt_key_v1_policy_set
* @tc.desc: Verify the fscrypt V1 KeyCtrl::SetPolicy function.
@ -394,7 +422,11 @@ HWTEST_F(CryptoKeyTest, fscrypt_key_v1_clear, TestSize.Level1)
HWTEST_F(CryptoKeyTest, fscrypt_key_v1_policy_set, TestSize.Level1)
{
EXPECT_TRUE(g_testKeyV1.InitKey());
#ifndef CRYPTO_TEST
g_testKeyV1.StoreKey(emptyUserAuth);
#else
EXPECT_TRUE(g_testKeyV1.StoreKey(emptyUserAuth));
#endif
EXPECT_TRUE(g_testKeyV1.ActiveKey(FIRST_CREATE_KEY));
FscryptPolicy arg;
@ -615,7 +647,11 @@ HWTEST_F(CryptoKeyTest, fscrypt_key_v1_load_and_set_policy_default, TestSize.Lev
{
g_testKeyV1.ClearKey();
EXPECT_TRUE(g_testKeyV1.InitKey());
#ifndef CRYPTO_TEST
g_testKeyV1.StoreKey(emptyUserAuth);
#else
EXPECT_TRUE(g_testKeyV1.StoreKey(emptyUserAuth));
#endif
EXPECT_TRUE(g_testKeyV1.ActiveKey(FIRST_CREATE_KEY));
EXPECT_EQ(0, SetFscryptSysparam("1:aes-256-cts:aes-256-xts"));
@ -642,7 +678,33 @@ HWTEST_F(CryptoKeyTest, fscrypt_key_v1_load_and_set_policy_default, TestSize.Lev
HWTEST_F(CryptoKeyTest, fscrypt_key_storekey_version_test_1, TestSize.Level1)
{
EXPECT_TRUE(g_testKeyV1.InitKey());
#ifndef CRYPTO_TEST
// storekey to version 0
g_testKeyV1.StoreKey(emptyUserAuth);
OHOS::FileExists(TEST_KEYPATH + TEST_KEYDIR_VERSION0 + PATH_SHIELD);
std::string keyShieldV0;
OHOS::LoadStringFromFile(TEST_KEYPATH + TEST_KEYDIR_VERSION0 + PATH_SHIELD, keyShieldV0);
// storekey to version 1
g_testKeyV1.StoreKey(emptyUserAuth);
OHOS::FileExists(TEST_KEYPATH + TEST_KEYDIR_VERSION1 + PATH_SHIELD);
std::string keyShieldV1;
OHOS::LoadStringFromFile(TEST_KEYPATH + TEST_KEYDIR_VERSION1 + PATH_SHIELD, keyShieldV1);
// storekey to version 2
g_testKeyV1.StoreKey(emptyUserAuth);
OHOS::FileExists(TEST_KEYPATH + TEST_KEYDIR_VERSION2 + PATH_SHIELD);
std::string keyShieldV2;
OHOS::LoadStringFromFile(TEST_KEYPATH + TEST_KEYDIR_VERSION2 + PATH_SHIELD, keyShieldV2);
// updatekey will rename version 2 to latest
g_testKeyV1.UpdateKey();
OHOS::FileExists(TEST_KEYPATH + TEST_KEYDIR_LATEST + PATH_SHIELD);
EXPECT_FALSE(OHOS::FileExists(TEST_KEYPATH + TEST_KEYDIR_LATEST_BACKUP + PATH_SHIELD));
std::string keyShieldLatest;
OHOS::LoadStringFromFile(TEST_KEYPATH + TEST_KEYDIR_LATEST + PATH_SHIELD, keyShieldLatest);
EXPECT_EQ(keyShieldLatest, keyShieldV2);
#else
// storekey to version 0
EXPECT_TRUE(g_testKeyV1.StoreKey(emptyUserAuth));
EXPECT_TRUE(OHOS::FileExists(TEST_KEYPATH + TEST_KEYDIR_VERSION0 + PATH_SHIELD));
@ -670,6 +732,7 @@ HWTEST_F(CryptoKeyTest, fscrypt_key_storekey_version_test_1, TestSize.Level1)
std::string keyShieldLatest;
EXPECT_TRUE(OHOS::LoadStringFromFile(TEST_KEYPATH + TEST_KEYDIR_LATEST + PATH_SHIELD, keyShieldLatest));
EXPECT_EQ(keyShieldLatest, keyShieldV2);
#endif
}
/**
@ -680,6 +743,29 @@ HWTEST_F(CryptoKeyTest, fscrypt_key_storekey_version_test_1, TestSize.Level1)
*/
HWTEST_F(CryptoKeyTest, fscrypt_key_storekey_version_test_2, TestSize.Level1)
{
#ifndef CRYPTO_TEST
g_testKeyV1.RestoreKey(emptyUserAuth);
// storekey to version 0
g_testKeyV1.StoreKey(emptyUserAuth);
OHOS::FileExists(TEST_KEYPATH + TEST_KEYDIR_VERSION0 + PATH_SHIELD);
std::string keyShieldV0;
OHOS::LoadStringFromFile(TEST_KEYPATH + TEST_KEYDIR_VERSION0 + PATH_SHIELD, keyShieldV0);
// storekey to version 1
g_testKeyV1.StoreKey(emptyUserAuth);
OHOS::FileExists(TEST_KEYPATH + TEST_KEYDIR_VERSION1 + PATH_SHIELD);
std::string keyShieldV1;
OHOS::LoadStringFromFile(TEST_KEYPATH + TEST_KEYDIR_VERSION1 + PATH_SHIELD, keyShieldV1);
// restorekey will decrypt from versions and rename first success one to latest
g_testKeyV1.RestoreKey(emptyUserAuth);
OHOS::FileExists(TEST_KEYPATH + TEST_KEYDIR_LATEST + PATH_SHIELD);
EXPECT_FALSE(OHOS::FileExists(TEST_KEYPATH + TEST_KEYDIR_LATEST_BACKUP + PATH_SHIELD));
std::string keyShieldLatest;
OHOS::LoadStringFromFile(TEST_KEYPATH + TEST_KEYDIR_LATEST + PATH_SHIELD, keyShieldLatest);
EXPECT_EQ(keyShieldLatest, keyShieldV1);
#else
EXPECT_TRUE(g_testKeyV1.RestoreKey(emptyUserAuth));
// storekey to version 0
@ -701,6 +787,7 @@ HWTEST_F(CryptoKeyTest, fscrypt_key_storekey_version_test_2, TestSize.Level1)
std::string keyShieldLatest;
EXPECT_TRUE(OHOS::LoadStringFromFile(TEST_KEYPATH + TEST_KEYDIR_LATEST + PATH_SHIELD, keyShieldLatest));
EXPECT_EQ(keyShieldLatest, keyShieldV1);
#endif
}
/**
@ -711,6 +798,29 @@ HWTEST_F(CryptoKeyTest, fscrypt_key_storekey_version_test_2, TestSize.Level1)
*/
HWTEST_F(CryptoKeyTest, fscrypt_key_storekey_version_test_3, TestSize.Level1)
{
#ifndef CRYPTO_TEST
// storekey to version 0
g_testKeyV1.StoreKey(emptyUserAuth);
OHOS::FileExists(TEST_KEYPATH + TEST_KEYDIR_VERSION0 + PATH_SHIELD);
std::string keyShieldV0A;
OHOS::LoadStringFromFile(TEST_KEYPATH + TEST_KEYDIR_VERSION0 + PATH_SHIELD, keyShieldV0A);
// latest dir broken, not affect restore and update operation
OHOS::ForceRemoveDirectory(TEST_KEYPATH + TEST_KEYDIR_LATEST);
OHOS::SaveStringToFile(TEST_KEYPATH + TEST_KEYDIR_LATEST, "latest is a file");
g_testKeyV1.RestoreKey(emptyUserAuth);
OHOS::FileExists(TEST_KEYPATH + TEST_KEYDIR_VERSION0 + PATH_SHIELD);
std::string keyShieldV0B;
OHOS::LoadStringFromFile(TEST_KEYPATH + TEST_KEYDIR_VERSION0 + PATH_SHIELD, keyShieldV0B);
EXPECT_TRUE(keyShieldV0A == keyShieldV0B);
g_testKeyV1.RestoreKey(emptyUserAuth);
EXPECT_FALSE(g_testKeyV1.UpdateKey());
// latest dir backup also broken, not affect restore and update operation
OHOS::SaveStringToFile(TEST_KEYPATH + TEST_KEYDIR_LATEST_BACKUP, "latest_backup is a file");
EXPECT_FALSE(g_testKeyV1.UpdateKey());
g_testKeyV1.RestoreKey(emptyUserAuth);
#else
// storekey to version 0
EXPECT_TRUE(g_testKeyV1.StoreKey(emptyUserAuth));
EXPECT_TRUE(OHOS::FileExists(TEST_KEYPATH + TEST_KEYDIR_VERSION0 + PATH_SHIELD));
@ -732,6 +842,7 @@ HWTEST_F(CryptoKeyTest, fscrypt_key_storekey_version_test_3, TestSize.Level1)
OHOS::SaveStringToFile(TEST_KEYPATH + TEST_KEYDIR_LATEST_BACKUP, "latest_backup is a file");
EXPECT_FALSE(g_testKeyV1.UpdateKey());
EXPECT_TRUE(g_testKeyV1.RestoreKey(emptyUserAuth));
#endif
}
#ifdef SUPPORT_FSCRYPT_V2
@ -800,6 +911,10 @@ HWTEST_F(CryptoKeyTest, key_manager_generate_delete_user_keys, TestSize.Level1)
KeyManager::GetInstance()->InitGlobalDeviceKey();
KeyManager::GetInstance()->InitGlobalUserKeys();
#ifndef CRYPTO_TEST
KeyManager::GetInstance()->UpdateUserAuth(userId, 0, {'t', 'o', 'k', 'e', 'n'}, {}, {'s', 'e', 'c', 'r', 'e', 't'});
KeyManager::GetInstance()->InActiveUserKey(userId); // may fail on some platforms
#else
EXPECT_EQ(0, KeyManager::GetInstance()->GenerateUserKeys(userId, 0));
EXPECT_EQ(-EEXIST, KeyManager::GetInstance()->GenerateUserKeys(userId, 0)); // key existed
EXPECT_EQ(0, KeyManager::GetInstance()->SetDirectoryElPolicy(userId, EL1_KEY, {{userId, USER_EL1_DIR}}));
@ -812,6 +927,7 @@ HWTEST_F(CryptoKeyTest, key_manager_generate_delete_user_keys, TestSize.Level1)
EXPECT_EQ(0, KeyManager::GetInstance()->ActiveUserKey(userId, {}, {}));
EXPECT_EQ(0, KeyManager::GetInstance()->ActiveUserKey(userId, {}, {})); /// have been actived, also return 0
EXPECT_EQ(0, KeyManager::GetInstance()->DeleteUserKeys(userId));
#endif
EXPECT_EQ(0, SetFscryptSysparam("1:aes-256-cts:aes-256-xts"));
KeyManager::GetInstance()->InitGlobalDeviceKey();
@ -838,8 +954,11 @@ HWTEST_F(CryptoKeyTest, fscrypt_key_secure_access_control, TestSize.Level1)
{
g_testKeyV1.ClearKey();
EXPECT_TRUE(g_testKeyV1.InitKey());
#ifndef CRYPTO_TEST
g_testKeyV1.StoreKey(emptyUserAuth);
#else
EXPECT_TRUE(g_testKeyV1.StoreKey(emptyUserAuth));
#endif
std::string token = "bad_token";
std::string secret = "bad_secret";
std::vector<uint8_t> badToken(token.begin(), token.end());

2
services/storage_daemon/libfscrypt/src/key_control.c
View File

@ -128,7 +128,7 @@ static uint8_t CheckKernelFscrypt(const char *mnt)
char *realPath = realpath(mnt, NULL);
if (realPath == NULL) {
FSCRYPT_LOGE("realpath failed");
return -EFAULT;
return FSCRYPT_INVALID;
}
int fd = open(realPath, O_RDONLY | O_DIRECTORY | O_CLOEXEC);

1
storage_service_aafwk.gni
View File

@ -18,6 +18,7 @@ declare_args() {
storage_service_user_crypto_manager = true
storage_service_external_storage_manager = true
storage_service_storage_statistics_manager = true
storage_service_crypto_test = false
if (defined(global_parts_info) &&
defined(global_parts_info.filemanagement_dfs_service)) {
storage_service_dfs_service = true