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 #include "code_sign_block_header.h"
16
17 namespace OHOS {
18 namespace SignatureTools {
19
CodeSignBlockHeader()20 CodeSignBlockHeader::CodeSignBlockHeader()
21 {
22 magic = MAGIC_NUM;
23 version = CODE_SIGNING_VERSION;
24 reserved = std::vector<int8_t>(RESERVED_BYTE_ARRAY_LENGTH);
25 }
26
CodeSignBlockHeader(Builder * builder)27 CodeSignBlockHeader::CodeSignBlockHeader(Builder* builder)
28 {
29 this->magic = builder->magic;
30 this->version = builder->version;
31 this->blockSize = builder->blockSize;
32 this->segmentNum = builder->segmentNum;
33 this->flags = builder->flags;
34 this->reserved = builder->reserved;
35 }
36
~CodeSignBlockHeader()37 CodeSignBlockHeader::~CodeSignBlockHeader()
38 {
39 }
40
SetSegmentNum(int num)41 void CodeSignBlockHeader::SetSegmentNum(int num)
42 {
43 segmentNum = num;
44 }
45
GetSegmentNum()46 int CodeSignBlockHeader::GetSegmentNum()
47 {
48 return segmentNum;
49 }
50
SetBlockSize(int64_t size)51 void CodeSignBlockHeader::SetBlockSize(int64_t size)
52 {
53 blockSize = static_cast<int>(size);
54 }
55
GetBlockSize()56 int CodeSignBlockHeader::GetBlockSize()
57 {
58 return blockSize;
59 }
60
SetFlags(int flags)61 void CodeSignBlockHeader::SetFlags(int flags)
62 {
63 this->flags = flags;
64 }
65
ToByteArray(std::vector<int8_t> & ret)66 void CodeSignBlockHeader::ToByteArray(std::vector<int8_t>& ret)
67 {
68 ByteBuffer bf(Size());
69 bf.PutInt64(magic);
70 bf.PutInt32(version);
71 bf.PutInt32(blockSize);
72 bf.PutInt32(segmentNum);
73 bf.PutInt32(flags);
74 bf.PutData(reinterpret_cast<const char*>(reserved.data()), reserved.size());
75 ret = std::vector<int8_t>(bf.GetBufferPtr(), bf.GetBufferPtr() + bf.GetPosition());
76 }
77
FromByteArray(const std::vector<int8_t> & bytes)78 CodeSignBlockHeader* CodeSignBlockHeader::FromByteArray(const std::vector<int8_t>& bytes)
79 {
80 if (bytes.size() != Size()) {
81 PrintErrorNumberMsg("VERIFY_ERROR", VERIFY_ERROR, "The size of code signature block is incorrect.");
82 return nullptr;
83 }
84 ByteBuffer bf(bytes.size());
85 bf.PutData(reinterpret_cast<const char*>(bytes.data()), bytes.size());
86 bf.Flip();
87 int64_t inMagic;
88 if (!bf.GetInt64(inMagic) || inMagic != MAGIC_NUM) {
89 PrintErrorNumberMsg("VERIFY_ERROR", VERIFY_ERROR,
90 "The magic number in the code signature block header is incorrect.");
91 return nullptr;
92 }
93 int inVersion;
94 bf.GetInt32(inVersion);
95 if (inVersion != CODE_SIGNING_VERSION) {
96 PrintErrorNumberMsg("VERIFY_ERROR", VERIFY_ERROR,
97 "The code signing version in the code signature block header is incorrect.");
98 return nullptr;
99 }
100 int inBlockSize;
101 bf.GetInt32(inBlockSize);
102 int inSegmentNum;
103 bf.GetInt32(inSegmentNum);
104 if (inSegmentNum != SEGMENT_NUM) {
105 PrintErrorNumberMsg("VERIFY_ERROR", VERIFY_ERROR,
106 "The segment number in the code signature block header is incorrect.");
107 return nullptr;
108 }
109 int inFlags;
110 bf.GetInt32(inFlags);
111 if (inFlags < 0 || inFlags >(FLAG_MERKLE_TREE_INLINED + FLAG_NATIVE_LIB_INCLUDED)) {
112 PrintErrorNumberMsg("VERIFY_ERROR", VERIFY_ERROR, "The flag in the code signature block header is incorrect.");
113 return nullptr;
114 }
115 std::vector<int8_t> inReserved(RESERVED_BYTE_ARRAY_LENGTH);
116 bf.GetByte(inReserved.data(), RESERVED_BYTE_ARRAY_LENGTH);
117 CodeSignBlockHeader::Builder* tempVar = new(std::nothrow) CodeSignBlockHeader::Builder();
118 if (tempVar == nullptr) {
119 PrintErrorNumberMsg("VERIFY_ERROR", VERIFY_ERROR, "create CodeSignBlockHeader::Builder failed");
120 return nullptr;
121 }
122 CodeSignBlockHeader* codeSignBlockHeader = tempVar->SetMagic(inMagic)->SetVersion(inVersion)->
123 SetBlockSize(inBlockSize)->SetSegmentNum(inSegmentNum)->
124 SetFlags(inFlags)->SetReserved(inReserved)->Build();
125 delete tempVar;
126 return codeSignBlockHeader;
127 }
128
Size()129 int CodeSignBlockHeader::Size()
130 {
131 return MAGIC_BYTE_ARRAY_LENGTH + MAGIC_BYTE_LENGTH * MAGIC_BYTE_LENGTH + RESERVED_BYTE_ARRAY_LENGTH;
132 }
133
SetMagic(int64_t magic)134 CodeSignBlockHeader::Builder* CodeSignBlockHeader::Builder::SetMagic(int64_t magic)
135 {
136 this->magic = magic;
137 return this;
138 }
139
SetVersion(int version)140 CodeSignBlockHeader::Builder* CodeSignBlockHeader::Builder::SetVersion(int version)
141 {
142 this->version = version;
143 return this;
144 }
145
SetBlockSize(int blockSize)146 CodeSignBlockHeader::Builder* CodeSignBlockHeader::Builder::SetBlockSize(int blockSize)
147 {
148 this->blockSize = blockSize;
149 return this;
150 }
151
SetSegmentNum(int segmentNum)152 CodeSignBlockHeader::Builder* CodeSignBlockHeader::Builder::SetSegmentNum(int segmentNum)
153 {
154 this->segmentNum = segmentNum;
155 return this;
156 }
157
SetFlags(int flags)158 CodeSignBlockHeader::Builder* CodeSignBlockHeader::Builder::SetFlags(int flags)
159 {
160 this->flags = flags;
161 return this;
162 }
163
SetReserved(const std::vector<int8_t> & reserved)164 CodeSignBlockHeader::Builder* CodeSignBlockHeader::Builder::SetReserved(const std::vector<int8_t>& reserved)
165 {
166 this->reserved = reserved;
167 return this;
168 }
169
Build()170 CodeSignBlockHeader* CodeSignBlockHeader::Builder::Build()
171 {
172 return new CodeSignBlockHeader(this);
173 }
174
~Builder()175 CodeSignBlockHeader::Builder::~Builder()
176 {
177 }
178
179 }
180 }