Skip to content

Liquid Glass and Apple Music touches for the Spotify iOS app. A GPL-3.0 fork of spoti.pw 0.21.1.

C
9.8 KB
Raw Blame
#!/usr/bin/env python3
"""Write tweak/Sources/Shared/Flags/SGFlagList.m, the table of Spotify's remote-config flags, from a decrypted IPA.

Every generated SPT*ImplProperties class reads its flags in initWithConfigurationProvider: through
boolValueForId:defaultValue:, intValueForId:lower:upper:defaultValue: or
enumValueForId:values:defaultValue:. The keys are cstrings, the defaults are immediates in the
initializer (or in the small outlined helpers it calls), so a linear walk over the arm64 code with
the leaf calls inlined recovers key, type and default for nearly every flag.

    scripts/extract-flags.py ipa/com.spotify.client-9.1.78-Decrypted.ipa
"""
import plistlib, re, struct, subprocess, sys, tempfile, zipfile
from pathlib import Path

ROOT = Path(__file__).resolve().parent.parent
BASE = 0x100000000
SELS = {'boolValueForId:defaultValue:': 'Bool', 'intValueForId:lower:upper:defaultValue:': 'Int',
        'enumValueForId:values:defaultValue:': 'Enum'}


def extract_binary(ipa):
    tmp = Path(tempfile.mkdtemp())
    with zipfile.ZipFile(ipa) as z:
        name = next(n for n in z.namelist() if re.fullmatch(r'Payload/[^/]+\.app/Spotify', n))
        z.extract(name, tmp)
    return tmp / name


def segments(binary):
    text = subprocess.run(['otool', '-l', binary], capture_output=True, text=True).stdout
    segs = []
    for m in re.finditer(r'segname (\S+)\n\s+vmaddr 0x([0-9a-f]+)\n\s+vmsize 0x[0-9a-f]+\n\s+fileoff (\d+)\n\s+filesize (\d+)', text):
        segs.append((int(m.group(2), 16), int(m.group(3)), int(m.group(4))))
    return segs


class Binary:
    def __init__(self, path):
        self.data = open(path, 'rb').read()
        self.segs = segments(path)
        self.keys = {}
        for line in subprocess.run(['strings', '-t', 'x', '-n', '8', path], capture_output=True, text=True).stdout.splitlines():
            m = re.match(r'\s*([0-9a-f]+) (ios-[a-z0-9-]+\.[A-Za-z0-9_.-]+)$', line)
            if m:
                self.keys[BASE + int(m.group(1), 16)] = m.group(2)
        self.thunks = []
        for line in subprocess.run(['nm', '-n', path], capture_output=True, text=True).stdout.splitlines():
            m = re.match(r'^([0-9a-f]+) [tT] -\[\S+ initWithConfigurationProvider:\]$', line)
            if m:
                self.thunks.append(int(m.group(1), 16))

    def offset(self, addr):
        for vm, off, size in self.segs:
            if vm <= addr < vm + size:
                return addr - vm + off
        return None

    def insn(self, addr):
        return struct.unpack_from('<I', self.data, addr - BASE)[0]

    def cstring(self, addr):
        off = self.offset(addr)
        if off is None:
            return None
        end = self.data.find(b'\0', off, off + 256)
        s = self.data[off:end] if end > 0 else b''
        return s.decode('ascii') if s and all(32 <= c < 127 for c in s) else None

    # A selector reference is a chained-fixup pointer: the low 36 bits hold the target.
    def selector(self, addr):
        off = self.offset(addr)
        if off is None:
            return None
        target = struct.unpack_from('<Q', self.data, off)[0] & 0xFFFFFFFFF
        return self.cstring(target + BASE if target < BASE else target)


def sext(v, bits):
    return v - (1 << bits) if v & (1 << (bits - 1)) else v


def bitmask(i):
    n, immr, imms, sf = (i >> 22) & 1, (i >> 16) & 0x3f, (i >> 10) & 0x3f, (i >> 31) & 1
    if n:
        length = 6
    else:
        ni = (~imms) & 0x3f
        length = ni.bit_length() - 1
        if length < 0:
            return None
    esize = 1 << length
    levels = esize - 1
    s, r = imms & levels, immr & levels
    welem = (1 << (s + 1)) - 1
    elem = ((welem >> r) | (welem << (esize - r))) & ((1 << esize) - 1)
    v = 0
    for _ in range((64 if sf else 32) // esize):
        v = (v << esize) | elem
    return v


def decode(i, pc):
    if (i & 0x9F000000) == 0x90000000:
        return ('adrp', i & 31, (pc & ~0xfff) + (sext((((i >> 5) & 0x7FFFF) << 2) | ((i >> 29) & 3), 21) << 12))
    if (i & 0x7F800000) in (0x11000000, 0x51000000):
        imm = ((i >> 10) & 0xfff) << (12 if (i >> 22) & 1 else 0)
        return ('add', i & 31, (i >> 5) & 31, imm if (i & 0x7F800000) == 0x11000000 else -imm)
    width = 0xffffffffffffffff if i >> 31 else 0xffffffff
    if (i & 0x7F800000) == 0x52800000:
        return ('movz', i & 31, (((i >> 5) & 0xffff) << (((i >> 21) & 3) * 16)) & width)
    if (i & 0x7F800000) == 0x12800000:
        return ('movz', i & 31, ~(((i >> 5) & 0xffff) << (((i >> 21) & 3) * 16)) & width)
    if (i & 0x7F800000) == 0x72800000:
        return ('movk', i & 31, ((i >> 5) & 0xffff) << (((i >> 21) & 3) * 16), ((i >> 21) & 3) * 16)
    if (i & 0x7FE0FFE0) == 0x2A0003E0:
        return ('mov', i & 31, (i >> 16) & 31)
    if (i & 0x7F800000) == 0x32000000:
        return ('orri', i & 31, (i >> 5) & 31, bitmask(i))
    if (i & 0xFFC00000) == 0xF9400000:
        return ('ldr', i & 31, (i >> 5) & 31, ((i >> 10) & 0xfff) << 3)
    if (i & 0xFC000000) == 0x94000000:
        return ('bl', pc + sext(i & 0x3FFFFFF, 26) * 4)
    if (i & 0xFC000000) == 0x14000000:
        return ('b', pc + sext(i & 0x3FFFFFF, 26) * 4)
    if i == 0xD65F03C0:
        return ('ret',)
    if (i & 0xFFFFFC1F) == 0xD61F0000:
        return ('br',)
    return ('other',)


class Walker:
    def __init__(self, binary):
        self.bin = binary
        self.regs = {}
        self.pending = None
        self.found = []
        self.steps = 0

    def is_leaf(self, addr):
        for _ in range(40):
            i = self.bin.insn(addr)
            d = decode(i, addr)
            if (i & 0xFFC07FFF) in (0xA9007BFD, 0xA9807BFD) or d[0] == 'br':
                return False
            if d[0] in ('ret', 'b'):
                return True
            addr += 4
        return False

    def call(self):
        regs, keys = self.regs, self.bin.keys
        sel = regs.get(1)
        if isinstance(sel, tuple) and sel[1] in SELS:
            nums = [v if isinstance(v, int) else None for v in (regs.get(3), regs.get(4), regs.get(5))]
            if self.pending:
                self.found.append((self.pending, SELS[sel[1]], *nums))
            self.pending = None
        else:
            # Swift passes the key to the bridge as (string address - 0x20) | immortal bit.
            for v in regs.values():
                if isinstance(v, int) and (v in keys or v + 0x20 in keys):
                    self.pending = keys.get(v) or keys.get(v + 0x20)
                    break
        self.regs = {r: v for r, v in regs.items() if r >= 19}

    def run(self, pc, depth=0):
        regs = self.regs
        while self.steps < 8000:
            self.steps += 1
            d = decode(self.bin.insn(pc), pc)
            op = d[0]
            if op == 'adrp':
                regs[d[1]] = d[2]
            elif op == 'add':
                v = regs.get(d[2])
                regs[d[1]] = v + d[3] if isinstance(v, int) else None
            elif op == 'movz':
                regs[d[1]] = d[2]
            elif op == 'movk':
                v = regs.get(d[1])
                if isinstance(v, int):
                    regs[d[1]] = (v & ~(0xffff << d[3])) | d[2]
            elif op == 'mov':
                regs[d[1]] = 0 if d[2] == 31 else regs.get(d[2])
            elif op == 'orri':
                regs[d[1]] = d[3] if d[2] == 31 else regs.get(d[2])
            elif op == 'ldr':
                v = regs.get(d[2])
                name = self.bin.selector(v + d[3]) if isinstance(v, int) else None
                regs[d[1]] = ('sel', name) if name else None
            elif op in ('bl', 'b'):
                if op == 'b' and depth == 0:
                    return
                if depth < 3 and self.is_leaf(d[1]):
                    self.run(d[1], depth + 1)
                    regs = self.regs
                else:
                    self.call()
                    regs = self.regs
                if op == 'b':
                    return
            elif op == 'ret':
                return
            elif op == 'br':
                self.call()
                return
            pc += 4


def signed(v):
    return v - (1 << 64) if v >= 1 << 63 else v


def swift_init(binary, thunk):
    target = None
    for _ in range(40):
        d = decode(binary.insn(thunk), thunk)
        if d[0] == 'bl':
            target = d[1]
        if d[0] == 'ret':
            break
        thunk += 4
    return target


def main():
    ipa = Path(sys.argv[1])
    binary = Binary(extract_binary(ipa))
    flags = {}
    for thunk in binary.thunks:
        target = swift_init(binary, thunk)
        if not target:
            continue
        walker = Walker(binary)
        walker.run(target)
        for key, kind, a, b, c in walker.found:
            if kind == 'Bool':
                flags[key] = ('Bool', a or 0, 0, 0)
            elif kind == 'Int':
                flags[key] = ('Int', c or 0, a or 0, b or 0)
            else:
                flags[key] = ('Enum', 0, 0, 0)
    for key in binary.keys.values():
        flags.setdefault(key, ('Unknown', 0, 0, 0))
    with zipfile.ZipFile(ipa) as z:
        info = next(n for n in z.namelist() if re.fullmatch(r'Payload/[^/]+\.app/Info\.plist', n))
        version = plistlib.loads(z.read(info))['CFBundleShortVersionString']
    lines = [f'// Generated by scripts/extract-flags.py from Spotify {version}. Do not edit.',
             '#import "Flags.h"', '', 'const SGFlagDef SGFlagTable[] = {']
    for key in sorted(flags):
        kind, value, lower, upper = flags[key]
        lines.append(f'    {{"{key}", SGFlag{kind}, {signed(value)}, {signed(lower)}, {signed(upper)}}},')
    lines += ['};', 'const NSUInteger SGFlagCount = sizeof(SGFlagTable) / sizeof(*SGFlagTable);', '']
    out = ROOT / 'tweak/Sources/Shared/Flags/SGFlagList.m'
    out.write_text('\n'.join(lines))
    typed = sum(1 for f in flags.values() if f[0] != 'Unknown')
    print(f'{out.relative_to(ROOT)}: {len(flags)} flags, {typed} with a type and default')


if __name__ == '__main__':
    main()