MachScope

Un outil natif d'analyse de binaires macOS offrant l'analyse Mach-O, le désassemblage ARM64 et le débogage de processus. Entièrement construit en Swift sans dépendances externes.

Fonctionnalités

Fonctionnalité	Description
Analyse Mach-O	En‑têtes, segments, sections, symboles, dylibs, chaînes
Signatures de code	Entitlements, CDHash, informations de signature, ID d'équipe
Désassemblage ARM64	Décodeur d'instructions complet avec annotation PAC
Débogage de processus	Attachement, points d'arrêt, mémoire, registres
Bibliothèque Swift	Intégration dans vos propres projets
Sortie JSON	Format de sortie adapté aux scripts

Pourquoi MachScope ?

Pure Swift — Aucune dépendance, facile à construire et à intégrer
Natif ARM64 — Conçu pour Apple Silicon, comprend les instructions PAC
Tout-en-un — Analyser + Désassembler + Déboguer en un seul outil
Bibliothèque + CLI — Utilisation autonome ou intégration dans vos projets Swift
Bien testé — Plus de 319 tests avec une gestion complète des erreurs

Démarrage rapide

# Construction
swift build

# Analyser un binaire
swift run machscope parse /bin/ls

# Analyser une application macOS
swift run machscope parse /Applications/Calculator.app/Contents/MacOS/Calculator

# Voir les entitlements
swift run machscope parse /Applications/Safari.app/Contents/MacOS/Safari --entitlements

# Sortie JSON
swift run machscope parse /bin/ls --json

Installation

Homebrew

brew install sadopc/tap/machscope

Construction à partir des sources

git clone https://github.com/sadopc/machscope.git
cd MachScope
swift build -c release

Installation globale (optionnelle)

sudo cp .build/release/machscope /usr/local/bin/

Utilisation

Commande parse

Analyser la structure d'un binaire Mach-O :

# Analyse basique
machscope parse /bin/ls

# Analyse complète
machscope parse /bin/ls --all

# Sections spécifiques
machscope parse /path/to/binary --symbols
machscope parse /path/to/binary --dylibs
machscope parse /path/to/binary --strings
machscope parse /path/to/binary --signatures
machscope parse /path/to/binary --entitlements

# Sortie JSON pour scripts
machscope parse /bin/ls --json --all > analysis.json

Commande disassemble

Désassembler du code ARM64 :

# Lister les fonctions
machscope disasm /bin/ls --list-functions

# Désassembler à partir d'une adresse
machscope disasm /bin/ls --address 0x100003f40 --length 50

# Afficher les octets d'instruction
machscope disasm /bin/ls --show-bytes

Vérifier les permissions

Voir les fonctionnalités disponibles :

machscope check-permissions

Sortie :

Feature               Status      Notes
------------------------------------------------------------
Static Analysis       ✓ Ready     No special permissions needed
Disassembly           ✓ Ready     No special permissions needed
Debugger              ✗ Denied    Missing debugger entitlement

Commande debug

Se connecter à des processus en cours d'exécution (nécessite une signature) :

# D'abord, signer avec l'entitlement de débogueur
codesign --force --sign - --entitlements Resources/MachScope.entitlements .build/debug/machscope

# Activer les outils de développement dans Réglages Système > Confidentialité et Sécurité

# Se connecter à un processus
machscope debug <pid>

Utilisation comme bibliothèque Swift

Ajoutez MachScope à votre Package.swift :

dependencies: [
    .package(url: "https://github.com/sadopc/machscope.git", from: "1.0.0")
]

Utilisez-le ensuite dans votre code :

import MachOKit
import Disassembler

// Analyser un binaire
let binary = try MachOBinary(path: "/bin/ls")
print("CPU : \(binary.header.cpuType)")
print("Segments : \(binary.segments.count)")

// Vérifier les entitlements
if let signature = try binary.parseCodeSignature(),
   let entitlements = signature.entitlements {
    for key in entitlements.keys {
        print("\(key) : \(entitlements[key] ?? "nil")")
    }
}

// Désassembler
let disasm = ARM64Disassembler(binary: binary)
let result = try disasm.disassembleFunction("_main", from: binary)
for instruction in result.instructions {
    print(disasm.format(instruction))
}

Prérequis

macOS 14.0 (Sonoma) ou ultérieur
Swift 6.0 ou ultérieur
ARM64 (Apple Silicon) — l'analyse x86_64 est prise en charge, mais l'outil s'exécute sur ARM64

Documentation

Structure du projet

MachScope/
├── Sources/
│   ├── MachOKit/        # Bibliothèque d'analyse Mach-O principale
│   ├── Disassembler/    # Décodeur d'instructions ARM64
│   ├── DebuggerCore/    # Débogage de processus
│   └── MachScope/       # Application CLI
├── Tests/               # Suites de tests (319+ tests)
├── Resources/           # Entitlements pour la signature de code
└── docs/                # Documentation

À qui s'adresse cet outil ?

Développeurs iOS/macOS — Inspecter les binaires, vérifier les entitlements avant soumission à l'App Store
Chercheurs en sécurité — Triage et analyse rapides de binaires
Étudiants — Apprendre le format Mach-O avec du code Swift lisible
Développeurs d'outils — Intégrer MachOKit dans vos propres projets Swift
Participants aux CTF — Analyse rapide de binaires

Comparaison avec d'autres outils

Le principal avantage de MachScope : une bibliothèque native Swift que vous pouvez intégrer dans vos propres outils.

Licence

Licence MIT — Voir LICENSE pour les détails.

Contribuer

Les contributions sont les bienvenues ! Veuillez d'abord lire le Guide de contribution.

# Exécutez les tests avant de soumettre
swift test

# Formatez le code
xcrun swift-format -i -r Sources/ Tests/

Remerciements

Documentation Mach-O d'Apple
Manuel de référence de l'architecture ARM
La communauté Swift

Historique d'étoiles

Construit avec ❤️ en Swift

MachScope	Swift	✅ Oui	✅ Oui	✅ Oui
otool	C	❌ Non	❌ Non	❌ Non
objdump	C	❌ Non	❌ Non	❌ Non
jtool2	C	❌ Non	✅ Oui	❌ Non
Hopper	—	❌ Non	✅ Oui	❌ Non

Populaires

machscope