1 /* 2 * Copyright (c) 2024-2024 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 <memory> 17 #include <vector> 18 #include <gtest/gtest.h> 19 #include "code_sign_block.h" 20 #include "segment_header.h" 21 #include "hap_info_segment.h" 22 #include "sign_info.h" 23 24 namespace OHOS { 25 namespace SignatureTools { 26 /* 27 * 测试套件,固定写法 28 */ 29 class CodeSignBlockTest : public testing::Test { 30 public: SetUpTestCase(void)31 static void SetUpTestCase(void) {}; TearDownTestCase()32 static void TearDownTestCase() {}; SetUp()33 void SetUp() {}; TearDown()34 void TearDown() {}; 35 }; 36 37 38 /** 39 * @tc.name: addOneMerkleTree002 40 * @tc.desc: Test function of CodeSignBlockTest::addOneMerkleTree002() interface for SUCCESS. 41 * @tc.size: MEDIUM 42 * @tc.type: FUNC 43 * @tc.level Level 1 44 * @tc.require: SR000H63TL 45 */ 46 HWTEST_F(CodeSignBlockTest, addOneMerkleTree002, testing::ext::TestSize.Level1) 47 { 48 std::shared_ptr<CodeSignBlock> api = std::make_shared<CodeSignBlock>(); 49 50 const std::string key; 51 std::vector<int8_t> merkleTree; 52 api->AddOneMerkleTree(key, merkleTree); // 返回值void 53 54 api->AddOneMerkleTree("111", merkleTree); 55 std::vector<int8_t> merkleTreeTemp = api->GetOneMerkleTreeByFileName(key); 56 EXPECT_EQ(merkleTree.empty(), merkleTreeTemp.empty()); 57 } 58 59 /** 60 * @tc.name: addToSegmentList 61 * @tc.desc: Test function of CodeSignBlockTest::addToSegmentList() interface for SUCCESS. 62 * @tc.size: MEDIUM 63 * @tc.type: FUNC 64 * @tc.level Level 1 65 * @tc.require: SR000H63TL 66 */ 67 HWTEST_F(CodeSignBlockTest, addToSegmentList, testing::ext::TestSize.Level1) 68 { 69 std::shared_ptr<CodeSignBlock> api = std::make_shared<CodeSignBlock>(); 70 71 SegmentHeader sh(SegmentHeader::CSB_NATIVE_LIB_INFO_SEG, 0); 72 api->AddToSegmentList(sh); 73 std::vector<SegmentHeader> header = api->GetSegmentHeaderList(); 74 EXPECT_EQ(header[0].GetType(), sh.GetType()); 75 } 76 77 /** 78 * @tc.name: computeMerkleTreeOffset 79 * @tc.desc: Test function of CodeSignBlockTest::ComputeMerkleTreeOffset() interface for SUCCESS. 80 * @tc.size: MEDIUM 81 * @tc.type: FUNC 82 * @tc.level Level 1 83 * @tc.require: SR000H63TL 84 */ 85 HWTEST_F(CodeSignBlockTest, computeMerkleTreeOffset, testing::ext::TestSize.Level1) 86 { 87 std::shared_ptr<CodeSignBlock> api = std::make_shared<CodeSignBlock>(); 88 89 int64_t codeSignBlockOffset = 949572; 90 int64_t offset = api->ComputeMerkleTreeOffset(codeSignBlockOffset); 91 92 EXPECT_NE(offset, 0); 93 } 94 95 /** 96 * @tc.name: computeMerkleTreeOffset001 97 * @tc.desc: Test function of CodeSignBlockTest::computeMerkleTreeOffset001() interface for SUCCESS. 98 * @tc.size: MEDIUM 99 * @tc.type: FUNC 100 * @tc.level Level 1 101 * @tc.require: SR000H63TL 102 */ 103 HWTEST_F(CodeSignBlockTest, computeMerkleTreeOffset001, testing::ext::TestSize.Level1) 104 { 105 std::shared_ptr<CodeSignBlock> api = std::make_shared<CodeSignBlock>(); 106 107 int64_t codeSignBlockOffset = -68; 108 int64_t offset = api->ComputeMerkleTreeOffset(codeSignBlockOffset); 109 110 EXPECT_EQ(offset, 0); 111 } 112 113 /** 114 * @tc.name: getOneMerkleTreeByFileName001 115 * @tc.desc: Test function of CodeSignBlockTest::getOneMerkleTreeByFileName001() interface for SUCCESS. 116 * @tc.size: MEDIUM 117 * @tc.type: FUNC 118 * @tc.level Level 1 119 * @tc.require: SR000H63TL 120 */ 121 HWTEST_F(CodeSignBlockTest, getOneMerkleTreeByFileName001, testing::ext::TestSize.Level1) 122 { 123 std::shared_ptr<CodeSignBlock> api = std::make_shared<CodeSignBlock>(); 124 125 api->ComputeSegmentOffset(); 126 api->GetCodeSignBlockHeader(); 127 api->GetHapInfoSegment(); 128 std::string key = "test.so"; 129 std::vector<int8_t> name = api->GetOneMerkleTreeByFileName(key); 130 131 EXPECT_EQ(name.size(), 0); 132 } 133 134 /** 135 * @tc.name: getOneMerkleTreeByFileName002 136 * @tc.desc: Test function of CodeSignBlockTest::getOneMerkleTreeByFileName002() interface for SUCCESS. 137 * @tc.size: MEDIUM 138 * @tc.type: FUNC 139 * @tc.level Level 1 140 * @tc.require: SR000H63TL 141 */ 142 HWTEST_F(CodeSignBlockTest, getOneMerkleTreeByFileName002, testing::ext::TestSize.Level1) 143 { 144 std::shared_ptr<CodeSignBlock> api = std::make_shared<CodeSignBlock>(); 145 146 std::string key; 147 std::vector<int8_t> name = api->GetOneMerkleTreeByFileName(key); 148 int size = name.size(); 149 150 EXPECT_EQ(size, 0); 151 } 152 153 /** 154 * @tc.name: getSegmentHeaderList 155 * @tc.desc: Test function of CodeSignBlockTest::getSegmentHeaderList() interface for SUCCESS. 156 * @tc.size: MEDIUM 157 * @tc.type: FUNC 158 * @tc.level Level 1 159 * @tc.require: SR000H63TL 160 */ 161 HWTEST_F(CodeSignBlockTest, getSegmentHeaderList, testing::ext::TestSize.Level1) 162 { 163 std::shared_ptr<CodeSignBlock> api = std::make_shared<CodeSignBlock>(); 164 165 std::vector<SegmentHeader> segmentHeaderList = api->GetSegmentHeaderList(); 166 167 EXPECT_EQ(segmentHeaderList.size(), 0); 168 } 169 170 /** 171 * @tc.name: getSoInfoSegment 172 * @tc.desc: Test function of CodeSignBlockTest::getSoInfoSegment() interface for SUCCESS. 173 * @tc.size: MEDIUM 174 * @tc.type: FUNC 175 * @tc.level Level 1 176 * @tc.require: SR000H63TL 177 */ 178 HWTEST_F(CodeSignBlockTest, getSoInfoSegment, testing::ext::TestSize.Level1) 179 { 180 std::shared_ptr<CodeSignBlock> api = std::make_shared<CodeSignBlock>(); 181 api->SetCodeSignBlockFlag(); 182 183 NativeLibInfoSegment nativeLibInfoSegment(0, 184 0, 185 1, 186 std::vector<SignedFilePos>(), 187 std::vector<std::string>(), 188 std::vector<SignInfo>(), 189 std::vector<int8_t>()); 190 191 api->SetSoInfoSegment(nativeLibInfoSegment); 192 api->SetCodeSignBlockFlag(); 193 194 EXPECT_NE(api->GetSoInfoSegment().GetSectionNum(), 0); 195 } 196 197 /** 198 * @tc.name: setCodeSignBlockHeader 199 * @tc.desc: Test function of CodeSignBlockTest::setCodeSignBlockHeader() interface for SUCCESS. 200 * @tc.size: MEDIUM 201 * @tc.type: FUNC 202 * @tc.level Level 1 203 * @tc.require: SR000H63TL 204 */ 205 HWTEST_F(CodeSignBlockTest, setCodeSignBlockHeader, testing::ext::TestSize.Level1) 206 { 207 std::shared_ptr<CodeSignBlock> api = std::make_shared<CodeSignBlock>(); 208 209 CodeSignBlockHeader::Builder* build = new CodeSignBlockHeader::Builder(); 210 build->SetBlockSize(4096); 211 build->SetFlags(1); 212 build->SetMagic(29); 213 std::vector<int8_t> reservedVec(32, 1); 214 build->SetReserved(reservedVec); 215 build->SetSegmentNum(394); 216 build->SetVersion(9); 217 CodeSignBlockHeader codeSignBlockHeader(build); 218 219 api->SetCodeSignBlockHeader(codeSignBlockHeader); 220 CodeSignBlockHeader tmp = api->GetCodeSignBlockHeader(); 221 EXPECT_NE(tmp.GetBlockSize(), 0); 222 } 223 224 /** 225 * @tc.name: setHapInfoSegment 226 * @tc.desc: Test function of CodeSignBlockTest::setHapInfoSegment() interface for SUCCESS. 227 * @tc.size: MEDIUM 228 * @tc.type: FUNC 229 * @tc.level Level 1 230 * @tc.require: SR000H63TL 231 */ 232 HWTEST_F(CodeSignBlockTest, setHapInfoSegment, testing::ext::TestSize.Level1) 233 { 234 std::shared_ptr<CodeSignBlock> api = std::make_shared<CodeSignBlock>(); 235 236 int32_t saltSize = 0; 237 int32_t flags = 1; 238 int64_t dataSize = 5390336; 239 std::vector<int8_t> salt; 240 std::vector<int8_t> sig{ 48, -126, 7, -46, 6, 9, 42, -122, 72, -122, -9, 13, 1, 7, 241 2, -96, -126, 7, -61, 48, -126, 7, -65, 2, 1, 1, 49, 13, 48, 11, 6, 9, 96, -122, 242 72, 1, 101, 3, 4, 2, 1, 48, 11, 6, 9, 42, -122, 72, -122, -9, 13, 1, 7, 1, -96, 243 -126, 6, 43, 48, -126, 1, -32, 48, -126, 1, -121, -96, 3, 2, 1, 2, 2, 4, 85, -67, 244 -54, 116, 48, 10, 6, 8, 42, -122, 72, -50, 61, 4, 3, 3, 48, 85, 49, 11, 48, 9, 6, 245 3, 85, 4, 6, 1 }; 246 SignInfo signInfo(saltSize, flags, dataSize, salt, sig); 247 HapInfoSegment hapInfoSegment(10945, signInfo); 248 api->SetHapInfoSegment(hapInfoSegment); 249 HapInfoSegment tmp = api->GetHapInfoSegment(); 250 EXPECT_NE(tmp.GetSize(), 0); 251 } 252 253 /** 254 * @tc.name: setSegmentHeaders 255 * @tc.desc: Test function of CodeSignBlockTest::setSegmentHeaders() interface for SUCCESS. 256 * @tc.size: MEDIUM 257 * @tc.type: FUNC 258 * @tc.level Level 1 259 * @tc.require: SR000H63TL 260 */ 261 HWTEST_F(CodeSignBlockTest, setSegmentHeaders, testing::ext::TestSize.Level1) 262 { 263 std::shared_ptr<CodeSignBlock> api = std::make_shared<CodeSignBlock>(); 264 api->SetSegmentNum(); 265 api->SetSegmentHeaders(); 266 FsVerityInfoSegment fsVeritySeg(1, 1, 12); 267 api->SetFsVerityInfoSegment(fsVeritySeg); 268 std::vector<SegmentHeader>list = api->GetSegmentHeaderList(); 269 270 int32_t magic = 248702752; 271 int32_t segmentSize = 0; 272 int32_t sectionNum = 0; 273 std::vector<SignedFilePos> signedFilePosList; 274 std::vector<std::string> fileNameList; 275 std::vector<SignInfo> signInfoList; 276 std::vector<int8_t> zeroPadding; 277 278 NativeLibInfoSegment soSeg(magic, segmentSize, sectionNum, signedFilePosList, 279 fileNameList, signInfoList, zeroPadding); 280 api->SetSoInfoSegment(soSeg); 281 282 EXPECT_NE(list.size(), 0); 283 } 284 285 } // namespace SignatureTools 286 } // namespace OHOS