0) { $out .= str_repeat($rep, $n); } } else { $avail = $pp_end - $pp; // literal bytes; 0-fill past pp_end $real = $n < $avail ? $n : $avail; if ($real > 0) { $out .= substr($ptr_packed, $pp, $real); } if ($real < $n) { $out .= str_repeat("\0", $n - $real); } $pp += $real; } $pu += $n; } mem_write($ptr_unpacked, $out); return; } $out = str_pad(substr(Alis::$mem, $ptr_unpacked, $unpacked_sz), $unpacked_sz, "\0"); $cnt = $modpack; do { $byte = ($pp < $pp_end) ? ord($ptr_packed[$pp++]) : 0; $counter = $byte & 0x7f; if ($byte & 0x80) { // read one byte, repeat it `counter` times $rep = ($pp < $pp_end) ? $ptr_packed[$pp++] : "\0"; while ($counter--) { if ($pu >= $pu_end) { if ((--$cnt) < 1) { break; } $pu = $modpack - $cnt; } $out[$pu] = $rep; $pu += $modpack; } } else { // copy `counter` literal bytes while ($counter--) { $b = ($pp < $pp_end) ? $ptr_packed[$pp++] : "\0"; if ($pu >= $pu_end) { if ((--$cnt) < 1) { break; } $pu = $modpack - $cnt; } $out[$pu] = $b; $pu += $modpack; } } } while ($pp != $pp_end && $cnt > 0); mem_write($ptr_unpacked, substr($out, 0, $unpacked_sz)); } // ============================================================================ // MARK: - New Silmarils unpacker // ============================================================================ /** All-ones 32-bit mask (u32 values are kept unsigned on 64-bit PHP, as raw bits on 32-bit PHP). */ function unpack_mask32(): int { return PHP_INT_SIZE === 8 ? (1 << 32) - 1 : -1; } /// swap higher and lower words in long value function swap(int $val): int { return ((($val & 0xffff) << 16) | (($val >> 16) & 0xffff)) & unpack_mask32(); } /// ROTate Left Long function rotll(int $shift, int $value): int { if (($shift &= 31) == 0) { return $value; } return (($value << $shift) | (($value >> (32 - $shift)) & ((1 << $shift) - 1))) & unpack_mask32(); } function byte(int $value): int { return s8($value); } function word(int $value): int { return s16($value); } /** * Unpack ALIS script. * $ptr_packed: raw packed data (PHP string, w/o header, specs, dictionary); $ptr_unpacked: output offset * in Alis::$mem; $dictionary: 8-byte string. Returns the length of unpacked data. */ function unpack_new(string $ptr_packed, int $packed_sz, int $ptr_unpacked, int $unpacked_sz, string $dictionary): int { $M = unpack_mask32(); $HI = ~0xffff & $M; // 0xffff0000 $p = $ptr_packed; if (strlen($p) < $packed_sz + 2) { $p = str_pad($p, $packed_sz + 2, "\0"); } $dict = str_pad($dictionary, 256, "\0"); $counter = 0; $ucount = 0; // __unpack_counter $pu = 0; $uend = $unpacked_sz; $pp = 0; $pend = $packed_sz; // unpack_pend $over = 0; // unpack_over $d5 = UnpackVars::$d5 & $M; $d7 = 0; UnpackVars::$unpack_beg = $ptr_unpacked; UnpackVars::$unpack_pend = $packed_sz; // local copy of the output (+ the 1024-byte slack of the C buffers) $out = substr(Alis::$mem, $ptr_unpacked, ($uend > 0 ? $uend : 0) + 1024); $outlen = strlen($out); while ($pu < $uend) { // loop: decode(1) $b = 1; $d5 &= $HI; $d7 = ($d7 - $b) & 0xff; if ($d7 & 0x80) { $d7 = ($d7 + $b) & 0xff; if ($s = $d7 & 31) { $d5 = (($d5 << $s) | (($d5 >> (32 - $s)) & ((1 << $s) - 1))) & $M; } if ($pp < $pend) { $w = (ord($p[$pp]) << 8) | ord($p[$pp + 1]); $pp += 2; } else { $w = 0; $over++; } $d5 = (($w << 16) | ($d5 & 0xffff)) & $M; $b = ($b - $d7) & 0xff; if ($s = $b & 31) { $d5 = (($d5 << $s) | (($d5 >> (32 - $s)) & ((1 << $s) - 1))) & $M; } $d7 = (0x10 - $b) & 0xff; } else { $d5 = (($d5 << 1) | (($d5 >> 31) & 1)) & $M; } if (($d5 & 0xff) != 0) { $counter = 0; // ZMB - get number of bytes to write to output: count(2, 3) do { $b = 2; $d5 &= $HI; $d7 = ($d7 - $b) & 0xff; if ($d7 & 0x80) { $d7 = ($d7 + $b) & 0xff; if ($s = $d7 & 31) { $d5 = (($d5 << $s) | (($d5 >> (32 - $s)) & ((1 << $s) - 1))) & $M; } if ($pp < $pend) { $w = (ord($p[$pp]) << 8) | ord($p[$pp + 1]); $pp += 2; } else { $w = 0; $over++; } $d5 = (($w << 16) | ($d5 & 0xffff)) & $M; $b = ($b - $d7) & 0xff; if ($s = $b & 31) { $d5 = (($d5 << $s) | (($d5 >> (32 - $s)) & ((1 << $s) - 1))) & $M; } $d7 = (0x10 - $b) & 0xff; } else { $d5 = (($d5 << 2) | (($d5 >> 30) & 3)) & $M; } $counter = ((($counter + (($d5 & 0xffff) ^ 0x8000) - 0x8000) & 0xffff) ^ 0x8000) - 0x8000; } while (($d5 & 0xffff) == 3); // QQCH - write d2+1 unpacked bytes (do { } while (--counter != -1) on a s16) $n = (($counter + 1) & 0xffff) ?: 0x10000; $counter = -1; if ($pu + $n > $outlen) { $out .= str_repeat("\0", $pu + $n - $outlen); $outlen = strlen($out); } for ($k = 0; $k < $n; $k++) { // decode(8) $b = 8; $d5 &= $HI; $d7 = ($d7 - $b) & 0xff; if ($d7 & 0x80) { $d7 = ($d7 + $b) & 0xff; if ($s = $d7 & 31) { $d5 = (($d5 << $s) | (($d5 >> (32 - $s)) & ((1 << $s) - 1))) & $M; } if ($pp < $pend) { $w = (ord($p[$pp]) << 8) | ord($p[$pp + 1]); $pp += 2; } else { $w = 0; $over++; } $d5 = (($w << 16) | ($d5 & 0xffff)) & $M; $b = ($b - $d7) & 0xff; if ($s = $b & 31) { $d5 = (($d5 << $s) | (($d5 >> (32 - $s)) & ((1 << $s) - 1))) & $M; } $d7 = (0x10 - $b) & 0xff; } else { $d5 = (($d5 << 8) | (($d5 >> 24) & 0xff)) & $M; } $out[$pu++] = chr($d5 & 0xff); } $ucount += $n; // check unpack end if ($pu >= $uend) { break; } } // MMI: decode(3) $b = 3; $d5 &= $HI; $d7 = ($d7 - $b) & 0xff; if ($d7 & 0x80) { $d7 = ($d7 + $b) & 0xff; if ($s = $d7 & 31) { $d5 = (($d5 << $s) | (($d5 >> (32 - $s)) & ((1 << $s) - 1))) & $M; } if ($pp < $pend) { $w = (ord($p[$pp]) << 8) | ord($p[$pp + 1]); $pp += 2; } else { $w = 0; $over++; } $d5 = (($w << 16) | ($d5 & 0xffff)) & $M; $b = ($b - $d7) & 0xff; if ($s = $b & 31) { $d5 = (($d5 << $s) | (($d5 >> (32 - $s)) & ((1 << $s) - 1))) & $M; } $d7 = (0x10 - $b) & 0xff; } else { $d5 = (($d5 << 3) | (($d5 >> 29) & 7)) & $M; } // u16 bit = dictionary[byte(d5)] — PORT: a s8 index < 0 (out of bounds in C) reads 0 here $bit = ord($dict[$d5 & 0xff]); $d5 = ($d5 & $HI) | ($d5 & 3); if (($d5 & 0xffff) != 0) { $counter = $d5 & 3; } else { $counter = 0; } // decode(bit) $b = $bit & 0xff; $d5 &= $HI; $d7 = ($d7 - $b) & 0xff; if ($d7 & 0x80) { $d7 = ($d7 + $b) & 0xff; if ($s = $d7 & 31) { $d5 = (($d5 << $s) | (($d5 >> (32 - $s)) & ((1 << $s) - 1))) & $M; } if ($pp < $pend) { $w = (ord($p[$pp]) << 8) | ord($p[$pp + 1]); $pp += 2; } else { $w = 0; $over++; } $d5 = (($w << 16) | ($d5 & 0xffff)) & $M; $b = ($b - $d7) & 0xff; if ($s = $b & 31) { $d5 = (($d5 << $s) | (($d5 >> (32 - $s)) & ((1 << $s) - 1))) & $M; } $d7 = (0x10 - $b) & 0xff; } elseif ($s = $b & 31) { $d5 = (($d5 << $s) | (($d5 >> (32 - $s)) & ((1 << $s) - 1))) & $M; } if ($counter == 0) { // SNS $save_d5w = $d5 & 0xffff; $counter = 0; // CRVL: count(3, 7) do { $b = 3; $d5 &= $HI; $d7 = ($d7 - $b) & 0xff; if ($d7 & 0x80) { $d7 = ($d7 + $b) & 0xff; if ($s = $d7 & 31) { $d5 = (($d5 << $s) | (($d5 >> (32 - $s)) & ((1 << $s) - 1))) & $M; } if ($pp < $pend) { $w = (ord($p[$pp]) << 8) | ord($p[$pp + 1]); $pp += 2; } else { $w = 0; $over++; } $d5 = (($w << 16) | ($d5 & 0xffff)) & $M; $b = ($b - $d7) & 0xff; if ($s = $b & 31) { $d5 = (($d5 << $s) | (($d5 >> (32 - $s)) & ((1 << $s) - 1))) & $M; } $d7 = (0x10 - $b) & 0xff; } else { $d5 = (($d5 << 3) | (($d5 >> 29) & 7)) & $M; } $counter = ((($counter + (($d5 & 0xffff) ^ 0x8000) - 0x8000) & 0xffff) ^ 0x8000) - 0x8000; } while (($d5 & 0xffff) == 7); // CRVL2 $d5 = ($d5 & $HI) | $save_d5w; $counter = ((($counter + 4) & 0xffff) ^ 0x8000) - 0x8000; } // write_neg(word(d5), &counter): copy from the already unpacked output $offset = -(((($d5 & 0xffff) ^ 0x8000) - 0x8000)); $n = (($counter + 1) & 0xffff) ?: 0x10000; $counter = -1; if ($pu + $n > $outlen) { $out .= str_repeat("\0", $pu + $n - $outlen); $outlen = strlen($out); } $src = $pu + $offset - 1; for ($k = 0; $k < $n; $k++, $src++) { $out[$pu++] = ($src >= 0 && $src < $outlen) ? $out[$src] : "\0"; } $ucount += $n; } UnpackVars::$d5 = $d5; UnpackVars::$d7 = $d7; UnpackVars::$unpack_over = $over; UnpackVars::$__unpack_counter = $ucount; // write back what was produced (C may overrun the buffer end into its slack) $max = strlen(Alis::$mem) - $ptr_unpacked; mem_write($ptr_unpacked, substr($out, 0, $pu < $max ? $pu : $max)); return $ucount; } // ============================================================================ // MARK: - Unpacker // ============================================================================ // More zero padding than the 0xff byte buffer slack means the packed data is damaged. function unpack_damaged(string $path): int { if (UnpackVars::$unpack_over <= 0x7f) { return 0; } UnpackVars::$unpack_fatal = "Damaged script file: $path\nTry another copy of this file or check the original medium."; AlisVars::$alis_fatal = UnpackVars::$unpack_fatal; Alis::$state = C::eAlisStateStopped; return 1; } function is_packed(int $packer_kind): int { return 0; // C: (u8)packer_kind < 0 is always false } /** True when the dictionary ("new") packer is used. */ function unpack_is_new(): bool { return (Alis::$platform->version > 11 && (Alis::$typepack & 0xf0) == 0xa0) // TODO: a quick fix to make the MadShow re-release work || (Alis::$platform->version == 11 && (Alis::$typepack & 0xff) == 0xa1); } function unpack_modpack(): int { $tp = Alis::$typepack & 0xff; return Alis::$platform->kind == C::EPlatformPC ? ($tp == 0x80 ? 1 : ($tp == 0xa0 ? 2 : 8)) : ((($tp & 0x40) == 0) ? 1 : 8); } /// Unpacks a script file to buffer ($unpacked_buffer: offset in Alis::$mem). /// Returns the unpacked file size if success, a negative value if error, or zero if the input file is not packed function unpack_script(string $packed_file_path, int $unpacked_buffer): int { $ret = 0; $damaged = 0; $pfp = sys_fopen($packed_file_path, 'rb'); if ($pfp) { // get packed sz fseek($pfp, 0, SEEK_END); $packed_size = (int)ftell($pfp); rewind($pfp); $magic = fread32($pfp); $is_main = fread16($pfp) == 0; $unpacked_size = $magic & 0x00ffffff; $dict = str_repeat("\0", UnpackVars::$kPackedDictionarySize); $packed_size -= UnpackVars::$kPackedHeaderSize; // size of magic + is_main $unpacked_size -= UnpackVars::$kPackedHeaderSize; // TODO: not sure about that if ($is_main) { // skip vm specs fseek($pfp, UnpackVars::$kVMSpecsSize, SEEK_CUR); $packed_size -= UnpackVars::$kVMSpecsSize; $unpacked_size -= UnpackVars::$kVMSpecsSize; // TODO: not sure about that } if (unpack_is_new()) { // read dictionary $dict = str_pad(fread_bytes($pfp, UnpackVars::$kPackedDictionarySize), UnpackVars::$kPackedDictionarySize, "\0"); $packed_size -= UnpackVars::$kPackedDictionarySize; } // read packed bytes in alloc'd buffer (+0xff zero bytes) $packed_buffer = str_pad(fread_bytes($pfp, $packed_size), 0xff + max($packed_size, 0), "\0"); fclose($pfp); if (unpack_is_new()) { unpack_new($packed_buffer, $packed_size, $unpacked_buffer, $unpacked_size, $dict); $damaged = unpack_damaged($packed_file_path); } else { unpack_old($packed_buffer, $packed_size, $unpacked_buffer, $unpacked_size, unpack_modpack()); } $ret = $damaged ? C::EUnpackErrorFormat : s32($unpacked_size); } else { // error $ret = C::EUnpackErrorInput; } return $ret; } /** $fp: PHP stream; $unpacked_buffer: offset in Alis::$mem. */ function unpack_script_fp($fp, int $unpacked_buffer, int $unpacked_size): int { $ret = 0; if ($fp) { $packed_size = $unpacked_size; if (unpack_is_new()) { $dict = str_pad(fread_bytes($fp, UnpackVars::$kPackedDictionarySize), UnpackVars::$kPackedDictionarySize, "\0"); $packed_buffer = str_pad(fread_bytes($fp, $packed_size), 0xff + max($packed_size, 0), "\0"); unpack_new($packed_buffer, $packed_size, $unpacked_buffer, $unpacked_size, $dict); unpack_damaged('(data file)'); } else { $packed_buffer = str_pad(fread_bytes($fp, $packed_size), 0xff + max($packed_size, 0), "\0"); unpack_old($packed_buffer, $packed_size, $unpacked_buffer, $unpacked_size, unpack_modpack()); } $ret = $unpacked_size; } else { // error $ret = C::EUnpackErrorInput; } return $ret; }