1 /* 2 * Copyright (c) 2022 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include <gtest/gtest.h> 17 #include "crypto/filesystem_crypto.h" 18 #include "storage_service_errno.h" 19 #include "storage_service_log.h" 20 namespace OHOS { 21 namespace StorageManager { 22 using namespace testing::ext; 23 24 class FileSystemCryptoTest : public testing::Test { 25 public: SetUpTestCase(void)26 static void SetUpTestCase(void) {}; TearDownTestCase(void)27 static void TearDownTestCase(void) {}; SetUp()28 void SetUp() {}; TearDown()29 void TearDown() {}; 30 }; 31 32 /** 33 * @tc.number: SUB_STORAGE_Storage_manager_crypto_GenerateUserKeys_0000 34 * @tc.name: Storage_manager_crypto_GenerateUserKeys_0000 35 * @tc.desc: Test function of GenerateUserKeys interface for SUCCESS. 36 * @tc.size: MEDIUM 37 * @tc.type: FUNC 38 * @tc.level Level 1 39 * @tc.require: AR000H0F7I 40 */ 41 HWTEST_F(FileSystemCryptoTest, Storage_manager_crypto_GenerateUserKeys_0000, testing::ext::TestSize.Level1) 42 { 43 GTEST_LOG_(INFO) << "FileSystemCryptoTest-start Storage_manager_crypto_GenerateUserKeys_0000"; 44 std::shared_ptr<FileSystemCrypto> fileSystemCrypto_ = 45 DelayedSingleton<FileSystemCrypto>::GetInstance(); 46 uint32_t userId = 108; 47 uint32_t flags = 2; // UserKeys type 48 uint32_t result = fileSystemCrypto_->GenerateUserKeys(userId, flags); 49 EXPECT_EQ(result, E_OK); 50 51 fileSystemCrypto_->DeleteUserKeys(userId); 52 GTEST_LOG_(INFO) << "FileSystemCryptoTest-end Storage_manager_crypto_GenerateUserKeys_0000"; 53 } 54 55 /** 56 * @tc.number: SUB_STORAGE_Storage_manager_crypto_GenerateUserKeys_0001 57 * @tc.name: Storage_manager_crypto_GenerateUserKeys_0001 58 * @tc.desc: Test function of GenerateUserKeys interface for Parameters ERROR which userId not in [101, 1099]. 59 * @tc.size: MEDIUM 60 * @tc.type: FUNC 61 * @tc.level Level 1 62 * @tc.require: AR000H0F7I 63 */ 64 HWTEST_F(FileSystemCryptoTest, Storage_manager_crypto_GenerateUserKeys_0001, testing::ext::TestSize.Level1) 65 { 66 GTEST_LOG_(INFO) << "FileSystemCryptoTest-start Storage_manager_crypto_GenerateUserKeys_0000"; 67 std::shared_ptr<FileSystemCrypto> fileSystemCrypto_ = 68 DelayedSingleton<FileSystemCrypto>::GetInstance(); 69 uint32_t userId = 19999; 70 uint32_t flags = 2; // UserKeys type 71 uint32_t ret = fileSystemCrypto_->GenerateUserKeys(userId, flags); 72 EXPECT_EQ(ret, E_USERID_RANGE); 73 74 GTEST_LOG_(INFO) << "FileSystemCryptoTest-end Storage_manager_crypto_GenerateUserKeys_0001"; 75 } 76 77 /** 78 * @tc.number: SUB_STORAGE_Storage_manager_crypto_DeleteUserKeys_0000 79 * @tc.name: Storage_manager_crypto_DeleteUserKeys_0000 80 * @tc.desc: Test function of DeleteUserKeys interface for SUCCESS. 81 * @tc.size: MEDIUM 82 * @tc.type: FUNC 83 * @tc.level Level 1 84 * @tc.require: AR000H0F7I 85 */ 86 HWTEST_F(FileSystemCryptoTest, Storage_manager_crypto_DeleteUserKeys_0000, testing::ext::TestSize.Level1) 87 { 88 GTEST_LOG_(INFO) << "FileSystemCryptoTest-start Storage_manager_crypto_DeleteUserKeys_0000"; 89 std::shared_ptr<FileSystemCrypto> fileSystemCrypto_ = 90 DelayedSingleton<FileSystemCrypto>::GetInstance(); 91 uint32_t userId = 109; 92 uint32_t flags = 2; // UserKeys type 93 uint32_t result = fileSystemCrypto_->GenerateUserKeys(userId, flags); 94 EXPECT_EQ(result, E_OK); 95 96 fileSystemCrypto_->DeleteUserKeys(userId); 97 EXPECT_EQ(result, E_OK); 98 GTEST_LOG_(INFO) << "FileSystemCryptoTest-end Storage_manager_crypto_DeleteUserKeys_0000"; 99 } 100 101 /** 102 * @tc.number: SUB_STORAGE_Storage_manager_crypto_DeleteUserKeys_0001 103 * @tc.name: Storage_manager_crypto_DeleteUserKeys_0001 104 * @tc.desc: Test function of DeleteUserKeys interface for Parameters ERROR which userId not in [101, 1099]. 105 * @tc.size: MEDIUM 106 * @tc.type: FUNC 107 * @tc.level Level 1 108 * @tc.require: AR000H0F7I 109 */ 110 HWTEST_F(FileSystemCryptoTest, Storage_manager_crypto_DeleteUserKeys_0001, testing::ext::TestSize.Level1) 111 { 112 GTEST_LOG_(INFO) << "FileSystemCryptoTest-start Storage_manager_crypto_DeleteUserKeys_0001"; 113 std::shared_ptr<FileSystemCrypto> fileSystemCrypto_ = 114 DelayedSingleton<FileSystemCrypto>::GetInstance(); 115 uint32_t userId = 19999; 116 uint32_t ret = fileSystemCrypto_->DeleteUserKeys(userId); 117 EXPECT_EQ(ret, E_USERID_RANGE); 118 119 GTEST_LOG_(INFO) << "FileSystemCryptoTest-end Storage_manager_crypto_DeleteUserKeys_0001"; 120 } 121 122 /** 123 * @tc.number: SUB_STORAGE_Storage_manager_crypto_UpdateUserAuth_0000 124 * @tc.name: Storage_manager_crypto_UpdateUserAuth_0000 125 * @tc.desc: Test function of UpdateUserAuth interface for SUCCESS. 126 * @tc.size: MEDIUM 127 * @tc.type: FUNC 128 * @tc.level Level 1 129 * @tc.require: AR000H0F7I 130 */ 131 HWTEST_F(FileSystemCryptoTest, Storage_manager_crypto_UpdateUserAuth_0000, testing::ext::TestSize.Level1) 132 { 133 GTEST_LOG_(INFO) << "FileSystemCryptoTest-start Storage_manager_crypto_UpdateUserAuth_0000"; 134 std::shared_ptr<FileSystemCrypto> fileSystemCrypto_ = 135 DelayedSingleton<FileSystemCrypto>::GetInstance(); 136 uint32_t userId = 110; 137 uint32_t flags = 2; // UserKeys type 138 uint32_t result = fileSystemCrypto_->GenerateUserKeys(userId, flags); 139 EXPECT_EQ(result, E_OK); 140 result = fileSystemCrypto_->UpdateUserAuth(userId, 0, {}, {}, {}); 141 EXPECT_EQ(result, E_OK); 142 143 fileSystemCrypto_->DeleteUserKeys(userId); 144 GTEST_LOG_(INFO) << "FileSystemCryptoTest-end Storage_manager_crypto_UpdateUserAuth_0000"; 145 } 146 147 /** 148 * @tc.number: SUB_STORAGE_Storage_manager_crypto_UpdateUserAuth_0001 149 * @tc.name: Storage_manager_crypto_UpdateUserAuth_0001 150 * @tc.desc: Test function of UpdateUserAuth interface for Parameters ERROR which userId not in [101, 1099]. 151 * @tc.size: MEDIUM 152 * @tc.type: FUNC 153 * @tc.level Level 1 154 * @tc.require: AR000H0F7I 155 */ 156 HWTEST_F(FileSystemCryptoTest, Storage_manager_crypto_UpdateUserAuth_0001, testing::ext::TestSize.Level1) 157 { 158 GTEST_LOG_(INFO) << "FileSystemCryptoTest-start Storage_manager_crypto_UpdateUserAuth_0001"; 159 std::shared_ptr<FileSystemCrypto> fileSystemCrypto_ = 160 DelayedSingleton<FileSystemCrypto>::GetInstance(); 161 uint32_t userId = 19999; 162 uint32_t ret = fileSystemCrypto_->UpdateUserAuth(userId, 0, {}, {}, {}); 163 EXPECT_EQ(ret, E_USERID_RANGE); 164 165 GTEST_LOG_(INFO) << "FileSystemCryptoTest-end Storage_manager_crypto_UpdateUserAuth_0001"; 166 } 167 168 /** 169 * @tc.number: SUB_STORAGE_Storage_manager_crypto_ActiveUserKey_0000 170 * @tc.name: Storage_manager_crypto_ActiveUserKey_0000 171 * @tc.desc: Test function of ActiveUserKey interface for SUCCESS. 172 * @tc.size: MEDIUM 173 * @tc.type: FUNC 174 * @tc.level Level 1 175 * @tc.require: AR000H0F7I 176 */ 177 HWTEST_F(FileSystemCryptoTest, Storage_manager_crypto_ActiveUserKey_0000, testing::ext::TestSize.Level1) 178 { 179 GTEST_LOG_(INFO) << "FileSystemCryptoTest-start Storage_manager_crypto_ActiveUserKey_0000"; 180 std::shared_ptr<FileSystemCrypto> fileSystemCrypto_ = 181 DelayedSingleton<FileSystemCrypto>::GetInstance(); 182 uint32_t userId = 111; 183 uint32_t flags = 2; // UserKeys type 184 uint32_t result = fileSystemCrypto_->GenerateUserKeys(userId, flags); 185 EXPECT_EQ(result, E_OK); 186 result = fileSystemCrypto_->ActiveUserKey(userId, {}, {}); 187 EXPECT_EQ(result, E_OK); 188 189 fileSystemCrypto_->DeleteUserKeys(userId); 190 GTEST_LOG_(INFO) << "FileSystemCryptoTest-end Storage_manager_crypto_ActiveUserKey_0000"; 191 } 192 193 /** 194 * @tc.number: SUB_STORAGE_Storage_manager_crypto_ActiveUserKey_0001 195 * @tc.name: Storage_manager_crypto_ActiveUserKey_0001 196 * @tc.desc: Test function of ActiveUserKey interface for Parameters ERROR which userId not in [101, 1099]. 197 * @tc.size: MEDIUM 198 * @tc.type: FUNC 199 * @tc.level Level 1 200 * @tc.require: AR000H0F7I 201 */ 202 HWTEST_F(FileSystemCryptoTest, Storage_manager_crypto_ActiveUserKey_0001, testing::ext::TestSize.Level1) 203 { 204 GTEST_LOG_(INFO) << "FileSystemCryptoTest-start Storage_manager_crypto_ActiveUserKey_0001"; 205 std::shared_ptr<FileSystemCrypto> fileSystemCrypto_ = 206 DelayedSingleton<FileSystemCrypto>::GetInstance(); 207 uint32_t userId = 19999; 208 uint32_t ret = fileSystemCrypto_->ActiveUserKey(userId, {}, {}); 209 EXPECT_EQ(ret, E_USERID_RANGE); 210 211 GTEST_LOG_(INFO) << "FileSystemCryptoTest-end Storage_manager_crypto_ActiveUserKey_0001"; 212 } 213 214 /** 215 * @tc.number: SUB_STORAGE_Storage_manager_crypto_InactiveUserKey_0000 216 * @tc.name: Storage_manager_crypto_InactiveUserKey_0000 217 * @tc.desc: Test function of InactiveUserKey interface for SUCCESS. 218 * @tc.size: MEDIUM 219 * @tc.type: FUNC 220 * @tc.level Level 1 221 * @tc.require: AR000H0F7I 222 */ 223 HWTEST_F(FileSystemCryptoTest, Storage_manager_crypto_InactiveUserKey_0000, TestSize.Level1) 224 { 225 GTEST_LOG_(INFO) << "FileSystemCryptoTest-start Storage_manager_crypto_InactiveUserKey_0000"; 226 std::shared_ptr<FileSystemCrypto> fileSystemCrypto_ = 227 DelayedSingleton<FileSystemCrypto>::GetInstance(); 228 int32_t userId = 112; 229 int32_t flags = 2; // UserKeys type 230 int32_t ret = fileSystemCrypto_->GenerateUserKeys(userId, flags); 231 ASSERT_EQ(ret, E_OK); 232 233 ret = fileSystemCrypto_->ActiveUserKey(userId, {}, {}); 234 EXPECT_EQ(ret, E_OK); 235 236 ret = fileSystemCrypto_->InactiveUserKey(userId); 237 EXPECT_EQ(ret, E_OK); 238 239 fileSystemCrypto_->DeleteUserKeys(userId); 240 GTEST_LOG_(INFO) << "FileSystemCryptoTest-end Storage_manager_crypto_InactiveUserKey_0000"; 241 } 242 243 /** 244 * @tc.number: SUB_STORAGE_Storage_manager_crypto_LockUserScreen_0000 245 * @tc.name: Storage_manager_crypto_LockUserScreen_0000 246 * @tc.desc: Test function of LockUserScreen interface for SUCCESS. 247 * @tc.size: MEDIUM 248 * @tc.type: FUNC 249 * @tc.level Level 1 250 * @tc.require: AR000H0F7I 251 */ 252 HWTEST_F(FileSystemCryptoTest, Storage_manager_crypto_LockUserScreen_0000, TestSize.Level1) 253 { 254 GTEST_LOG_(INFO) << "FileSystemCryptoTest-start Storage_manager_crypto_LockUserScreen_0000"; 255 std::shared_ptr<FileSystemCrypto> fileSystemCrypto_ = 256 DelayedSingleton<FileSystemCrypto>::GetInstance(); 257 int32_t userId = 100; 258 259 int32_t ret = fileSystemCrypto_->LockUserScreen(userId); 260 EXPECT_EQ(ret, E_OK); 261 262 GTEST_LOG_(INFO) << "FileSystemCryptoTest-end Storage_manager_crypto_LockUserScreen_0000"; 263 } 264 265 /** 266 * @tc.number: SUB_STORAGE_Storage_manager_crypto_UnlockUserScreen_0000 267 * @tc.name: Storage_manager_crypto_UnlockUserScreen_0000 268 * @tc.desc: Test function of UnlockUserScreen interface for SUCCESS. 269 * @tc.size: MEDIUM 270 * @tc.type: FUNC 271 * @tc.level Level 1 272 * @tc.require: AR000H0F7I 273 */ 274 HWTEST_F(FileSystemCryptoTest, Storage_manager_crypto_UnlockUserScreen_0000, TestSize.Level1) 275 { 276 GTEST_LOG_(INFO) << "FileSystemCryptoTest-start Storage_manager_crypto_UnlockUserScreen_0000"; 277 std::shared_ptr<FileSystemCrypto> fileSystemCrypto_ = 278 DelayedSingleton<FileSystemCrypto>::GetInstance(); 279 int32_t userId = 100; 280 281 int32_t ret = fileSystemCrypto_->UnlockUserScreen(userId, {}, {}); 282 EXPECT_EQ(ret, E_OK); 283 284 GTEST_LOG_(INFO) << "FileSystemCryptoTest-end Storage_manager_crypto_UnlockUserScreen_0000"; 285 } 286 287 /** 288 * @tc.number: SUB_STORAGE_Storage_manager_crypto_GetLockScreenStatus_0000 289 * @tc.name: Storage_manager_crypto_GetLockScreenStatus_0000 290 * @tc.desc: Test function of GetLockScreenStatus interface for SUCCESS. 291 * @tc.size: MEDIUM 292 * @tc.type: FUNC 293 * @tc.level Level 1 294 * @tc.require: AR000H0F7I 295 */ 296 HWTEST_F(FileSystemCryptoTest, Storage_manager_crypto_GetLockScreenStatus_0000, TestSize.Level1) 297 { 298 GTEST_LOG_(INFO) << "FileSystemCryptoTest-start Storage_manager_crypto_GetLockScreenStatus_0000"; 299 std::shared_ptr<FileSystemCrypto> fileSystemCrypto_ = 300 DelayedSingleton<FileSystemCrypto>::GetInstance(); 301 int32_t userId = 100; 302 bool lockScreenStatus = false; 303 int32_t ret = fileSystemCrypto_->GetLockScreenStatus(userId, lockScreenStatus); 304 EXPECT_EQ(ret, E_OK); 305 306 GTEST_LOG_(INFO) << "FileSystemCryptoTest-end Storage_manager_crypto_GetLockScreenStatus_0000"; 307 } 308 309 /** 310 * @tc.number: SUB_STORAGE_Storage_manager_crypto_InactiveUserKey_0001 311 * @tc.name: Storage_manager_crypto_InactiveUserKey_0001 312 * @tc.desc: Test function of InactiveUserKey interface for Parameters ERROR which userId not in [101, 1099]. 313 * @tc.size: MEDIUM 314 * @tc.type: FUNC 315 * @tc.level Level 1 316 * @tc.require: AR000H0F7I 317 */ 318 HWTEST_F(FileSystemCryptoTest, Storage_manager_crypto_InactiveUserKey_0001, testing::ext::TestSize.Level1) 319 { 320 GTEST_LOG_(INFO) << "FileSystemCryptoTest-start Storage_manager_crypto_InactiveUserKey_0001"; 321 std::shared_ptr<FileSystemCrypto> fileSystemCrypto_ = 322 DelayedSingleton<FileSystemCrypto>::GetInstance(); 323 uint32_t userId = 19999; 324 uint32_t ret = fileSystemCrypto_->InactiveUserKey(userId); 325 EXPECT_EQ(ret, E_USERID_RANGE); 326 327 GTEST_LOG_(INFO) << "FileSystemCryptoTest-end Storage_manager_crypto_InactiveUserKey_0001"; 328 } 329 330 /** 331 * @tc.number: SUB_STORAGE_Storage_manager_crypto_UpdateKeyContext_0000 332 * @tc.name: Storage_manager_crypto_UpdateKeyContext_0000 333 * @tc.desc: Test function of UpdateKeyContext interface for SUCCESS. 334 * @tc.size: MEDIUM 335 * @tc.type: FUNC 336 * @tc.level Level 1 337 * @tc.require: AR000H0F7I 338 */ 339 HWTEST_F(FileSystemCryptoTest, Storage_manager_crypto_UpdateKeyContext_0000, TestSize.Level1) 340 { 341 GTEST_LOG_(INFO) << "FileSystemCryptoTest-start Storage_manager_crypto_UpdateKeyContext_0000"; 342 std::shared_ptr<FileSystemCrypto> fileSystemCrypto_ = 343 DelayedSingleton<FileSystemCrypto>::GetInstance(); 344 int32_t userId = 113; 345 int32_t flags = 2; // UserKeys type 346 int32_t ret = fileSystemCrypto_->GenerateUserKeys(userId, flags); 347 ASSERT_EQ(ret, E_OK); 348 349 ret = fileSystemCrypto_->UpdateUserAuth(userId, 0, {}, {}, {}); 350 EXPECT_EQ(ret, E_OK); 351 352 ret = fileSystemCrypto_->UpdateKeyContext(userId); 353 EXPECT_EQ(ret, E_OK); 354 355 fileSystemCrypto_->DeleteUserKeys(userId); 356 GTEST_LOG_(INFO) << "FileSystemCryptoTest-end Storage_manager_crypto_UpdateKeyContext_0000"; 357 } 358 359 /** 360 * @tc.number: SUB_STORAGE_Storage_manager_crypto_UpdateKeyContext_0001 361 * @tc.name: Storage_manager_crypto_UpdateKeyContext_0001 362 * @tc.desc: Test function of UpdateKeyContext interface for Parameters ERROR which userId not in [101, 1099]. 363 * @tc.size: MEDIUM 364 * @tc.type: FUNC 365 * @tc.level Level 1 366 * @tc.require: AR000H0F7I 367 */ 368 HWTEST_F(FileSystemCryptoTest, Storage_manager_crypto_UpdateKeyContext_0001, testing::ext::TestSize.Level1) 369 { 370 GTEST_LOG_(INFO) << "FileSystemCryptoTest-start Storage_manager_crypto_UpdateKeyContext_0001"; 371 std::shared_ptr<FileSystemCrypto> fileSystemCrypto_ = 372 DelayedSingleton<FileSystemCrypto>::GetInstance(); 373 uint32_t userId = 19999; 374 uint32_t ret = fileSystemCrypto_->UpdateKeyContext(userId); 375 EXPECT_EQ(ret, E_USERID_RANGE); 376 377 GTEST_LOG_(INFO) << "FileSystemCryptoTest-end Storage_manager_crypto_UpdateKeyContext_0001"; 378 } 379 380 /** 381 * @tc.number: SUB_STORAGE_Storage_manager_crypto_GenerateAppkey_0000 382 * @tc.name: Storage_manager_crypto_GenerateAppkey_0000 383 * @tc.desc: Test function of GenerateAppkey interface for SUCCESS. 384 * @tc.size: MEDIUM 385 * @tc.type: FUNC 386 * @tc.level Level 1 387 * @tc.require: AR000H0F7I 388 */ 389 HWTEST_F(FileSystemCryptoTest, Storage_manager_crypto_GenerateAppkey_0000, testing::ext::TestSize.Level1) 390 { 391 GTEST_LOG_(INFO) << "FileSystemCryptoTest-start Storage_manager_crypto_GenerateAppkey_0000"; 392 std::shared_ptr<FileSystemCrypto> fileSystemCrypto_ = 393 DelayedSingleton<FileSystemCrypto>::GetInstance(); 394 uint32_t userId = 108; 395 uint32_t hashId = -1; 396 std::string keyId = "keys"; // UserKeys type 397 ASSERT_TRUE(fileSystemCrypto_ != nullptr); 398 uint32_t result = fileSystemCrypto_->GenerateAppkey(hashId, userId, keyId); 399 EXPECT_EQ(result, E_OK); 400 401 fileSystemCrypto_->DeleteAppkey(keyId); 402 GTEST_LOG_(INFO) << "FileSystemCryptoTest-end Storage_manager_crypto_GenerateAppkey_0000"; 403 } 404 } 405 }