Skip to content

Run a virtual iPhone on an Apple Silicon Mac.

Swift
15.0 KB
Raw Blame
@testable import FirmwarePatcher
import Foundation
import Testing
import VPhonePatchKit

@Suite("GLES point draw guards")
struct DyldSharedCacheGLESPointDrawTests {
    typealias Patcher = DyldSharedCacheGLESPointDrawPatcher
    let directBase: UInt64 = 0x4000
    let primitiveBase: UInt64 = 0x8000
    let selector: UInt64 = 0x10000
    let draw: UInt64 = 0x11000
    let fields = Patcher.Fields(pipeline: 0x898, usage: 0x8a0, encoder: 0x10)
    let indexedDraw = Patcher.IndexedDrawFields(selector: 0xde8, imp: 0xdf0)

    func decode(_ bytes: Data, at address: UInt64) -> [ARM64Instruction] {
        ARM64Disassembler().disassemble(bytes, at: address)
    }

    func setter(_ fields: Patcher.Fields) throws -> Data {
        let instructions = [
            ARM64Encoder.encodeMovX(rd: 19, rm: 0),
            try #require(ARM64Encoder.encodeBL(from: 0x2004, to: 0x12000)),
            // A later saved return value must not be confused with `this`.
            ARM64Encoder.encodeMovX(rd: 20, rm: 0),
            try #require(ARM64Encoder.encodeLdrXUnsignedOffset(rt: 2, rn: 8, offset: 0)),
            try #require(ARM64Encoder.encodeStrXUnsignedOffset(rt: 2, rn: 19, offset: UInt32(fields.pipeline))),
            try #require(ARM64Encoder.encodeLdrXUnsignedOffset(rt: 8, rn: 8, offset: 8)),
            try #require(ARM64Encoder.encodeStrXUnsignedOffset(rt: 8, rn: 19, offset: UInt32(fields.usage))),
            try #require(ARM64Encoder.encodeLdrXUnsignedOffset(rt: 0, rn: 19, offset: UInt32(fields.encoder))),
            try #require(ARM64Encoder.encodeBL(from: 0x2020, to: Int(selector))),
            try #require(ARM64Encoder.encodeLdrXUnsignedOffset(rt: 8, rn: 19, offset: UInt32(fields.usage))),
            ARM64.ret,
        ]
        return instructions.reduce(into: Data()) { $0 += $1 }
    }

    struct Fixture {
        var direct: Data
        var primitive: Data
        let directSites: [Int]
        let primitiveSite: Int
    }

    func fixture(fields: Patcher.Fields? = nil, mode: UInt32 = 0x178) throws -> Fixture {
        let fields = fields ?? self.fields
        func block(at start: Int, primitive: Bool, interveningLoads: Bool) throws -> (Data, Int) {
            // Preserve the two intervening index-buffer loads on the EBO path.
            let extra = interveningLoads ? 8 : 0
            let guardOffset = 20 + extra + (primitive ? 4 : 0)
            let end = start + guardOffset + 16
            var bytes = try #require(ARM64Encoder.encodeLdrXUnsignedOffset(rt: 8, rn: 19, offset: UInt32(fields.pipeline)))
            bytes += try #require(ARM64Encoder.encodeCompareBranch(nonzero: false, register: 8, from: start + 4, to: end, width64: true))
            if interveningLoads {
                bytes += try #require(ARM64Encoder.encodeLdrXUnsignedOffset(rt: 8, rn: 27, offset: 24))
                bytes += try #require(ARM64Encoder.encodeLdrXUnsignedOffset(rt: 27, rn: 8, offset: 0))
            }
            if primitive {
                bytes += try #require(ARM64Encoder.encodeTestBitBranch(nonzero: true, register: 22, bit: 0, from: start + bytes.count, to: end))
            }
            bytes += try #require(ARM64Encoder.encodeLdrBUnsignedOffset(rt: 8, rn: 19, offset: mode))
            bytes += try #require(ARM64Encoder.encodeTestBitBranch(nonzero: false, register: 8, bit: 0, from: start + bytes.count, to: start + guardOffset + 4))
            bytes += try #require(ARM64Encoder.encodeLdrBUnsignedOffset(rt: 8, rn: 19, offset: UInt32(fields.usage)))
            #expect(bytes.count == guardOffset)
            bytes += try #require(ARM64Encoder.encodeTestBitBranch(nonzero: false, register: 8, bit: 7, from: start + bytes.count, to: end))
            bytes += try #require(ARM64Encoder.encodeLdrXUnsignedOffset(rt: 0, rn: 19, offset: UInt32(fields.encoder)))
            bytes += try #require(ARM64Encoder.encodeBL(from: start + bytes.count, to: Int(draw)))
            bytes += ARM64.nop
            bytes += ARM64.ret
            return (bytes, guardOffset)
        }
        // An early RET is deliberate: discovery must use the symbol span and
        // inspect the later draw paths, as the real direct callback requires.
        var direct = ARM64Encoder.encodeMovX(rd: 19, rm: 0) + ARM64.ret
        var directSites: [Int] = []
        for path in 0 ..< 3 {
            let start = direct.count
            let (bytes, site) = try block(at: Int(directBase) + start, primitive: false, interveningLoads: path == 1)
            directSites.append(start + site)
            direct += bytes
        }
        var primitive = ARM64Encoder.encodeMovX(rd: 19, rm: 0)
        let (bytes, site) = try block(at: Int(primitiveBase) + primitive.count, primitive: true, interveningLoads: false)
        let primitiveSite = primitive.count + site
        primitive += bytes
        return .init(direct: direct, primitive: primitive, directSites: directSites, primitiveSite: primitiveSite)
    }

    func plan(_ fixture: Fixture, fields: Patcher.Fields? = nil) throws -> Patcher.Plan {
        try Patcher.plan(direct: decode(fixture.direct, at: directBase), primitive: decode(fixture.primitive, at: primitiveBase),
                         fields: fields ?? self.fields, indexedDraw: indexedDraw, drawTargets: [draw])
    }

    @Test func `derives context layout from the actual pipeline call`() throws {
        #expect(try Patcher.pipelineFields(in: decode(setter(fields), at: 0x2000), selector: selector) == fields)
        let relocated = Patcher.Fields(pipeline: 0x280, usage: 0x288, encoder: 0x28)
        #expect(try Patcher.pipelineFields(in: decode(setter(relocated), at: 0x2000), selector: selector) == relocated)
        #expect(try plan(fixture(fields: relocated, mode: 0x90), fields: relocated).sites.count == 4)
        var wrong = try setter(fields)
        wrong.replaceSubrange(12 ..< 16, with: try #require(ARM64Encoder.encodeLdrXUnsignedOffset(rt: 3, rn: 8, offset: 0)))
        #expect(throws: (any Error).self) { try Patcher.pipelineFields(in: decode(wrong, at: 0x2000), selector: selector) }
        wrong = try setter(fields)
        wrong.replaceSubrange(36 ..< 40, with: try #require(ARM64Encoder.encodeLdrXUnsignedOffset(rt: 8, rn: 19, offset: 0x900)))
        #expect(throws: (any Error).self) { try Patcher.pipelineFields(in: decode(wrong, at: 0x2000), selector: selector) }
        #expect(throws: (any Error).self) { try Patcher.pipelineFields(in: decode(setter(fields), at: 0x2000), selector: selector + 4) }
    }

    @Test func `uses the next symbol rather than an early return`() throws {
        let fixture = try fixture()
        let end = directBase + UInt64(fixture.direct.count)
        #expect(try Patcher.functionSpan(at: directBase, symbolAddresses: [directBase, directBase, end, end + 4]) == directBase ..< end)
        #expect(try plan(fixture).sites.count == 4)
        #expect(throws: (any Error).self) { try Patcher.functionSpan(at: directBase, symbolAddresses: [directBase]) }
        #expect(throws: (any Error).self) { try Patcher.functionSpan(at: directBase, symbolAddresses: [directBase + 65540]) }
        #expect(throws: (any Error).self) { try Patcher.functionSpan(at: directBase, symbolAddresses: [directBase + 3]) }
        let truncated = Fixture(direct: Data(fixture.direct.prefix(8)), primitive: fixture.primitive,
                                directSites: [], primitiveSite: fixture.primitiveSite)
        #expect(throws: (any Error).self) { try plan(truncated) }
    }

    @Test func `derives indexed IMP slots from the named selector and method lookup`() throws {
        let lookup: UInt64 = 0x12000
        let literalAddress: UInt64 = 0x307b4
        let literal = Data((Patcher.indexedDrawSelector + "\0").utf8)
        func setup(_ slots: Patcher.IndexedDrawFields) throws -> Data {
            let instructions = [
                ARM64Encoder.encodeMovX(rd: 19, rm: 0),
                try #require(ARM64Encoder.encodeLdrXUnsignedOffset(rt: 0, rn: 19, offset: UInt32(fields.encoder))),
                try #require(ARM64Encoder.encodeADRP(rd: 8, pc: 0x2008, target: literalAddress)),
                try #require(ARM64Encoder.encodeAddImm12(rd: 2, rn: 8, imm12: UInt32(literalAddress & 0xfff))),
                try #require(ARM64Encoder.encodeStrXUnsignedOffset(rt: 2, rn: 19, offset: UInt32(slots.selector))),
                try #require(ARM64Encoder.encodeBL(from: 0x2014, to: Int(lookup))),
                try #require(ARM64Encoder.encodeStrXUnsignedOffset(rt: 0, rn: 19, offset: UInt32(slots.imp))),
                ARM64.ret,
            ]
            return instructions.reduce(into: Data()) { $0 += $1 }
        }
        func discover(_ bytes: Data, text: Data? = nil) throws -> Patcher.IndexedDrawFields {
            try Patcher.indexedDrawFields(in: decode(bytes, at: 0x2000), fields: fields, methodForSelector: lookup) { address, count in
                #expect(address == literalAddress)
                #expect(count == literal.count)
                return text ?? literal
            }
        }
        #expect(try discover(setup(indexedDraw)) == indexedDraw)
        let relocated = Patcher.IndexedDrawFields(selector: 0x380, imp: 0x388)
        #expect(try discover(setup(relocated)) == relocated)
        // An equally shaped cached method with another selector is not a draw.
        #expect(throws: (any Error).self) { try discover(setup(indexedDraw), text: Data("setVertexBuffer:offset:atIndex:\0".utf8)) }
        #expect(throws: (any Error).self) { try discover(setup(indexedDraw), text: Data(literal.dropLast())) }
        let mutations: [(Int, Data)] = [
            (4, try #require(ARM64Encoder.encodeLdrXUnsignedOffset(rt: 0, rn: 19, offset: 0x28))),
            (12, try #require(ARM64Encoder.encodeAddImm12(rd: 3, rn: 8, imm12: UInt32(literalAddress & 0xfff)))),
            (20, try #require(ARM64Encoder.encodeBL(from: 0x2014, to: Int(lookup + 4)))),
            (24, try #require(ARM64Encoder.encodeStrXUnsignedOffset(rt: 1, rn: 19, offset: UInt32(indexedDraw.imp)))),
            (24, try #require(ARM64Encoder.encodeStrXUnsignedOffset(rt: 0, rn: 19, offset: UInt32(indexedDraw.imp + 8)))),
        ]
        for (offset, replacement) in mutations {
            var wrong = try setup(indexedDraw)
            wrong.replaceSubrange(offset ..< offset + 4, with: replacement)
            #expect(throws: (any Error).self) { try discover(wrong) }
        }
    }

    @Test func `requires all four original guards or all four exact NOPs`() throws {
        let original = try fixture()
        let initial = try plan(original)
        #expect(!initial.alreadyPatched)
        #expect(initial.sites.map(\.address) == original.directSites.map { directBase + UInt64($0) } + [primitiveBase + UInt64(original.primitiveSite)])
        for count in 1 ... 4 {
            var changed = original
            for site in original.directSites.prefix(count) { changed.direct.replaceSubrange(site ..< site + 4, with: ARM64.nop) }
            if count == 4 { changed.primitive.replaceSubrange(changed.primitiveSite ..< changed.primitiveSite + 4, with: ARM64.nop) }
            if count < 4 {
                #expect(throws: (any Error).self) { try plan(changed) }
            } else {
                #expect(try plan(changed).alreadyPatched)
                #expect(try plan(changed).sites.map(\.address) == initial.sites.map(\.address))
            }
        }
    }

    @Test func `refuses stale flags mode pipeline skip and draw shapes`() throws {
        let original = try fixture()
        let site = original.directSites[0]
        let address = Int(directBase) + site
        let skip = try #require(try plan(original).sites.first?.skip)
        let mutations: [(Int, Data)] = [
            (site, try #require(ARM64Encoder.encodeTestBitBranch(nonzero: false, register: 8, bit: 6, from: address, to: Int(skip)))),
            (site, try #require(ARM64Encoder.encodeTestBitBranch(nonzero: false, register: 8, bit: 7, from: address, to: Int(skip) - 4))),
            (site - 4, try #require(ARM64Encoder.encodeLdrBUnsignedOffset(rt: 8, rn: 19, offset: 0x900))),
            (site - 8, try #require(ARM64Encoder.encodeTestBitBranch(nonzero: false, register: 8, bit: 1, from: address - 8, to: address + 4))),
            (site - 12, try #require(ARM64Encoder.encodeLdrBUnsignedOffset(rt: 8, rn: 19, offset: 0x188))),
            (site - 20, try #require(ARM64Encoder.encodeLdrXUnsignedOffset(rt: 8, rn: 19, offset: 0x900))),
            (site + 8, ARM64.ret),
        ]
        for (offset, replacement) in mutations {
            var changed = original
            changed.direct.replaceSubrange(offset ..< offset + 4, with: replacement)
            #expect(throws: (any Error).self) { try plan(changed) }
        }
        var wrongPrimitive = original
        let gate = original.primitiveSite - 16
        wrongPrimitive.primitive.replaceSubrange(gate ..< gate + 4, with: ARM64.nop)
        #expect(throws: (any Error).self) { try plan(wrongPrimitive) }
    }

    @Test func `recognizes the real authenticated indexed draw call`() throws {
        // Frozen 23G90 input at renderer __TEXT + 0x145cc. This is the
        // existing call sequence, not generated replacement instructions.
        let words: [UInt32] = [
            0xf9400a60, 0xd0000028, 0x9117e108, 0xf8765902,
            0x93407ea3, 0xa94093e6, 0x93407e87, 0xf946fa68,
            0xf946f661, 0xaa1703e5, 0xd63f091f,
        ]
        let bytes = words.reduce(into: Data()) { $0 += ARM64.encodeU32($1) }
        #expect(Patcher.containsDraw(decode(bytes, at: directBase), context: .x(19), fields: fields, indexedDraw: indexedDraw, drawTargets: []))
        var wrong = bytes
        wrong.replaceSubrange(32 ..< 36, with: try #require(ARM64Encoder.encodeLdrXUnsignedOffset(rt: 1, rn: 20, offset: 0xde8)))
        #expect(!Patcher.containsDraw(decode(wrong, at: directBase), context: .x(19), fields: fields, indexedDraw: indexedDraw, drawTargets: []))
        // A different adjacent selector/IMP pair can have exactly the same
        // calling shape; it must not satisfy this guard's draw proof.
        wrong = bytes
        wrong.replaceSubrange(28 ..< 32, with: try #require(ARM64Encoder.encodeLdrXUnsignedOffset(rt: 8, rn: 19, offset: 0xde0)))
        wrong.replaceSubrange(32 ..< 36, with: try #require(ARM64Encoder.encodeLdrXUnsignedOffset(rt: 1, rn: 19, offset: 0xdd8)))
        #expect(!Patcher.containsDraw(decode(wrong, at: directBase), context: .x(19), fields: fields, indexedDraw: indexedDraw, drawTargets: []))
        wrong = bytes
        wrong.replaceSubrange(0 ..< 4, with: ARM64.nop)
        #expect(!Patcher.containsDraw(decode(wrong, at: directBase), context: .x(19), fields: fields, indexedDraw: indexedDraw, drawTargets: []))
        // A call after an unconditional return is not a draw on this path.
        wrong = bytes
        wrong.replaceSubrange(4 ..< 8, with: ARM64.ret)
        #expect(!Patcher.containsDraw(decode(wrong, at: directBase), context: .x(19), fields: fields, indexedDraw: indexedDraw, drawTargets: []))
        wrong = bytes
        wrong.replaceSubrange(16 ..< 20, with: ARM64Encoder.encodeMovX(rd: 0, rm: 19))
        #expect(!Patcher.containsDraw(decode(wrong, at: directBase), context: .x(19), fields: fields, indexedDraw: indexedDraw, drawTargets: []))
    }
}