Djinious
DjiniousSafeCode certifiable

Ce qui est prouvéest ce qui part en production.

La chaîne d’outils de code prouvé · IEC 61508 · SIL 4Prouver

DjiniousSafe est une chaîne d’outils pour construire des fonctions de sécurité conformes à l’IEC 61508 SIL 4 : spécifiez-les formellement en Lean 4, prouvez leurs propriétés de sécurité avec le noyau Lean, et générez du Rust no_std, sans panic — avec, à chaque build, un certificat vérifié par machine attestant que le code livré équivaut à la spécification, et une traçabilité complète des exigences jusqu’aux théorèmes.

DjiniousSafe
Pipeline de certification DjiniousSafe : les exigences (REQ-SF-xxx, YAML, SHA-256) alimentent une spécification Lean 4 vérifiée par le noyau, exportée sous forme d’IR canonique haché vers deux générateurs divers, l’un en Rust et l’autre en Lean ; un jalon d’équivalence exige des AST identiques, le Rust no_std émis est reparcouru, un certificat du noyau prouve qu’il est équivalent à la spécification, et un dossier de preuves clôt la chaîne.
Chaque flèche est un jalon à sécurité positive (fail-closed). Les générateurs ne sont jamais crus sur parole — un défaut dans l’un des deux est intercepté par son jumeau divers ou par le noyau Lean.
jalons à sécurité positive par build
13jalons à sécurité positive par buildle premier échec interrompt le build
générateurs divers
2générateurs diversl’un en Rust, l’autre en Lean — sorties identiques au byte près
théorèmes vérifiés par le noyau par fonction
5théorèmes vérifiés par le noyau par fonctionreprouvés à partir du code émis à chaque build
fonctions de sécurité de référence
9fonctions de sécurité de référencecertifiées de bout en bout dans examples/voter

Ce que c’est

Générez du Rust embarqué dont on peut prouver qu’il implémente sa spécification formelle

Un pipeline de génération de code de sécurité de Lean vers Rust. Il valide les exigences, exporte l’IR vérifiée par Lean, génère du Rust restreint, effectue les jalons d’équivalence et de comparaison croisée (back-to-back), et écrit un dossier de preuves d’audit pour les builds acceptés. Les builds en échec sont à sécurité positive.

Un DSL de sécurité Lean 4 contraint

Écrivez des fonctions de sécurité sous forme de machines à états, de transitions gardées, de flux de données booléens et à virgule fixe — et prouvez des propriétés de sécurité (invariants, atteignabilité d’un état sûr) avec le noyau Lean.

Lean 4

Génération diverse à double canal

Deux générateurs conçus indépendamment, l’un en Rust, l’autre en Lean, à partir de la même spécification. Leurs sorties doivent être structurellement identiques — toute divergence fait échouer le build.

sgen-a · sgen-b

Validation de traduction

Chaque build reparcourt le texte Rust émis, et le noyau Lean vérifie un certificat neuf attestant qu’il est sémantiquement équivalent à la spécification. Ce qui est prouvé est ce qui part en production.

Certificat du noyau

Sortie Rust restreint

Aucun tas, sans panic, sans unsafe, boucles bornées par des constantes, arithmétique saturante — prêt pour le compilateur qualifié Ferrocene.

#![no_std]

Traçabilité bidirectionnelle, vérifiée par machine

Exigence → théorème Lean → symbole Rust → vecteur de test. Le texte de l’exigence figé par hachage transforme tout impact de changement en erreur de build.

Matrice de traçabilité

Arithmétique à virgule fixe au format Q

Largeurs, mise à l’échelle et saturation explicites — ainsi que l’absence de dépassement et les obligations d’exactitude sur chaque constante, vérifiées par le noyau.

Q-format

Dans le produit

Voyez-la fonctionner.

Chaque capture ci-dessous est le produit en fonctionnement.

01 · Sécurité positive partout

Treize jalons, et le premier échec arrête le build

Un build exécute ses jalons dans un ordre fixe, et chaque jalon ajoute une ligne aux preuves. Les preuves, l’équivalence des générateurs, le certificat, la matrice de traçabilité et les tests de comparaison croisée sont tous des jalons stricts : le premier échec interrompt le build, l’erreur étant consignée comme détail de la ligne en échec — et aucun jalon suivant ne s’exécute.

  • requirements · lean-proofs · export-fresh · ir-load · trace
  • generate · equiv · reprint · certificate
  • b2b-host · no_std-check · b2b-target · evidence-finalize
  • b2b-target ne s’exécute que lorsqu’une [target] est configurée — sinon, il est absent des preuves, et non marqué comme ignoré

02 · Les générateurs ne sont jamais crus sur parole

Le même programme, écrit deux fois, par deux chaînes d’outils

Le texte Rust est produit deux fois, indépendamment : sgen-a abaisse l’IR exportée en Rust ; sgen-b l’imprime directement depuis la fonction de sécurité élaborée en Lean. Le jalon d’équivalence exige une identité d’AST, le jalon de réimpression une identité au byte près — un défaut doit se produire de façon identique dans les deux chaînes d’outils pour passer.

  • Chaque hash inter-langages est calculé deux fois — par une implémentation Lean de SHA-256 et par la crate Rust sha2 — et les deux sont consignés
  • L’artefact livré doit être canonique au byte près : print(parse(bytes)) == bytes
  • Les certificats sont construits à partir du code émis lui-même, jamais de l’état du générateur

03 · Fonctions de sécurité de référence

De l’exigence YAML au Rust no_std certifié

L’exemple voter porte neuf fonctions de sécurité de référence, de l’exigence jusqu’au code certifié : un voteur 2oo3, un déclenchement à verrouillage, un limiteur de débit, un moniteur de seuil à hystérésis, un bloc de gain, un bloc statistique, un bloc de rapport point à point, un interverrouillage de pression et une jauge de débit avec une limite f32 IEEE-754 — chacun livré avec un certificat d’équivalence vérifié par le noyau.

  • Chaque fichier généré porte sa ligne // TRACE: requirement
  • Pour chaque fonction, le certificat prouve la bonne formation, l’égalité structurelle exacte et la simulation pas à pas de la spécification
  • div, rem, sqrt et l’arithmétique i64 étendue certifiées sans panic
DjiniousSafe
Deux fonctions de sécurité de référence : le Rust généré pour l’étape du voteur 2oo3, tracé jusqu’à REQ-SF-001, et le certificat Lean pour le limiteur de débit avec ses théorèmes wfAll, structEqExact et d’équivalence pas à pas, chacun déchargé par decide.
Le code généré et son certificat, tous deux marqués « GENERATED. DO NOT EDIT. » — examples/voter, REQ-SF-001/002 et REQ-SF-010/011.

04 · Relecture sur cible

Comparaison croisée (back-to-back) sur l’hôte, et sur un Cortex-M4F émulé

Les vecteurs de référence côté Lean — produits croisés de bornes, séquences LCG de 8 × 32 pas et, pour les fonctions à bornes flottantes, des sondes f32 incluant NaN, ±inf, ±0 et les égalités d’arrondi — sont rejoués sur le code compilé, sur l’hôte. Quand une cible est configurée, les mêmes vecteurs sont rejoués sous QEMU sur thumbv7em-none-eabihf, avec le SHA-256 de chaque ELF rejoué figé dans les preuves.

  • Une graine de vecteurs fixe, si bien que chaque décompte est déterministe
  • Égalité de décompte entre l’hôte et la cible : pas de crédit partiel, pas de fonction manquante
  • Construire deux fois avec des sources et un environnement inchangés n’a produit aucune différence dans evidence.json, hashs ELF compris

IA et agents

Les agents appellent le même pipeline que vous

djsafe serve encapsule le pipeline existant sans dupliquer le comportement de build : les commandes CLI locales restent la source de vérité, et le service expose ces mêmes opérations via une API fournisseur prête pour les agents et un point de terminaison MCP.

01

API fournisseur

Capacités, identité et un document OpenAPI, avec build et clean comme opérations idempotentes.

02

Point de terminaison MCP

Les mêmes opérations sous forme d’outils MCP, pour qu’un agent puisse les découvrir et les invoquer.

03

Règles pour les agents

Découvrez les capacités avant d’invoquer des opérations, gardez les jetons hors des journaux et des résumés, rapportez les jalons en échec de façon assez littérale pour diagnostiquer le build, et demandez avant de déployer.

Capacités

La chaîne d’outils, crate par crate

Un seul CLI, djsafe, orchestre un espace de travail de petites crates à usage unique et un package Lean.

Spécification et preuve3 capacités

leansafe

Sémantique de sécurité, spécifications et code d’export en Lean : le DSL, l’absence de dépassement par intervalles, le pont de précision machine, le générateur côté Lean et l’export des vecteurs de comparaison croisée.

req-model

Analyse et hachage du modèle d’exigences — SHA-256 par exigence sur un texte normalisé au niveau des espaces.

safe-ir

L’IR de sécurité typée exportée depuis Lean et figée par hachage des deux côtés.

Génération et jalons5 capacités

sgen-a

Générateur Rust A, abaissant l’IR exportée.

rrust-syntax

L’analyseur et l’imprimeur de Rust restreint derrière la règle de canonicité au byte près.

equiv-gate

Le jalon d’équivalence des générateurs : identité d’AST, sinon le build échoue.

cert-gen

Génération de certificat : un terme Lean reconstruit à partir de l’artefact analysé, vérifié par le noyau.

trace

Génération de la matrice de traçabilité en JSON, CSV et HTML, rejetant nommément les exigences orphelines, les références inconnues et les fonctions non tracées.

Exploitation2 capacités

djsafe

CLI, orchestration du pipeline, service HTTP et commandes client distant — build et clean en local ou sur le service déployé.

Compétence djinious-safe-service

Une compétence pour agent IA permettant d’exploiter le service déployé.

Confiance

Une base de confiance bornée — et des limites honnêtes

Aucun composant seul n’est cru sur parole pour une affirmation qui n’est pas recoupée par un chemin structurellement différent. Toute affirmation porteuse peut être redérivée par un évaluateur sans se fier au rapport du pipeline lui-même.

Le noyau Lean est la racine de confiance

Toute affirmation sémantique se ramène à des preuves vérifiées par le noyau. Un audit des axiomes montre que les certificats ne dépendent que des axiomes standard de Lean — pas de sorry, pas de native_decide, pas d’axiome personnalisé.

Lean 4.15.0

Guide de vérification indépendante

Refigez une spécification avec votre propre tierce empreinte, repassez un certificat par le noyau, relancez tout le build et comparez les preuves, rejouez un binaire sur cible à la main, et faites transiter un artefact livré par l’analyseur puis l’imprimeur.

Prêt pour un compilateur qualifié

Les builds de code généré peuvent être dirigés vers Ferrocene via la configuration [toolchain] ; l’identité du compilateur est consignée dans chaque dossier de preuves. L’identité n’est pas une qualification, et les preuves le disent explicitement.

Ferrocene

Ce qui n’est pas affirmé

La validité des exigences reste une revue humaine. Aucune affirmation ne concerne le temps d’exécution, le WCET, les bornes de pile ou l’empreinte mémoire. QEMU valide le code machine compilé de façon croisée et la libcore cible, pas le silicium physique.

Dans le fil numérique

Ce qu’elle reçoit. Ce qu’elle transmet.

DjiniousSafe assure sa part de la boucle d’ingénierie et transmet ses preuves — et fonctionne tout aussi bien seule.

Seule

À elle seule, DjiniousSafe est une chaîne d’outils en ligne de commande : pointez djsafe vers un projet d’exigences et de spécifications Lean, et il renvoie du Rust embarqué certifié avec ses preuves — ou le jalon qui l’a refusé.

Réserver une démo

Voyez-la sur votre problème.

Voyez une fonction de sécurité passer de l’exigence au Rust embarqué certifié — et regardez le build refuser quand il le doit.

  1. Écrire une fonction de sécurité et ses propriétés dans le DSL de sécurité Lean 4
  2. Un build djsafe complet à travers les treize jalons, jusqu’à BUILD ACCEPTED
  3. Altérer un artefact généré et regarder le jalon du certificat le rejeter
  4. Lire le dossier de preuves : matrice de traçabilité, certificats, comparaison croisée et relecture sur cible
  5. Les choix de chaîne d’outils, la base de confiance, et ce que les preuves n’affirment pas