1 /* 2 * Copyright (c) 2023-2025 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 <cstdlib> 17 #include <gtest/gtest.h> 18 #include <string> 19 20 #include "access_token_setter.h" 21 #include "byte_buffer.h" 22 #include "code_sign_test_common.h" 23 #include "code_sign_utils.h" 24 #include "local_code_sign_client.h" 25 #include "local_code_sign_kit.h" 26 #include "local_code_sign_load_callback.h" 27 #include "local_key_helper.h" 28 #include "log.h" 29 #include "signer_info.h" 30 31 using namespace OHOS::Security::CodeSign; 32 using namespace testing::ext; 33 using namespace std; 34 35 namespace OHOS { 36 namespace Security { 37 namespace CodeSign { 38 static const std::string AN_BASE_PATH = "/data/local/ark-cache/tmp/"; 39 static const std::string DEMO_AN_PATH = AN_BASE_PATH + "demo.an"; 40 static const std::string DEMO_AN_PATH2 = AN_BASE_PATH + "demo2.an"; 41 42 class LocalCodeSignTest : public testing::Test { 43 public: LocalCodeSignTest()44 LocalCodeSignTest() {}; ~LocalCodeSignTest()45 virtual ~LocalCodeSignTest() {}; SetUpTestCase()46 static void SetUpTestCase() {}; TearDownTestCase()47 static void TearDownTestCase() {}; SetUp()48 void SetUp() {}; TearDown()49 void TearDown() {}; 50 }; 51 52 /** 53 * @tc.name: LocalCodeSignTest_0001 54 * @tc.desc: init local certificate successfully 55 * @tc.type: Func 56 * @tc.require: 57 */ 58 HWTEST_F(LocalCodeSignTest, LocalCodeSignTest_0001, TestSize.Level0) 59 { 60 ByteBuffer cert; 61 uint64_t selfTokenId = GetSelfTokenID(); 62 EXPECT_TRUE(MockTokenId("key_enable")); 63 int ret = LocalCodeSignKit::InitLocalCertificate(cert); 64 EXPECT_EQ(0, SetSelfTokenID(selfTokenId)); 65 EXPECT_EQ(ret, CS_SUCCESS); 66 } 67 68 /** 69 * @tc.name: LocalCodeSignTest_0002 70 * @tc.desc: init local certificate failed with invalid caller 71 * @tc.type: Func 72 * @tc.require: 73 */ 74 HWTEST_F(LocalCodeSignTest, LocalCodeSignTest_0002, TestSize.Level0) 75 { 76 ByteBuffer cert; 77 int ret = LocalCodeSignKit::InitLocalCertificate(cert); 78 EXPECT_EQ(ret, CS_ERR_NO_PERMISSION); 79 } 80 81 /** 82 * @tc.name: LocalCodeSignTest_0003 83 * @tc.desc: sign local code successfully, owner ID is empty 84 * @tc.type: Func 85 * @tc.require: 86 */ 87 HWTEST_F(LocalCodeSignTest, LocalCodeSignTest_0003, TestSize.Level0) 88 { 89 ByteBuffer sig; 90 uint64_t selfTokenId = GetSelfTokenID(); 91 EXPECT_TRUE(MockTokenId("compiler_service")); 92 int ret = LocalCodeSignKit::SignLocalCode(DEMO_AN_PATH, sig); 93 EXPECT_EQ(0, SetSelfTokenID(selfTokenId)); 94 EXPECT_EQ(ret, CS_SUCCESS); 95 std::string retOwnerID; 96 ret = CodeSignUtils::ParseOwnerIdFromSignature(sig, retOwnerID); 97 EXPECT_EQ(ret, CS_ERR_NO_OWNER_ID); 98 EXPECT_EQ(retOwnerID, ""); 99 ret = CodeSignUtils::EnforceCodeSignForFile(DEMO_AN_PATH, sig); 100 EXPECT_EQ(ret, GetEnforceFileResult()); 101 } 102 103 /** 104 * @tc.name: LocalCodeSignTest_0004 105 * @tc.desc: sign local code failed with invalid caller 106 * @tc.type: Func 107 * @tc.require: 108 */ 109 HWTEST_F(LocalCodeSignTest, LocalCodeSignTest_0004, TestSize.Level0) 110 { 111 ByteBuffer sig; 112 int ret = LocalCodeSignKit::SignLocalCode(DEMO_AN_PATH, sig); 113 EXPECT_EQ(ret, CS_ERR_NO_PERMISSION); 114 } 115 116 /** 117 * @tc.name: LocalCodeSignTest_0005 118 * @tc.desc: sign local code failed with wrong path 119 * @tc.type: Func 120 * @tc.require: 121 */ 122 HWTEST_F(LocalCodeSignTest, LocalCodeSignTest_0005, TestSize.Level0) 123 { 124 ByteBuffer sig; 125 uint64_t selfTokenId = GetSelfTokenID(); 126 EXPECT_TRUE(MockTokenId("compiler_service")); 127 int ret = LocalCodeSignKit::SignLocalCode(DEMO_AN_PATH + "invalid", sig); 128 EXPECT_EQ(0, SetSelfTokenID(selfTokenId)); 129 EXPECT_EQ(ret, CS_ERR_FILE_PATH); 130 } 131 132 /** 133 * @tc.name: LocalCodeSignTest_0006 134 * @tc.desc: local codesignsvr died 135 * @tc.type: Func 136 * @tc.require: 137 */ 138 HWTEST_F(LocalCodeSignTest, LocalCodeSignTest_0006, TestSize.Level0) 139 { 140 LocalCodeSignClient *client = GetLocalCodeSignClient(); 141 EXPECT_NE(client, nullptr); 142 sptr<ISystemAbilityManager> systemAbilityManager = 143 SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); 144 EXPECT_NE(systemAbilityManager, nullptr); 145 sptr<IRemoteObject> remoteObject = 146 systemAbilityManager->GetSystemAbility(LOCAL_CODE_SIGN_SA_ID); 147 client->OnRemoteLocalCodeSignSvrDied(remoteObject); 148 } 149 150 /** 151 * @tc.name: LocalCodeSignTest_0007 152 * @tc.desc: sign local code with owner ID successfully, parse owner ID from signature success 153 * @tc.type: Func 154 * @tc.require: issueI88PPA 155 */ 156 HWTEST_F(LocalCodeSignTest, LocalCodeSignTest_0007, TestSize.Level0) 157 { 158 ByteBuffer sig; 159 uint64_t selfTokenId = GetSelfTokenID(); 160 EXPECT_TRUE(MockTokenId("compiler_service")); 161 std::string ownerID = "AppName123"; 162 int ret = LocalCodeSignKit::SignLocalCode(ownerID, DEMO_AN_PATH2, sig); 163 EXPECT_EQ(0, SetSelfTokenID(selfTokenId)); 164 EXPECT_EQ(ret, CS_SUCCESS); 165 166 std::string retOwnerID; 167 ret = CodeSignUtils::ParseOwnerIdFromSignature(sig, retOwnerID); 168 EXPECT_EQ(ownerID, retOwnerID); 169 ret = CodeSignUtils::EnforceCodeSignForFile(DEMO_AN_PATH2, sig); 170 EXPECT_EQ(ret, GetEnforceFileResult()); 171 } 172 173 /** 174 * @tc.name: LocalCodeSignTest_0008 175 * @tc.desc: sign local code with empty owner ID successfully 176 * @tc.type: Func 177 * @tc.require: issueI88PPA 178 */ 179 HWTEST_F(LocalCodeSignTest, LocalCodeSignTest_0008, TestSize.Level0) 180 { 181 ByteBuffer sig; 182 uint64_t selfTokenId = GetSelfTokenID(); 183 EXPECT_TRUE(MockTokenId("compiler_service")); 184 std::string ownerID = ""; 185 int ret = LocalCodeSignKit::SignLocalCode(ownerID, DEMO_AN_PATH2, sig); 186 EXPECT_EQ(0, SetSelfTokenID(selfTokenId)); 187 EXPECT_EQ(ret, CS_SUCCESS); 188 std::string retOwnerID; 189 ret = CodeSignUtils::ParseOwnerIdFromSignature(sig, retOwnerID); 190 EXPECT_EQ(ret, CS_ERR_NO_OWNER_ID); 191 EXPECT_EQ(retOwnerID, ""); 192 } 193 194 /** 195 * @tc.name: LocalCodeSignTest_0009 196 * @tc.desc: sign local code with owner ID failed, reason = invalid path 197 * @tc.type: Func 198 * @tc.require: issueI88PPA 199 */ 200 HWTEST_F(LocalCodeSignTest, LocalCodeSignTest_0009, TestSize.Level0) 201 { 202 ByteBuffer sig; 203 uint64_t selfTokenId = GetSelfTokenID(); 204 EXPECT_TRUE(MockTokenId("compiler_service")); 205 std::string ownerID = "AppName123"; 206 int ret = LocalCodeSignKit::SignLocalCode(ownerID, DEMO_AN_PATH2 + "invalid", sig); 207 EXPECT_EQ(0, SetSelfTokenID(selfTokenId)); 208 EXPECT_EQ(ret, CS_ERR_FILE_PATH); 209 } 210 211 /** 212 * @tc.name: LocalCodeSignTest_0010 213 * @tc.desc: sign local code failed with invalid caller 214 * @tc.type: Func 215 * @tc.require: issueI88PPA 216 */ 217 HWTEST_F(LocalCodeSignTest, LocalCodeSignTest_0010, TestSize.Level0) 218 { 219 ByteBuffer sig; 220 std::string ownerID = "AppName123"; 221 int ret = LocalCodeSignKit::SignLocalCode(ownerID, DEMO_AN_PATH2, sig); 222 EXPECT_EQ(ret, CS_ERR_NO_PERMISSION); 223 } 224 225 /** 226 * @tc.name: LocalCodeSignTest_0011 227 * @tc.desc: sign local code failed with ownerID exceed 128 bytes 228 * @tc.type: Func 229 * @tc.require: issueI8FCGF 230 */ 231 HWTEST_F(LocalCodeSignTest, LocalCodeSignTest_0011, TestSize.Level0) 232 { 233 ByteBuffer sig; 234 uint64_t selfTokenId = GetSelfTokenID(); 235 EXPECT_TRUE(MockTokenId("compiler_service")); 236 std::string ownerID(33, 'a'); 237 int ret = LocalCodeSignKit::SignLocalCode(ownerID, DEMO_AN_PATH2, sig); 238 EXPECT_EQ(0, SetSelfTokenID(selfTokenId)); 239 EXPECT_EQ(ret, CS_ERR_INVALID_OWNER_ID); 240 } 241 242 /** 243 * @tc.name: LocalCodeSignTest_0012 244 * @tc.desc: sign local code failed with ownerID exceed 128 bytes 245 * @tc.type: Func 246 * @tc.require: issueI8FCGF 247 */ 248 HWTEST_F(LocalCodeSignTest, LocalCodeSignTest_0012, TestSize.Level0) 249 { 250 ByteBuffer sig; 251 uint64_t selfTokenId = GetSelfTokenID(); 252 EXPECT_TRUE(MockTokenId("compiler_service")); 253 std::string ownerID = "AppName123"; 254 255 int ret = LocalCodeSignKit::SignLocalCode(ownerID, DEMO_AN_PATH2, sig); 256 257 EXPECT_TRUE(MockTokenId("local_code_sign")); 258 sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); 259 EXPECT_NE(samgr, nullptr); 260 261 ret = samgr->UnloadSystemAbility(LOCAL_CODE_SIGN_SA_ID); 262 EXPECT_EQ(ret, ERR_OK); 263 EXPECT_TRUE(MockTokenId("compiler_service")); 264 LocalCodeSignKit::SignLocalCode(ownerID, DEMO_AN_PATH2, sig); 265 EXPECT_EQ(0, SetSelfTokenID(selfTokenId)); 266 } 267 268 /** 269 * @tc.name: LocalCodeSignTest_0013 270 * @tc.desc: load sa success and return remote object is not null 271 * @tc.type: Func 272 * @tc.require: 273 */ 274 HWTEST_F(LocalCodeSignTest, LocalCodeSignTest_0013, TestSize.Level0) 275 { 276 LocalCodeSignLoadCallback cb; 277 cb.OnLoadSystemAbilityFail(LOCAL_CODE_SIGN_SA_ID); 278 cb.OnLoadSystemAbilitySuccess(LOCAL_CODE_SIGN_SA_ID - 1, nullptr); 279 cb.OnLoadSystemAbilitySuccess(LOCAL_CODE_SIGN_SA_ID, nullptr); 280 281 sptr<ISystemAbilityManager> systemAbilityManager = 282 SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); 283 EXPECT_NE(systemAbilityManager, nullptr); 284 sptr<IRemoteObject> remoteObject = 285 systemAbilityManager->GetSystemAbility(LOCAL_CODE_SIGN_SA_ID); 286 cb.OnLoadSystemAbilitySuccess(LOCAL_CODE_SIGN_SA_ID, remoteObject); 287 } 288 } // namespace CodeSign 289 } // namespace Security 290 } // namespace OHOS 291