Glass

au sens de transparent et lisse

Un désassembleur interactif rapide, natif et pensé d’abord pour les applications mobiles. Successeur spirituel d’IDA Pro pour le workflow de rétro-ingénierie Android / iOS, construit autour de :

• smali pour la gestion des APK / DEX / smali
• armv8-encode pour AArch64 et ARMv7 (A32 / Thumb) — .so natifs, Mach-O iOS
• gpui (Zed) pour l’interface native accélérée par GPU
• redb pour la persistance adressée par contenu
• Un serveur MCP intégré pour que tout hôte compatible MCP (Claude Desktop, Cursor, Zed) puisse piloter Glass directement
• rquickjs pour des plugins scriptables (prévu)

Licence : GPL-3.0-only (héritée de smali).

Pourquoi ?

Nous avons tous utilisé IDA Pro — c’est la référence du secteur pour la rétro-ingénierie, avec des années de plugins derrière lui, mais c’est lent, cher et daté. Glass est 100 % natif en Rust avec une interface accélérée par GPU pour une interaction fluide. C’est aussi 100 % gratuit et open source — contribuez.

Fonctionnalités

• Rendu accéléré par GPU incroyablement fluide à 120 fps
• Analyse éclair : 1 à 2 secondes pour la plupart des binaires volumineux, contre des minutes sur IDA Pro
• Désassemblage AArch64 et ARMv7 (mode ARM + Thumb) — couvre iOS arm64 / arm64e et les deux ABI Android courantes.
• Désassemblages entièrement reliés et annotés, avec lignes de flux de contrôle, littéraux de données dans les commentaires, liens cliquables vers d’autres fonctions. Le tout coloré pour une visibilité aisée.
• Graphes de flux de contrôle montrant les blocs de base et des liens cliquables vers d’autres fonctions
• Recherche complète dans le projet des symboles ou des littéraux de chaînes dans les sections DEX, code et données
• Vue d’ensemble de la disposition des binaires natifs avec les données de section
• Recherche Xref des appelants, références vers des données
• Recherche binaire et d’instructions dans tous les artefacts natifs du bundle (les copies arm64-v8a et armeabi-v7a d’une bibliothèque sont donc cherchées en une seule requête). Grammaire de motifs d’octets avec masquage + intervalles ; grammaire d’assembleur typée pour AArch64 et ARMv7, avec une liste déroulante d’autocomplétion tenant compte de l’ISA.
• Annotez n’importe quelle ligne (code ou données) avec une couleur et/ou un commentaire afin de la retrouver facilement plus tard.
• Édition sur place des instructions et des données (double-cliquez sur un élément). Éditeur de classes Smali + éditeur d’instructions AArch64 / ARMv7 ; clic droit sur n’importe quelle ligne du listing pour ouvrir une vue hexadécimale au niveau octet à la même adresse, comme échappatoire.
• Le serveur MCP expose chaque verbe d’analyse comme outil pour tout hôte compatible MCP — Claude Desktop, Cursor, Zed.
• Thèmes pour Glass ainsi que des couleurs d’arrière-plan sélectionnables pour chaque espace de travail.

Captures d’écran

Un parcours des vues principales — cliquez sur n’importe quelle vignette pour la voir en taille réelle.

Script

Chaque analyse que Glass effectue dans l’interface graphique est également exposée comme verbe CLI émettant du JSON structuré. Le même binaire glass est le point d’entrée de l’automatisation — choisissez une sous-commande et vous obtenez un résultat ponctuel et scriptable, parfait pour les pipelines jq et l’intégration continue.```sh

What classes ship in this APK?

glass classes ./app.apk --package com.example. --text

Who calls glass::main, by address?

glass callers ./libfoo.so --artifact libfoo.so --symbol "glass::main"

Every onCreate across DEX, machine-readable:

glass search ./app.apk onCreate | jq '.data.hits[] | select(.kind=="method")'

All ObjC + Swift types in an iOS bundle (filter by kind if you like):

glass types ./app.ipa --kind swift-class --text

Drill into one type — methods, ivars, properties for ObjC;

fields + vtable for Swift:

glass type ./app.ipa --artifact app --name blackjack.ContentView

Passez `--text` pour un rendu lisible par un humain, omettez-le pour le JSON.

Référence complète : **[docs/cli-api.md](https://github.com/azw413/glass/blob/HEAD/docs/cli-api.md)**.

Cela signifie que vous pouvez scripter et automatiser les opérations courantes.


## Compétences et MCP

Chaque verbe CLI est également exposé en tant qu'outil via un serveur MCP (Model Context Protocol) intégré, de sorte que tout hôte compatible MCP — Claude Desktop, Cursor, Zed, votre propre client — peut piloter Glass directement pour aider aux tâches de rétro-ingénierie.```sh
# Print the machine-readable skill catalog (one JSON object listing
# every verb with its schema and an example invocation).
glass skills

# Run as an MCP stdio server. Plug into any MCP host's tool list.
glass mcp

Pour enregistrer Glass auprès de Claude Desktop, ajoutez Glass à ~/Library/Application Support/Claude/claude_desktop_config.json:```json { "mcpServers": { "glass": { "command": "/usr/local/bin/glass", "args": ["mcp"] } } }

Le modèle peut ensuite appeler `inspect`, `symbols`, `disasm`, `cfg-of`, `dex-callers`, `search` et tous les autres verbes sur n'importe quel bundle que vous lui désignez. Les résultats des outils reviennent dans la même enveloppe JSON que celle que vous obtiendriez avec la CLI.


## Recherche

Trois moteurs complémentaires, tous disponibles depuis la même palette ⌘F de l'interface graphique et en tant que verbes CLI / MCP.

### Recherche en texte intégral

Correspondance floue à l'échelle du bundle entre les symboles natifs, les classes / méthodes / champs DEX et les littéraux de chaîne dans les sections de code et de données. Filtrage en direct pendant la saisie ; les résultats sont acheminés vers la vue appropriée (listing pour les adresses natives, visionneuse smali pour les cibles DEX, vue hexadécimale pour les correspondances de données). Les index sont construits sur un thread d'arrière-plan après le chargement — une pastille de progression s'affiche pendant l'opération.```sh
glass search ./app.apk onCreate                 # all things named like "onCreate"
glass search ./libfoo.so init --limit 20

Référence CLI : verbe search dans docs/cli-api.md.

Recherche binaire

Moteur de motifs au niveau octet. Chaque atome est un masque hexadécimal de 2 caractères (c0, e?, ?f, ??) ou un écart (* = 0..=32 octets, *(min..max) pour des bornes explicites). Les correspondances ne traversent pas les sections. Dans la palette de l'interface graphique, ⌘2 bascule en mode binaire ; la case Code only (activée par défaut) limite l'analyse aux sections de texte afin de ne pas être submergé par les résultats de données lorsqu'on recherche une forme d'instruction.```sh

returning-true stub finder — mov w0, #1 ; ret

glass bin-search ./libfoo.so --artifact libfoo.so --pattern '20 00 80 52 c0 03 5f d6'

any ADRP+ADD pair with no intervening bytes

glass bin-search ./libfoo.so --artifact libfoo.so --pattern '?? ?? ?? 9? ?? ?? 4? 91'

raw data: find embedded magic

glass bin-search ./libfoo.so --artifact libfoo.so --pattern 'de ad be ef'

Grammaire complète + exemples détaillés : [`docs/BinSearch.md`](https://github.com/azw413/glass/blob/HEAD/docs/BinSearch.md).

### Recherche d'instructions

Écrivez le code assembleur, Glass le compile en octets. Une séquence séparée par `;` est encodée via [armv8-encode](https://github.com/azw413/armv8-encode) — **AArch64** (`mov w0, #1`, `adrp x1, *`) et **ARMv7** dans les deux modes (Thumb `mov r1, r7` / `bxeq lr` / `push {r4-r7, lr}` et A32). Tous les jokers sont traduits en masques de bits d'opérande avant que le moteur d'octets ne prenne le relais. L'analyse est globale — chaque artefact natif du bundle reçoit les atomes de la bonne ISA (les applications Android contenant à la fois des bibliothèques `arm64-v8a` et `armeabi-v7a` sont recherchées en une seule requête).

Dans le mode binaire de l'interface graphique, ⌘B bascule entre les grammaires **Bytes** et **Asm** ; une liste déroulante d'autocomplétion sensible à l'ISA affiche les variantes qui correspondent encore à ce que vous avez saisi — `r1` filtre les candidats AArch64, `w0` filtre ceux ARMv7.

Jokers :

| Jeton | Signification |
|---|---|
| `*` | tout opérande (type déduit de l'opcode choisi) |
| `#*` | tout immédiat (suggère le sélecteur d'opcode) |
| `x`, `w` | tout registre AArch64 de classe X ou W |
| `r` | tout GPR ARMv7 (`r0..r15`, `sp`, `lr`, `pc`) |
| `<*>`, `<X>`, `<W>`, `<R>`, `<imm>` | équivalents entre chevrons, utiles imbriqués dans d'autres syntaxes (`[x, #*]`, `[r, #*]`) |```sh
# AArch64 — every `mov w0, #N` (any N)
glass insn-search ./libfoo.so --artifact libfoo.so --pattern 'mov w0, #*'

# AArch64 — any ADRP into x1 followed immediately by ADD into the same reg
glass insn-search ./libfoo.so --artifact libfoo.so --pattern 'adrp x1, * ; add x1, x1, #*'

# ARMv7 (Thumb) — `mov r1, r*` followed by a return
glass insn-search ./libfoo.so --artifact libfoo.so --pattern 'mov r1, r* ; bx lr'

# ARMv7 (any cond) — conditional bx in literal-pool callers
glass insn-search ./libfoo.so --artifact libfoo.so --pattern 'bxeq lr'

# every `ret x30` — concrete, no wildcards
glass insn-search ./libfoo.so --artifact libfoo.so --pattern 'ret'

La réponse contient bytes_hex affichant le masque compilé (par ex. 01/1f ?? ?? 90/9f pour adrp x1, *) afin que vous puissiez voir exactement quels bits sont épinglés par rapport aux jokers. Les captures (<name:kind> référençant la même opérande plus loin dans le motif) sont conçues mais pas encore implémentées.

Conception complète + phasage : docs/InsnPattern.md. Référence CLI/MCP : insn-search dans docs/cli-api.md.

Statut actuel

Glass est utilisable aujourd'hui pour le reverse engineering d'applications Android (APK / DEX / .so natif) et iOS (IPA / Mach-O) ciblant AArch64 et ARMv7 32 bits (bibliothèques armeabi-v7a, A32 + Thumb).

Ce qui fonctionne

Chargement de fichiers

• Ouvrez directement les bundles Android (.apk, .aab), les bundles iOS (.ipa) ou tout binaire ELF / Mach-O autonome (.so, .dylib, exécutables bruts) — Glass détecte automatiquement le format.
• Le Mach-O gras / universel est géré de manière transparente : arm64e est privilégié, arm64 classique est la solution de repli. Fonctionne aussi bien sur les bundles que sur les fichiers autonomes (par ex. glass gui /usr/lib/dyld).
• Le pipeline de chargement affiche la progression (Lecture de l'archive → Analyse DEX / Désassemblage natif → Construction des symboles).
• Identifiants par artefact adressés par contenu (blake3, rayon-parallel pour les grosses bibliothèques). Les annotations suivent l'artefact, pas le conteneur — le même libfoo.so embarqué dans deux APK (ou le même libswiftCore.dylib dans deux IPA) partage l'état d'analyse.
• Visionneuse AndroidManifest (XML binaire décodé via smali).
• Visionneuse Info.plist pour les bundles iOS — identifiant du bundle, nom de l'exécutable, version, OS minimum, et le reste du plist rendu en XML à code couleur.

iOS — IPA / Mach-O

• Décompressez l'IPA, localisez Payload/*.app/, analysez Info.plist et choisissez la tranche arm64 / arm64e dans tout binaire gras présent.
• L'exécutable principal et chaque Frameworks/*.framework + *.dylib sont chargés comme leur propre artefact natif, avec les mêmes vues Vue d'ensemble + désassemblage par section que pour les fichiers .so Android.
• Navigateur de classes Objective-C issu de __objc_classlist — classes, catégories, méthodes, ivars, propriétés — avec noms démasqués (mangling Swift _TtC... hérité inclus) et sauts cliquables depuis les adresses de méthodes vers le listing.
• Navigateur de types Swift issu de __swift5_types — classes, structures, énumérations avec leurs champs et (pour les classes) les vtables, également cliquables vers le listing.
• Carte des symboles enrichie avec les symboles de méthodes ObjC et les symboles de types Swift, de sorte que les lignes du listing qui retombaient sur des adresses brutes affichent maintenant des noms résolus.

Android — APK / DEX / natif

• Arborescence des classes sur l'ensemble des fichiers DEX de l'APK.
• Listing Smali par classe avec tokenisation sensible à la syntaxe (directives, types, noms de méthodes, littéraux de chaînes, etc.).
• Les références croisées de méthodes résolvent la bonne classe + ligne.
• Les fichiers .so natifs sous lib/<abi>/ sont chargés par ABI ; AArch64 (arm64-v8a) et ARMv7 (armeabi-v7a) obtiennent tous deux des vues de désassemblage complètes. Les autres ABI (x86 / x86_64) sont routées vers la vue hexadécimale jusqu'à ce qu'un décodeur soit disponible.

Édition

• Éditeur de classes Smali (double-cliquez sur un en-tête / champ / méthode de classe pour ouvrir des éditeurs en ligne).
• Édition d'instructions AArch64 en place : tapez le nouvel assemblage, Glass le ré-encode en octets ; les modifications en attente apparaissent avec une teinte verte dans le listing jusqu'à ce que vous exportiez vers un nouvel APK / IPA.
• Édition en place ARMv7 : gère les remplacements de même largeur, les réductions de 4 octets → 2 octets (rembourrage automatique avec un NOP Thumb-1) et les extensions de 2 octets → 4 octets qui consomment un NOP suivant. Refuse les extensions non sûres qui déplaceraient le code en aval.
• Autocomplétion sensible à l'ISA dans l'éditeur en ligne — taper r1 n'affiche que les variantes ARMv7 ; w0 n'affiche que l'AArch64.
• Clic droit sur n'importe quelle ligne du listing → Ouvrir la vue hexadécimale ici pour passer à un éditeur hexadécimal au niveau octet à la même adresse lorsque l'éditeur d'assemblage typé ne peut pas exprimer ce dont vous avez besoin.

AArch64 natif (ELF + thin Mach-O)

• Désassemblage par balayage linéaire avec rendu virtualisé — les grandes bibliothèques s'ouvrent en quelques secondes, pas en quelques minutes.
• Carte des symboles fusionnée à partir de la symtab ELF, dynsym, DWARF, des FDE .eh_frame et des entrées <name>@plt synthétisées. Démangling C++/Rust/Swift via symbolic-demangle.
• Les opérandes de branchement sont rendus sous forme de références de symboles cliquables ; les paires adrp + add/ldr sont résolues vers des cibles de données, y compris les littéraux de chaînes affichés en ligne sous forme de commentaires.
• Vues par section (les sections de code obtiennent le désassemblage ; les sections de données une vue hexadécimale).

ARMv7 natif (ELF)

• Désassemblage par descente récursive depuis les points d'entrée des symboles afin que les pools de littéraux, les tables de saut et les données en ligne ne soient pas mal décodés comme des instructions. Le mode par symbole (ARM vs Thumb) est respecté via le marqueur de bit de poids faible.
• Rendu Thumb à largeur variable : les lignes Thumb-1 16 bits affichent 2 octets (sans rembourrage fantôme 00 00), les Thumb-2 32 bits et A32 en affichent 4.
• Carte des symboles : symtab ELF, DWARF, .eh_frame et entrées <name>@plt synthétisées (stubs de 12 octets).
• Fusion movw + movt : movw R, #lo16 ; movt R, #hi16 est détecté à travers les paires d'instructions et la constante 32 bits résolue reçoit un commentaire ; "..." de chaîne rodata sur la ligne movt.
• Les chargements de pool de littéraux Thumb ldr Rt, [pc, #imm] déréférencent un niveau dans rodata pour le même type de commentaire de chaîne en ligne que le chemin ADRP+ADD d'AArch64 produit.
• Gouttière de flèches de flux de contrôle sur les branchements conditionnels et inconditionnels (même affectation de voie que pour AArch64).

UI

• Panneau droit à onglets avec menu déroulant anti-débordement, boutons de fermeture, clic pour activer.
• Barres de défilement horizontales et verticales sur les vues listing, hexadécimale et manifeste.
• Palette de symboles Cmd-F avec filtre flou. Les requêtes multi-mots sont mises en correspondance ET dans l'ordre (change me trouve changeMessage et change_me_count mais pas dispatchMenuVisibilityChanged).
• Palette binaire / instructions (⌘2 pour y basculer) analyse chaque artefact natif globalement — les applications Android avec arm64-v8a + armeabi-v7a obtiennent des résultats unifiés avec l'artefact + la section étiquetés pour chaque correspondance.
• Références croisées par clic droit dans chaque vue : Références vers l'adresse / Appelants de la fonction / Ouvrir la vue hexadécimale ici dans le listing, la vue hexadécimale et le CFG ; Appelants de la méthode / Références vers le champ dans smali. Les résultats s'affichent dans la palette avec une pastille de portée ; Esc efface la portée pour revenir à la recherche sur tout le bundle. Les index se construisent sur un fil d'arrière-plan après le chargement — une pastille de progression s'affiche pendant le traitement.
• Thèmes (View → Theme) avec teintes d'arrière-plan sélectionnables par fenêtre.
• Cmd-O ouvrir, Cmd-N nouvelle fenêtre, Cmd-W fermer la fenêtre, Cmd-⇧W fermer le fichier (retour de la fenêtre à l'état vide au lancement) — sur Linux / Windows, les mêmes raccourcis utilisent Ctrl au lieu de Cmd. File → Open Recent (10 derniers bundles, dédupliqués par chemin) et View → Theme. Sur macOS, ceux-ci se trouvent dans la barre de menus native ; sur Linux / Windows (où gpui ne dessine pas de menu natif), Glass rend sa propre barre de menus dans l'en-tête de la fenêtre.

Ce qui manque

• Désassemblage x86 / x86_64 (ces sections de code sont actuellement routées vers la vue hexadécimale).
• Éditions en place ARMv7 qui doivent grandir sans NOP adjacent — refusées aujourd'hui avec une erreur claire ; nécessiteraient un réagencement au niveau de la section + une re-liure des cibles de branchement pour être prises en charge.
• Analyse des entitlements iOS et de embedded.mobileprovision.
• Références croisées DEX ↔ natif via les signatures JNI.
• Hôte de script QuickJS.
• Glisser pour défiler sur les barres de défilement (actuellement uniquement visuel — utilisez le pavé tactile / la molette).
• Décodage des ID de ressources dans le manifest (nécessiterait l'analyse de resources.arsc).
• Éditeur d'assemblage typé ARMv7 : fonctionne pour les formes courantes ; les opérandes décalés (r0, lsl #2) et la mémoire pré/post-indexée ([rN, #imm]!, [rN], #imm) sont analysés mais uniquement de manière concrète — pas de jokers entre crochets.

Compilation

Glass fonctionne sur macOS 13+ (la cible principale, accélérée GPU via Metal — aucun SDK supplémentaire requis, le framework Metal est fourni avec le système), Linux (X11 ou Wayland via gpui_linux, support Vulkan) et Windows 10/11 (support Direct3D via gpui, compilé avec la chaîne d'outils MSVC).

Il existe un binaire précompilé pour macOS dans Releases mais si vous devez compiler depuis les sources : la bonne nouvelle : deux commandes suffisent.

1. Installer Rust (si vous ne l'avez pas déjà) : ```sh curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
   root@kitploit:~

2. Linux uniquement — installer les dépendances natives de gpui. Le plus simple est d'exécuter le script d'installation de Zed, qui connaît apt / dnf / pacman / etc : ```sh curl -sSL https://raw.githubusercontent.com/zed-industries/zed/main/script/linux | bash
   root@kitploit:~

Cela installe libxkbcommon-dev, les en-têtes Wayland et XCB, Vulkan, ALSA, ainsi que le reste de la chaîne d'outils dont gpui_linux a besoin pour lier. Sans eux, la compilation échoue à l'édition de liens avec des symboles xkbcommon / wayland-client manquants.

Si vous préférez ne pas exécuter le script, les paquets équivalents sur Debian / Ubuntu (amd64) sont : ```sh sudo apt-get update && sudo apt-get install -y
build-essential clang cmake pkg-config
libfontconfig-dev libfreetype-dev
libwayland-dev libxkbcommon-x11-dev
libasound2-dev libvulkan-dev
libzstd-dev libsqlite3-dev libssl-dev
libglib2.0-dev

La compilation échoue tôt dans un script de construction de dépendance (`fontconfig was not found in the pkg-config search path`) si `libfontconfig-dev` est manquant, puis plus tard à l'édition de liens pour les bibliothèques X11/Wayland/Vulkan. `libglib2.0-dev` est nécessaire car le pilote Frida lie GLib dynamiquement sous Linux (sur macOS, le devkit Frida l'inclut statiquement) — sans lui, l'édition de liens échoue avec `undefined symbol: g_object_unref`.

**Windows uniquement — installer la chaîne d'outils de compilation native.** `gpui` nécessite la chaîne d'outils MSVC (la cible GNU/MinGW n'est pas prise en charge). Avec [winget](https://learn.microsoft.com/windows/package-manager/winget/) :   ```powershell
# 1. MSVC compiler, linker, and Windows SDK (the "Desktop development with C++" workload).
winget install --id Microsoft.VisualStudio.2022.BuildTools `
  --override "--quiet --wait --add Microsoft.VisualStudio.Workload.VCTools --includeRecommended"

# 2. CMake — tree-sitter (via the Zed `language` crates) builds wasmtime's C API with it.
winget install --id Kitware.CMake

# 3. LLVM/Clang — `bindgen` (frida-sys, gpui, media) needs libclang.dll.
winget install --id LLVM.LLVM

L'installateur de LLVM ne s'ajoute pas à PATH, pointez donc bindgen vers libclang.dll avant de compiler (définissez-la de manière permanente via Système → Variables d'environnement, ou par session shell) : ```powershell $env:LIBCLANG_PATH = "C:\Program Files\LLVM\bin"

Sans ces éléments, la compilation échoue dans les scripts de compilation des dépendances : `linker 'link.exe' not found` (pas de MSVC), `failed to spawn 'cmake'` (pas de CMake), ou `Unable to find libclang` (pas de `LIBCLANG_PATH`). La réserve de pile du binaire `glass` est augmentée automatiquement sur MSVC (voir `crates/glass-cli/build.rs`) afin que la CLI ne fasse pas déborder la petite pile du thread principal par défaut de Windows — aucune action requise.
3. **Cloner et compiler**:   ```sh
git clone https://github.com/azw413/Glass.git
cd glass
cargo build --release -p glass-cli
cp target/release/glass <to somewhere on your PATH>

The first build will compile gpui and friends and will take several minutes. Subsequent builds are fast.

La première compilation compilera gpui et consorts et prendra plusieurs minutes. Les compilations suivantes sont rapides.

4. Lancez-le : ```sh

   Open the GUI on an Android APK or iOS IPA — no subcommand needed.

   glass ~/path/to/app.apk glass ~/path/to/app.ipa

   Or on a standalone binary — ELF .so, Mach-O .dylib, or raw

   executable. Fat / universal Mach-O is sliced automatically.

   glass ~/path/to/libfoo.so glass ~/path/to/libBar.dylib glass /usr/lib/dyld

   No args → opens an empty Glass window; use File → Open.

   glass

   Headless bundle inspect

   glass bundle ~/path/to/app.apk

   Inspect persisted state for a bundle

   glass db-dump ~/path/to/app.apk

   root@kitploit:~

Utilisez toujours la version release — les versions de débogage désassemblent des ordres de grandeur plus lentement.

Empaquetage d'un bundle .app

Pour envelopper le binaire release dans un bundle Glass.app afin de le lancer en double-cliquant depuis Finder :```sh cargo build --release -p glass-cli ./packaging/make-app.sh open dist/Glass.app

Le bundle est signé ad hoc (non signé avec Developer-ID / non notarisé), donc au premier lancement macOS refusera de l'ouvrir ; clic droit → **Ouvrir** pour contourner Gatekeeper une fois.

Deux façons d'obtenir un zip précompilé sans avoir à compiler localement :

- **Dernier `main`** — chaque push téléverse un `Glass-app-<sha>.zip` comme artefact de workflow conservé 14 jours. Récupérez-le depuis l'[onglet Actions](https://github.com/azw413/Glass/actions).
- **Version taguée** — pousser un tag `v*` (par ex. `v0.1.0`) déclenche le même workflow et publie également un `Glass-<tag>-macOS.zip` sur la [page Releases](https://github.com/azw413/Glass/releases) avec des notes de version générées automatiquement.

## Espace de travail

| Crate            | Rôle                                                             |
|------------------|------------------------------------------------------------------|
| `glass-core`     | Types partagés (`CodeKind`, ID)                                   |
| `glass-arch-arm` | Désassemblage AArch64 + ARMv7, carte des symboles, synthèse PLT, démangling |
| `glass-arch-dex` | Façade DEX / smali sur `smali`                                    |
| `glass-mobile`   | Chargement de bundles APK + IPA, extraction des libs natives, manifeste |
| `glass-db`       | Persistance adressée par contenu (redb) : bundles, onglets, paramètres |
| `glass-device`   | Découverte d'appareils Android (adb) + iOS (usbmux)               |
| `glass-api`      | Verbes d'analyse (recherche, xrefs, CFG, modifications) partagés par CLI + MCP + GUI |
| `glass-ui`       | Front-end `gpui` : arborescence, liste, hex, manifeste, palette   |
| `glass-cli`      | Inspecteur headless + lanceur GUI                                 |
| `glass-mcp`      | Serveur MCP exposant chaque verbe CLI comme un outil              |
| `glass-script`   | Runtime de plugins QuickJS (provisoire)                           |

## Feuille de route

- **iOS plus en profondeur** — Analyse des entitlements et de `embedded.mobileprovision`. (La passe de métadonnées ObjC `__objc_classlist` et Swift `__swift5_types` a été intégrée — voir `glass types` / `glass type`.)
- **x86 / x86_64** — Désassemblage pour les builds émulateur des fichiers `.so` Android.
- **Scripting interne** — Hôte de plugins QuickJS avec une API stable pour les passes d'analyse.
- **Avancé** — Reconstruction d'APK signés, downstream-shift sur les modifications en place ARMv7 (afin que les agrandissements 2→4 octets puissent s'insérer au-delà du code adjacent plutôt que d'être refusés).