Mojo-V Logo

Mojo-V: Secret Computation für RISC-V

Mojo-V (ausgesprochen „mojo-five“) ist eine neue RISC-V-Erweiterung, die datenschutzorientierte Programmiermöglichkeiten für RISC-V einführt. Mojo-V implementiert Secret Computation und ermöglicht sichere, effiziente und daten-oblivious Ausführung ohne Abhängigkeit von fragiler Software und Vertrauen in Programmierer. Durch die Absonderung sensibler Daten in dedizierten Secret-Registern und die Verschlüsselung des Speichers unter einem Drittanbieter-Schlüssel verhindert Mojo-V Offenlegungen und erzwingt eine Berechnung, die sowohl blind (keine direkten Offenlegungen) als auch still (kein Seitenkanal-Leck) ist. Das Design integriert sich nahtlos in die bestehende RISC-V-ISA mit nur einem Modus-Bit und vier neuen Instruktionen, die vollständig beim Decode erzwungen werden. Erste Ergebnisse zeigen nahezu native Ausführungsgeschwindigkeiten und bieten gleichzeitig eine Leistungsverbesserung von über 5–7 Größenordnungen im Vergleich zu vollständig homomorpher Verschlüsselung (FHE), mit einer klaren Roadmap für die Integration in CPUs, GPUs und spezialisierte Beschleuniger.

Um mehr zu erfahren...

Hier ist ein Einführungsvideo, das Mojo-V beschreibt: https://www.youtube.com/watch?v=HUT46TcNyyM
Folien, die einen Überblick über das Mojo-V-Projekt geben: https://drive.google.com/file/d/1VVzZqYHvQgnKMgXZjg7I_cX2GzF7awSN

Die aktuelle Mojo-V-ISA-Erweiterungsspezifikation (Release 1.02):

[Im PDF-Format.] (https://drive.google.com/file/d/1yfiBqp0xyXD-S_G5d2o7Ggta5wI6nRot)

Um die Entwickler von Mojo-V zu kontaktieren:

E-Mail: [email protected]

🧩 Mojo-V-Referenzplattform — Release 1.03

🚧 Projektstatus

Die Mojo-V-Referenzplattform Release 1.03 implementiert eine Referenz-Spike-Simulatorplattform für RISC-V RV64GC und den EXO-Compiler für die Mojo-V-ISA-Spezifikation v1.02. Die aktuelle Implementierung unterstützt schnelle, starke und beweistragende Verschlüsselungsmodi sowie die sichere Offenlegung verschlüsselter Berechnungsergebnisse und zertifizierte Zufallszahlengenerierung. Das Release enthält eine breite Palette von Mojo-V-Tests, datenschutzorientierten Benchmarks und Demonstrator-Anwendungen für sichere Offenlegung. Es enthält außerdem die vollständige Mojo-V-ISA-Spezifikation und Entwicklerdokumentation.

Dieses Release eignet sich für die Verwendung als i) Mojo-V-Anwendungsentwicklungsplattform, ii) Golden Model zur Validierung von Mojo-V-Hardwareimplementierungen und iii) Referenzimplementierung für Sicherheitsanalysen. Die aktuelle Arbeit konzentriert sich auf die Entwicklung von i) einem LLVM-basierten Mojo-V-Compiler, ii) einem gem5-basierten Mojo-V-Modell für Architekturerkundung und -analyse und iii) einer Referenz-CVA6-SystemVerilog-RTL-Implementierung von RISC-V RV64GC mit Mojo-V-Erweiterungen.

Spezifikationsversion: 1.02 (August 2026)
Kontakt: [email protected]

Aktuelle Komponenten

Mojo-V-ISA-Spezifikation v1.02
- veröffentlicht in doc/
Spike (Instruction-Set-Simulator) mit Mojo-V-Erweiterungen
- Mojo-V integriert in riscv-isa-sim und funktionsvollständig für eine RV64GC-CPU mit ML-KEM-512-Schlüsselkapselung für das Laden von Datenverträgen und SIMON-128-Symmetrischer-Schlüsselverschlüsselung für den Schutz der Secret Computation.
- Um Spike mit aktivierten Mojo-V-Erweiterungen auszuführen, fügen Sie beim Ausführen von spike das Flag --isa=rv64gc_zicond_zkmojov_zicntr hinzu
Datenvertrags-Multitool

Datenverträge sind verschlüsselte Pakete, die der Hardware einer Mojo-V-CPU den Zugriff auf den Datenzugriffsschlüssel und Konfigurationsinformationen (z. B. Speicherverschlüsselungsmodus) für einen Mojo-V-verschlüsselten Datensatz ermöglichen. Das DC-Multitool ermöglicht die folgenden Funktionen:
- Hardwareentwickler können öffentliche/private ML-KEM512-Schlüsselpaare erstellen: Öffentliche Schlüssel werden mit Dienstanbietern geteilt, private Schlüssel werden in die Mojo-V-Hardwareimplementierung eingebettet.
- Dateneigentümer können Datenverträge erstellen und sie unter den öffentlichen ML-KEM512-Schlüsseln der Dienstanbieter verschlüsseln. Die passende Mojo-V-Hardware kann dann Secret Computation an den geschützten, von Dritten verschlüsselten Daten durchführen.
Mojo-V-Bringup-Bench-Benchmarks
- Vollständige Batterie von Sicherheitstests für RV64GC+Mojo-V
- Vollständige Batterie von Integritätsangriffstests für RV64GC+Mojo-V
- Vollständige Batterie von EXO-Compiler-Bibliothekstests
- Vollständige Batterien von EXO-Mathe- und String-Bibliothekstests
- Zahlreiche datenschutzorientierte Benchmarks, die mit der EXO-Mojo-V-Compiler-Bibliothek erstellt wurden
- Vollständige Batterie von Demonstrationsanwendungen für sichere Offenlegung
- Vollständige Batterie von zertifizierten TRNG-Demonstrationsanwendungen

Hinweis: Der Rest der Bringup-Bench-Benchmarks wurde noch nicht auf Mojo-V portiert.

⚙️ Erstellen und Ausführen der Mojo-V-Referenzplattform

A. Installieren Sie einen RISC-V-LLVM-Compiler

Sie benötigen einen LLVM-basierten RISC-V-Cross-Compiler, der in der Lage ist, RV64GC-Binärdateien zu erzeugen.

Hier ist ein guter Ausgangspunkt: https://github.com/openssl/openssl

B. Installieren Sie OpenSSL Version 3.6 oder neuer

Sie benötigen eine Entwicklerinstallation von OpenSSL Version 3.6 oder neuer. Diese stellt Bibliotheken bereit, die ML-KEM512 implementieren, das von Spike für den geschützten Schlüsselaustausch verwendet wird.

Hier ist ein guter Ausgangspunkt: https://clang.llvm.org/get_started.html

C. Klonen Sie das Mojo-V-Repository```bash

git clone https://github.com/toddmaustin/mojo-v.git cd mojo-v

### D. Den RISC-V-Spike-Simulator mit Mojo-V-Unterstützung bauen```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

E. Data-Contract-Multi-Tool erstellen und testen

Data Contracts sind verschlüsselte Pakete, die es der Hardware einer Mojo-V-CPU ermöglichen, auf den Datenzugriffsschlüssel und die Konfigurationsinformationen (z. B. den Speicherverschlüsselungsmodus) für einen verschlüsselten Mojo-V-Datensatz zuzugreifen.``` cd dc-tool make clean build test

### **E. Mojo-V Bringup-Bench-Benchmarktests erstellen und ausführen**

1. **Den Spike-Gerätetreiber erstellen**   ```bash
   cd bringup-bench/target
   make

Konfiguriere deinen Compiler

Bearbeite ../Makefile und setze TARGET_CC für das mojov-Ziel auf den Speicherort deines LVM-Clang-basierten RISC-V-Compilers.
Erstelle und teste die Bringup-Bench-Testprogramme ```bash cd .. # go to the top-level bringup-bench directory make TARGET=mojov-spike mojov-tests # run all Mojo-V tests

Als Alternative können Sie einen einzelnen Benchmark ausführen, indem Sie in dessen Verzeichnis wechseln und den folgenden Befehl ausführen. ```bash cd ../mojov-test make TARGET=mojov-spike clean build test

## 🧪 Übersicht der Mojo-V Bringup-Bench-Tests

| Programm | Beschreibung |
|:---------|:-------------|
| `mojov-test` | Einführungsbeispiel aus den Folien |
| `mojov-test1` | Tests zur Semantik von Secret-Registern und verschlüsseltem Speicher |
| `mojov-test2` | Handcodierter datenoblivierter Integer-Bubble-Sort-Benchmark mit Mojo-V-Schnellverschlüsselung (int,fast) |
| `mojov-test3` | Handcodierter datenoblivierter Gleitkomma-Bubble-Sort-Benchmark mit Mojo-V-Schnellverschlüsselung (fp,fast) |
| `mojov-test4` | Handcodierter datenoblivierter Integer-Bubble-Sort-Benchmark mit Mojo-V-Starkverschlüsselung (int,strong) |
| `mojov-test5` | Handcodierter datenoblivierter Gleitkomma-Bubble-Sort-Benchmark mit Mojo-V-Starkverschlüsselung (fp,strong) |
| `mojov-typetests` | Typsystem-Validierungstests für Mojo-V-verschlüsselte Typen und die EXO-Bibliotheksnutzung |
| `mojov-pctests` | Handcodierte Integritätsprüfungs-Testsuite für RV64GC+Mojo-V, die positive und negative Tests für Mojo-Vs beweisführendes Verschlüsselungsformat enthält (proofcarrying) |
| `mojov-sectests` | Handcodierte Sicherheits-Testsuite für RV64GC+Mojo-V mit 130 pos + 245 neg Tests == 375 gesamt (int,fp,fast,strong) |
| `mojov-stringtests` | Validierungstests der verschlüsselten EXO-Stringbibliothek für sichere Stringoperationen und -vergleiche |
| `mojov-mathtests` | Validierungstests der verschlüsselten EXO-Mathebibliothek für `_sincos`, `mojov_sin`, `mojov_cos`, `mojov_fabs`, `mojov_floor`, `mojov_pow`, `mojov_round` und `mojov_sqrt` |

Diese Test-Benchmarks demonstrieren die Mojo-V-ISA-Regeln, das Verhalten der EXO-Bibliothek und die Sicherheitssemantik.

## 🧪 Übersicht der Mojo-V Bringup-Bench-Benchmarks

Der aktuelle Bring-up-Benchmark-Satz umfasst die folgenden Mojo-V-Benchmark-Anwendungen:

| Programm | Beschreibung |
|:---------|:-------------|
| `bitonic-sort` | Datenoblivierter Bitonic-Sortier-Benchmark |
| `bloom-filter` | Bloom-Filter-Benchmark zur Mengenzugehörigkeit |
| `bubble-sort` | Integer-Bubble-Sort-Benchmark |
| `bubble-sort-strong` | Integer-Bubble-Sort-Benchmark, konfiguriert für starke Verschlüsselung |
| `chi-squared` | Chi-Quadrat-Benchmark zur statistischen Anpassungsgüte |
| `distinctness` | Benchmark zur Distinktheitsanalyse |
| `distinctness-Onlog2n` | Distinktheits-Benchmark-Variante mit O(n log² n)-Strategie |
| `edit-distance` | Editierdistanz-Benchmark (Stringdistanz) |
| `eulers-approx` | Benchmark zur Näherung der Euler-Konstante/-Reihe |
| `fft-int` | Integer-FFT-Benchmark |
| `flood-fill` | Flood-Fill-Benchmark |
| `flood-fill-On2` | Flood-Fill-Benchmark-Variante mit O(n²)-Verhalten |
| `fuzzy-match` | Benchmark zum unscharfen Stringabgleich |
| `gcd-list` | Benchmark zum größten gemeinsamen Teiler über eine Liste |
| `gemm` | Benchmark zur allgemeinen Matrixmultiplikation |
| `gemm-strong` | GEMM-Benchmark, konfiguriert für starke Verschlüsselung |
| `grad-descent` | Benchmark zur Gradientenabstiegs-Optimierung |
| `heat-calc` | Benchmark zur Wärmeübertragungs-/Wärmegleichungsberechnung |
| `heldkarp-tsp` | Held-Karp-Benchmark zum Problem des Handlungsreisenden mittels dynamischer Programmierung über verschlüsselten Graphen |
| `highlife` | HighLife-Zellularautomaten-Benchmark mit verschlüsselter Brettzustandsentwicklung |
| `kadane` | Benchmark zum maximalen Subarray (Kadane-Algorithmus) |
| `kalman-filter` | Kalman-Filter-Benchmark |
| `kcore-decomp` | Benchmark zur k-Kern-Zerlegung von Graphen |
| `kepler-calc` | Benchmark zur Kepler-Gleichung/numerischen Berechnung |
| `knapsack` | Rucksack-Optimierungsbenchmark |
| `lcs` | Datenoblivierter Benchmark zur längsten gemeinsamen Teilsequenz über verschlüsselten Strings |
| `lda` | Benchmark zur Latenten Dirichlet-Allokation |
| `manacher-lps` | Benchmark zum längsten palindromischen Teilstring (Manacher-Algorithmus) |
| `mersenne` | Benchmark zur Berechnung von Mersenne-Zahlen |
| `minspan` | Benchmark zur minimalen aufspannenden Struktur |
| `monte-carlo` | Monte-Carlo-Simulationsbenchmark |
| `moving-average` | Benchmark zur Analyse gleitender Mittelwerte |
| `moving-average-fp64` | FP64-Benchmark zur Analyse gleitender Mittelwerte |
| `nbody-sim` | N-Körper-Simulationsbenchmark |
| `nonlinear-nn` | Benchmark für nichtlineare neuronale Netze |
| `nr-solver` | Newton-Raphson-Löser-Benchmark |
| `ntt-kernel` | Benchmark zum Kernel der zahlentheoretischen Transformation |
| `packet-filter` | Paketfilter-Benchmark |
| `pagerank` | PageRank-Graphbenchmark |
| `parrondo` | Parrondo-Prozess/-Strategie-Benchmark |
| `partition-equal` | Benchmark zur Partitionierung in gleiche Teilmengensummen über verschlüsselten Mengen |
| `pca-analysis` | Benchmark zur Hauptkomponentenanalyse |
| `primal-test` | Benchmark zur Primzahltestung |
| `private-join` | Benchmark zum datenschutzfreundlichen Join |
| `psi` | Benchmark zur privaten Schnittmengenberechnung |
| `quartile-stats` | Benchmark zur Quartil-Analyse (Quartilschnitt und Quartilsmittelwert) über verschlüsselten Daten |
| `rabinkarp-search` | Rabin-Karp-Mustersuchbenchmark |
| `rad-to-deg` | Benchmark zur Umrechnung von Bogenmaß in Grad |
| `randshell-sort` | Benchmark zum randomisierten Shell-Sort |
| `ransac` | RANSAC-Modellanpassungsbenchmark |
| `regex-match` | Benchmark zum Abgleich regulärer Ausdrücke |
| `risk-score` | Benchmark zur Risikobewertungsanalyse |
| `scrambled-compare` | Benchmark zum Vergleich verschlüsselter Strings mittels verschlüsselter dynamischer Programmierung |
| `seq-align` | Benchmark zur globalen Sequenzausrichtung (Needleman-Wunsch) über verschlüsselten Strings |
| `shortest-path` | Benchmark zu kürzesten Pfaden in Graphen |
| `sieve` | Primzahl-Sieb-Benchmark |
| `skeleton` | Skelett-/Vorlagenbenchmark, verwendet als Bring-up-Baseline |
| `soundex` | Soundex-Benchmark zur phonetischen Kodierung |
| `string-search` | Stringsuchbenchmark |
| `tea-cipher` | TEA-Chiffre-Benchmark |
| `tiny-NN` | Benchmark zur Inferenz mit winzigen neuronalen Netzen |
| `triangle-count` | Benchmark zur Dreieckszählung in Graphen |
| `variability-sample` | Benchmark zu Variabilität und Stichprobenstatistik |
| `verlet` | Verlet-Integrations-Physikbenchmark |

## Übersicht der Mojo-V Safe-Disclosure-Demonstratoren

Mojo-V enthält drei Safe-Disclosure-Demonstrator-Benchmarks in `bringup-bench`. Diese Anwendungen nutzen beweisführenden verschlüsselten Speicher sowie verschlüsselte Daten-Grants, um zu zeigen, wie ein Programm über sensible Eingaben rechnen, nur ausdrücklich autorisierte abgeleitete Ergebnisse offenlegen und Versuche abfangen kann, einen Grant für einen anderen Wert, eine Roh-Eingabe, eine veraltete Berechnung, einen manipulierten Grant oder ein Zwischenprädikat wiederzuverwenden.

| Programm | Sensible Eingabe | Autorisierte Offenlegungen | Demonstrierte Schutzmaßnahmen |
|:---------|:----------------|:------------------------|:--------------------------|
| `private-auction` | Acht verschlüsselte private Gebote. | ID des Höchstbieters und Wert des Höchstgebots. | Findet das maximale Gebot mit verschlüsselten Vergleichen und `cmov()` und validiert anschließend die Daten-Grants pro Ausgabe. Negativfälle weisen nicht übereinstimmende Grants, die Offenlegung des Roh-Höchstgebots, gefälschte oder manipulierte Grants, veraltete Grants nach Änderung der Auktion, abgeleitete `winning_bid + 1`-Werte und Zwischenvergleichsprädikate zurück. |
| `vote-tally` | Zweiunddreißig verschlüsselte Stimmzettel über drei Kandidaten, einschließlich zweier ungültiger Stimmzettel. | Aggregierte Auszählungen für die Kandidaten A, B und C sowie Heilungsprädikate pro Stimmzettel. | Berechnet alle Kandidatenzählungen und Stimmzettelgültigkeitsprädikate in verschlüsselter Form. Negativfälle weisen die Verwendung eines Auszählungs-Grants für eine andere Auszählung, die Offenlegung roher Stimmzettel, gefälschte oder manipulierte Grants, veraltete Grants nach Änderung der Stimmzettel, abgeleitete Auszählungswerte und Zwischenstimmzettelprädikate zurück. |
| `gene-risk` | Acht verschlüsselte SNP-Marker-Dosierungen für eine Spielzeug-Genomrisiko-Workload. | Ein abgeleiteter polygener Risikoscore und ein niedriger/mittlerer/hoher Risiko-Bucket. | Akkumuliert einen gewichteten Risikoscore und leitet den Risiko-Bucket mit verschlüsselten Prädikaten und `cmov()` ab. Negativfälle weisen die Kreuzverwendung von Score- und Bucket-Grants, die Offenlegung roher Marker, gefälschte oder manipulierte Grants, veraltete Grants nach Änderung des Genoms, abgeleitete Score-Werte und Zwischenprädikate für hohes Risiko zurück. |

Jeder Demonstrator ist in `MOJOV_DISCAPPS` aufgeführt und gehört damit zur Safe-Disclosure-Anwendungsbatterie. Um einen direkt auszuführen, wechseln Sie in dessen Benchmark-Verzeichnis und verwenden Sie das Mojo-V-Ziel, zum Beispiel:```bash
cd bringup-bench/private-auction
make TARGET=mojov-spike clean build test

Verwende Spikes Option --mojov-arg=<n>, um beim manuellen Ausführen eines Demonstrators den positiven Pfad (0) oder einen der negativen Offenlegungstests (1 und höher) auszuwählen.

Übersicht der Mojo-V-zertifizierten TRNG-Demonstratoren

Mojo-V enthält drei zertifizierte Demonstrator-Benchmarks für echte Zufallszahlengeneratoren (CERTRNG) in bringup-bench. Sie verwenden unterschiedliche CERTRNG-Sites, beweisbare verschlüsselte Berechnung und fordern Nonces an, um zu zeigen, dass ein Client verifizieren kann, wo frische Zufallswerte in eine genehmigte Berechnung eingegangen sind. Die Ergebnisse bleiben bis zur Empfangsvalidierung und Verpflichtung verschlüsselt. Die negativen Fälle zeigen, dass softwaregenerierte Zufälligkeit, fehlende oder wiederverwendete Ziehungen, falsche Site-Zuweisungen, veraltete Anfragen, veränderte Berechnungsgraphen und verzerrtes Resampling den ehrlichen Datengewährungsvertrag nicht erfüllen. Sie zeigen auch eine wichtige Grenze: Zertifizierte Zufälligkeit allein kann Grinding nicht verhindern, wenn Ergebnisse (mit Mojo-V-DISC- oder FDISC-Anweisungen) vor der Verpflichtung offengelegt werden.

Diese Demonstratoren sind in MOJOV_CERTRNG_APPS aufgeführt, sodass sie in die Mojo-V-Benchmark-Batterie aufgenommen werden. Führe einen direkt aus seinem Verzeichnis aus, zum Beispiel:```bash cd bringup-bench/blind-audit make TARGET=mojov-spike clean build test

Use Spike's `--mojov-arg=<n>`-Option, wenn du einen Demonstrator manuell ausführst. Fall
`0` ist der ehrliche Pfad, niedrig nummerierte Fälle sind erfolgreiche erklärende Kontrollen,
und Fälle `10` und höher sind Angriffe, von denen erwartet wird, dass sie mit einer Mojo-V-
Sicherheitsausnahme enden. Die genaue Matrix für jede Anwendung ist in ihrer
benchmark-lokalen `README.md` dokumentiert.


## 🛠️ Mojo-V Data Contract Multi-Tool-Nutzung

Das Data-Contract-Multi-Tool „dc-tool" wird verwendet, um Mojo-V-Datenverträge zu erstellen und zu validieren.

Um ein ML-KEM512-Public/Private-Key-Paar zu erstellen, führe den folgenden Befehl aus. Beachte, dass der öffentliche Schlüssel mit Drittanbieter-Datenanbietern geteilt werden muss, um Datenverträge vorzubereiten. Private Schlüssel werden in der Hardware (oder im Simulator) installiert.```bash
./dc-tool keygen <pk_file> <sk_file>          # public key in <pk_file>, private key in <sk_file>

Sobald ein öffentliches/privates Schlüsselpaar existiert, ist es möglich, verschlüsselte Datenverträge zu erstellen. Ein Datenvertrag enthält einen verschlüsselten Datenzugriffsschlüssel (für Mojo-V-Hardware zum Zugriff auf Daten Dritter) und eine verschlüsselte Speichermodus-Konfiguration. Führen Sie den folgenden Befehl aus, um einen verschlüsselten Datenvertrag zu erstellen.```bash ./dc-tool dcgen <pk_file> {fast,strong,proof-carrying} <ct_file> # specify mem mode, contract in <ct_file>

Die gemeinsame Nutzung eines verschlüsselten Datenvertrags mit der Mojo-V-Hardware, der dem öffentlichen ML-KEM512-Schlüssel entspricht, der zum Verschlüsseln des Vertrags verwendet wurde, ermöglicht es der Mojo-V-fähigen CPU, geheime Berechnungen an den geschützten Drittanbieterdaten durchzuführen. Um zu validieren, dass der verschlüsselte Vertrag gültig ist, verwenden Sie die folgenden Befehle.```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>

🛠️ Mojo-V-spezifische Optionen, die zum RISC-V-Spike-ISA-Simulator hinzugefügt wurden

Die folgenden Optionen wurden zu Spike, dem Standard-RISC-V-ISA-Simulator, hinzugefügt.```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>

## 🧠 Mojo-V-Programmierübersicht

Die Mojo-V-Softwareentwicklung verwendet derzeit die EXO-Compilerbibliothek und folgt sicheren datenoblivischen Codierungspraktiken:

1. **Programmierung mit den EXO-Bibliotheksheadern**
   - Binde `exo/mojov-exo.h` ein, um auf das Mojo-V-Programmierframework und die verschlüsselten Typabstraktionen zuzugreifen.
   - Binde `exo/mojov-math.h` ein, um auf verschlüsselte Mathematikunterstützung und Hilfsoperationen zuzugreifen.

2. **Verwendung datenoblivischer Berechnungen für verschlüsselte Variablen**
   - Verschlüsselte Werte müssen mit datenoblivischen Kontrollflüssen und Speicherzugriffsmustern manipuliert werden, um Mojo-Vs Ziele der stillen Ausführung und Seitenkanalresistenz zu wahren.

3. **Befolge das EXO-Programmiertutorial**
   - Siehe den EXO-Programmierleitfaden: [exo/EXO-library-programming.md](https://github.com/toddmaustin/mojo-v/blob/main/exo/EXO-library-programming.md)

4. **Details zu Compilerstruktur und Architektur in der EXO-Dokumentation**
   - Interne Struktur und Designkontext für den aktuellen Mojo-V-Compiler-/Bibliotheksansatz sind dokumentiert in: [exo/EXO-library-overview.md](https://github.com/toddmaustin/mojo-v/blob/main/exo/EXO-library-overview.md)

---
## Code-Lizenzierung
Der gesamte Mojo-V-bezogene Code in diesem Repository wird unter der Lizenz des jeweiligen modifizierten Tools (z. B. Spike, LLVM, Bringup-Bench) veröffentlicht. Details zur Lizenzierung findest du in den jeweiligen Tool-Verzeichnissen.

---

## 💬 Fragen & Feedback
Wir freuen uns über Beiträge, Fehlerberichte und Vorschläge!

📧 **E-Mail:** [[email protected]](mailto:[email protected])  
🌐 **Projekt-Homepage:** [https://github.com/toddmaustin/mojo-v](https://github.com/toddmaustin/mojo-v)

`blind-audit`	Wählt einen von acht Prüfdatensätzen aus, indem das Minimum von acht verschiedenen, anfragegebundenen Zufallsprioritäten genommen wird.	Zertifiziert den vollständigen festen Argmin-Graphen; zeigt auch, dass ungenutzte Ziehungen den Empfang nicht beeinflussen und dass vorzeitige Offenlegung Grinding ermöglicht.	Lehnt ein erzwungenes Ziel, Software-RNG, eine fehlende oder veraltete Nonce, Wiederverwendung von Ziehungen, einen verworfenen Kandidaten, vertauschte Sites und die Wiedergabe einer vorberechneten Auswahl ab.
`diffpriv-count`	Fügt zentriertes Binomialrauschen, gebildet als Differenz zweier unabhängiger `Binomial(8, 1/2)`-Werte, zu einem verschlüsselten Zähler hinzu, wobei 16 verschiedene Zufallssites verwendet werden.	Zertifiziert den präzisen Rauschgenerierungs- und Anfragebindungsgraphen, während sowohl Rauschen als auch Antwort bis zur Validierung verborgen bleiben.	Lehnt ausgelassenes oder abgeschwächtes Rauschen, Software-RNG, günstiges Resampling und Wiedergabe veralteter Anfragen ab; unzusammenhängende ungenutzte Zufälligkeit bleibt außerhalb des Empfangs.
`certified-lotto`	Wählt den teilnehmer mit der höchsten Punktzahl unter acht verschlüsselten Einträgen aus und verwendet verschiedene anfragegebundene Prioritäten, um Punktgleichstände zu brechen.	Zertifiziert jeden Teilnehmer, jede Zufallssite, jede Nonce-Mischung und jeden Turnierschritt; demonstriert auch das Verhalten ungenutzter Ziehungen und die Grinding-Gefahr bei Offenlegung vor der Verpflichtung.	Lehnt einen ausgelassenen Teilnehmer, Software-RNG, eine übersprungene oder veraltete Nonce, Wiederverwendung von Ziehungen, vertauschte Sites und einen deterministischen Tie-Breaker ab.

mojo-v

Beliebteste