Produit phare · ParanoidBSD

Un système d’exploitation où l’autorité est détenue, pas présumée

Presque toutes les intrusions fonctionnent pareil : un programme atteint quelque chose qu’il n’aurait jamais dû toucher. ParanoidBSD est un système d’exploitation construit pour qu’il ne le puisse pas. Chaque programme ne reçoit que ce dont il a besoin, et tout le reste n’est pas seulement interdit — il est hors de portée. Bâti sur HardenedBSD, réécrit en C++ moderne, avec l’original conservé à côté pour que chaque changement puisse être vérifié contre lui.

LangageC / C++23
De baseHardenedBSD 15-STABLE
BureauKDE Plasma 6
Dernier envoirécemment
Étoiles—
Structure du dépôt
pbsd/Modules C++23 — cœur du noyau, portages de l’espace utilisateur, UDA, BIFROST, compositeur, thème
hbsd/Sources de HardenedBSD 15-STABLE — l’original, conservé comme spécification
kde/Plasma 6, KWin et les frameworks pour la vague bureau
tools/Inventaire, passes de réécriture déterministes, portage par agent, utilitaires Clang
docs/Spécifications, modèle de sécurité, état de la migration, provenance
scripts/Script pilote Windows Subsystem for Linux (WSL), chien de garde, console de progression
En clair

Ce que c’est, en une minute

Le problème

Un système d’exploitation se trouve sous tout le reste de ce qu’une organisation fait tourner. La plupart reposent sur des décennies de code ancien, et laissent n’importe quel programme demander n’importe quoi — le système décide après coup s’il autorise. C’est pour ça qu’une seule faille dans quelque chose d’anodin, comme le code qui dessine une police à l’écran, peut finir en mots de passe volés.

La solution

ParanoidBSD change, dès le départ, ce qu’un programme est capable de demander. Plutôt que de vérifier la permission après la demande, il remet à chaque programme une courte liste de ce qu’il peut toucher, et ne lui donne aucun moyen de nommer autre chose. Une faille dans une partie cesse d’être un chemin vers le reste.

À qui cela s’adresse

Les fournisseurs de la défense et de l’État à qui l’on demande désormais du logiciel écrit dans des langages plus sûrs. Les équipements qui restent des années sur le terrain et qu’on ne peut pas corriger vite — automates d’usine, machines médicales, matériel des réseaux publics. Les enseignants et les chercheurs qui veulent un vrai système d’exploitation, assez petit pour être lu de bout en bout.

La sécurité ne devrait pas commencer à la couche applicative. Elle devrait commencer par le système d’exploitation en dessous. Le reste de cette page, c’est l’ingénierie : ce qui a été changé, comment ça a été vérifié, et ce qui n’est pas encore fait.
Le problème

L’autorité ambiante est le bug qu’on ne peut pas corriger

Sur un Unix classique, un processus ne détient pas le droit d’ouvrir /etc/master.passwd. Il se contente de demander, et le noyau tranche ensuite, selon l’identité que le processus revendique. Tout processus peut nommer n’importe quelle ressource du système. L’espace de noms est global et ambiant ; le contrôle n’est qu’une arrière-pensée tardive.

C’est pourquoi un seul bug d’analyse dans un moteur de rendu de polices peut devenir un vol d’identifiants. Le moteur de rendu n’a jamais eu besoin du fichier de mots de passe — mais rien dans l’architecture ne l’empêchait de le demander.

HardenedBSD fait déjà un travail sérieux ici : la randomisation de la disposition de l’espace d’adressage (ASLR), qui charge un programme à un endroit différent à chaque fois pour qu’un attaquant ne puisse pas deviner où se trouve quoi ; l’intégrité du flot de contrôle (CFI), qui empêche de détourner un programme vers du code qu’il n’a jamais été conçu pour exécuter ; et, à côté, des protections dérivées de PaX, SafeStack et des allocateurs mémoire durcis. PBSD garde tout cela et change la forme de la question sous-jacente — de “ce processus a-t-il le droit ?” à “ce processus détient-il un descripteur vers cela ?”

Deux façons de répondre à un même appel système

// Ambient authority — the traditional path
int fd = open("/etc/master.passwd", O_RDONLY);
// kernel walks a global namespace, then
// checks uid/gid/MAC after the fact

// Handle nucleus — the PBSD path
auto f = dir_handle.open("master.passwd", Rights::Read);
// there is no global namespace to walk.
// no handle, no name, no operation.

Forme illustrative de la différence, pas une liste littérale des appels qu’un programme adresse au noyau — son interface de programmation applicative, ou API. Le modèle qui fait foi se trouve dans docs/.

Deux modèles d’autorité comparés côte à côte : sous l’autorité ambiante, le processus atteint les sockets, exec et ptrace et ne se voit refuser le fichier de mots de passe qu’après avoir demandé ; sous le noyau de descripteurs, seule la ressource dont il détient un descripteur peut seulement être nommée
faites défiler pour voir tout le schéma →
Où le contrôle a lieu. À gauche, la demande part toujours et n’est jugée qu’ensuite. À droite, trois des quatre opérations n’ont aucun nom avec lequel demander, il n’y a donc rien à refuser.
Interactif

Suivez un appel système à travers le noyau

Donnez des descripteurs au processus, choisissez ce qu’il doit tenter, et basculez entre les deux modèles d’autorité. Le verdict et le raisonnement sont calculés en direct dans votre navigateur — ceci est un modèle pédagogique de la conception, pas un émulateur de noyau.

Noyau de capacités — moniteur de référence

Le processus tente…

Trace

Descripteurs détenus par le processus

Verdict

En attente d’une tentative
Choisissez une opération pour la faire passer par le moniteur.
Atteignable
0
Refusé
0

“Atteignable” compte combien des opérations listées ce processus pourrait seulement effectuer sous le modèle courant. Sous l’autorité ambiante, l’atteignabilité est décidée par l’identité ; sous le noyau, par les descripteurs qu’il détient réellement.

Un modèle pédagogique de la conception de sécurité de PBSD, écrit pour cette page. Le vrai noyau se trouve dans pbsd/; la spécification est dans docs/specs/.
Le portage

Quatre étapes, et un modèle qui ne se certifie jamais lui-même

Porter à la main l’espace utilisateur et le noyau d’une Berkeley Software Distribution (BSD) vers C++23, c’est dix ans de travail. Le porter en demandant à un modèle de langage de réécrire les fichiers, c’est un moyen rapide de produire des ordures plausibles. PBSD ne fait ni l’un ni l’autre.

Le pipeline de portage de ParanoidBSD : inventaire, passes déterministes, boucle d’agent et contrôle de vérification, avec les fichiers rejetés qui repartent dans la boucle
faites défiler pour voir tout le schéma →
Comment un fichier devient un fichier porté. Le chemin rouge en pointillés est la partie qui compte — le travail qui échoue à la vérification repart dans la boucle au lieu d’être compté comme de l’avancement.
Étape 1

Inventaire

tools/inventory_c_sources.py et clang_cxx23_port.py notent chaque fichier C par difficulté et écrivent c_inventory.csv. Rien n’est deviné quant au périmètre.

Étape 2

Passes déterministes

run_todo_passes.py applique des réécritures mécaniques sûres, par paliers 0–4. Aucun modèle n’intervient. Tout ce qu’une passe refuse est consigné dans refusals.jsonl plutôt que forcé.

Étape 3

Boucle d’agent

pbsd.py remplit les fichiers ébauchés et refusés avec DeepSeek Flash, en escaladant vers Pro à effort de raisonnement maximal — 48 workers Flash et 24 Pro par défaut. C’est ce que finance le Kickstarter.

Étape 4

Contrôle de vérification

Compilation, ASan, UBSan, exécution différentielle et comparaison au niveau de la représentation intermédiaire (IR) du compilateur. Un fichier qui ne fait que compiler est non vérifié. Les échecs atterrissent dans agent_port_failures.jsonl.

Le démon BSD montré deux fois : à gauche la mascotte rouge d’origine, à droite la même figure rendue en fil de fer cyan, avec un signe égal entre les deux
Le projet en une image. Même démon, même forme, reconstruit dans une autre représentation — et le signe égal est la partie qu’il faut mériter, fichier par fichier, par vérification différentielle. BSD Daemon © Marshall Kirk McKusick.
Ce que “égal” doit vouloir dire

Un portage est une affirmation d’équivalence

Dire qu’un fichier a été porté, c’est dire que le nouveau se comporte comme l’ancien. C’est une affirmation, et une affirmation demande des preuves. Une réécriture C++23 qui compile est un fil de fer à l’air plausible ; ce n’est pas encore le même démon.

Le signe égal est donc le contrôle. L’exécution différentielle lance les deux et compare le comportement observable. La comparaison d’IR vérifie qu’ils veulent dire la même chose pour le compilateur. Tant que l’un des deux n’est pas passé, le fichier reste ouvert dans le journal de migration et ne compte pas dans l’avancement — aussi fini qu’il en ait l’air.

La règle qui rend cela défendable : le modèle ne s’auto-certifie pas. Il propose ; l’outillage déterministe dispose. Chaque règle non négociable du dépôt existe pour garder cette frontière intacte — et c’est aussi pourquoi on ne peut pas simplement accélérer le portage en dépensant davantage en inférence seule.
Règles non négociables

Les règles auxquelles le dépôt est réellement tenu

Aucun fichier n’est fini tant que la vérification différentielle ou par IR n’est pas passée
Compiler seulement est traité comme non vérifié. Un fichier porté doit soit produire un comportement observable identique à l’original HardenedBSD en exécution différentielle, soit correspondre au niveau de l’IR. Les fichiers qui ne passent ni l’un ni l’autre restent ouverts dans le journal de migration et ne sont pas comptés dans les chiffres d’avancement.
Porter fidèlement — ne pas “corriger” en silence les bugs de l’original
L’arbre HardenedBSD est la spécification de comportement. Si l’original a un défaut, le portage le reproduit, parce qu’un test différentiel ne sait pas distinguer un correctif d’une régression. Les améliorations viennent après, consignées à part, pour que le changement soit visible et relisable plutôt qu’enfoui dans une traduction.
L’outillage déterministe d’abord ; les modèles ne remplissent que le reste
Les réécritures mécaniques sont appliquées par des scripts qui se comportent à l’identique à chaque exécution. Les modèles ne servent que sur le résidu — les entrées d’inventaire ébauchées et les fichiers que les passes déterministes ont refusés. Cela garde la majeure partie du portage reproductible et auditable, et confine la sortie des modèles aux parties qu’un humain aurait de toute façon dû écrire à la main.
Le C++ du noyau est autonome : -fno-exceptions -fno-rtti
Le cœur du noyau ne peut pas dépendre d’un environnement d’exécution C++ hébergé. Pas d’exceptions, pas d’informations de type à l’exécution (RTTI), aucun chemin de la bibliothèque standard qui alloue sur le tas à l’entrée du noyau. Les contraintes sont écrites dans docs/specs/KERNEL_CXX_ABI.md pour qu’un contributeur puisse savoir ce qui est légal en contexte noyau sans avoir à deviner.
Chaque module a besoin d’une entrée de provenance avant d’être compté comme fini
docs/PROVENANCE.md consigne d’où vient chaque module et sous quelle licence. C’est ce qui rend la déclaration de licence ci-dessous vérifiable plutôt que déclarative — vous pouvez contrôler, module par module, quel code est dérivé de HardenedBSD et lequel est du nouveau travail PBSD.
Licences

Deux licences, honnêtement séparées

Le nouveau code PBSD — le cœur du noyau, les modules C++23, l’outillage — est proposé aux conditions habituelles d’Imortek : la licence publique générale GNU Affero (AGPL-3.0+), gratuite pour l’usage personnel, les associations, l’enseignement et les organisations à moins de 50 000 dollars australiens (AUD) par an, avec une licence commerciale par paliers au-delà.

Le code dérivé de HardenedBSD reste sous sa licence BSD d’origine. Il ne peut pas être relicencié et Imortek ne prétend pas le faire. docs/PROVENANCE.md est le registre de ce qui relève de l’une ou de l’autre.

Conditions de licence complètes →
AGPL-3.0+ & commerciale

Nouveau travail PBSD

pbsd/, tools/, scripts/, le noyau de capacités, UDA, BIFROST, le compositeur et le thème.

BSD (inchangée)

Dérivé de HardenedBSD

hbsd/ et chaque fichier porté qui y remonte. Conditions d’origine, attribution d’origine.

À qui cela s’adresse

Un système d’exploitation plus difficile à pénétrer

La plupart des intrusions exploitent le même genre d’erreur : un programme qui atteint de la mémoire qu’il n’aurait jamais dû toucher. ParanoidBSD reconstruit un système éprouvé dans un langage qui rend cette erreur bien plus difficile, et ne remet à chaque programme que les accès dont il a réellement besoin.

01

Fournisseurs de la défense et des administrations

Les acheteurs commencent à exiger des logiciels écrits dans des langages qui ferment des classes entières d’attaques. Repartir de zéro coûte dix ans. Ici, on fait plutôt traverser un système éprouvé, en gardant une trace écrite de chaque fichier modifié et de la façon dont ce changement a été contrôlé.

02

Des équipements qui restent des années sur le terrain

Automates d’usine, machines médicales, matériel de réseau public. Quand une faille apparaît, on ne peut souvent pas se contenter de pousser une mise à jour. Ceci limite jusqu’où va un intrus une fois entré, parce qu’aucun programme ne peut aller au-delà de ce qu’on lui a remis.

03

Universités et chercheurs en sécurité

Un vrai système d’exploitation, assez petit pour être lu de bout en bout, avec l’original à côté pour comparer. Utile pour enseigner et pour tester des idées sur quelque chose qui tourne vraiment.

Vous reconnaissez votre situation ? C’est ouvert aux tests bêta dès maintenant, et ce sont les retours des gens pour qui c’est construit qui le font réellement changer. Devenir bêta-testeur →
Kickstarter en ligne · clôture le 12 novembre 2026

Le portage tourne sur du calcul qu’il n’a pas

Les passes déterministes sont gratuites. La boucle d’agent qui remplit le résidu — et les exécutions de vérification qui la contrôlent — ne le sont pas. C’est toute la demande.