1 /*
2 * Copyright (c) 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 <sys/types.h>
17 #include <sys/stat.h>
18 #include <unistd.h>
19 #include <cstddef>
20 #include <cstdint>
21 #include <cstdio>
22
23 #include "zip_signer.h"
24
25 namespace OHOS {
26 namespace SignatureTools {
27 static constexpr int ALIGNMENT = 4;
28 const char* UNSIGNED_HAP_FILE_PATH = "./zip/unsigned.hap";
29 const char* SIGNED_HAP_FILE_PATH = "./zip/signed.hap";
30 const char* OUT_HAP_FILE_PATH = "./zip/output.hap";
31 const char* DATA_DESC_HAP_FILE_PATH = "./zip/data_descriptor_hap.hap";
32
ZipSignerCompleteFlowFunc(const uint8_t * data,size_t size)33 void ZipSignerCompleteFlowFunc(const uint8_t* data, size_t size)
34 {
35 std::string name(reinterpret_cast<const char*>(data), size);
36 std::ifstream inputFile(SIGNED_HAP_FILE_PATH + name, std::ios::binary);
37 std::ofstream outputFile(OUT_HAP_FILE_PATH + name, std::ios::binary | std::ios::trunc);
38 auto zip = std::make_shared<ZipSigner>();
39 if (!zip->Init(inputFile)) {
40 return;
41 }
42 zip->Alignment(ALIGNMENT);
43 zip->RemoveSignBlock();
44 zip->ToFile(inputFile, outputFile);
45 }
46
ZipSignerInfoFunc(const uint8_t * data,size_t size)47 void ZipSignerInfoFunc(const uint8_t* data, size_t size)
48 {
49 std::ifstream inputFile(SIGNED_HAP_FILE_PATH, std::ios::binary);
50 auto zip = std::make_shared<ZipSigner>();
51 if (!zip->Init(inputFile)) {
52 return;
53 }
54 std::vector<ZipEntry*> zipEntries{nullptr};
55 zip->SetZipEntries(zipEntries);
56 zip->SetSigningOffset(size);
57 std::string signingBlock(reinterpret_cast<const char*>(data), size);
58 zip->SetSigningBlock(signingBlock);
59 zip->SetCDOffset(size);
60 zip->SetEOCDOffset(size);
61 zip->SetEndOfCentralDirectory(nullptr);
62
63 zip->GetZipEntries();
64 zip->GetSigningOffset();
65 zip->GetSigningBlock();
66 zip->GetCDOffset();
67 zip->GetEOCDOffset();
68 zip->GetEndOfCentralDirectory();
69 }
70
ZipEntryHeaderInfoFunc(const uint8_t * data,size_t size)71 void ZipEntryHeaderInfoFunc(const uint8_t* data, size_t size)
72 {
73 std::ifstream inputFile(SIGNED_HAP_FILE_PATH, std::ios::binary);
74 auto zip = std::make_shared<ZipSigner>();
75 if (!zip->Init(inputFile)) {
76 return;
77 }
78 auto zipEntries = zip->GetZipEntries();
79 for (const auto& zipEntry : zipEntries) {
80 auto zipEntryData = zipEntry->GetZipEntryData();
81 auto zipEntryHeader = zipEntryData->GetZipEntryHeader();
82
83 std::string fileName(reinterpret_cast<const char*>(data), size);
84 zipEntryHeader->SetFileName(fileName);
85
86 zipEntryHeader->GetCrc32();
87 zipEntryHeader->GetLastTime();
88 zipEntryHeader->GetLastDate();
89 zipEntryHeader->GetCompressedSize();
90 zipEntryHeader->GetUnCompressedSize();
91 zipEntryHeader->GetHeaderLength();
92 zipEntryHeader->GetSIGNATURE();
93 zipEntryHeader->GetVersion();
94 }
95 }
96
CentralDirectoryInfoFunc(const uint8_t * data,size_t size)97 void CentralDirectoryInfoFunc(const uint8_t* data, size_t size)
98 {
99 std::ifstream inputFile(UNSIGNED_HAP_FILE_PATH, std::ios::binary);
100 auto zip = std::make_shared<ZipSigner>();
101 if (!zip->Init(inputFile)) {
102 return;
103 }
104 auto zipEntries = zip->GetZipEntries();
105 for (const auto& zipEntry : zipEntries) {
106 auto cd = zipEntry->GetCentralDirectory();
107 cd->GetLength();
108 cd->GetCdLength();
109 cd->GetSIGNATURE();
110 cd->GetVersion();
111 cd->GetVersionExtra();
112 cd->GetFlag();
113 cd->GetLastTime();
114 cd->GetLastDate();
115 cd->GetCrc32();
116 cd->GetDiskNumStart();
117 cd->GetInternalFile();
118 cd->GetExternalFile();
119 cd->GetFileName();
120
121 std::string comment(reinterpret_cast<const char*>(data), size);
122 cd->SetComment(comment);
123
124 cd->GetComment();
125 }
126 }
127
DataDescriptorInfoFunc(const uint8_t * data,size_t size)128 void DataDescriptorInfoFunc(const uint8_t* data, size_t size)
129 {
130 std::string name(reinterpret_cast<const char*>(data), size);
131 std::ifstream inputFile(DATA_DESC_HAP_FILE_PATH + name, std::ios::binary);
132 auto zip = std::make_shared<ZipSigner>();
133 if (!zip->Init(inputFile)) {
134 return;
135 }
136 auto zipEntries = zip->GetZipEntries();
137 for (const auto& zipEntry : zipEntries) {
138 auto zipEntryData = zipEntry->GetZipEntryData();
139 auto dataDescriptor = zipEntryData->GetDataDescriptor();
140 if (!dataDescriptor) {
141 continue;
142 }
143 dataDescriptor->GetDesLength();
144 dataDescriptor->GetSIGNATURE();
145 dataDescriptor->GetCrc32();
146 dataDescriptor->GetCompressedSize();
147 dataDescriptor->GetUnCompressedSize();
148 }
149 }
150
AlignmentFunc(const uint8_t * data,size_t size)151 void AlignmentFunc(const uint8_t* data, size_t size)
152 {
153 std::string name(reinterpret_cast<const char*>(data), size);
154 std::ifstream inputFile(UNSIGNED_HAP_FILE_PATH + name, std::ios::binary);
155 auto zip = std::make_shared<ZipSigner>();
156 int aliBytes = 102400;
157 if (!zip->Init(inputFile)) {
158 return;
159 }
160 auto zipEntries = zip->GetZipEntries();
161 for (const auto& zipEntry : zipEntries) {
162 zipEntry->Alignment(aliBytes);
163 }
164 }
165
EndOfCentralDirectoryInfoFunc(const uint8_t * data,size_t size)166 void EndOfCentralDirectoryInfoFunc(const uint8_t* data, size_t size)
167 {
168 std::string name(reinterpret_cast<const char*>(data), size);
169 std::ifstream inputFile(UNSIGNED_HAP_FILE_PATH + name, std::ios::binary);
170 auto zip = std::make_shared<ZipSigner>();
171 if (!zip->Init(inputFile)) {
172 return;
173 }
174 auto eocd = zip->GetEndOfCentralDirectory();
175 eocd->GetLength();
176 eocd->GetEocdLength();
177 eocd->GetSIGNATURE();
178 eocd->GetDiskNum();
179 eocd->GetcDStartDiskNum();
180 eocd->GetThisDiskCDNum();
181
182 std::string comment(reinterpret_cast<const char*>(data), size);
183 eocd->SetComment(comment);
184
185 eocd->GetComment();
186 }
187
DoSomethingInterestingWithMyAPI(const uint8_t * data,size_t size)188 void DoSomethingInterestingWithMyAPI(const uint8_t* data, size_t size)
189 {
190 if (data == nullptr || size == 0) {
191 return;
192 }
193
194 ZipSignerCompleteFlowFunc(data, size);
195 ZipSignerInfoFunc(data, size);
196 ZipEntryHeaderInfoFunc(data, size);
197 CentralDirectoryInfoFunc(data, size);
198 DataDescriptorInfoFunc(data, size);
199 AlignmentFunc(data, size);
200 EndOfCentralDirectoryInfoFunc(data, size);
201 }
202 } // namespace SignatureTools
203 } // namespace OHOS
204
205 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)206 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
207 {
208 /* Run your code on data */
209 (void)rename("./zip/data_descriptor_hap.txt", OHOS::SignatureTools::DATA_DESC_HAP_FILE_PATH);
210 (void)rename("./zip/unsigned.txt", OHOS::SignatureTools::UNSIGNED_HAP_FILE_PATH);
211 (void)rename("./zip/signed.txt", OHOS::SignatureTools::SIGNED_HAP_FILE_PATH);
212 sync();
213 OHOS::SignatureTools::DoSomethingInterestingWithMyAPI(data, size);
214 return 0;
215 }