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 = 9999; 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 = 9999; 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 = 9999; 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 = 9999; 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_InactiveUserKey_0001 245 * @tc.name: Storage_manager_crypto_InactiveUserKey_0001 246 * @tc.desc: Test function of InactiveUserKey interface for Parameters ERROR which userId not in [101, 1099]. 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_InactiveUserKey_0001, testing::ext::TestSize.Level1) 253 { 254 GTEST_LOG_(INFO) << "FileSystemCryptoTest-start Storage_manager_crypto_InactiveUserKey_0001"; 255 std::shared_ptr<FileSystemCrypto> fileSystemCrypto_ = 256 DelayedSingleton<FileSystemCrypto>::GetInstance(); 257 uint32_t userId = 9999; 258 uint32_t ret = fileSystemCrypto_->InactiveUserKey(userId); 259 EXPECT_EQ(ret, E_USERID_RANGE); 260 261 GTEST_LOG_(INFO) << "FileSystemCryptoTest-end Storage_manager_crypto_InactiveUserKey_0001"; 262 } 263 264 /** 265 * @tc.number: SUB_STORAGE_Storage_manager_crypto_UpdateKeyContext_0000 266 * @tc.name: Storage_manager_crypto_UpdateKeyContext_0000 267 * @tc.desc: Test function of UpdateKeyContext interface for SUCCESS. 268 * @tc.size: MEDIUM 269 * @tc.type: FUNC 270 * @tc.level Level 1 271 * @tc.require: AR000H0F7I 272 */ 273 HWTEST_F(FileSystemCryptoTest, Storage_manager_crypto_UpdateKeyContext_0000, TestSize.Level1) 274 { 275 GTEST_LOG_(INFO) << "FileSystemCryptoTest-start Storage_manager_crypto_UpdateKeyContext_0000"; 276 std::shared_ptr<FileSystemCrypto> fileSystemCrypto_ = 277 DelayedSingleton<FileSystemCrypto>::GetInstance(); 278 int32_t userId = 113; 279 int32_t flags = 2; // UserKeys type 280 int32_t ret = fileSystemCrypto_->GenerateUserKeys(userId, flags); 281 ASSERT_EQ(ret, E_OK); 282 283 ret = fileSystemCrypto_->UpdateUserAuth(userId, 0, {}, {}, {}); 284 EXPECT_EQ(ret, E_OK); 285 286 ret = fileSystemCrypto_->UpdateKeyContext(userId); 287 EXPECT_EQ(ret, E_OK); 288 289 fileSystemCrypto_->DeleteUserKeys(userId); 290 GTEST_LOG_(INFO) << "FileSystemCryptoTest-end Storage_manager_crypto_UpdateKeyContext_0000"; 291 } 292 293 /** 294 * @tc.number: SUB_STORAGE_Storage_manager_crypto_UpdateKeyContext_0001 295 * @tc.name: Storage_manager_crypto_UpdateKeyContext_0001 296 * @tc.desc: Test function of UpdateKeyContext interface for Parameters ERROR which userId not in [101, 1099]. 297 * @tc.size: MEDIUM 298 * @tc.type: FUNC 299 * @tc.level Level 1 300 * @tc.require: AR000H0F7I 301 */ 302 HWTEST_F(FileSystemCryptoTest, Storage_manager_crypto_UpdateKeyContext_0001, testing::ext::TestSize.Level1) 303 { 304 GTEST_LOG_(INFO) << "FileSystemCryptoTest-start Storage_manager_crypto_UpdateKeyContext_0001"; 305 std::shared_ptr<FileSystemCrypto> fileSystemCrypto_ = 306 DelayedSingleton<FileSystemCrypto>::GetInstance(); 307 uint32_t userId = 9999; 308 uint32_t ret = fileSystemCrypto_->UpdateKeyContext(userId); 309 EXPECT_EQ(ret, E_USERID_RANGE); 310 311 GTEST_LOG_(INFO) << "FileSystemCryptoTest-end Storage_manager_crypto_UpdateKeyContext_0001"; 312 } 313 } 314 }