ioscpy

Da fare

• https://github.com/lautarovculic/ioscpy/issues/7
• Registrazione dello schermo (con indicazione dello stato) nel pannello laterale.
• Ricerca: supporto per Windows con interfaccia grafica e installer (Riservato, l'autore implementerà completamente)
• Aggiungere autenticazione e autorizzazione, oltre a una notifica sul dispositivo che ioscpy è in esecuzione (Riservato, l'autore implementerà completamente)
• Rendere ioscpy wireless (BLE, Wi-Fi) (Riservato, l'autore implementerà completamente)
• Azioni personalizzate dei pulsanti (Macro) (In fase, concetto in arrivo)

Un'interfaccia a riga di comando per macOS, Linux e Windows che rispecchia e controlla un iPhone jailbroken tramite USB.

Con un solo dispositivo collegato, tutto ciò che serve. Si connette da solo.

Installazione

Ci sono due lati. L'app Mac esegue il mirror, il pacchetto iPhone permette di controllare il telefono. Installa entrambi.

Sul Mac, con Homebrew:

brew tap lautarovculic/ioscpy   # l'app Mac
brew trust lautarovculic/ioscpy
brew install ioscpy
ioscpy --version

Sull'iPhone jailbroken, aggiungi questo repository in Sileo o Zebra, poi installa ioscpy da esso e fai respring:

https://lautarovculic.github.io/ioscpy-repo/

Il repository contiene sia build rootless che rootful, e il gestore pacchetti sceglie quella corrispondente al jailbreak.

ioscpy --device <UDID>   # scegli un dispositivo quando ne sono collegati più di uno
ioscpy --list            # elenca i dispositivi collegati
ioscpy --no-keyboard     # nasconde la tastiera su schermo, scrivi dal Mac
ioscpy --mjpeg           # forza video MJPEG invece del predefinito H.264
ioscpy --debug           # diagnostica completa
ioscpy --version

Linux

Non esiste ancora un precompilato per Linux. Compila l'host dal sorgente. Il pacchetto dispositivo è lo stesso di macOS, installato dal repository Sileo/Zebra sopra.

Clona questo repo, poi esegui l'installer:

./install.sh

--yes salta le richieste di conferma. --prefix DIR installa in DIR invece di /usr/local e omette sudo quando la directory è sotto $HOME. --uninstall rimuove il binario installato.

Installazione manuale

Prerequisiti su Debian/Ubuntu:

sudo apt install build-essential pkg-config nasm \
                 libimobiledevice-utils usbmuxd \
                 libxkbcommon-dev libwayland-dev \
                 libxcb1-dev libxkbcommon-x11-dev
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Assicurati che usbmuxd sia in esecuzione in modo che il dispositivo venga visualizzato:

sudo systemctl enable --now usbmuxd
idevice_id -l   # dovrebbe stampare l'UDID con il telefono collegato

Compila l'host come tuo utente, poi installa:

make host-release
sudo make install-host    # installa in /usr/local/bin/ioscpy
ioscpy --version

Per Arch Linux

./install.sh funziona anche su Arch Linux.

sudo pacman -S --needed \
  base-devel pkgconf nasm \
  libimobiledevice usbmuxd \
  libxkbcommon wayland libxcb libxkbcommon-x11 \
  rustup curl git

rustup default stable

Abilita il servizio

sudo systemctl enable --now usbmuxd.service

Controlla se il dispositivo è collegato

idevice_id -l

Poi esegui il binario

cd host/target/release && chmod +x ioscpy

./ioscpy

Il passo di compilazione rimane come tuo utente così viene trovato un cargo installato da rustup. install-host è un target separato che copia solo il binario compilato, quindi funziona bene sotto sudo senza bisogno di cargo nel PATH di root. Per un'installazione senza sudo nella tua home, usa make install-host PREFIX=$HOME/.local e assicurati che $HOME/.local/bin sia nel tuo PATH.

La decodifica H.264 funziona su Linux tramite il decoder software openh264. Passa --mjpeg se preferisci il percorso MJPEG.

Su compositor Wayland che rifiutano le decorazioni lato server (GNOME/mutter), ioscpy torna automaticamente a X11/XWayland così la finestra ottiene una normale barra del titolo. Passa --wayland per rimanere su Wayland nativo invece.

Windows

Non esiste ancora un precompilato per Windows. Compila l'host dal sorgente. Il pacchetto dispositivo è lo stesso di macOS e Linux, installato dal repository Sileo/Zebra.

ioscpy su Windows riutilizza gli strumenti USB che una configurazione iOS già ha, e non sostituisce alcun driver, quindi Frida, objection, grapefruit, ideviceinfo, iTunes e qualsiasi altro strumento usbmux continuano a funzionare mentre è in esecuzione.

1. Stack USB

• Apple Mobile Device Support: installato con iTunes da apple.com (prendi la build dal sito Apple, non quella del Microsoft Store), o il pacchetto AMDS standalone. Questo fornisce il driver USB e usbmuxd. iTunes deve vedere il telefono.

• libimobiledevice-win32: fornisce iproxy.exe, idevice_id.exe, ideviceinfo.exe. Installa con Scoop:

  root@kitploit:~

  scoop install libimobiledevice
  

  o con MSYS2:

  root@kitploit:~

  pacman -S mingw-w64-x86_64-libimobiledevice
  

  Assicurati che i tre file .exe siano nel tuo PATH (o mettili accanto a ioscpy.exe). Verifica con idevice_id -l, che dovrebbe stampare il tuo UDID del dispositivo.

2. Toolchain di compilazione

• Rust con il toolchain MSVC: installa da rustup.rs.
• Visual Studio Build Tools con il carico di lavoro C++ (il decoder openh264 compila una piccola libreria C tramite cc).
• nasm nel PATH: l'assemblatore di openh264 (scoop install nasm).

3. Compila ed esegui

git clone https://github.com/lautarovculic/ioscpy
cd ioscpy
cargo build --release --manifest-path host/Cargo.toml
.\host\target\release\ioscpy.exe --list      # conferma che il dispositivo è visto
.\host\target\release\ioscpy.exe             # apre la finestra del mirror

Passa --mjpeg se preferisci il percorso MJPEG rispetto a H.264. Se openh264 non riesce a compilare, verifica che nasm sia nel PATH.

Primo tocco

Dopo un respring o una connessione fresca, dai al telefono un tocco fisico sullo schermo prima di guidarlo dall'host. iOS si fida solo degli eventi tattili che provengono dal digitizer reale, quindi quel primo tocco reale è ciò che permette il passaggio di quelli iniettati. Lo fai una volta, poi l'host prende il controllo.

Comandi

• Mouse: clicca per toccare, clicca e trascina per scorrere.
• Digitazione: i tasti vanno al campo focalizzato, in qualsiasi layout di tastiera Mac. Accenti ed emoji passano tramite gli appunti.
• Esc: torna indietro.
• Cmd+J, Cmd+L, Cmd+T, Cmd+R: Home, Blocca, Switcher app, Ruota.
• Cmd+A, Cmd+C, Cmd+V, Cmd+X, Cmd+Z: Seleziona tutto, Copia, Incolla, Taglia, Annulla. Gli appunti si sincronizzano in entrambe le direzioni, quindi Cmd+C sul telefono raggiunge il Mac.
• Invio, Backspace, Tab, frecce: i tasti di modifica corrispondenti.

Su Linux e Windows, usa Ctrl al posto di Cmd per queste scorciatoie (Ctrl+C, Ctrl+V e così via); gli appunti si sincronizzano comunque in entrambe le direzioni.

Ruotare il telefono ruota e ridimensiona il mirror.

Testato su

Host:

• Debian, KDE/Wayland
• Ubuntu 26.04, GNOME/Wayland
• Arch Linux, BSPWM
• Windows 11 x64

Dispositivi:

ioscpy è sviluppato e testato sui dispositivi sopra. Non ho un dispositivo rootful o ogni versione iOS a portata di mano, quindi la copertura per layout è incompleta:

Se esegui ioscpy su un iPhone, versione iOS o jailbreak diverso, per favore aiutaci a completare questa tabella. Soprattutto rootful e altre versioni iOS necessitano di test.

• Se funziona, aggiungi una riga con il tuo dispositivo, versione iOS, layout e framework di iniezione, e apri una pull request.
• Se fallisce, apri un issue con abbastanza dettagli per risolverlo:
  • Modello iPhone e versione iOS
  • jailbreak e layout (Dopamine, palera1n rootless o rootful, roothide)
  • framework di iniezione (ElleKit, Substitute, Substrate)
  • l'output di ioscpy --debug
  • cosa si è rotto (schermo, tocco, tastiera, appunti, installazione, ecc.)

Struttura

host/       CLI host in Rust (macOS, Linux e Windows)
device/     Pacchetto iOS (Theos): demone, ctl, tweak, jbcompat, pacchettizzazione
protocol/   Documentazione del formato wire, tenuta in sincronia con il codice
scripts/    Script di deploy sul dispositivo, respring, log e diagnostica
docs/       Architettura, compatibilità jailbreak, risoluzione problemi, rilascio

Compilazione

make host-release        # binario host macOS
make device-rootless     # .deb rootless (Dopamine, palera1n-rootless, /var/jb)
make device-rootful      # .deb rootful (palera1n-rootful, /)
make release             # host più entrambe le varianti dispositivo

Richiede Rust, Theos ($THEOS), libimobiledevice (idevice_id, iproxy), ldid e dpkg-deb.

Ambito

ioscpy serve per controllare il tuo stesso iPhone jailbroken dal tuo Mac e Linux (Debian, Ubuntu e Arch Linux), tramite cavo USB, sulla stessa scrivania.

Per host Linux, stesso requisito esterno di macOS: strumenti libimobiledevice (iproxy, idevice_id, ideviceinfo) e usbmuxd.

Ora funziona anche su Windows, riutilizzando gli strumenti USB standard di iOS senza sostituire alcun driver. È ancora SOLO per iPhone jailbroken.