Dekompilacja aplikacji Android napisanej w .NET MAUI 9 (Xamarin)

lib/
 ├── arm64-v8a/
 │   ├── libassemblies.arm64-v8a.blob.so
 │   ├── libmonosgen-2.0.so
 │   ├── libaot-*.so
 ├── x86_64/
 │   ├── [podobne pliki dla innej architektury]
 ├── armeabi-v7a/
 │   ├── [itd.]

$ llvm-readelf --section-headers libassemblies.arm64-v8a.blob.so
There are 11 section headers, starting at offset 0x158ade8:

Section Headers:
  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al
  [ 0]                   NULL            0000000000000000 000000 000000 00      0   0  0
  [ 1] .note.gnu.build-id NOTE           0000000000000200 000200 000024 00   A  0   0  4
  [ 2] .dynsym           DYNSYM          0000000000000228 000228 000030 18   A  5   1  8
  [ 3] .gnu.hash         GNU_HASH        0000000000000258 000258 000020 00   A  2   0  8
  [ 4] .hash             HASH            0000000000000278 000278 000018 04   A  2   0  4
  [ 5] .dynstr           STRTAB          0000000000000290 000290 000040 00   A  0   0  1
  [ 6] .dynamic          DYNAMIC         00000000000042d0 0002d0 0000b0 10  WA  5   0  8
  [ 7] .relro_padding    NOBITS          0000000000004380 000380 000c80 00  WA  0   0  1
  [ 8] .data             PROGBITS        0000000000008380 000380 000001 00  WA  0   0  1
  [ 9] .shstrtab         STRTAB          0000000000000000 000381 00005e 00      0   0  1
  [10] payload           PROGBITS        0000000000000000 004000 1586de4 00      0   0 16384
Key to Flags:
  W (write), A (alloc), X (execute), M (merge), S (strings), I (info), ...

$ llvm-objcopy --dump-section=payload=payload.bin libassemblies.arm64-v8a.blob.so

$ ls -lh payload.bin
-rw-rw-r-- 1 22572516 Mar 14 12:56 payload.bin

$ hexdump -c -n 4 payload.bin
0000000   X   A   B   A                                                
0000004

import struct

class AssemblyStoreHeader:
    def __init__(self, magic, version, entry_count, index_entry_count, index_size):
        self.magic = magic              # Sygnatura "XABA" (0x41424158)
        self.version = version          # Wersja formatu
        self.entry_count = entry_count  # Liczba bibliotek w magazynie
        self.index_entry_count = index_entry_count  # Liczba wpisów w indeksie (opcjonalne)
        self.index_size = index_size    # Rozmiar sekcji indeksu w bajtach
    
    @staticmethod
    def from_file(f):
        data = f.read(20)  # Czytamy 20 bajtów
        magic, version, entry_count, index_entry_count, index_size = struct.unpack('<5I', data)
        if magic != 0x41424158:  # Sprawdzamy sygnaturę "XABA"
            raise ValueError("Invalid magic number, not an assembly store file")
        return AssemblyStoreHeader(magic, version, entry_count, index_entry_count, index_size)

class AssemblyStoreEntryDescriptor:
    def __init__(self, mapping_index, data_offset, data_size, debug_offset, debug_size, config_offset, config_size):
        self.mapping_index = mapping_index  # Indeks mapowania (nieużywany w ekstrakcji)
        self.data_offset = data_offset      # Offset danych biblioteki
        self.data_size = data_size          # Rozmiar danych biblioteki
        self.debug_offset = debug_offset    # Offset danych debugowania (opcjonalne)
        self.debug_size = debug_size        # Rozmiar danych debugowania
        self.config_offset = config_offset  # Offset danych konfiguracyjnych (opcjonalne)
        self.config_size = config_size      # Rozmiar danych konfiguracyjnych
    
    @staticmethod
    def from_file(f):
        data = f.read(28)  # 7 pól po 4 bajty = 28 bajtów
        return AssemblyStoreEntryDescriptor(*struct.unpack('<7I', data))

def read_names(f, entry_count):
    names = []
    for _ in range(entry_count):
        name_length = struct.unpack('<I', f.read(4))[0]  # Długość nazwy w bajtach
        name = f.read(name_length).decode('utf-8')       # Odczyt nazwy
        names.append(name)
    return names

import os

def extract_assemblies(file_path, output_dir):
    os.makedirs(output_dir, exist_ok=True)
    with open(file_path, 'rb') as f:
        # Odczyt nagłówka
        header = AssemblyStoreHeader.from_file(f)
        print(f"Found {header.entry_count} assemblies in store")

        # Odczyt deskryptorów
        descriptors = [AssemblyStoreEntryDescriptor.from_file(f) for _ in range(header.entry_count)]
        
        # Przesunięcie do nazw (po pominięciu indeksu, jeśli istnieje)
        f.seek(header.index_size, 1)
        names = read_names(f, header.entry_count)

        # Ekstrakcja bibliotek
        for desc, name in zip(descriptors, names):
            f.seek(desc.data_offset)
            assembly_data = f.read(desc.data_size)
            
            # Dodajemy rozszerzenie .dll, jeśli brakuje
            if not name.endswith('.dll'):
                name += '.dll'
            
            out_path = os.path.join(output_dir, name)
            with open(out_path, 'wb') as out_file:
                out_file.write(assembly_data)
            print(f"Extracted: {out_path}")

$  hexdump -c -n 4 ./output/System.IO.FileSystem.Primitives.dll
0000000   X   A   L   Z                                                
0000004

def decompress_lz4(compressed_data):
    uncompressed_size = struct.unpack('<I', compressed_data[8:12])[0]
    compressed_payload = compressed_data[12:]
    return lz4.block.decompress(compressed_payload, uncompressed_size=uncompressed_size)