toddmaustin/mojo-vExtension du jeu d'instructions RISC-V pour le calcul secret renforcé par matériel utilisant l'encapsulation de clés ML-KEM-512 et le chiffrement SIMON-128, permettant une exécution sans dépendance des données avec des performances proches du natif.
Mojo-V (prononcé « mojo-five ») est une nouvelle extension RISC-V qui introduit des capacités de programmation orientées confidentialité pour RISC-V. Mojo-V implémente le calcul secret, permettant une exécution sécurisée, efficace et insensible aux données (data-oblivious), sans dépendre de logiciels fragiles ni de la confiance accordée aux programmeurs. En séquestrant les données sensibles dans des registres secrets dédiés et en chiffrant la mémoire avec une clé tierce, Mojo-V empêche les divulgations et impose un calcul à la fois aveugle (aucune divulgation directe) et silencieux (aucune fuite par canaux auxiliaires). La conception s'intègre de manière transparente dans l'ISA RISC-V existante avec seulement un bit de mode et quatre nouvelles instructions, appliquées entièrement au décodage. Les premiers résultats montrent des vitesses d'exécution proches du natif, tout en offrant une amélioration de performance de 5 à 7 ordres de grandeur par rapport au chiffrement totalement homomorphe (FHE), avec une feuille de route claire pour l'intégration dans les CPU, GPU et accélérateurs spécialisés.
Pour en savoir plus...
La spécification actuelle de l'extension ISA Mojo-V (version 1.02) :
Pour contacter les développeurs de Mojo-V :
La plateforme de référence Mojo-V version 1.03 implémente une plateforme de simulateur Spike de référence pour RISC-V RV64GC ainsi que le compilateur EXO pour la spécification ISA Mojo-V v1.02. L'implémentation actuelle prend en charge les modes de chiffrement rapide, robuste et à preuve (proof-carrying), ainsi que la divulgation sécurisée des résultats de calcul chiffrés et la génération certifiée de nombres aléatoires. La version inclut une large gamme de tests Mojo-V, des benchmarks orientés confidentialité et des applications de démonstration pour la divulgation sécurisée. Elle inclut également la spécification complète de l'ISA Mojo-V et la documentation développeur.
Cette version est appropriée pour être utilisée comme i) une plateforme de développement d'applications Mojo-V, ii) un modèle de référence (golden model) pour valider les implémentations matérielles Mojo-V, et iii) une implémentation de référence pour l'analyse de sécurité. Les travaux actuels se concentrent sur le développement de i) un compilateur Mojo-V basé sur LLVM, ii) un modèle Mojo-V basé sur gem5 pour l'exploration et l'analyse architecturales, et iii) une implémentation RTL SystemVerilog de référence CVA6 de RISC-V RV64GC avec les extensions Mojo-V.
Version de spécification : 1.02 (Août 2026)
Contact : [email protected]
Spécification ISA Mojo-V v1.02
doc/Spike (simulateur de jeu d'instructions) avec extensions Mojo-V
riscv-isa-sim, et fonctionnellement complet pour un CPU RV64GC avec encapsulation de clé ML-KEM-512 pour le chargement des contrats de données, et chiffrement symétrique SIMON-128 pour la protection du calcul secret.--isa=rv64gc_zicond_zkmojov_zicntr lors de l'exécution de spikeMulti-outil de contrat de données
Les contrats de données sont des paquets chiffrés qui permettent au matériel d'un CPU Mojo-V d'accéder à la clé d'accès aux données et aux informations de configuration (par exemple, le mode de chiffrement mémoire) pour un ensemble de données chiffrées Mojo-V. Le multi-outil DC offre les capacités suivantes :
Benchmarks Mojo-V Bringup-Bench
Note : le reste des benchmarks Bringup-bench n'a pas encore été porté vers Mojo-V.
Vous aurez besoin d'un compilateur croisé RISC-V basé sur LLVM capable de produire des binaires RV64GC.
Voici un bon point de départ : https://github.com/openssl/openssl
Vous aurez besoin d'une installation de développement d'OpenSSL version 3.6 ou plus récente. Celle-ci fournit les bibliothèques qui implémentent ML-KEM512, utilisées par Spike pour l'échange de clés protégé.
Voici un bon point de départ : https://clang.llvm.org/get_started.html
git clone https://github.com/toddmaustin/mojo-v.git cd mojo-v
### D. Construire le simulateur Spike RISC-V avec le support Mojo-V```bash
sudo apt-get install device-tree-compiler libboost-regex-dev libboost-system-dev
cd riscv-isa-sim
mkdir build
cd build
../configure --prefix=$RISCV
make
Les contrats de données sont des paquets chiffrés qui permettent au matériel d'un CPU Mojo-V d'accéder à la clé d'accès aux données et aux informations de configuration (par exemple, le mode de chiffrement de la mémoire) pour un ensemble de données chiffrées Mojo-V.``` cd dc-tool make clean build test
### **E. Compiler et exécuter les tests de référence Mojo-V Bringup-Bench**
1. **Compiler le pilote de périphérique Spike** ```bash
cd bringup-bench/target
make
Configurez votre compilateur
Modifiez ../Makefile et définissez TARGET_CC pour la cible mojov sur l'emplacement de votre compilateur RISC-V basé sur LVM Clang.
Compilez et testez les programmes de test Bringup-Bench ```bash cd .. # go to the top-level bringup-bench directory make TARGET=mojov-spike mojov-tests # run all Mojo-V tests
En alternative, vous pouvez exécuter un benchmark individuel en vous rendant dans son répertoire et en exécutant la commande suivante. ```bash cd ../mojov-test make TARGET=mojov-spike clean build test
## 🧪 Aperçu des tests de Mojo-V Bringup-Bench
| Programme | Description |
|:---------|:-------------|
| `mojov-test` | Exemple d'introduction tiré des diapositives |
| `mojov-test1` | Tests de sémantique des registres secrets et de la mémoire chiffrée |
| `mojov-test2` | Benchmark data-oblivious de tri à bulles d'entiers codé à la main avec chiffrement rapide Mojo-V (int,fast) |
| `mojov-test3` | Benchmark data-oblivious de tri à bulles à virgule flottante codé à la main avec chiffrement rapide Mojo-V (fp,fast) |
| `mojov-test4` | Benchmark data-oblivious de tri à bulles d'entiers codé à la main avec chiffrement fort Mojo-V (int,strong) |
| `mojov-test5` | Benchmark data-oblivious de tri à bulles à virgule flottante codé à la main avec chiffrement fort Mojo-V (fp,strong) |
| `mojov-typetests` | Tests de validation du système de types pour les types chiffrés Mojo-V et l'utilisation de la bibliothèque EXO |
| `mojov-pctests` | Suite de tests de vérification d'intégrité codée à la main pour RV64GC+Mojo-V incluant des tests positifs et négatifs pour le format de chiffrement proof-carrying de Mojo-V (proofcarrying) |
| `mojov-sectests` | Suite de tests de sécurité codée à la main pour RV64GC+Mojo-V incluant 130 tests pos + 245 tests neg == 375 au total (int,fp,fast,strong) |
| `mojov-stringtests` | Tests de validation de la bibliothèque de chaînes EXO chiffrée pour les opérations et comparaisons de chaînes sécurisées |
| `mojov-mathtests` | Tests de validation de la bibliothèque mathématique EXO chiffrée pour `_sincos`, `mojov_sin`, `mojov_cos`, `mojov_fabs`, `mojov_floor`, `mojov_pow`, `mojov_round`, et `mojov_sqrt` |
Ces benchmarks de test démontrent les règles de l'ISA Mojo-V, le comportement de la bibliothèque EXO et la sémantique de sécurité.
## 🧪 Aperçu des benchmarks de Mojo-V Bringup-Bench
L'ensemble actuel de benchmarks de bring-up comprend les applications de benchmark Mojo-V suivantes :
| Programme | Description |
|:---------|:-------------|
| `bitonic-sort` | Benchmark data-oblivious de tri bitonique |
| `bloom-filter` | Benchmark d'appartenance à un ensemble avec filtre de Bloom |
| `bubble-sort` | Benchmark de tri à bulles d'entiers |
| `bubble-sort-strong` | Benchmark de tri à bulles d'entiers configuré pour le chiffrement fort |
| `chi-squared` | Benchmark statistique du chi-carré pour la qualité d'ajustement |
| `distinctness` | Benchmark d'analyse de distinctivité |
| `distinctness-Onlog2n` | Variante du benchmark de distinctivité avec stratégie O(n log² n) |
| `edit-distance` | Benchmark de distance d'édition (distance de chaînes) |
| `eulers-approx` | Benchmark d'approximation de la constante/série d'Euler |
| `fft-int` | Benchmark FFT entier |
| `flood-fill` | Benchmark flood-fill |
| `flood-fill-On2` | Variante du benchmark flood-fill avec comportement O(n²) |
| `fuzzy-match` | Benchmark de correspondance floue de chaînes |
| `gcd-list` | Benchmark du plus grand commun diviseur sur une liste |
| `gemm` | Benchmark de multiplication matricielle générale (GEMM) |
| `gemm-strong` | Benchmark GEMM configuré pour le chiffrement fort |
| `grad-descent` | Benchmark d'optimisation par descente de gradient |
| `heat-calc` | Benchmark de calcul de transfert de chaleur/équation de la chaleur |
| `heldkarp-tsp` | Benchmark du problème du voyageur de commerce par programmation dynamique de Held-Karp sur graphes chiffrés |
| `highlife` | Benchmark d'automate cellulaire HighLife avec évolution chiffrée de l'état du plateau |
| `kadane` | Benchmark du sous-tableau maximal (algorithme de Kadane) |
| `kalman-filter` | Benchmark de filtrage de Kalman |
| `kcore-decomp` | Benchmark de décomposition en k-core de graphe |
| `kepler-calc` | Benchmark de calcul de l'équation/du calcul numérique de Kepler |
| `knapsack` | Benchmark d'optimisation du sac à dos |
| `lcs` | Benchmark data-oblivious de la plus longue sous-séquence commune sur chaînes chiffrées |
| `lda` | Benchmark d'allocation de Dirichlet latente (LDA) |
| `manacher-lps` | Benchmark de la plus longue sous-chaîne palindromique (algorithme de Manacher) |
| `mersenne` | Benchmark de calcul des nombres de Mersenne |
| `minspan` | Benchmark de structure couvrante minimale |
| `monte-carlo` | Benchmark de simulation de Monte-Carlo |
| `moving-average` | Benchmark analytique de moyenne mobile |
| `moving-average-fp64` | Benchmark analytique de moyenne mobile FP64 |
| `nbody-sim` | Benchmark de simulation à N corps |
| `nonlinear-nn` | Benchmark de réseau de neurones non linéaire |
| `nr-solver` | Benchmark du solveur de Newton-Raphson |
| `ntt-kernel` | Benchmark du noyau de transformée de la théorie des nombres |
| `packet-filter` | Benchmark de filtrage de paquets |
| `pagerank` | Benchmark de graphe PageRank |
| `parrondo` | Benchmark du processus/stratégie de Parrondo |
| `partition-equal` | Benchmark de partition en sous-ensembles à somme égale sur ensembles chiffrés |
| `pca-analysis` | Benchmark d'analyse en composantes principales |
| `primal-test` | Benchmark de test de primalité |
| `private-join` | Benchmark de jointure préservant la confidentialité |
| `psi` | Benchmark d'intersection d'ensembles privés |
| `quartile-stats` | Benchmark analytique de découpage en quartiles et de moyenne par quartile sur données chiffrées |
| `rabinkarp-search` | Benchmark de recherche de motif Rabin-Karp |
| `rad-to-deg` | Benchmark de conversion radians-degrés |
| `randshell-sort` | Benchmark de tri Shell randomisé |
| `ransac` | Benchmark d'ajustement de modèle RANSAC |
| `regex-match` | Benchmark de correspondance d'expressions régulières |
| `risk-score` | Benchmark analytique de score de risque |
| `scrambled-compare` | Benchmark de comparaison de chaînes brouillées utilisant la programmation dynamique chiffrée |
| `seq-align` | Benchmark d'alignement global de séquences (Needleman-Wunsch) sur chaînes chiffrées |
| `shortest-path` | Benchmark de plus court chemin dans un graphe |
| `sieve` | Benchmark du crible de nombres premiers |
| `skeleton` | Benchmark squelette/modèle utilisé comme référence de bring-up |
| `soundex` | Benchmark d'encodage phonétique Soundex |
| `string-search` | Benchmark de recherche de chaîne |
| `tea-cipher` | Benchmark du chiffrement TEA |
| `tiny-NN` | Benchmark d'inférence de mini réseau de neurones |
| `triangle-count` | Benchmark de comptage de triangles dans un graphe |
| `variability-sample` | Benchmark de variabilité et de statistiques d'échantillonnage |
| `verlet` | Benchmark physique d'intégration de Verlet |
## Aperçu des démonstrateurs de divulgation sécurisée de Mojo-V
Mojo-V inclut trois benchmarks démonstrateurs de divulgation sécurisée dans `bringup-bench`. Ces applications utilisent une mémoire chiffrée proof-carrying ainsi que des autorisations de données chiffrées pour montrer comment un programme peut calculer sur des entrées sensibles, ne divulguer que des résultats dérivés explicitement autorisés, et intercepter les tentatives de réutilisation d'une autorisation pour une valeur différente, une entrée brute, un calcul obsolète, une autorisation falsifiée ou un prédicat intermédiaire.
| Programme | Entrée sensible | Divulgations autorisées | Protections démontrées |
|:---------|:----------------|:------------------------|:--------------------------|
| `private-auction` | Huit offres privées chiffrées. | Identifiant de l'enchérisseur gagnant et valeur de l'enchère gagnante. | Trouve l'enchère maximale grâce à des comparaisons chiffrées et `cmov()`, puis valide les autorisations de données par sortie. Les cas négatifs rejettent les autorisations non correspondantes, la divulgation brute de l'enchère gagnante, les autorisations frauduleuses ou falsifiées, les autorisations obsolètes après modification de l'enchère, les valeurs dérivées `winning_bid + 1` et les prédicats de comparaison intermédiaires. |
| `vote-tally` | Trente-deux bulletins de vote chiffrés répartis entre trois candidats, dont deux bulletins invalides. | Décomptes agrégés pour les candidats A, B et C, ainsi que des prédicats de régularisation par bulletin. | Calcule tous les décomptes des candidats et les prédicats de validité des bulletins sous forme chiffrée. Les cas négatifs rejettent l'utilisation d'une autorisation de décompte pour un autre décompte, la divulgation brute des bulletins, les autorisations frauduleuses ou falsifiées, les autorisations obsolètes après modification des bulletins, les valeurs de décompte dérivées et les prédicats de bulletin intermédiaires. |
| `gene-risk` | Huit dosages de marqueurs SNP chiffrés pour une charge de travail illustrative de risque génomique. | Un score de risque polygénique dérivé et une catégorie de risque faible/moyen/élevé. | Accumule un score de risque pondéré et dérive la catégorie de risque grâce à des prédicats chiffrés et `cmov()`. Les cas négatifs rejettent l'utilisation croisée des autorisations de score et de catégorie, la divulgation brute des marqueurs, les autorisations frauduleuses ou falsifiées, les autorisations obsolètes après modification du génome, les valeurs de score dérivées et les prédicats intermédiaires de risque élevé. |
Chaque démonstrateur est répertorié dans `MOJOV_DISCAPPS` ; il fait donc partie de la batterie d'applications de divulgation sécurisée. Pour en exécuter un directement, entrez dans son répertoire de benchmark et utilisez la cible Mojo-V, par exemple :```bash
cd bringup-bench/private-auction
make TARGET=mojov-spike clean build test
Utilisez l'option --mojov-arg=<n> de Spike pour sélectionner le chemin positif (0) ou l'un des tests de divulgation négatifs (1 et plus) lors de l'exécution manuelle d'un démonstrateur.
Mojo-V inclut trois démonstrateurs de générateur de nombres véritablement aléatoires certifié (CERTRNG)
dans bringup-bench. Ils utilisent des sites CERTRNG distincts,
du calcul chiffré avec preuve et des nonces de requête pour montrer qu'un client
peut vérifier où des valeurs aléatoires fraîches sont entrées dans un calcul approuvé. Les
résultats restent chiffrés jusqu'à la validation du reçu et l'engagement. Les cas négatifs
démontrent que le caractère aléatoire généré par logiciel, les tirages manquants ou réutilisés,
les mauvaises affectations de sites, les requêtes obsolètes, les graphes de calcul modifiés et le
rééchantillonnage biaisé ne satisfont pas à l'octroi honnête de données. Ils montrent aussi une
limite importante : le caractère aléatoire certifié seul ne peut pas empêcher le grinding si les résultats sont divulgués
(à l'aide des instructions Mojo-V DISC ou FDISC) avant l'engagement.
Ces démonstrateurs sont listés dans MOJOV_CERTRNG_APPS, ils sont donc inclus dans
la batterie de benchmarks Mojo-V. Exécutez-en un directement depuis son répertoire, par exemple :```bash
cd bringup-bench/blind-audit
make TARGET=mojov-spike clean build test
Utilisez l'option `--mojov-arg=<n>` de Spike lors de l'exécution manuelle d'un démonstrateur. Cas
`0` est le chemin honnête, les cas à faible numéro sont des contrôles explicatifs réussis,
et les cas `10` et plus sont des attaques censées se terminer par une exception
de sécurité Mojo-V. La matrice exacte de chaque application est documentée dans son
`README.md` local au benchmark.
## 🛠️ Utilisation du Mojo-V Data Contract Multi-tool
Le multi-outil de contrats de données « dc-tool » est utilisé pour créer et valider les contrats de données Mojo-V.
Pour créer une paire de clés publique/privée ML-KEM512, exécutez la commande suivante. Notez que la clé publique doit être partagée avec les fournisseurs de données tiers pour préparer les contrats de données. Les clés privées sont installées dans le matériel (ou le simulateur).```bash
./dc-tool keygen <pk_file> <sk_file> # public key in <pk_file>, private key in <sk_file>
Une fois qu'une paire de clés publique/privée existe, il est alors possible de créer des contrats de données chiffrés. Un contrat de données contient une clé d'accès aux données chiffrée (pour que le matériel Mojo-V puisse accéder aux données de tiers) et une configuration de mode mémoire chiffrée. Exécutez la commande suivante pour créer un contrat de données chiffré.```bash ./dc-tool dcgen <pk_file> {fast,strong,proof-carrying} <ct_file> # specify mem mode, contract in <ct_file>
Le partage d'un contrat de données chiffré avec le matériel Mojo-V qui correspond à la clé publique ML-KEM512 utilisée pour chiffrer le contrat permettra au processeur compatible Mojo-V d'effectuer des calculs secrets sur les données protégées de tiers. Pour valider que le contrat chiffré est valide, utilisez les commandes suivantes.```bash
./dc-tool dcchk <sk_file> <ct_file> # decrypt contract <ct_file> with secret key <sk_file>
./dc-tool dcchk-v <sk_file> <ct_file> # same as above, but also dump decrypted contents of <ct_file>
Les options suivantes ont été ajoutées à Spike, le simulateur ISA RISC-V standard.```bash --mojov-verbose Mojo-V setup processing is verbose --mojov-fast Use Mojo-V fast encryption mode (default mode) --mojov-strong Use Mojo-V strong encryption format (otherwise using data contract specified mode) --mojov-proofcarrying Use Mojo-V proof-carrying encryption format (otherwise use data contract specified mode) --mojov-arg= Pass a numeric argument to a Mojo-V test code --mojov-pk=<pem_file> Load Mojo-V CPU public key from <pem_file> --mojov-sk=<pem_file> Load Mojo-V CPU secret key from <pem_file>
## 🧠 Aperçu de la programmation Mojo-V
Le développement logiciel Mojo-V utilise actuellement la bibliothèque du compilateur EXO et suit des pratiques de codage data-oblivious sécurisées :
1. **Programmer avec les en-têtes de la bibliothèque EXO**
- Incluez `exo/mojov-exo.h` pour accéder au framework de programmation Mojo-V et aux abstractions de types chiffrés.
- Incluez `exo/mojov-math.h` pour accéder au support mathématique chiffré et aux opérations auxiliaires.
2. **Utiliser le calcul data-oblivious pour les variables chiffrées**
- Les valeurs chiffrées doivent être manipulées avec des flux de contrôle et des schémas d'accès mémoire data-oblivious afin de préserver les objectifs d'exécution silencieuse et de résistance aux canaux auxiliaires de Mojo-V.
3. **Suivre le tutoriel de programmation EXO**
- Voir le guide de programmation EXO : [exo/EXO-library-programming.md](https://github.com/toddmaustin/mojo-v/blob/HEAD/exo/EXO-library-programming.md)
4. **Voir les détails de la structure du compilateur et de l'architecture dans la documentation EXO**
- La structure interne et le contexte de conception de l'approche actuelle compilateur/bibliothèque de Mojo-V sont documentés dans : [exo/EXO-library-overview.md](https://github.com/toddmaustin/mojo-v/blob/HEAD/exo/EXO-library-overview.md)
---
## Licence du code
Tout le code lié à Mojo-V dans ce dépôt est publié sous la licence de l'outil qu'il modifie (par exemple, Spike, LLVM, Bringup-Bench). Veuillez consulter les répertoires respectifs des outils pour les détails de licence.
---
## 💬 Questions et retours
Nous accueillons volontiers les contributions, les rapports de bugs et les suggestions !
📧 **Email :** [[email protected]](mailto:[email protected])
🌐 **Page du projet :** [https://github.com/toddmaustin/mojo-v](https://github.com/toddmaustin/mojo-v)
| Program | Charge de travail aléatoire certifiée | Comportement positif | Protections démontrées |
|---|
blind-audit | Sélectionne un des huit enregistrements d'audit en prenant le minimum de huit priorités aléatoires distinctes liées à la requête. | Certifie le graphe argmin fixe complet ; montre aussi que les tirages inutilisés n'affectent pas le reçu et que la divulgation prématurée permet le grinding. | Rejette une cible forcée, un RNG logiciel, un nonce manquant ou obsolète, la réutilisation de tirages, un candidat abandonné, des sites inversés et la relecture d'une sélection précalculée. |
diffpriv-count | Ajoute un bruit binomial centré, formé comme la différence de deux valeurs Binomial(8, 1/2) indépendantes, à un compte chiffré en utilisant 16 sites aléatoires distincts. | Certifie le graphe précis de génération de bruit et de liaison à la requête tout en gardant le bruit et la réponse cachés jusqu'à la validation. | Rejette un bruit omis ou affaibli, un RNG logiciel, un rééchantillonnage favorable et la relecture de requêtes obsolètes ; le caractère aléatoire inutilisé sans rapport reste hors du reçu. |
certified-lotto | Choisit le participant éligible au score le plus élevé parmi huit entrées chiffrées et utilise des priorités distinctes liées à la requête pour départager les égalités de score. | Certifie chaque participant, site aléatoire, mélange de nonces et étape de tournoi ; démontre aussi le comportement des tirages inutilisés et le danger de grinding par divulgation avant engagement. | Rejette un participant omis, un RNG logiciel, un nonce sauté ou obsolète, la réutilisation de tirages, des sites inversés et un départage déterministe. |