FalOS

Un sistema operativo escrito desde cero en Fal, un lenguaje de programación en español. Se construye en público, un día cada vez: cada día, un paso que se pueda ver, subido aquí y contado en TikTok.

Por qué

Casi todo el código que corre debajo de tus programas está escrito en C, y C deja leer y escribir la memoria fuera de donde toca. De ahí sale la mayoría de los agujeros graves: Microsoft calcula que cerca del 70 % de las vulnerabilidades que corrige son de este tipo, y Chromium da la misma cifra para las suyas.

Y entender cómo funciona un sistema operativo por dentro pasa casi siempre por leer C y leer inglés. FalOS intenta las dos cosas a la vez: un sistema escrito en un idioma que entiendes, en un lenguaje donde salirse de la memoria no es un descuido posible, sino un error que para el sistema y dice en qué línea.

Cómo

Hace falta el fal de la rama main, que es el que sabe compilar para arrancar sin sistema debajo (cómo funciona), y QEMU para tener un ordenador virtual:

git clone https://github.com/NissanBoss/Fal
cd Fal && go build -o fal .

fal haz_disco.fal

fal --arranca sistema.fal

haz_disco.fal compila lo que hay en programas/, lo junta con los textos de disco/ y hace un disco.img, y fal --arranca lo conecta solo.

El núcleo está en sistema.fal, y los tres programas que necesita para ver, oír y leer, en controladores/. Lo que se va añadiendo cada día está en el diario.

Hoy FalOS arranca, pasa al modo de 64 bits, escribe en la pantalla con colores y tildes, lee el teclado español con AltGr y entiende unas pocas órdenes: ayuda, limpia, hora, colores, encendido, memoria, programas, lanza, tareas, para, permisos, permite, prohibe, disco, lee, cuelga, rompe y reinicia. Lo que escribes se corrige con las flechas, y las de arriba y abajo traen las órdenes de antes.

Sabe cuánta memoria tiene y la reparte en páginas de 4 KB, que entrega siempre borradas. Monta sus propias tablas de páginas: su código es de solo lectura, los datos no se pueden ejecutar y la dirección 0 no existe, y eso lo hace cumplir el procesador.

El reloj y el teclado avisan por interrupciones, así que mientras espera, el procesador duerme.

Y corre programas, varios a la vez, cada uno con 10 ms de procesador por turno. Salen del disco, y FalOS no se cree lo que dicen: mira su cabecera antes de hacer una sola cuenta con ella, y si miente, no los carga. Van en el anillo 3, sin permisos, cada uno con sus propias tablas de páginas: no ven la memoria de nadie. Para hacer algo, tienen que pedírselo al sistema. Si intentan tocar un aparato o leer memoria ajena, el procesador los para y FalOS los cierra sin que caiga nada más.

lanza cuenta
lanza primos
lanza apaga
lanza espia
tareas

lanza gigante
lanza desborda
lanza fuera
lanza corto
lanza carta

Los programas nacen sin ningún permiso, tampoco el de hablar con otro. Se hablan con mensajes, una pregunta y una respuesta, y solo si tienen una llave: una capacidad que guarda el núcleo y que un programa no puede fabricar ni adivinar. Las das y las quitas tú, mientras corren:

lanza caja
lanza curioso
lanza ladron
permite 2 1
prohibe 2 1
permisos

El teclado, el disco y la pantalla ya no van dentro del núcleo. Son programas del anillo 3, y el procesador solo les deja tocar lo suyo: teclado, el puerto 96; disco, del 496 al 503; y pantalla, los puertos de la tarjeta gráfica y su imagen, y lee lo que hay que pintar sin poder cambiarlo. Si uno se cuelga o se rompe, FalOS lo nota, lo cierra y lanza otro sin que caiga nada más. Se puede probar:

lanza cuenta
cuelga teclado
rompe teclado
cuelga pantalla
rompe pantalla
disco
lee carta.txt
lanza fisgon
lanza impostor

Cada vez que se sube algo, GitHub lo arranca en QEMU, comprueba que llega a esperar órdenes sin reventar, lanza apaga y espia y mira que los dos acaban cerrados y el sistema sigue. Da un permiso, lo quita y mira que ladron no ha abierto nada. Cuelga y rompe el teclado, el disco y la pantalla, y comprueba que todo vuelve. Le da archivos que mienten sobre lo que son, y le conecta discos hechos para romperlo.

La idea a la que se quiere llegar es un micronúcleo con capacidades, como seL4: un núcleo pequeño que casi no hace nada, y cada programa y cada controlador en su propia caja, sin poder tocar lo que no se le ha dado expresamente. Los mensajes, las capacidades y tres controladores ya están. Falta sacar del núcleo lo que todavía vive en él.

Lo que no cubre

• Casi todo, de momento. No hay red ni ventanas ni ratón, y el disco solo se lee: no se puede escribir un programa dentro de FalOS. Es el día 6.
• Aún no es un micronúcleo. El teclado, el disco y la pantalla ya salieron, pero la consola, el cargador y el vigilante que los reinicia siguen dentro del núcleo, y un fallo ahí para todo. El núcleo no adelgaza: tiene unas 2.400 líneas, más que ayer, porque ahora también carga programas.
• Nadie comprueba quién escribió un programa. No hay firmas. Quien pueda cambiar el disco puede cambiar un programa, y FalOS lo lanzará. Lo que le protege es la caja, no saber de dónde viene.
• La cabecera se mira, el código no. Un programa que no miente sobre su forma se carga aunque sea malo. Hace lo que quiera dentro de su caja.
• El programa de la pantalla ve todo lo que se pinta, y puede pintar mentiras. No puede cambiar lo que escribe el núcleo, pero sí enseñarte otra cosa. Aún no hay nada en la pantalla de lo que te puedas fiar del todo.
• Los gráficos son los de la tarjeta de QEMU. Con otra tarjeta, FalOS se queda en modo de texto. En un portátil de verdad haría falta otro camino.
• La letra tiene 119 caracteres. El español y poco más.
• El programa del teclado ve todo lo que escribes. Está en su caja y no puede hacer nada más, pero si alguien lo cambiara por otro, lo leería todo.
• El disco es el IDE de siempre. Es el que trae QEMU, no el de un portátil de ahora, y el formato es uno de texto propio: ni FAT, ni nada que escriba otro sistema.
• Un controlador que se cae siempre se relanza siempre. No hay espera ni tope, y la pantalla se llena.
• Un cuelgue tarda 1 s en notarse, o más. Solo cuenta el tiempo en que el controlador pudo contestar y no lo hizo, para que un programa que acapare el procesador no lo haga parecer colgado. Con el procesador lleno son varios segundos de reloj. Las teclas que caben en la cola del aparato llegan después. Las que no, se pierden.
• No hay prioridades. Tres programas que gasten todo lo que les dan dejan a los controladores con un cuarto del procesador, y todo va más lento.
• Las capacidades solo cubren hablar con otro programa. La línea de la pantalla, el procesador, la memoria y los puertos se reparten sin ellas. Y las das tú desde la consola: un programa no le puede pasar una a otro.
• seL4 está demostrado matemáticamente, y FalOS no. Copiar la idea no copia la demostración.
• Solo el teclado español. Y sin €: todavía no lo he dibujado.
• Solo el primer giga de memoria. Si el ordenador tiene más, el resto no se usa todavía.
• No es seguro todavía. Está diseñado para el aislamiento, que no es lo mismo. Un sistema es seguro cuando alguien de fuera intenta romperlo y no puede, y eso aquí aún no ha pasado. No lo uses para nada que importe.
• Solo se ha probado en QEMU. En un ordenador de verdad debería arrancar con GRUB, pero no se ha comprobado.
• Solo x86-64 y arranque por BIOS (multiboot). Ni ARM ni UEFI.

Filosofía

• Un día, un paso que se vea. Mejor poco y funcionando que mucho a medias.
• No se promete lo que no se ha comprobado. Lo que dice este README lo comprueba la prueba automática, o no lo dice.
• Nadie tiene más permisos de los que necesita. Tampoco el propio núcleo.
• Los errores enseñan. Cuando algo falla, la pantalla dice qué, en qué línea y cómo arreglarlo, como en el resto de Fal.
• En castellano. El código, los mensajes y el diario.

Otros que hacen algo parecido

• SerenityOS también nació en público, con vídeos de su autor programándolo. Es C++ y quiere ser un escritorio completo; FalOS va a paso de día y pone el aislamiento por delante.
• TempleOS se escribió en un lenguaje propio, HolyC, pero sin ninguna protección: todo corre con todos los permisos. FalOS es lo contrario.
• Redox es un micronúcleo en Rust, con la misma idea de seguridad de memoria. Está mucho más avanzado; FalOS se construye desde cero y a la vista, para que se entienda cada paso.
• Qubes OS aísla con máquinas virtuales sobre Xen y Linux. FalOS busca ese aislamiento en el diseño del propio núcleo, sin máquinas virtuales.

Licencia

MIT.