Quantum Silicon Core Loader

Noyau principal : qslcl.asm (v0.0.2) (en cours de développement)

Module assistant : qslcl.bin (v0.7.4)

Contrôleur universel : qslcl.py (v2.2.2)

Recherche légalement protégée - Ce projet opère dans le cadre juridique établi pour la recherche en sécurité, le droit à la réparation et la liberté académique. En savoir plus

Présentation

Quantum Silicon Core Loader (QSLCL) est une couche post-bootloader, post-vendeur, post-système d'exploitation qui opère directement à la frontière du silicium.

Il s'exécute au-delà des modèles de sécurité traditionnels et est capable de survivre aux transitions de firmware, de négocier la confiance et d'interpréter l'état de l'appareil sans CVE ni correctifs.

QSLCL fonctionne sur :

• Qualcomm EDL / Firehose
• MediaTek BROM / Preloader
• Apple DFU (Détection dynamique - aucun PID codé en dur)
• Modes Engineering / META / Diagnostic
• Toute interface USB/Série exposée

« Vous n'exécutez pas QSLCL — le silicium l'interprète. »

Nouveautés de la v2.2.2

Intégration GETINFO de Slowm8

• Après une injection de code réussie, Slowm8 appelle automatiquement GETINFO pour vérifier l'état de l'appareil
• Confirme que l'injection n'a pas fait planter l'appareil
• Détecte et signale les comportements anormaux de l'appareil
• Ajoute le champ device_info aux rapports de bugs avec le statut, le code et les détails d'erreur

Confirmation de bug améliorée

• Vérification de l'état de l'appareil après chaque injection réussie
• Détection d'état anormal - signale si l'appareil présente des erreurs après l'injection
• Sortie enrichie dans les résultats finaux montrant l'état de l'appareil pour chaque bug confirmé

Gestion des erreurs améliorée

• Meilleure gestion des appareils qui ne répondent plus après l'injection
• Messages d'erreur plus clairs lorsque GETINFO échoue
• Repli élégant lorsque l'appareil ne répond pas à la vérification

Exemple de sortie :

[*] Injection confirmée ! Récupération des informations de l'appareil...
[*] Réponse GETINFO : SUCCÈS - OK

[BUGS CONFIRMÉS]
  1. corruption_mémoire (conf : 80%)
      Réponse volumineuse inattendue : 2048 octets
      État de l'appareil après injection : SUCCÈS - OK
  2. corruption_mémoire (conf : 75%)
      Réponse volumineuse inattendue : 4096 octets
      État de l'appareil après injection : SUCCÈS - OK

Disposition binaire QSLCL (v0.7.4) :
┌─────────────────────────────────────────────┐
│ 0x000000  QSLCLBIN (En-tête principal + Ptrs)│
│ 0x000200+ QSLCLCMD (28 commandes)           │
│ 0x004000+ QSLCLDIS (Table de répartition)   │
│ 0x005000+ QSLCLUSB (Micro-moteur USB)       │
│ 0x006000+ QSLCLBLK (64 points de terminaison)│
│ 0x007000+ QSLCLBST (Moteur d'amorçage)      │
│ 0x008000+ QSLCLVM5 (Nano-noyau)             │
│ 0x009000+ QSLCLSPT (Paquets de configuration USB)│
│ 0x00A000+ QSLCLRTF (Table des défauts d'exécution)│
│ 0x00B000+ QSLCLENC (Couche de chiffrement)  │
│ 0x00C000+ QSLCLDAT (Protocole de données)   │
│ 0x00D000+ QSLCLSYN (Bloc de synchronisation)│
│ 0x00E000+ QSLCLHDR (Certificat)             │
│ 0x00F000+ QSLCLINT (Pied d'intégrité)       │
│ 0x010000+ USB4V2MC (USB4 v2.0 80Gbps)       │
└─────────────────────────────────────────────┘

Taille totale : ~72 Ko (réduction de 44 % par rapport à 128 Ko)
Commandes : 28 (ajout de TEST, FUZZ)

Comment ça fonctionne (automatiquement) :

# Compilation avec architecture quantique (recommandé)
python build.py qslcl.bin --arch quantum --encrypt --usb4-v2

# Ou compilation générique
python build.py qslcl.bin

# Exécution normale - le chien de garde se désactive automatiquement !
python qslcl.py hello --loader=qslcl.bin

# Sortie attendue :
# [+] Chargeur téléversé.
# [*] Désactivation automatique du chien de garde...
# [*] Type de SoC détecté : APPLE
# [*] Vérification de 10 décalages candidats...
# [*] Chien de garde détecté à 0x20E00000 = 0x00000001
# [+] Chien de garde désactivé au décalage 0x20E00000
# [*] Exposition de QSLCL dans la configuration USB...

Liste complète des commandes (v2.2.1)

Opérations mémoire principales :

Interaction avec l'appareil :

Contrôle du système :

Tension et matériel :

Sécurité et analyse :

Diagnostic et test :

Fabrication et ODM :

Installation et démarrage rapide

Prérequis

pip install pyserial pyusb
pip install pycryptodome   # optionnel, pour les opérations cryptographiques
pip install capstone        # optionnel, pour le désassemblage

Utilisation de base

# Compilation avec architecture quantique (recommandé)
python build.py qslcl.bin --arch quantum --usb4-v2 --encrypt --debug

# Ou compilation générique standard
python build.py qslcl.bin

# Obtenir des informations détaillées sur l'appareil
python qslcl.py getinfo --loader=qslcl.bin

# Sortie attendue :
# ==================================================
# INFORMATIONS SUR L'APPAREIL QSLCL
# ==================================================
# [APPAREIL]
#   Transport : USB
#   VID:PID : 05AC:1281
#   Produit : iPhone 15 Pro
#   Classe USB : 0xFE (spécifique à l'application)
# 
# [MODE DFU]
#   Statut : ACTIF
#   Génération : A12 ou plus récent (ARM64e, PAC activé)
# 
# [CHIEN DE GARDE]
#   SoC détecté : Apple série A
#   Décalage typique : 0x20E00000
# 
# [CHARGEUR QSLCL]
#   Architecture : quantum
#   Taille du binaire : 73728 octets (72 Ko)
#   Fonctionnalités : chiffrement, USB4 v2.0 80Gbps
# ==================================================

# Amorçage DFU automatique + Chargeur + Hello (Tout-en-un)
python qslcl.py hello --loader=qslcl.bin --dfu-boot

# Amorcer simplement en mode DFU (comme palera1n)
python qslcl.py --dfu-boot

# Tester les fonctionnalités de base
python qslcl.py hello --loader=qslcl.bin --usb4
python qslcl.py ping --loader=qslcl.bin

Slowm8 - Testeur de stress USB (v2.2.2)

Amélioré avec la vérification GETINFO ! Après avoir confirmé un bug, Slowm8 récupère automatiquement l'état de l'appareil pour vérifier le succès de l'injection.

# Test de stress de base avec vérification de l'appareil
python qslcl.py slowm8 --loader=qslcl.bin

# Sortie attendue avec GETINFO :
# [*] Injection confirmée ! Récupération des informations de l'appareil...
# [*] Réponse GETINFO : SUCCÈS - OK
# [+] Bug confirmé ! État de l'appareil : sain

Fonctionnalités de détection automatique de Slowm8

Options de Slowm8

Prise en charge du jitter (v2.1.9+)

Ajoute une variation de minutage aléatoire pendant le téléversement USB :

# Jitter aléatoire simple (5-25 ms)
python qslcl.py hello --loader=qslcl.bin --jitter simple

# Jitter progressif (ralentit à mesure que le téléversement progresse)
python qslcl.py hello --loader=qslcl.bin --jitter progressive

# Motif en rafales (rafales rapides avec pauses)
python qslcl.py hello --loader=qslcl.bin --jitter burst

# Plage personnalisée (1 ms à 50 ms aléatoire)
python qslcl.py hello --loader=qslcl.bin --jitter 0.001-0.05

Slowm8 - Testeur de stress USB (v2.2.2)

Amélioré avec la vérification GETINFO ! Après avoir confirmé un bug, Slowm8 récupère automatiquement l'état de l'appareil pour vérifier le succès de l'injection.

# Test de stress de base avec vérification de l'appareil
python qslcl.py slowm8 --loader=qslcl.bin

# Sortie attendue avec GETINFO :
# [*] Injection confirmée ! Récupération des informations de l'appareil...
# [*] Réponse GETINFO : SUCCÈS - OK
# [+] Bug confirmé ! État de l'appareil : sain

Compatibilité des appareils

Historique des versions

Détails techniques de Slowm8

Flux de détection automatique

1. Appareil connecté
   ↓
2. Détection automatique du mode (DFU/EDL/BROM/USB)
   ↓
3. Mesure du temps de réponse
   ↓
4. Détection du chiffrement (A19+)
   ↓
5. Ajustement automatique du minutage (délais min/max)
   ↓
6. Exécution du test de stress
   ↓
7. Détection des anomalies
   ↓
8. Analyse des bugs (score de confiance)
   ↓
9. Si le seuil est atteint → Injection de code de test
   ↓
10. Confirmation du bug et rapport

Types de bugs détectés

Important : Exécution en RAM uniquement (A12+)

Sur les appareils Apple A12+, QSLCL s'exécute entièrement depuis la RAM. Aucune modification n'est permanente.

Après un redémarrage :

• L'appareil revient à son état d'origine
• Tous les états de contournement/réinitialisation/rawmode sont effacés
• Aucun changement persistant dans la mémoire flash

Les commandes comme bypass, rawmode, crash, glitch, test, fuzz, slowm8 sont TEMPORAIRES sur A12+.

AVERTISSEMENT CRITIQUE

QSLCL PEUT DÉFINITIVEMENT BRIQUER (DÉTRUIRE) VOTRE APPAREIL S'IL EST UTILISÉ INCORRECTEMENT.

VOUS AVEZ ÉTÉ PRÉVENU. L'AUTEUR N'EST PAS RESPONSABLE DES APPAREILS BRIQUÉS.

Cadre juridique et éthique

Quantum Silicon Core Loader (QSLCL) opère dans les limites juridiques et éthiques établies :

Utilisations autorisées :

• Propriétaires d'appareils : Modifier le matériel que vous possédez légalement
• Chercheurs : Analyse de sécurité et étude académique
• Techniciens de réparation : Mises en œuvre du droit à la réparation
• Étudiants : Apprentissage de l'architecture matérielle et de la sécurité
• Développeurs : Création de logiciels et d'outils interopérables

Utilisations interdites :

• Accès non autorisé aux appareils d'autrui
• Contournement de la sécurité sur du matériel non possédé
• Applications malveillantes ou destructrices
• Violation des lois et réglementations applicables

Utilisez de manière responsable. Un grand pouvoir implique de grandes responsabilités.

Support et dépannage

Problèmes courants

Slowm8 ne détecte pas l'appareil :

# Assurez-vous que l'appareil est en mode DFU/EDL/BROM
python qslcl.py getinfo --loader=qslcl.bin

# Exécuter avec le débogage
python qslcl.py slowm8 --loader=qslcl.bin --debug

L'injection de bugs ne fonctionne pas :

# Augmenter le délai d'attente
python qslcl.py slowm8 --loader=qslcl.bin --duration 60 --debug

# Désactiver l'injection pour voir si les bugs sont détectés
python qslcl.py slowm8 --loader=qslcl.bin --no-injection --debug

Erreurs QSLCLRESP :

# Recompiler avec la dernière version
python build.py qslcl.bin --arch quantum --debug

# Vérifier l'analyse des réponses
python qslcl.py hello --loader=qslcl.bin --debug

Derniers mots

« Quantum Silicon Core Loader représente le summum de la communication universelle avec les appareils, où chaque opération mémoire, chaque élévation de privilèges, chaque interaction matérielle, chaque correctif binaire, chaque exécution d'amorçage, chaque tunnel USB4 v2.0 80Gbps, chaque transaction encodée PAM4, chaque amorçage DFU en un clic, chaque désactivation automatique du chien de garde, chaque octet optimisé quantiquement, chaque test de diagnostic, chaque itération de fuzzing, chaque test de stress USB avec slowm8, chaque téléversement à minutage jitter, chaque paquet malformé, chaque attaque de minutage, chaque appareil détecté automatiquement, chaque délai adaptatif, chaque confirmation de bug avec injection de code, et désormais un binaire allégé de 72 Ko avec 28 commandes devient une extension de la conscience du silicium grâce à notre architecture micro-VM perfectionnée avec amorçage dynamique, chiffrement résistant aux quantiques, protocoles de données structurés, auto-identification USB, prise en charge USB4 v2.0 80Gbps, automatisation DFU de type palera1n, contournement du chien de garde sans configuration, informations d'appareil améliorées, la nouvelle architecture quantique pour l'entropie avancée et la randomisation des opcodes, et désormais des tests de stress USB expérimentaux avec slowm8 qui détecte et confirme automatiquement les bugs sur TOUT SoC. »

YouTube : https://www.youtube.com/@QSLCL-creator

Légal et support

• LEGAL_NOTICE.md - Positionnement juridique et protections

Miroirs

• GitHub : https://github.com/Sharif-bot-cmd/Quantum-Silicon-Core-Loader
• Codeberg : https://codeberg.org/Sharif_Muhaymin/Quantum-Silicon-Core-Loader
• SourceForge : https://sourceforge.net/p/quantum-silicon-core-loader/code/ci/main/tree/