1 /*
2 * Copyright (c) 2023 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 /*
17 * We generate muid-hashcode according to the MD5 Message-Digest Algorithm here.
18 */
19 #include "muid.h"
20 #include <cstring>
21 #include "securec.h"
22
23 /*
24 * Basic MUID functions.
25 */
26 #define F(x, y, z) (((x) & (y)) | ((~(x)) & (z)))
27 #define G(x, y, z) (((x) & (z)) | ((y) & (~(z))))
28 #define H(x, y, z) ((x) ^ (y) ^ (z))
29 #define I(x, y, z) ((y) ^ ((x) | (~(z))))
30
31 /*
32 * Muid Transformation function.
33 */
34 #define TRANS(f, a, b, c, d, x, t, s) \
35 (a) += f((b), (c), (d)) + (x) + (t); \
36 (a) = (((a) << (s)) | (((a)&0xffffffff) >> (32 - (s)))); \
37 (a) += (b);
38
39 /*
40 * Divide the whole input data into sevral groups with kGroupSizebit each and decode them.
41 */
42 #if defined(__i386__) || defined(__x86_64__) || defined(__vax__)
43 #define DECODE(n, input, output) \
44 ((output)[(n)] = (*reinterpret_cast<unsigned int *>(const_cast<unsigned char *>(&(input)[(n)*4]))))
45 #else
46 #define DECODE(n, input, output) \
47 ((output)[(n)] = (unsigned int)(input)[(n)*4] | ((unsigned int)(input)[(n)*4 + 1] << 8) | \
48 ((unsigned int)(input)[(n)*4 + 2] << 16) | ((unsigned int)(input)[(n)*4 + 3] << 24))
49 #endif
50
51 /*
52 * Encode function.
53 */
54 #define ENCODE(dst, src) \
55 (dst)[0] = (unsigned char)(src); \
56 (dst)[1] = (unsigned char)((src) >> 8); \
57 (dst)[2] = (unsigned char)((src) >> 16); \
58 (dst)[3] = (unsigned char)((src) >> 24);
59
60 /*
61 * Body of transformation.
62 */
MuidTransform(MuidContext & status,const unsigned char & data,uint64_t count)63 static const unsigned char *MuidTransform(MuidContext &status, const unsigned char &data, uint64_t count)
64 {
65 unsigned int a, b, c, d;
66 auto *result = &data;
67
68 while (count--) {
69 for (unsigned int i = 0; i < kBlockLength; i++) {
70 DECODE(i, result, status.block);
71 }
72
73 a = status.a;
74 b = status.b;
75 c = status.c;
76 d = status.d;
77
78 /* Round 1 */
79 TRANS(F, a, b, c, d, status.block[0], 0xd76aa478, 7)
80 TRANS(F, d, a, b, c, status.block[1], 0xe8c7b756, 12)
81 TRANS(F, c, d, a, b, status.block[2], 0x242070db, 17)
82 TRANS(F, b, c, d, a, status.block[3], 0xc1bdceee, 22)
83 TRANS(F, a, b, c, d, status.block[4], 0xf57c0faf, 7)
84 TRANS(F, d, a, b, c, status.block[5], 0x4787c62a, 12)
85 TRANS(F, c, d, a, b, status.block[6], 0xa8304613, 17)
86 TRANS(F, b, c, d, a, status.block[7], 0xfd469501, 22)
87 TRANS(F, a, b, c, d, status.block[8], 0x698098d8, 7)
88 TRANS(F, d, a, b, c, status.block[9], 0x8b44f7af, 12)
89 TRANS(F, c, d, a, b, status.block[10], 0xffff5bb1, 17)
90 TRANS(F, b, c, d, a, status.block[11], 0x895cd7be, 22)
91 TRANS(F, a, b, c, d, status.block[12], 0x6b901122, 7)
92 TRANS(F, d, a, b, c, status.block[13], 0xfd987193, 12)
93 TRANS(F, c, d, a, b, status.block[14], 0xa679438e, 17)
94 TRANS(F, b, c, d, a, status.block[15], 0x49b40821, 22)
95
96 /* Round 2 */
97 TRANS(G, a, b, c, d, status.block[1], 0xf61e2562, 5)
98 TRANS(G, d, a, b, c, status.block[6], 0xc040b340, 9)
99 TRANS(G, c, d, a, b, status.block[11], 0x265e5a51, 14)
100 TRANS(G, b, c, d, a, status.block[0], 0xe9b6c7aa, 20)
101 TRANS(G, a, b, c, d, status.block[5], 0xd62f105d, 5)
102 TRANS(G, d, a, b, c, status.block[10], 0x02441453, 9)
103 TRANS(G, c, d, a, b, status.block[15], 0xd8a1e681, 14)
104 TRANS(G, b, c, d, a, status.block[4], 0xe7d3fbc8, 20)
105 TRANS(G, a, b, c, d, status.block[9], 0x21e1cde6, 5)
106 TRANS(G, d, a, b, c, status.block[14], 0xc33707d6, 9)
107 TRANS(G, c, d, a, b, status.block[3], 0xf4d50d87, 14)
108 TRANS(G, b, c, d, a, status.block[8], 0x455a14ed, 20)
109 TRANS(G, a, b, c, d, status.block[13], 0xa9e3e905, 5)
110 TRANS(G, d, a, b, c, status.block[2], 0xfcefa3f8, 9)
111 TRANS(G, c, d, a, b, status.block[7], 0x676f02d9, 14)
112 TRANS(G, b, c, d, a, status.block[12], 0x8d2a4c8a, 20)
113
114 /* Round 3 */
115 TRANS(H, a, b, c, d, status.block[5], 0xfffa3942, 4)
116 TRANS(H, d, a, b, c, status.block[8], 0x8771f681, 11)
117 TRANS(H, c, d, a, b, status.block[11], 0x6d9d6122, 16)
118 TRANS(H, b, c, d, a, status.block[14], 0xfde5380c, 23)
119 TRANS(H, a, b, c, d, status.block[1], 0xa4beea44, 4)
120 TRANS(H, d, a, b, c, status.block[4], 0x4bdecfa9, 11)
121 TRANS(H, c, d, a, b, status.block[7], 0xf6bb4b60, 16)
122 TRANS(H, b, c, d, a, status.block[10], 0xbebfbc70, 23)
123 TRANS(H, a, b, c, d, status.block[13], 0x289b7ec6, 4)
124 TRANS(H, d, a, b, c, status.block[0], 0xeaa127fa, 11)
125 TRANS(H, c, d, a, b, status.block[3], 0xd4ef3085, 16)
126 TRANS(H, b, c, d, a, status.block[6], 0x04881d05, 23)
127 TRANS(H, a, b, c, d, status.block[9], 0xd9d4d039, 4)
128 TRANS(H, d, a, b, c, status.block[12], 0xe6db99e5, 11)
129 TRANS(H, c, d, a, b, status.block[15], 0x1fa27cf8, 16)
130 TRANS(H, b, c, d, a, status.block[2], 0xc4ac5665, 23)
131
132 /* Round 4 */
133 TRANS(I, a, b, c, d, status.block[0], 0xf4292244, 6)
134 TRANS(I, d, a, b, c, status.block[7], 0x432aff97, 10)
135 TRANS(I, c, d, a, b, status.block[14], 0xab9423a7, 15)
136 TRANS(I, b, c, d, a, status.block[5], 0xfc93a039, 21)
137 TRANS(I, a, b, c, d, status.block[12], 0x655b59c3, 6)
138 TRANS(I, d, a, b, c, status.block[3], 0x8f0ccc92, 10)
139 TRANS(I, c, d, a, b, status.block[10], 0xffeff47d, 15)
140 TRANS(I, b, c, d, a, status.block[1], 0x85845dd1, 21)
141 TRANS(I, a, b, c, d, status.block[8], 0x6fa87e4f, 6)
142 TRANS(I, d, a, b, c, status.block[15], 0xfe2ce6e0, 10)
143 TRANS(I, c, d, a, b, status.block[6], 0xa3014314, 15)
144 TRANS(I, b, c, d, a, status.block[13], 0x4e0811a1, 21)
145 TRANS(I, a, b, c, d, status.block[4], 0xf7537e82, 6)
146 TRANS(I, d, a, b, c, status.block[11], 0xbd3af235, 10)
147 TRANS(I, c, d, a, b, status.block[2], 0x2ad7d2bb, 15)
148 TRANS(I, b, c, d, a, status.block[9], 0xeb86d391, 21)
149
150 status.a += a;
151 status.b += b;
152 status.c += c;
153 status.d += d;
154
155 result += kGroupSize;
156 }
157
158 return result;
159 }
160
161 /*
162 * Initialize constants here.
163 */
MuidInit(MuidContext & status)164 void MuidInit(MuidContext &status)
165 {
166 status.a = 0x67452301;
167 status.b = 0xefcdab89;
168 status.c = 0x98badcfe;
169 status.d = 0x10325476;
170
171 status.count[0] = 0;
172 status.count[1] = 0;
173 }
174
175 /*
176 * Decoding part(byte to unsigned int).
177 */
MuidDecode(MuidContext & status,const unsigned char & data,size_t size)178 void MuidDecode(MuidContext &status, const unsigned char &data, size_t size)
179 {
180 unsigned int tmp = status.count[0];
181 status.count[0] = (tmp + size) & 0x1fffffff;
182 if (status.count[0] < tmp) {
183 status.count[1]++;
184 }
185 uint32_t higherBits = static_cast<uint64_t>(size) >> kShiftAmount;
186 status.count[1] += higherBits * kByteLength;
187
188 size_t idx = tmp & kBitMask;
189 size_t remain = kGroupSize - idx;
190 auto *position = &data;
191
192 if (idx != 0) {
193 if (size < remain) {
194 if (memcpy_s(&status.buffer[idx], kGroupSize, &data, size) != EOK) {
195 return;
196 }
197 return;
198 }
199
200 if (memcpy_s(&status.buffer[idx], kGroupSize, &data, remain) != EOK) {
201 return;
202 }
203 (void)MuidTransform(status, *status.buffer, 1);
204
205 size -= remain;
206 position += remain;
207 }
208
209 if (size >= kGroupSize) {
210 position = MuidTransform(status, *position, size / kGroupSize);
211 size &= kBitMask;
212 }
213
214 if (memcpy_s(status.buffer, kGroupSize, position, size) != EOK) {
215 return;
216 }
217 }
218
219 /*
220 * Encoding part(unsigned int to byte).
221 */
222 template <typename T>
FullEncode(T & result,MuidContext & status)223 void FullEncode(T &result, MuidContext &status)
224 {
225 size_t idx = status.count[0] & kBitMask;
226 status.buffer[idx++] = 0x80;
227
228 size_t remain = kGroupSize - idx;
229
230 if (remain < kByteLength) {
231 if (memset_s(&status.buffer[idx], kGroupSize, 0, remain) != EOK) {
232 return;
233 }
234 (void)MuidTransform(status, *status.buffer, 1);
235 idx = 0;
236 remain = kGroupSize;
237 }
238
239 if (memset_s(&status.buffer[idx], kGroupSize, 0, remain - kByteLength) != EOK) {
240 return;
241 }
242 status.count[0] *= kByteLength;
243 const unsigned int indexOfLastEight = 56;
244 const unsigned int indexOfLastFour = 60;
245 ENCODE(&status.buffer[indexOfLastEight], status.count[0])
246 ENCODE(&status.buffer[indexOfLastFour], status.count[1])
247
248 (void)MuidTransform(status, *status.buffer, 1);
249 ENCODE(&result[0], status.a)
250 ENCODE(&result[4], status.b)
251 }
252
MuidEncode(unsigned char (& result)[kDigestShortHashLength],MuidContext & status)253 void MuidEncode(unsigned char (&result)[kDigestShortHashLength], MuidContext &status)
254 {
255 FullEncode(result, status);
256 if (memset_s(&status, sizeof(status), 0, sizeof(status)) != EOK) {
257 return;
258 }
259 }
260
MuidEncode(unsigned char (& result)[kDigestHashLength],MuidContext & status,bool use64Bit)261 void MuidEncode(unsigned char (&result)[kDigestHashLength], MuidContext &status, bool use64Bit)
262 {
263 FullEncode(result, status);
264 if (!use64Bit) {
265 ENCODE(&result[8], status.c)
266 ENCODE(&result[12], status.d)
267 }
268 if (memset_s(&status, sizeof(status), 0, sizeof(status)) != EOK) {
269 return;
270 }
271 }
272
273 /*
274 * The entrance functions.
275 */
GetMUIDHash(const unsigned char & data,size_t size,MUID & muid)276 void GetMUIDHash(const unsigned char &data, size_t size, MUID &muid)
277 {
278 MuidContext status;
279 MuidInit(status);
280 MuidDecode(status, data, size);
281 MuidEncode(muid.data.bytes, status);
282 }
283
GetDigestHash(const unsigned char & bytes,uint32_t len)284 DigestHash GetDigestHash(const unsigned char &bytes, uint32_t len)
285 {
286 DigestHash digestHash;
287 MuidContext digestContext;
288
289 digestHash.data.first = 0;
290 digestHash.data.second = 0;
291
292 MuidInit(digestContext);
293 MuidDecode(digestContext, bytes, len);
294 MuidEncode(digestHash.bytes, digestContext);
295
296 return digestHash;
297 }
298
GetMUID(const std::string & symbolName,bool forSystem)299 MUID GetMUID(const std::string &symbolName, bool forSystem)
300 {
301 MUID muid;
302 auto *data = reinterpret_cast<const unsigned char *>(symbolName.c_str());
303 GetMUIDHash(*data, symbolName.length(), muid);
304 if (forSystem) {
305 muid.SetSystemNameSpace();
306 } else {
307 muid.SetApkNameSpace();
308 }
309 return muid;
310 }