Instructions for creating a custom pak repack tool, regardless of file size

1. Preserve Base Data:

- The tool reads the .pak file structure to determine the exact end point of the

Data Block and the beginning point of the Index Table.

- It preserves all data from byte 0x0 up to just before the Index Table.

2. Append Modified Files:

- If a file is modified (e.g., BRPlayerCharacterBase.lua), the tool will compress (ZLIB/ZSTD) and encrypt (AES/SM4) this file in RAM.

- Then, it directly applies this compressed data block immediately after the old data block (overwriting the old Index Table).

- The new offset of this file will be recorded.

3. Index Modification:

- Load the old Index table into RAM.

- Locate the entry (Entry) of the newly modified and updated file:

- Offset = New coordinates inserted in step 2.

- Size & Uncompressed Size = New size.

- Content Hash = New hash of the file.

4. Finalize the New Index Table & Security Key:

- The new Index table (containing the updated coordinates) will be encrypted using AES-CBC with a valid key.

- Write this Index table immediately after the inserted data.

- Create a standard RSA block (containing a valid AES Key & IV so the game can decrypt it).

- Write the final 45 bytes of the footer pointing to the new Index Table coordinates and RSA

1. IDENTIFY THE LOCATION OF THE INDEX TABLE

2. COMPRESS THE REPACK FILE => ENCODE => CHUNK

3. INSERT THE FILE DIRECTLY INTO THE INDEX TABLE LOCATION TO PUSH THE ENTIRE INDEX BLOCK DOWN

4. UPDATE THE INDEX POINTING TO THE OFFSET OF THE NEWLY INSERTED FILE

🔥THIS METHOD WILL COMPLETELY BYPASS ANTI-CHEAT SYSTEMS THAT SCAN STATIONARY HASH FILES WITHOUT FIRWWALL NEEDED

def repack_inject(self, repack_dir: PurePath, target_pak_path: Path):
 
        footer_len = TencentPakInfo._mem_size(self._pak_info.version)
        with open(target_pak_path, 'rb') as f:
            f.seek(-footer_len, os.SEEK_END)
            original_footer = bytearray(f.read(footer_len))
        with open(target_pak_path, 'a+b') as target_file:
            
            for dir_path, dir_content in self._index.items():
                for file_name, entry in dir_content.items():
                    
                    selected_path = None
                    if is_auto_scan:
                        candidates = user_files_map.get(file_name)
                        if candidates: selected_path = candidates[0] 
                    else:
                        check_path = repack_base_path / dir_path / file_name
                        if check_path.exists(): selected_path = check_path

                    if not selected_path:
                        continue

                    files_processed_count += 1
                    internal_pak_path = dir_path / file_name                    
                    try:                        
                        with open(selected_path, 'rb') as f_modified:
                            raw_data = f_modified.read()

                        entry.content_hash = SHA1.new(raw_data).digest()
                        entry.uncompressed_size = len(raw_data)
                        entry.compression_method = CM_ZLIB
                        entry.encryption_method = 44
                        entry.encrypted = True
                        entry.compression_block_size = 65536  
                        
                        target_file.seek(0, os.SEEK_END)
                        entry.offset = target_file.tell()
                        
                        entry.compressed_blocks = []
                        total_compressed_size = 0
                        
                        chunks = [raw_data[i:i+entry.compression_block_size] for i in range(0, len(raw_data), entry.compression_block_size)]
                        
                        for i, chunk in enumerate(chunks):
 
                            comp_chunk = zlib.compress(chunk, level=9)
                            enc_chunk = PakCrypto.encrypt_block(comp_chunk, internal_pak_path, entry.encryption_method)
                            
                            start_offset = target_file.tell()
                            target_file.write(enc_chunk)
                            end_offset = target_file.tell()
                            
                            block = PakCompressedBlock.new(PakCompressedBlock)
                            block.start = start_offset
                            block.end = end_offset
                            entry.compressed_blocks.append(block)
                            
                            total_compressed_size += (end_offset - start_offset)
                            sys.stdout.flush()

                        entry.size = total_compressed_size
                        repacked_success_list.append(file_name)

            if files_processed_count == 0: 
                return False 
            raw_new_index = self._pack_index()            
            if self._pak_info.index_encrypted:
                if self._pak_info.version > 7:
                    aes_key = PakCrypto.rsa_extract(self._pak_info.packed_key, RSA_MOD_1)
                    aes_iv = PakCrypto.rsa_extract(self._pak_info.packed_iv, RSA_MOD_1)
                    aes = AES.new(aes_key, MODE_CBC, aes_iv[:16])
                    enc_new_index = aes.encrypt(pad(raw_new_index, AES.block_size))
                else:
                    enc_new_index = PakCrypto._encrypt_simple1(raw_new_index)
            else:
                enc_new_index = raw_new_index

Here's a sample for your reference.