├── README.md
├── aes
    ├── aes.abc
    ├── aes.js
    └── aes_decompiled.js
├── image.png
└── md5
    ├── md5.abc
    └── md5_decompiled.js


/README.md:
--------------------------------------------------------------------------------
 1 | ## xpanda
 2 | 一款HarmonyOS NEXT APP的反编译器。
 3 | ![结果](./image.png)<br>
 4 | 欢迎在线试用：[https://https://panda.jmp0.top/](https://panda.jmp0.top/)<br>
 5 | 目前只支持abc文件，且文件大小限制50kb。<br>
 6 | 附送几个apikey:<br>
 7 | FrwOTKjhvDZdxWbN<br>
 8 | 2ixWZbMeJjGXIjrZ<br>
 9 | mTlVqfZvud1YH5A4<br>
10 | 


--------------------------------------------------------------------------------
/aes/aes.abc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asmjmp0/xpanda/645f690f04e8e02b1a8cf09f1cf84db198560e0e/aes/aes.abc


--------------------------------------------------------------------------------
/aes/aes.js:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * JavaScript AES implementation using Counter Mode
  3 |  *
  4 |  * Copyright (c) 2010 Robert Sosinski (http://www.robertsosinski.com)
  5 |  * Offical Web Site (http://github.com/robertsosinski/js-aes)
  6 |  *
  7 |  * Permission is hereby granted, free of charge, to any person
  8 |  * obtaining a copy of this software and associated documentation
  9 |  * files (the "Software"), to deal in the Software without
 10 |  * restriction, including without limitation the rights to use,
 11 |  * copy, modify, merge, publish, distribute, sublicense, and/or sell
 12 |  * copies of the Software, and to permit persons to whom the
 13 |  * Software is furnished to do so, subject to the following
 14 |  * conditions:
 15 |  *
 16 |  * The above copyright notice and this permission notice shall be
 17 |  * included in all copies or substantial portions of the Software.
 18 |  *
 19 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 20 |  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 21 |  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 22 |  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 23 |  * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 24 |  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 25 |  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 26 |  * OTHER DEALINGS IN THE SOFTWARE.
 27 |  */
 28 | var AES = {
 29 |     VERSION: "1.2",
 30 | 
 31 |     sbox: [0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
 32 |         0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
 33 |         0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
 34 |         0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
 35 |         0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
 36 |         0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
 37 |         0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
 38 |         0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
 39 |         0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
 40 |         0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
 41 |         0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
 42 |         0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
 43 |         0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
 44 |         0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
 45 |         0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
 46 |         0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16],
 47 | 
 48 |     rcon: [[0x00, 0x00, 0x00, 0x00],
 49 |         [0x01, 0x00, 0x00, 0x00],
 50 |         [0x02, 0x00, 0x00, 0x00],
 51 |         [0x04, 0x00, 0x00, 0x00],
 52 |         [0x08, 0x00, 0x00, 0x00],
 53 |         [0x10, 0x00, 0x00, 0x00],
 54 |         [0x20, 0x00, 0x00, 0x00],
 55 |         [0x40, 0x00, 0x00, 0x00],
 56 |         [0x80, 0x00, 0x00, 0x00],
 57 |         [0x1b, 0x00, 0x00, 0x00],
 58 |         [0x36, 0x00, 0x00, 0x00]],
 59 | 
 60 |     cipher: function(input, w) {
 61 |         var nb     = 4;
 62 |         var nr     = w.length / nb - 1;
 63 |         var state  = [new Array(nb), new Array(nb), new Array(nb), new Array(nb)];
 64 |         var output = new Array(4 * nb);
 65 | 
 66 |         var i, round;
 67 | 
 68 |         for (i = 0; i < input.length; i++) {
 69 |             state[i % 4][Math.floor(i / 4)] = input[i];
 70 |         }
 71 | 
 72 |         this.addRoundKey(state, w, 0, nb);
 73 | 
 74 |         for (round = 1; round < nr; round++) {
 75 |             this.subBytes(state, nb);
 76 |             this.shiftRows(state, nb);
 77 |             this.mixColumns(state, nb);
 78 |             this.addRoundKey(state, w, round, nb);
 79 |         }
 80 | 
 81 |         this.subBytes(state, nb);
 82 |         this.shiftRows(state, nb);
 83 |         this.addRoundKey(state, w, round, nb);
 84 | 
 85 |         for (i = 0; i < output.length; i++) {
 86 |             output[i] = state[i % 4][Math.floor(i / 4)];
 87 |         }
 88 | 
 89 |         return output;
 90 |     },
 91 | 
 92 |     subBytes: function(state, nb) {
 93 |         var r, c;
 94 | 
 95 |         for (c = 0; c < nb; c++) {
 96 |             for (r = 0; r < 4; r++) {
 97 |                 state[r][c] = this.sbox[state[r][c]];
 98 |             }
 99 |         }
100 |     },
101 | 
102 |     shiftRows: function(state, nb) {
103 |         var temp = new Array(nb);
104 | 
105 |         var r, c;
106 | 
107 |         for (r = 1; r < 4; r++) {
108 |             for (c = 0; c < nb; c++) {
109 |                 temp[c] = state[r][(c + r) % nb];
110 |             }
111 |             for (c = 0; c < 4; c++) {
112 |                 state[r][c] = temp[c];
113 |             }
114 |         }
115 |     },
116 | 
117 |     mixColumns: function(state, nb) {
118 |         var r, c, a, b;
119 | 
120 |         for (c = 0; c < nb; c++) {
121 |             a = new Array(4);
122 |             b = new Array(4);
123 | 
124 |             for (r = 0; r < 4; r++) {
125 |                 a[r] = state[r][c];
126 |                 b[r] = state[r][c] & 0x80 ? state[r][c] << 1 ^ 0x11b : state[r][c] << 1;
127 |             }
128 | 
129 |             state[0][c] = b[0] ^ a[3] ^ a[2] ^ b[1] ^ a[1];
130 |             state[1][c] = b[1] ^ a[0] ^ a[3] ^ b[2] ^ a[2];
131 |             state[2][c] = b[2] ^ a[1] ^ a[0] ^ b[3] ^ a[3];
132 |             state[3][c] = b[3] ^ a[2] ^ a[1] ^ b[0] ^ a[0];
133 |         }
134 |     },
135 | 
136 |     addRoundKey: function(state, w, round, nb) {
137 |         var r, c;
138 | 
139 |         for (c = 0; c < nb; c++) {
140 |             for (r = 0; r < 4; r++) {
141 |                 state[r][c] ^= w[round * 4 + c][r];
142 |             }
143 |         }
144 |     },
145 | 
146 |     keyExpansion: function(key) {
147 |         var nk   = key.length / 4;
148 |         var nb   = 4;
149 |         var nr   = nk + 6;
150 |         var w    = new Array(nb * (nr + 1));
151 |         var temp = new Array(4);
152 | 
153 |         var i, j;
154 | 
155 |         for (i = 0; i < nk; i++) {
156 |             w[i] = [key[4 * i], key[4 * i + 1], key[4 * i + 2], key[4 * i + 3]];
157 |         }
158 | 
159 |         for (i = nk; i < w.length; i++) {
160 |             w[i] = new Array(4);
161 | 
162 |             for (j = 0; j < 4; j++) {
163 |                 temp[j] = w[i - 1][j];
164 |             }
165 | 
166 |             if (i % nk === 0) {
167 |                 this.rotWord(temp);
168 |                 this.subWord(temp);
169 | 
170 |                 for (j = 0; j < 4; j++) {
171 |                     temp[j] ^= AES.rcon[i / nk][j];
172 |                 }
173 |             }
174 |             else if (nk > 6 && i % nk === 4) {
175 |                 this.subWord(temp);
176 |             }
177 | 
178 |             for (j = 0; j < 4; j++) {
179 |                 w[i][j] = w[i - nk][j] ^ temp[j];
180 |             }
181 |         }
182 | 
183 |         return w;
184 |     },
185 | 
186 |     rotWord: function(w) {
187 |         var temp = w[0];
188 | 
189 |         var i;
190 | 
191 |         for (i = 0; i < 3; i++) {
192 |             w[i] = w[i + 1];
193 |         }
194 | 
195 |         w[3] = temp;
196 |     },
197 | 
198 |     subWord: function(w) {
199 |         var i;
200 | 
201 |         for (i = 0; i < 4; i++) {
202 |             w[i] = this.sbox[w[i]];
203 |         }
204 |     },
205 | 
206 |     generateKey: function() {
207 |         var key = new Array(16);
208 | 
209 |         var i;
210 | 
211 |         for (i = 0; i < 16; i++) {
212 |             key[i] = Math.floor(Math.random() * 0x100);
213 |         }
214 | 
215 |         return key;
216 |     }
217 | };
218 | 
219 | AES.Base64 = {
220 |     characters: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",
221 | 
222 |     encode: function (input) {
223 |         var output = "";
224 | 
225 |         var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
226 | 
227 |         var i;
228 | 
229 |         for (i = 0; i < input.length;) {
230 |             chr1 = input.charCodeAt(i++);
231 |             chr2 = input.charCodeAt(i++);
232 |             chr3 = input.charCodeAt(i++);
233 | 
234 |             enc1 = chr1 >> 2;
235 |             enc2 = ((chr1 & 0x3) << 4) | (chr2 >> 4);
236 |             enc3 = ((chr2 & 0xf) << 2) | (chr3 >> 6);
237 |             enc4 = chr3 & 0x3f;
238 | 
239 |             if (isNaN(chr2)) {
240 |                 enc3 = enc4 = 64;
241 |             }
242 |             else if (isNaN(chr3)) {
243 |                 enc4 = 64;
244 |             }
245 | 
246 |             output = output + this.characters.charAt(enc1) +
247 |                 this.characters.charAt(enc2) +
248 |                 this.characters.charAt(enc3) +
249 |                 this.characters.charAt(enc4);
250 |         }
251 | 
252 |         return output;
253 |     },
254 | 
255 |     decode: function (input) {
256 |         var output = "";
257 | 
258 |         var chr1, chr2, chr3, dec1, dec2, dec3, dec4;
259 | 
260 |         var i;
261 | 
262 |         input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
263 | 
264 |         for (i = 0; i < input.length;) {
265 |             dec1 = this.characters.indexOf(input.charAt(i++));
266 |             dec2 = this.characters.indexOf(input.charAt(i++));
267 |             dec3 = this.characters.indexOf(input.charAt(i++));
268 |             dec4 = this.characters.indexOf(input.charAt(i++));
269 | 
270 |             chr1 = (dec1 << 2) | (dec2 >> 4);
271 |             chr2 = ((dec2 & 0xf) << 4) | (dec3 >> 2);
272 |             chr3 = ((dec3 & 0x3) << 6) | dec4;
273 | 
274 |             output = output + String.fromCharCode(chr1);
275 | 
276 |             if (dec3 !== 64) {
277 |                 output = output + String.fromCharCode(chr2);
278 |             }
279 |             if (dec4 !== 64) {
280 |                 output = output + String.fromCharCode(chr3);
281 |             }
282 |         }
283 | 
284 |         return output;
285 |     }
286 | };
287 | 
288 | AES.Counter = function() {
289 |     var time = 1715592630;//Math.floor((new Date()).getTime() / 1000);
290 | 
291 |     this.arr = new Array(16);
292 | 
293 |     var i;
294 | 
295 |     for (i = 0; i < 4; i++) {
296 |         this.arr[i] = (time >>> i * 8) & 0xff;
297 |     }
298 |     // for (i = 4; i < 8; i++) {
299 |     //     this.arr[i] = Math.floor(Math.random() * 0x100);
300 |     // }
301 |     this.arr[4] = 123;
302 |     this.arr[5] = 223;
303 |     this.arr[6] = 13;
304 |     this.arr[7] = 23;
305 | 
306 |     for (i = 8; i < 16; i++) {
307 |         this.arr[i] = 0;
308 |     }
309 | 
310 |     this.increment = function() {
311 |         for (i = 15; i >= 8; i--) {
312 |             if (this.arr[i] === 0xff) {
313 |                 this.arr[i] = 0;
314 |             }
315 |             else {
316 |                 this.arr[i]++;
317 |                 break;
318 |             }
319 |         }
320 | 
321 |         return this;
322 |     };
323 |     console.log()
324 | };
325 | 
326 | AES.Crypto = function(key) {
327 |     var blockSize = 16;
328 | 
329 |     this.key         = key;
330 |     this.keySchedule = AES.keyExpansion(key);
331 |     this.counter     = new AES.Counter();
332 | 
333 |     var i;
334 | 
335 |     this.setCounter = function(arr) {
336 |         for (i = 0; i < 16; i++) {
337 |             this.counter.arr[i] = arr[i];
338 |         }
339 | 
340 |         return this;
341 |     };
342 | 
343 |     this.getCounter = function() {
344 |         return this.counter.arr;
345 |     };
346 | 
347 |     this.run = function(input) {
348 |         var blockCount = Math.ceil(input.length / blockSize);
349 |         var output     = new Array(input.length);
350 | 
351 |         var counterBlock, byteCount, offset;
352 | 
353 |         var block, c;
354 | 
355 |         for (block = 0; block < blockCount; block++) {
356 |             counterBlock = AES.cipher(this.counter.arr, this.keySchedule);
357 |             byteCount    = block + 1 === blockCount ? input.length % blockSize : blockSize;
358 |             offset       = block * blockSize;
359 | 
360 |             for (c = 0; c < byteCount; c++) {
361 |                 output[offset + c] = String.fromCharCode(counterBlock[c] ^ input.charCodeAt(offset + c));
362 |             }
363 | 
364 |             this.counter.increment();
365 |         }
366 | 
367 |         return output.join("");
368 |     };
369 | 
370 |     this.encrypt = function(text) {
371 |         return AES.Base64.encode(this.run(text));
372 |     };
373 | 
374 |     this.decrypt = function(text) {
375 |         return this.run(AES.Base64.decode(text));
376 |     };
377 | };
378 | var aSide = new AES.Crypto([190, 100, 76, 127, 43, 253, 149, 65, 72, 90, 40, 65, 6, 211, 77, 37]);
379 | var bSide = new AES.Crypto(aSide.key);
380 | bSide.setCounter(aSide.getCounter());
381 | var cipherText = aSide.encrypt("the quick brown fox jumped over the lazy dog");
382 | var plainText = bSide.decrypt(cipherText);
383 | console.log(plainText === "the quick brown fox jumped over the lazy dog")


--------------------------------------------------------------------------------
/aes/aes_decompiled.js:
--------------------------------------------------------------------------------
  1 | /*
  2 | * class name:L_GLOBAL;
  3 | * Source code created from a .abc file.
  4 | * powered by xpanda decompiler, author: jmp0
  5 | */
  6 | let v0, v1;
  7 | globalThis.plainText = undefined;
  8 | globalThis.cipherText = undefined;
  9 | globalThis.bSide = undefined;
 10 | globalThis.aSide = undefined;
 11 | globalThis.AES = undefined;
 12 | v0 = {
 13 |   "cipher": false,
 14 |   "generateKey": false,
 15 |   "keyExpansion": false,
 16 |   "rcon": false,
 17 |   "shiftRows": false,
 18 |   "mixColumns": false,
 19 |   "VERSION": "1.2",
 20 |   "addRoundKey": false,
 21 |   "subWord": false,
 22 |   "sbox": false,
 23 |   "rotWord": false,
 24 |   "subBytes": false
 25 | };
 26 | v0.sbox = [99, 124, 119, 123, 242, 107, 111, 197, 48, 1, 103, 43, 254, 215, 171, 118, 202, 130, 201, 125, 250, 89, 71, 240, 173, 212, 162, 175, 156, 164, 114, 192, 183, 253, 147, 38, 54, 63, 247, 204, 52, 165, 229, 241, 113, 216, 49, 21, 4, 199, 35, 195, 24, 150, 5, 154, 7, 18, 128, 226, 235, 39, 178, 117, 9, 131, 44, 26, 27, 110, 90, 160, 82, 59, 214, 179, 41, 227, 47, 132, 83, 209, 0, 237, 32, 252, 177, 91, 106, 203, 190, 57, 74, 76, 88, 207, 208, 239, 170, 251, 67, 77, 51, 133, 69, 249, 2, 127, 80, 60, 159, 168, 81, 163, 64, 143, 146, 157, 56, 245, 188, 182, 218, 33, 16, 255, 243, 210, 205, 12, 19, 236, 95, 151, 68, 23, 196, 167, 126, 61, 100, 93, 25, 115, 96, 129, 79, 220, 34, 42, 144, 136, 70, 238, 184, 20, 222, 94, 11, 219, 224, 50, 58, 10, 73, 6, 36, 92, 194, 211, 172, 98, 145, 149, 228, 121, 231, 200, 55, 109, 141, 213, 78, 169, 108, 86, 244, 234, 101, 122, 174, 8, 186, 120, 37, 46, 28, 166, 180, 198, 232, 221, 116, 31, 75, 189, 139, 138, 112, 62, 181, 102, 72, 3, 246, 14, 97, 53, 87, 185, 134, 193, 29, 158, 225, 248, 152, 17, 105, 217, 142, 148, 155, 30, 135, 233, 206, 85, 40, 223, 140, 161, 137, 13, 191, 230, 66, 104, 65, 153, 45, 15, 176, 84, 187, 22];
 27 | v1 = [];
 28 | v1[0] = [0, 0, 0, 0];
 29 | v1[1] = [1, 0, 0, 0];
 30 | v1[2] = [2, 0, 0, 0];
 31 | v1[3] = [4, 0, 0, 0];
 32 | v1[4] = [8, 0, 0, 0];
 33 | v1[5] = [16, 0, 0, 0];
 34 | v1[6] = [32, 0, 0, 0];
 35 | v1[7] = [64, 0, 0, 0];
 36 | v1[8] = [128, 0, 0, 0];
 37 | v1[9] = [27, 0, 0, 0];
 38 | v1[10] = [54, 0, 0, 0];
 39 | v0.rcon = v1;
 40 | v0.cipher = function cipher(p0, p1) {
 41 |   let v0, v1, v3, v4, v5, v6;
 42 |   v0 = 0;
 43 |   v1 = 1;
 44 |   v3 = p1.length / 4 - v1;
 45 |   v4 = [];
 46 |   v4[0] = new Array(4);
 47 |   v4[1] = new Array(4);
 48 |   v4[2] = new Array(4);
 49 |   v4[3] = new Array(4);
 50 |   v5 = new Array(4 * 4);
 51 |   for (v6 = v0; v6 < p0.length; ++v6) {
 52 |     v4[v6 % 4][Math.floor(v6 / 4)] = p0[v6];
 53 |   }
 54 |   for (this.addRoundKey(v4, p1, v0, 4); v1 < v3; ++v1) {
 55 |     this.subBytes(v4, 4);
 56 |     this.shiftRows(v4, 4);
 57 |     this.mixColumns(v4, 4);
 58 |     this.addRoundKey(v4, p1, v1, 4);
 59 |   }
 60 |   this.subBytes(v4, 4);
 61 |   this.shiftRows(v4, 4);
 62 |   for (this.addRoundKey(v4, p1, v1, 4); v0 < v5.length; ++v0) {
 63 |     v5[v0] = v4[v0 % 4][Math.floor(v0 / 4)];
 64 |   }
 65 |   return v5;
 66 | };
 67 | v0.subBytes = function subBytes(p0, p1) {
 68 |   let v2, v3;
 69 |   for (v2 = 0; v2 < p1; ++v2) {
 70 |     for (v3 = 0; v3 < 4; ++v3) {
 71 |       p0[v3][v2] = this.sbox[p0[v3][v2]];
 72 |     }
 73 |   }
 74 | };
 75 | v0.shiftRows = function shiftRows(p0, p1) {
 76 |   let v2, v3, v4;
 77 |   v2 = 1;
 78 |   for (v3 = new Array(p1); v2 < 4; ++v2) {
 79 |     for (v4 = 0; v4 < p1; ++v4) {
 80 |       v3[v4] = p0[v2][(v4 + v2) % p1];
 81 |     }
 82 |     for (v4 = 0; v4 < 4; ++v4) {
 83 |       p0[v2][v4] = v3[v4];
 84 |     }
 85 |   }
 86 | };
 87 | v0.mixColumns = function mixColumns(p0, p1) {
 88 |   let v7, v8, v9, v10;
 89 |   for (v7 = 0; v7 < p1; ++v7) {
 90 |     v8 = new Array(4);
 91 |     v9 = new Array(4);
 92 |     for (v10 = 0; v10 < 4; ++v10) {
 93 |       v8[v10] = p0[v10][v7];
 94 |       v9[v10] = p0[v10][v7] & 128 ? p0[v10][v7] << 1 ^ 283 : p0[v10][v7] << 1;
 95 |     }
 96 |     p0[0][v7] = v9[0] ^ v8[3] ^ v8[2] ^ v9[1] ^ v8[1];
 97 |     p0[1][v7] = v9[1] ^ v8[0] ^ v8[3] ^ v9[2] ^ v8[2];
 98 |     p0[2][v7] = v9[2] ^ v8[1] ^ v8[0] ^ v9[3] ^ v8[3];
 99 |     p0[3][v7] = v9[3] ^ v8[2] ^ v8[1] ^ v9[0] ^ v8[0];
100 |   }
101 | };
102 | v0.addRoundKey = function addRoundKey(p0, p1, p2, p3) {
103 |   let v2, v3;
104 |   for (v2 = 0; v2 < p3; ++v2) {
105 |     for (v3 = 0; v3 < 4; ++v3) {
106 |       p0[v3][v2] = p0[v3][v2] ^ p1[p2 * 4 + v2][v3];
107 |     }
108 |   }
109 | };
110 | v0.keyExpansion = function keyExpansion(p0) {
111 |   let v0, v1, v6, v7, v8, v9, v10, acc;
112 |   v0 = 3;
113 |   v1 = 2;
114 |   v6 = p0.length / 4;
115 |   v7 = new Array(4 * (v6 + 6 + 1));
116 |   v8 = new Array(4);
117 |   for (v9 = 0; v9 < v6; ++v9) {
118 |     v10 = [];
119 |     v10[0] = p0[4 * v9];
120 |     v10[1] = p0[4 * v9 + 1];
121 |     v10[2] = p0[4 * v9 + v1];
122 |     v10[3] = p0[4 * v9 + v0];
123 |     v7[v9] = v10;
124 |   }
125 |   for (v0 = v6; v0 < v7.length; ++v0) {
126 |     v7[v0] = new Array(4);
127 |     for (v1 = 0; v1 < 4; ++v1) {
128 |       v8[v1] = v7[v0 - 1][v1];
129 |     }
130 |     v1 = v0 % v6;
131 |     if (v1 === 0) {
132 |       this.rotWord(v8);
133 |       this.subWord(v8);
134 |       for (v1 = 0; v1 < 4; ++v1) {
135 |         v8[v1] = v8[v1] ^ globalThis.AES.rcon[v0 / v6][v1];
136 |       }
137 |     } else if (v6 > 6 && v0 % v6 === 4) {
138 |       this.subWord(v8);
139 |     }
140 |     for (v1 = 0; v1 < 4; ++v1) {
141 |       v7[v0][v1] = v7[v0 - v6][v1] ^ v8[v1];
142 |     }
143 |   }
144 |   return v7;
145 | };
146 | v0.rotWord = function rotWord(p0) {
147 |   let v2, v3;
148 |   v2 = 0;
149 |   for (v3 = p0[v2]; v2 < 3; ++v2) {
150 |     p0[v2] = p0[v2 + 1];
151 |   }
152 |   p0[3] = v3;
153 | };
154 | v0.subWord = function subWord(p0) {
155 |   let v1;
156 |   for (v1 = 0; v1 < 4; ++v1) {
157 |     p0[v1] = this.sbox[p0[v1]];
158 |   }
159 | };
160 | v0.generateKey = function generateKey() {
161 |   let v1, v3;
162 |   v1 = 0;
163 |   for (v3 = new Array(16); v1 < 16; ++v1) {
164 |     v3[v1] = Math.floor(Math.random() * 256);
165 |   }
166 |   return v3;
167 | };
168 | globalThis.AES = v0;
169 | v1 = {
170 |   "encode": false,
171 |   "characters": "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",
172 |   "decode": false
173 | };
174 | v1.encode = function encode(p0) {
175 |   let v7, v8, v9, v10, v11, v12, v13, v14, acc;
176 |   v7 = 0;
177 |   acc = undefined;
178 |   acc = "";
179 |   for (v8 = acc; v7 < p0.length; v8 = v8 + this.characters.charAt(v12) + this.characters.charAt(v9) + this.characters.charAt(v10) + this.characters.charAt(v11)) {
180 |     acc = v7;
181 |     v7 = acc;
182 |     v10 = ++acc;
183 |     v9 = p0.charCodeAt(v7);
184 |     acc = v10;
185 |     v10 = acc;
186 |     v11 = ++acc;
187 |     v10 = p0.charCodeAt(v10);
188 |     acc = v11;
189 |     v11 = acc;
190 |     v7 = ++acc;
191 |     v11 = p0.charCodeAt(v11);
192 |     v12 = v9 >> 2;
193 |     v9 = (v9 & 3) << 4 | v10 >> 4;
194 |     v13 = (v10 & 15) << 2 | v11 >> 6;
195 |     v14 = v11 & 63;
196 |     if (isNaN(v10)) {
197 |       v10 = 64;
198 |       v11 = 64;
199 |     } else if (isNaN(v11)) {
200 |       v10 = v13;
201 |       v11 = 64;
202 |     } else {
203 |       v10 = v13;
204 |       v11 = v14;
205 |     }
206 |   }
207 |   return v8;
208 | };
209 | v1.decode = function decode(p0) {
210 |   let v6, v7, v8, v9, v10, v11, v12, v13, v14, acc;
211 |   v6 = 0;
212 |   acc = undefined;
213 |   v7 = "";
214 |   v11 = "g";
215 |   v9 = new RegExp("[^A-Za-z0-9\\+\\/\\=]", v11);
216 |   v10 = "";
217 |   acc = p0.replace(v9, v10);
218 |   v8 = acc;
219 |   while (true) {
220 |     if (v6 >= v8.length) break;
221 |     acc = v6;
222 |     v6 = acc;
223 |     v12 = ++acc;
224 |     v9 = this.characters.indexOf(v8.charAt(v6));
225 |     acc = v12;
226 |     v12 = acc;
227 |     v13 = ++acc;
228 |     v10 = this.characters.indexOf(v8.charAt(v12));
229 |     acc = v13;
230 |     v13 = acc;
231 |     v14 = ++acc;
232 |     v11 = this.characters.indexOf(v8.charAt(v13));
233 |     acc = v14;
234 |     v14 = acc;
235 |     v6 = ++acc;
236 |     v12 = this.characters.indexOf(v8.charAt(v14));
237 |     v9 = v9 << 2 | v10 >> 4;
238 |     v10 = (v10 & 15) << 4 | v11 >> 2;
239 |     v13 = (v11 & 3) << 6 | v12;
240 |     v7 = v7 + String.fromCharCode(v9);
241 |     if (v11 !== 64) {
242 |       v7 = v7 + String.fromCharCode(v10);
243 |     }
244 |     if (v12 !== 64) {
245 |       v7 = v7 + String.fromCharCode(v13);
246 |     }
247 |   }
248 |   return v7;
249 | };
250 | globalThis.AES.Base64 = v1;
251 | globalThis.AES.Counter = function () {
252 |   let local0;
253 |   local0 = undefined;
254 |   this.arr = new Array(16);
255 |   for (local0 = 0; local0 < 4; ++local0) {
256 |     this.arr[local0] = 1715592630 >>> local0 * 8 & 255;
257 |   }
258 |   this.arr[4] = 123;
259 |   this.arr[5] = 223;
260 |   this.arr[6] = 13;
261 |   this.arr[7] = 23;
262 |   for (local0 = 8; local0 < 16; ++local0) {
263 |     this.arr[local0] = 0;
264 |   }
265 |   this.increment = function () {
266 |     for (local0 = 15; local0 >= 8; --local0) {
267 |       if (this.arr[local0] !== 255) {
268 |         this.arr[local0] = ++this.arr[local0];
269 |         break;
270 |       }
271 |       this.arr[local0] = 0;
272 |     }
273 |     return this;
274 |   };
275 |   console.log();
276 | };
277 | globalThis.AES.Crypto = function (p0) {
278 |   let local0;
279 |   local0 = undefined;
280 |   this.key = p0;
281 |   this.keySchedule = globalThis.AES.keyExpansion(p0);
282 |   this.counter = new globalThis.AES.Counter();
283 |   this.setCounter = function (p0) {
284 |     for (local0 = 0; local0 < 16; ++local0) {
285 |       this.counter.arr[local0] = p0[local0];
286 |     }
287 |     return this;
288 |   };
289 |   this.getCounter = function () {
290 |     return this.counter.arr;
291 |   };
292 |   this.run = function (p0) {
293 |     let v2, v3, v4, v5, v6, v7, v8, acc;
294 |     v2 = Math.ceil(p0.length / 16);
295 |     v3 = new Array(p0.length);
296 |     for (v4 = 0; v4 < v2; ++v4) {
297 |       v5 = globalThis.AES.cipher(this.counter.arr, this.keySchedule);
298 |       v6 = v4 + 1 === v2 ? p0.length % 16 : 16;
299 |       v7 = v4 * 16;
300 |       for (v8 = 0; v8 < v6; ++v8) {
301 |         v3[v7 + v8] = String.fromCharCode(v5[v8] ^ p0.charCodeAt(v7 + v8));
302 |       }
303 |       this.counter.increment();
304 |     }
305 |     return v3.join("");
306 |   };
307 |   this.encrypt = function (p0) {
308 |     return globalThis.AES.Base64.encode(this.run(p0));
309 |   };
310 |   this.decrypt = function (p0) {
311 |     return this.run(globalThis.AES.Base64.decode(p0));
312 |   };
313 | };
314 | globalThis.aSide = new globalThis.AES.Crypto([190, 100, 76, 127, 43, 253, 149, 65, 72, 90, 40, 65, 6, 211, 77, 37]);
315 | globalThis.bSide = new globalThis.AES.Crypto(globalThis.aSide.key);
316 | globalThis.bSide.setCounter(globalThis.aSide.getCounter());
317 | globalThis.cipherText = globalThis.aSide.encrypt("the quick brown fox jumped over the lazy dog");
318 | globalThis.plainText = globalThis.bSide.decrypt(globalThis.cipherText);
319 | console.log(globalThis.plainText === "the quick brown fox jumped over the lazy dog");


--------------------------------------------------------------------------------
/image.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asmjmp0/xpanda/645f690f04e8e02b1a8cf09f1cf84db198560e0e/image.png


--------------------------------------------------------------------------------
/md5/md5.abc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asmjmp0/xpanda/645f690f04e8e02b1a8cf09f1cf84db198560e0e/md5/md5.abc


--------------------------------------------------------------------------------
/md5/md5_decompiled.js:
--------------------------------------------------------------------------------
  1 | /*
  2 | * class name:L_GLOBAL;
  3 | * Source code created from a .abc file.
  4 | * powered by xpanda decompiler, author: jmp0
  5 | */
  6 | (function () {
  7 |     let local0, local1, local2, local3, local4, local5, local6, local7, local8, local9, local10, local11;
  8 |     local4 = function add32(p0, p1) {
  9 |       return p0 + p1 & 4294967295;
 10 |     };
 11 |     local9 = function rhex(p0) {
 12 |       let v3, v4;
 13 |       v3 = 0;
 14 |       for (v4 = ""; v3 < 4; ++v3) {
 15 |         v4 = v4 + (local8[p0 >> v3 * 8 + 4 & 15] + local8[p0 >> v3 * 8 & 15]);
 16 |       }
 17 |       return v4;
 18 |     };
 19 |     local1 = function gg(p0, p1, p2, p3, p4, p5, p6) {
 20 |       return local5(p1 & p3 | p2 & ~p3, p0, p1, p4, p5, p6);
 21 |     };
 22 |     local7 = function md5blk(p0) {
 23 |       let v8, v9;
 24 |       v8 = 0;
 25 |       for (v9 = []; v8 < 64; v8 = v8 + 4) {
 26 |         v9[v8 >> 2] = p0.charCodeAt(v8) + (p0.charCodeAt(v8 + 1) << 8) + (p0.charCodeAt(v8 + 2) << 16) + (p0.charCodeAt(v8 + 3) << 24);
 27 |       }
 28 |       return v9;
 29 |     };
 30 |     local8 = undefined;
 31 |     local11 = function md51(p0) {
 32 |       let v0, v2, v3, v4, v6, v8, acc;
 33 |       acc = undefined;
 34 |       acc = new RegExp("[\\x80-\\xFF]");
 35 |       if (acc.test(p0)) {
 36 |         p0 = unescape(encodeURI(p0));
 37 |       }
 38 |       v0 = 64;
 39 |       globalThis.txt = "";
 40 |       v2 = [1732584193];
 41 |       v2[1] = -271733879;
 42 |       v2[2] = -1732584194;
 43 |       v2[3] = 271733878;
 44 |       for (v3 = v0; v3 <= p0.length; v3 = v3 + v0) {
 45 |         acc = local6(v2, local7(p0.substring(v3 - v0, v3)));
 46 |       }
 47 |       v4 = 3;
 48 |       v6 = 2;
 49 |       v0 = p0.substring(v3 - v0);
 50 |       v3 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
 51 |       for (v8 = 0; v8 < v0.length; ++v8) {
 52 |         v3[v8 >> v6] = v3[v8 >> v6] | v0.charCodeAt(v8) << (v8 % 4 << v4);
 53 |       }
 54 |       acc = v8 >> v6;
 55 |       v0 = acc;
 56 |       v6 = v3[acc];
 57 |       v4 = v8 % 4 << v4;
 58 |       v3[v0] = v6 | 128 << v4;
 59 |       if (v8 > 55) {
 60 |         acc = local6(v2, v3);
 61 |         for (v4 = 0; v4 < 16; ++v4) {
 62 |           v3[v4] = 0;
 63 |         }
 64 |       }
 65 |       v3[14] = p0.length * 8;
 66 |       acc = local6(v2, v3);
 67 |       return v2;
 68 |     };
 69 |     local0 = function ff(p0, p1, p2, p3, p4, p5, p6) {
 70 |       return local5(p1 & p2 | ~p1 & p3, p0, p1, p4, p5, p6);
 71 |     };
 72 |     local10 = function hex(p0) {
 73 |       let v0;
 74 |       for (v0 = 0; v0 < p0.length; ++v0) {
 75 |         p0[v0] = local9(p0[v0]);
 76 |       }
 77 |       return p0.join("");
 78 |     };
 79 |     local3 = function ii(p0, p1, p2, p3, p4, p5, p6) {
 80 |       return local5(p2 ^ (p1 | ~p3), p0, p1, p4, p5, p6);
 81 |     };
 82 |     local2 = function hh(p0, p1, p2, p3, p4, p5, p6) {
 83 |       return local5(p1 ^ p2 ^ p3, p0, p1, p4, p5, p6);
 84 |     };
 85 |     local6 = function md5cycle(p0, p1) {
 86 |       let v1, v3, v5, v7;
 87 |       v1 = local0(p0[0], p0[1], p0[2], p0[3], p1[0], 7, -680876936);
 88 |       v7 = local0(p0[3], v1, p0[1], p0[2], p1[1], 12, -389564586);
 89 |       v5 = local0(p0[2], v7, v1, p0[1], p1[2], 17, 606105819);
 90 |       v3 = local0(p0[1], v5, v7, v1, p1[3], 22, -1044525330);
 91 |       v1 = local0(v1, v3, v5, v7, p1[4], 7, -176418897);
 92 |       v7 = local0(v7, v1, v3, v5, p1[5], 12, 1200080426);
 93 |       v5 = local0(v5, v7, v1, v3, p1[6], 17, -1473231341);
 94 |       v3 = local0(v3, v5, v7, v1, p1[7], 22, -45705983);
 95 |       v1 = local0(v1, v3, v5, v7, p1[8], 7, 1770035416);
 96 |       v7 = local0(v7, v1, v3, v5, p1[9], 12, -1958414417);
 97 |       v5 = local0(v5, v7, v1, v3, p1[10], 17, -42063);
 98 |       v3 = local0(v3, v5, v7, v1, p1[11], 22, -1990404162);
 99 |       v1 = local0(v1, v3, v5, v7, p1[12], 7, 1804603682);
100 |       v7 = local0(v7, v1, v3, v5, p1[13], 12, -40341101);
101 |       v5 = local0(v5, v7, v1, v3, p1[14], 17, -1502002290);
102 |       v3 = local0(v3, v5, v7, v1, p1[15], 22, 1236535329);
103 |       v1 = local1(v1, v3, v5, v7, p1[1], 5, -165796510);
104 |       v7 = local1(v7, v1, v3, v5, p1[6], 9, -1069501632);
105 |       v5 = local1(v5, v7, v1, v3, p1[11], 14, 643717713);
106 |       v3 = local1(v3, v5, v7, v1, p1[0], 20, -373897302);
107 |       v1 = local1(v1, v3, v5, v7, p1[5], 5, -701558691);
108 |       v7 = local1(v7, v1, v3, v5, p1[10], 9, 38016083);
109 |       v5 = local1(v5, v7, v1, v3, p1[15], 14, -660478335);
110 |       v3 = local1(v3, v5, v7, v1, p1[4], 20, -405537848);
111 |       v1 = local1(v1, v3, v5, v7, p1[9], 5, 568446438);
112 |       v7 = local1(v7, v1, v3, v5, p1[14], 9, -1019803690);
113 |       v5 = local1(v5, v7, v1, v3, p1[3], 14, -187363961);
114 |       v3 = local1(v3, v5, v7, v1, p1[8], 20, 1163531501);
115 |       v1 = local1(v1, v3, v5, v7, p1[13], 5, -1444681467);
116 |       v7 = local1(v7, v1, v3, v5, p1[2], 9, -51403784);
117 |       v5 = local1(v5, v7, v1, v3, p1[7], 14, 1735328473);
118 |       v3 = local1(v3, v5, v7, v1, p1[12], 20, -1926607734);
119 |       v1 = local2(v1, v3, v5, v7, p1[5], 4, -378558);
120 |       v7 = local2(v7, v1, v3, v5, p1[8], 11, -2022574463);
121 |       v5 = local2(v5, v7, v1, v3, p1[11], 16, 1839030562);
122 |       v3 = local2(v3, v5, v7, v1, p1[14], 23, -35309556);
123 |       v1 = local2(v1, v3, v5, v7, p1[1], 4, -1530992060);
124 |       v7 = local2(v7, v1, v3, v5, p1[4], 11, 1272893353);
125 |       v5 = local2(v5, v7, v1, v3, p1[7], 16, -155497632);
126 |       v3 = local2(v3, v5, v7, v1, p1[10], 23, -1094730640);
127 |       v1 = local2(v1, v3, v5, v7, p1[13], 4, 681279174);
128 |       v7 = local2(v7, v1, v3, v5, p1[0], 11, -358537222);
129 |       v5 = local2(v5, v7, v1, v3, p1[3], 16, -722521979);
130 |       v3 = local2(v3, v5, v7, v1, p1[6], 23, 76029189);
131 |       v1 = local2(v1, v3, v5, v7, p1[9], 4, -640364487);
132 |       v7 = local2(v7, v1, v3, v5, p1[12], 11, -421815835);
133 |       v5 = local2(v5, v7, v1, v3, p1[15], 16, 530742520);
134 |       v3 = local2(v3, v5, v7, v1, p1[2], 23, -995338651);
135 |       v1 = local3(v1, v3, v5, v7, p1[0], 6, -198630844);
136 |       v7 = local3(v7, v1, v3, v5, p1[7], 10, 1126891415);
137 |       v5 = local3(v5, v7, v1, v3, p1[14], 15, -1416354905);
138 |       v3 = local3(v3, v5, v7, v1, p1[5], 21, -57434055);
139 |       v1 = local3(v1, v3, v5, v7, p1[12], 6, 1700485571);
140 |       v7 = local3(v7, v1, v3, v5, p1[3], 10, -1894986606);
141 |       v5 = local3(v5, v7, v1, v3, p1[10], 15, -1051523);
142 |       v3 = local3(v3, v5, v7, v1, p1[1], 21, -2054922799);
143 |       v1 = local3(v1, v3, v5, v7, p1[8], 6, 1873313359);
144 |       v7 = local3(v7, v1, v3, v5, p1[15], 10, -30611744);
145 |       v5 = local3(v5, v7, v1, v3, p1[6], 15, -1560198380);
146 |       v3 = local3(v3, v5, v7, v1, p1[13], 21, 1309151649);
147 |       v1 = local3(v1, v3, v5, v7, p1[4], 6, -145523070);
148 |       v7 = local3(v7, v1, v3, v5, p1[11], 10, -1120210379);
149 |       v5 = local3(v5, v7, v1, v3, p1[2], 15, 718787259);
150 |       p0[0] = local4(v1, p0[0]);
151 |       p0[1] = local4(local3(v3, v5, v7, v1, p1[9], 21, -343485551), p0[1]);
152 |       p0[2] = local4(v5, p0[2]);
153 |       p0[3] = local4(v7, p0[3]);
154 |     };
155 |     local5 = function cmn(p0, p1, p2, p3, p4, p5) {
156 |       let v0;
157 |       v0 = local4(local4(p1, p0), local4(p3, p5));
158 |       v0 = v0 << p4 | v0 >>> 32 - p4;
159 |       return local4(v0, p2);
160 |     };
161 |     local8 = "0123456789abcdef".split("");
162 |     globalThis.md5 = function md5(p0) {
163 |       return local10(local11(p0));
164 |     };
165 |     console.log("md5 of admin is ", md5("admin"));
166 |   })();


--------------------------------------------------------------------------------