toddmaustin/mojo-vExtensão da ISA RISC-V para computação secreta reforçada por hardware usando encapsulamento de chaves ML-KEM-512 e criptografia SIMON-128, permitindo execução data-oblivious com desempenho próximo ao nativo.
Mojo-V (pronunciado “mojo-five”) é uma nova extensão RISC-V que introduz capacidades de programação voltadas à privacidade para RISC-V. Mojo-V implementa computação secreta, permitindo execução segura, eficiente e independente dos dados, sem depender de software frágil ou da confiança no programador. Ao isolar dados sensíveis em registradores secretos dedicados e criptografar a memória sob uma chave de terceiros, Mojo-V previne divulgações e impõe uma computação que é tanto cega (sem divulgações diretas) quanto silenciosa (sem vazamento por canais laterais). O design integra-se perfeitamente à ISA RISC-V existente com apenas um bit de modo e quatro novas instruções, imposto inteiramente na decodificação. Os primeiros resultados mostram velocidades de execução próximas às nativas, ao mesmo tempo em que oferecem uma melhoria de desempenho de 5 a 7 ordens de grandeza em comparação com a criptografia totalmente homomórfica (FHE), com um roteiro claro para integração em CPUs, GPUs e aceleradores especializados.
Para saber mais...
A Especificação Atual da Extensão de ISA Mojo-V (lançamento 1.02):
Para entrar em contato com os desenvolvedores de Mojo-V:
A Plataforma de Referência Mojo-V, lançamento 1.03, implementa uma plataforma de simulação Spike de referência para RISC-V RV64GC e o compilador EXO para a Especificação de ISA Mojo-V v1.02. A implementação atual suporta modos de criptografia rápidos, fortes e com prova, juntamente com a divulgação segura de resultados de computação criptografados e geração certificada de números aleatórios. O lançamento inclui uma ampla gama de testes Mojo-V, benchmarks voltados à privacidade e aplicações demonstrativas para divulgação segura. Também inclui a especificação completa da ISA Mojo-V e a documentação para desenvolvedores.
Este lançamento é adequado para uso como i) uma plataforma de desenvolvimento de aplicações Mojo-V, ii) um modelo de referência para validar implementações de hardware Mojo-V e iii) uma implementação de referência para análise de segurança. O trabalho atual concentra-se no desenvolvimento de i) um compilador Mojo-V baseado em LLVM, ii) um modelo Mojo-V baseado em gem5 para exploração e análise arquitetural e iii) uma implementação RTL de referência CVA6 SystemVerilog de RISC-V RV64GC com extensões Mojo-V.
Versão da Especificação: 1.02 (agosto de 2026)
Contato: [email protected]
Especificação de ISA Mojo-V v1.02
doc/Spike (Simulador de Conjunto de Instruções) com Extensões Mojo-V
riscv-isa-sim, e funcionalmente completo para uma CPU RV64GC com encapsulamento de chave ML-KEM-512 para carregamento de contrato de dados e criptografia de chave simétrica SIMON-128 para proteção da computação secreta.--isa=rv64gc_zicond_zkmojov_zicntr ao executar spikeFerramenta Multiuso de Contrato de Dados
Contratos de dados são pacotes criptografados que permitem que o hardware de uma CPU Mojo-V acesse a chave de acesso a dados e as informações de configuração (por exemplo, modo de criptografia de memória) para um conjunto de dados criptografados Mojo-V. A Ferramenta Multiuso DC permite as seguintes capacidades:
Benchmarks Mojo-V Bringup-Bench
Nota: o restante dos benchmarks Bringup-bench ainda NÃO foi portado para Mojo-V.
Você precisará de um compilador cruzado RISC-V baseado em LLVM capaz de produzir binários RV64GC.
Aqui está um bom lugar para começar: https://github.com/openssl/openssl
Você precisará de uma instalação de desenvolvedor do OpenSSL versão 3.6 ou mais recente. Isso fornece bibliotecas que implementam ML-KEM512, usadas pelo Spike para troca de chaves protegida.
Aqui está um bom lugar para começar: https://clang.llvm.org/get_started.html
git clone https://github.com/toddmaustin/mojo-v.git cd mojo-v
### D. Construir o simulador RISC-V Spike com suporte 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
Os contratos de dados são pacotes criptografados que permitem que o hardware de uma CPU Mojo-V acesse a chave de acesso a dados e as informações de configuração (por exemplo, modo de criptografia de memória) para um conjunto de dados criptografados Mojo-V.``` cd dc-tool make clean build test
### **E. Compilar e executar os testes de benchmark Bringup-Bench do Mojo-V**
1. **Compilar o driver de dispositivo Spike** ```bash
cd bringup-bench/target
make
Configure seu compilador
Edite o ../Makefile e defina TARGET_CC para o alvo mojov como a localização do seu compilador LVM baseado em Clang para RISC-V.
Compile e teste os programas de teste do Bringup-Bench ```bash cd .. # go to the top-level bringup-bench directory make TARGET=mojov-spike mojov-tests # run all Mojo-V tests
Como alternativa, você pode executar um benchmark individual entrando em seu diretório e executando o seguinte comando. ```bash cd ../mojov-test make TARGET=mojov-spike clean build test
## 🧪 Visão Geral dos Testes Mojo-V Bringup-Bench
| Programa | Descrição |
|:---------|:-------------|
| `mojov-test` | Exemplo introdutório dos slides |
| `mojov-test1` | Testes de semântica de registros secretos e memória criptografada |
| `mojov-test2` | Benchmark de bubble-sort de inteiros data-oblivious codificado manualmente com criptografia rápida Mojo-V (int,fast) |
| `mojov-test3` | Benchmark de bubble-sort de ponto flutuante data-oblivious codificado manualmente com criptografia rápida Mojo-V (fp,fast) |
| `mojov-test4` | Benchmark de bubble-sort de inteiros data-oblivious codificado manualmente com criptografia forte Mojo-V (int,strong) |
| `mojov-test5` | Benchmark de bubble-sort de ponto flutuante data-oblivious codificado manualmente com criptografia forte Mojo-V (fp,strong) |
| `mojov-typetests` | Testes de validação do sistema de tipos para tipos criptografados Mojo-V e uso da biblioteca EXO |
| `mojov-pctests` | Suíte de testes de verificação de integridade codificada manualmente para RV64GC+Mojo-V que inclui testes positivos e negativos para o formato de criptografia proof-carrying do Mojo-V (proofcarrying) |
| `mojov-sectests` | Suíte de testes de segurança codificada manualmente para RV64GC+Mojo-V que inclui 130 testes positivos + 245 negativos == 375 no total (int,fp,fast,strong) |
| `mojov-stringtests` | Testes de validação da biblioteca de strings EXO criptografada para operações e comparações seguras de strings |
| `mojov-mathtests` | Testes de validação da biblioteca matemática EXO criptografada para `_sincos`, `mojov_sin`, `mojov_cos`, `mojov_fabs`, `mojov_floor`, `mojov_pow`, `mojov_round` e `mojov_sqrt` |
Esses benchmarks de teste demonstram as regras da ISA Mojo-V, o comportamento da biblioteca EXO e as semânticas de segurança.
## 🧪 Visão Geral dos Benchmarks Mojo-V Bringup-Bench
O conjunto atual de benchmarks de bring-up inclui os seguintes aplicativos de benchmark Mojo-V:
| Programa | Descrição |
|:---------|:-------------|
| `bitonic-sort` | Benchmark de ordenação bitônica data-oblivious |
| `bloom-filter` | Benchmark de pertinência a conjunto com filtro de Bloom |
| `bubble-sort` | Benchmark de bubble-sort de inteiros |
| `bubble-sort-strong` | Benchmark de bubble-sort de inteiros configurado para criptografia forte |
| `chi-squared` | Benchmark estatístico de qui-quadrado de qualidade de ajuste |
| `distinctness` | Benchmark de análise de distintividade |
| `distinctness-Onlog2n` | Variante do benchmark de distintividade com estratégia O(n log² n) |
| `edit-distance` | Benchmark de distância de edição (distância entre strings) |
| `eulers-approx` | Benchmark de aproximação da constante/série de Euler |
| `fft-int` | Benchmark FFT de inteiros |
| `flood-fill` | Benchmark de preenchimento por inundação (flood-fill) |
| `flood-fill-On2` | Variante do benchmark de flood-fill com comportamento O(n²) |
| `fuzzy-match` | Benchmark de correspondência difusa de strings |
| `gcd-list` | Benchmark de máximo divisor comum sobre lista |
| `gemm` | Benchmark de multiplicação geral de matrizes |
| `gemm-strong` | Benchmark GEMM configurado para criptografia forte |
| `grad-descent` | Benchmark de otimização por descida de gradiente |
| `heat-calc` | Benchmark de cálculo de transferência/equação de calor |
| `heldkarp-tsp` | Benchmark do caixeiro-viajante por programação dinâmica de Held-Karp sobre grafos criptografados |
| `highlife` | Benchmark de autômato celular HighLife com evolução de estado do tabuleiro criptografado |
| `kadane` | Benchmark de subarray máximo (algoritmo de Kadane) |
| `kalman-filter` | Benchmark de filtragem de Kalman |
| `kcore-decomp` | Benchmark de decomposição de k-core de grafos |
| `kepler-calc` | Benchmark de equação/cálculo numérico de Kepler |
| `knapsack` | Benchmark de otimização de mochila (knapsack) |
| `lcs` | Benchmark data-oblivious da maior subsequência comum sobre strings criptografadas |
| `lda` | Benchmark de alocação latente de Dirichlet |
| `manacher-lps` | Benchmark da maior substring palíndroma (algoritmo de Manacher) |
| `mersenne` | Benchmark de cálculo de números de Mersenne |
| `minspan` | Benchmark de estrutura geradora mínima |
| `monte-carlo` | Benchmark de simulação de Monte Carlo |
| `moving-average` | Benchmark analítico de média móvel |
| `moving-average-fp64` | Benchmark analítico de média móvel FP64 |
| `nbody-sim` | Benchmark de simulação de N-corpos |
| `nonlinear-nn` | Benchmark de rede neural não linear |
| `nr-solver` | Benchmark de solucionador de Newton-Raphson |
| `ntt-kernel` | Benchmark de kernel de transformada teórica de números |
| `packet-filter` | Benchmark de filtragem de pacotes |
| `pagerank` | Benchmark de grafo PageRank |
| `parrondo` | Benchmark de processo/estratégia de Parrondo |
| `partition-equal` | Benchmark de partição de soma de subconjunto igual sobre conjuntos criptografados |
| `pca-analysis` | Benchmark de análise de componentes principais |
| `primal-test` | Benchmark de teste de primalidade |
| `private-join` | Benchmark de junção com preservação de privacidade |
| `psi` | Benchmark de interseção privada de conjuntos |
| `quartile-stats` | Benchmark analítico de corte de quartis e média de quartis sobre dados criptografados |
| `rabinkarp-search` | Benchmark de busca de padrões de Rabin-Karp |
| `rad-to-deg` | Benchmark de conversão de radianos para graus |
| `randshell-sort` | Benchmark de Shell-sort aleatorizado |
| `ransac` | Benchmark de ajuste de modelo RANSAC |
| `regex-match` | Benchmark de correspondência de expressões regulares |
| `risk-score` | Benchmark analítico de pontuação de risco |
| `scrambled-compare` | Benchmark de comparação de strings embaralhadas usando programação dinâmica criptografada |
| `seq-align` | Benchmark de alinhamento global de sequências (Needleman-Wunsch) sobre strings criptografadas |
| `shortest-path` | Benchmark de caminho mais curto em grafos |
| `sieve` | Benchmark de crivo de primos |
| `skeleton` | Benchmark esqueleto/modelo usado como linha de base de bring-up |
| `soundex` | Benchmark de codificação fonética Soundex |
| `string-search` | Benchmark de busca de strings |
| `tea-cipher` | Benchmark de cifra TEA |
| `tiny-NN` | Benchmark de inferência de rede neural minúscula |
| `triangle-count` | Benchmark de contagem de triângulos em grafos |
| `variability-sample` | Benchmark de variabilidade e estatísticas de amostragem |
| `verlet` | Benchmark de física de integração de Verlet |
## Visão Geral dos Demonstradores de Divulgação Segura Mojo-V
O Mojo-V inclui três benchmarks demonstradores de divulgação segura em `bringup-bench`. Esses aplicativos usam memória criptografada proof-carrying além de concessões de dados criptografadas para mostrar como um programa pode computar sobre entradas sensíveis, divulgar apenas resultados derivados explicitamente autorizados e capturar tentativas de reutilizar uma concessão para um valor diferente, entrada bruta, computação obsoleta, concessão adulterada ou predicado intermediário.
| Programa | Entrada sensível | Divulgações autorizadas | Proteções demonstradas |
|:---------|:----------------|:------------------------|:--------------------------|
| `private-auction` | Oito lances privados criptografados. | ID do licitante vencedor e valor do lance vencedor. | Encontra o lance máximo com comparações criptografadas e `cmov()`, e então valida as concessões de dados por saída. Os casos negativos rejeitam concessões incompatíveis, divulgação bruta do lance vencedor, concessões falsas ou adulteradas, concessões obsoletas após alterar o leilão, valores derivados de `winning_bid + 1` e predicados intermediários de comparação. |
| `vote-tally` | Trinta e dois votos criptografados entre três candidatos, incluindo dois votos inválidos. | Contagens agregadas para os candidatos A, B e C, além de predicados de cura por voto. | Calcula todas as contagens de candidatos e predicados de validade de voto em forma criptografada. Os casos negativos rejeitam usar uma concessão de contagem para outra contagem, divulgação bruta de voto, concessões falsas ou adulteradas, concessões obsoletas após modificar os votos, valores derivados de contagem e predicados intermediários de voto. |
| `gene-risk` | Oito dosagens de marcadores SNP criptografados para uma carga de trabalho genômica de risco de brinquedo. | Um escore de risco poligênico derivado e um compartimento de risco baixo/médio/alto. | Acumula um escore de risco ponderado e deriva o compartimento de risco com predicados criptografados e `cmov()`. Os casos negativos rejeitam uso cruzado das concessões de escore e de compartimento, divulgação bruta de marcador, concessões falsas ou adulteradas, concessões obsoletas após alterar o genoma, valores derivados de escore e predicados intermediários de alto risco. |
Cada demonstrador está listado em `MOJOV_DISCAPPS`, portanto faz parte da bateria de aplicativos de divulgação segura. Para executar um diretamente, entre no diretório do benchmark e use o alvo Mojo-V, por exemplo:```bash
cd bringup-bench/private-auction
make TARGET=mojov-spike clean build test
Use a opção --mojov-arg=<n> do Spike para selecionar o caminho positivo (0) ou um dos testes negativos de divulgação (1 e superiores) ao executar um demonstrador manualmente.
O Mojo-V inclui três benchmarks demonstrativos de gerador certificado de números verdadeiramente aleatórios (CERTRNG) em bringup-bench. Eles usam sites CERTRNG distintos, computação criptografada com prova e nonces de solicitação para mostrar que um cliente pode verificar onde valores aleatórios novos entraram em uma computação aprovada. Os resultados permanecem criptografados até a validação do recibo e o comprometimento. Os casos negativos demonstram que aleatoriedade gerada por software, sorteios ausentes ou reutilizados, atribuições de sites incorretas, solicitações obsoletas, grafos de computação alterados e reamostragem tendenciosa não satisfazem a concessão honesta de dados. Eles também mostram um limite importante: a aleatoriedade certificada sozinha não pode impedir o grinding se os resultados forem divulgados (usando as instruções DISC ou FDISC do Mojo-V) antes do comprometimento.
Esses demonstradores estão listados em MOJOV_CERTRNG_APPS, portanto estão incluídos na bateria de benchmarks do Mojo-V. Execute um diretamente do seu diretório, por exemplo:```bash
cd bringup-bench/blind-audit
make TARGET=mojov-spike clean build test
Use a opção `--mojov-arg=<n>` do Spike ao executar um demonstrador manualmente. O caso `0` é o caminho honesto, os casos de número baixo são controles explicativos bem-sucedidos, e os casos `10` e superiores são ataques que devem terminar com uma exceção de segurança Mojo-V. A matriz exata para cada aplicação está documentada no `README.md` local do benchmark.
## 🛠️ Uso da Multi-ferramenta de Contrato de Dados Mojo-V
A multi-ferramenta de contrato de dados "dc-tool" é usada para criar e validar contratos de dados Mojo-V.
Para criar um par de chaves pública/privada ML-KEM512, execute o seguinte comando. Observe que a chave pública deve ser compartilhada com provedores de dados terceiros para preparar contratos de dados. As chaves privadas são instaladas no hardware (ou simulador).```bash
./dc-tool keygen <pk_file> <sk_file> # public key in <pk_file>, private key in <sk_file>
Uma vez que um par de chaves pública/privada exista, é então possível criar contratos de dados criptografados. Um contrato de dados contém uma chave de acesso a dados criptografada (para o hardware Mojo-V acessar dados de terceiros) e uma configuração de modo de memória criptografada. Execute o seguinte comando para criar um contrato de dados criptografado.```bash ./dc-tool dcgen <pk_file> {fast,strong,proof-carrying} <ct_file> # specify mem mode, contract in <ct_file>
Compartilhar um contrato de dados criptografado com o hardware Mojo-V que corresponde à chave pública ML-KEM512 usada para criptografar o contrato permitirá que a CPU habilitada para Mojo-V execute computação secreta nos dados protegidos de terceiros. Para validar se o contrato criptografado é válido, use os seguintes comandos.```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>
As seguintes opções foram adicionadas ao Spike, o simulador padrão de ISA RISC-V.```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>
## 🧠 Visão Geral da Programação Mojo-V
O desenvolvimento de software Mojo-V atualmente usa a biblioteca do compilador EXO e segue práticas seguras de codificação data-oblivious:
1. **Programe com os cabeçalhos da biblioteca EXO**
- Inclua `exo/mojov-exo.h` para acessar o framework de programação Mojo-V e as abstrações de tipos criptografados.
- Inclua `exo/mojov-math.h` para acessar o suporte matemático criptografado e operações auxiliares.
2. **Use computação data-oblivious para variáveis criptografadas**
- Valores criptografados devem ser manipulados com fluxo de controle data-oblivious e padrões de acesso à memória para preservar os objetivos de execução silenciosa e resistência a canais laterais do Mojo-V.
3. **Siga o tutorial de programação EXO**
- Consulte o guia de programação EXO: [exo/EXO-library-programming.md](https://github.com/toddmaustin/mojo-v/blob/main/exo/EXO-library-programming.md)
4. **Consulte detalhes da estrutura do compilador e da arquitetura na documentação EXO**
- A estrutura interna e o contexto de design para a abordagem atual de compilador/biblioteca do Mojo-V estão documentados em: [exo/EXO-library-overview.md](https://github.com/toddmaustin/mojo-v/blob/main/exo/EXO-library-overview.md)
---
## Licenciamento de Código
Todo o código relacionado ao Mojo-V neste repositório é distribuído sob a licença da ferramenta que foi modificada (por exemplo, Spike, LLVM, Bringup-Bench). Consulte os respectivos diretórios das ferramentas para obter detalhes de licenciamento.
---
## 💬 Perguntas e Comentários
Recebemos com satisfação contribuições, relatórios de bugs e sugestões!
📧 **E-mail:** [[email protected]](mailto:[email protected])
🌐 **Página do Projeto:** [https://github.com/toddmaustin/mojo-v](https://github.com/toddmaustin/mojo-v)
| Programa | Carga de trabalho de aleatoriedade certificada | Comportamento positivo | Proteções demonstradas |
|---|
blind-audit | Seleciona um dos oito registros de auditoria tomando o mínimo de oito prioridades aleatórias distintas e vinculadas à solicitação. | Certifica o grafo argmin fixo completo; também mostra que sorteios não usados não afetam o recibo e que a divulgação prematura permite grinding. | Rejeita um alvo forçado, RNG de software, um nonce ausente ou obsoleto, reutilização de sorteio, um candidato descartado, sites trocados e replay de uma seleção pré-computada. |
diffpriv-count | Adiciona ruído binomial centrado, formado pela diferença de dois valores independentes Binomial(8, 1/2), a uma contagem criptografada usando 16 sites aleatórios distintos. | Certifica o grafo preciso de geração de ruído e de vinculação à solicitação, mantendo tanto o ruído quanto a resposta ocultos até a validação. | Rejeita ruído omitido ou enfraquecido, RNG de software, reamostragem favorável e replay de solicitação obsoleta; aleatoriedade não relacionada e não usada permanece fora do recibo. |
certified-lotto | Escolhe o participante elegível com maior pontuação entre oito entradas criptografadas e usa prioridades distintas vinculadas à solicitação para desempate de pontuação. | Certifica cada participante, site aleatório, mistura de nonces e etapa do torneio; também demonstra o comportamento de sorteio não usado e o risco de grinding por divulgação antes do comprometimento. | Rejeita um participante omitido, RNG de software, um nonce pulado ou obsoleto, reutilização de sorteio, sites trocados e um desempate determinístico. |