CLR

Comprobador de

Lifetimes (vida útil) y otros

Refinement types (tipos de refinamiento)

para Zig

Vídeo: https://www.youtube.com/watch?v=mf0WzTOe-40 Patrocinio: https://buymeacoffee.com/dnautics

discutir en hn: https://news.ycombinator.com/item?id=42923829

discutir en lobste.rs: https://lobste.rs/s/9sitsj/clr_checker_for_lifetimes_other

vídeo de demostración en vivo: https://www.youtube.com/watch?v=ZY_Z-aGbYm8

Resumen

Este proyecto crea un transpilador Zig para el compilador Zig, que transforma AIR (Intermediate Representation Abstracta) en código fuente Zig que realiza análisis estático en tiempo de compilación. El analizador generado detecta problemas de seguridad de memoria como uso antes de asignación, uso después de liberación, fugas de puntero de pila, así como UB específicos de Zig como aserciones de no nulidad, violaciones de uniones etiquetadas o mal uso de fieldParentPtr.

El objetivo es aportar garantías de seguridad de memoria al nivel de Rust a Zig mediante análisis estático de AIR, sin cambiar el lenguaje en sí.

CLR depende de una versión bifurcada del compilador Zig (incluida como submódulo en zig/) que agrega soporte para enrutar AIR a complementos externos. Cuando se invoca con -ofmt=air -fair-out=<plugin.so>, el compilador carga la biblioteca compartida especificada y le pasa el AIR generado para su procesamiento.

Arquitectura orientada a la seguridad

CLR está diseñado para empujar los programas hacia patrones de ciclo de vida que sean explícitos y verificables localmente, no simplemente para reconocer todo programa Zig técnicamente válido. Cuando dos representaciones son posibles, CLR prefiere aquella que hace visible el estado del recurso en el tipo y en la estructura de flujo de control.

Por ejemplo, evite cerrar condicionalmente un descriptor de archivo no opcional:

const file = try std.fs.cwd().openFile(path, .{});
if (should_close) {
    file.close(); // Mal: el archivo queda ambiguamente abierto después de esta rama.
}

Prefiera representar la propiedad condicional con un opcional:

var file: ?std.fs.File = null;
if (should_open) {
    file = try std.fs.cwd().openFile(path, .{});
}

if (file) |open_file| {
    open_file.close();
}

Cerrar condicionalmente un descriptor no opcional deja su ciclo de vida ambiguo después de la rama. La política prevista de CLR es rechazar ese patrón en lugar de llevar un estado permanente de "tal vez cerrado".

El mismo principio se aplica a los punteros asignados. No libere a través de un puntero derivado:

const allocation = try allocator.alloc(u8, size);
const payload = allocation[header_size..];
allocator.free(payload); // Mal: payload no es la base de la asignación.

Mantenga disponible el puntero base de la asignación para la desasignación, y use los punteros derivados solo para acceso:

const allocation = try allocator.alloc(u8, size);
defer allocator.free(allocation);

const payload = allocation[header_size..];
use(payload);

Liberar un puntero de campo, subsegmento o puntero producido por aritmética es rechazado a menos que una regla interna documentada restablezca la procedencia de la base de asignación.

Estas políticas son estrictas por defecto porque producen código con ciclos de vida de recursos más simples y más revisables. Un mecanismo futuro de anotación unsafe permitirá que GIDs u operaciones seleccionadas opten por no participar en análisis individuales. Eso respaldará código que acepta deliberadamente comprobaciones más débiles a cambio de rendimiento, sin debilitar el modelo predeterminado para el resto del programa.

Estado

Esta es una reescritura activa del prototipo original basado en Elixir en Zig. La implementación en Zig se carga como un complemento del compilador y analiza AIR directamente.

Actualmente implementado:

• Seguimiento de valores no definidos (uso antes de asignación, seguimiento a nivel de campo para estructuras)
• Análisis de seguridad de memoria (uso después de liberación, doble liberación, fugas de memoria, desajuste de asignador, fugas de pila)
• Cobertura completa de la interfaz std.mem.Allocator:
  • create/destroy - asignación de un solo elemento
  • alloc/free - asignación de segmentos (incluyendo alignedAlloc, allocSentinel, etc.)
  • realloc/remap - reasignación de segmentos con seguimiento de segmento anterior liberado
  • dupe/dupeZ - duplicación de segmentos
  • Detección de desajuste de asignador (liberar con asignador incorrecto, create/destroy vs alloc/free)
  • Tipos de asignador complejo (GPA, ArenaAllocator, FixedBufferAllocator)
• Seguimiento del ciclo de vida de ArenaAllocator:
  • init/deinit/allocator - ciclo de vida completo del arena
  • Asignaciones del arena liberadas en deinit (sin falsos positivos de fuga)
  • Detección de uso después de deinit, doble deinit, asignación después de deinit
  • Desajuste entre asignadores (arena vs page_allocator)
• Seguimiento de punteros derivados (no se pueden liberar punteros de campo, subsegmentos - solo asignaciones raíz)
• Seguridad aritmética de punteros (bloquea ptr_add/ptr_sub en punteros de un solo elemento)
• Seguridad nula (detección de desenvolvimiento opcional sin comprobar)
• Seguridad de variantes (acceso a campos de unión inactivos, variante ambigua después de ramas)
• Seguridad de FieldParentPtr (detección de recuperación de contenedor inválida desde punteros de campo)
• Análisis interprocedimental (seguimiento de valores a través de llamadas a funciones mediante argumentos de puntero)
• Seguimiento de punteros a funciones (las llamadas indirectas se envían a los objetivos posibles)
• Seguimiento de campos de estructuras y uniones (campos de puntero, tipos anidados)
• Seguimiento de segmentos (alloc/free con regiones, derivación de subsegmentos)
• Soporte de uniones de error (expresiones try, envoltura/desenvolvimiento de carga útil)
• Soporte de sentencias switch (fusión en N vías con seguimiento de variantes)
• Soporte de switch etiquetado/dispositivo de Duff
• Seguimiento de ubicación fuente y nombre de variable para mensajes de error
• Ramificación/flujo de control con fusión de estados
• Análisis de bucles (for, while, for-else, while-else con iteración de punto fijo)
• Seguimiento de variables globales (indefinidas, variantes y seguridad de memoria)
• Tipos de datos recursivos (listas enlazadas, árboles, uniones recursivas)
• Reducciones de límites de stdlib para patrones comunes como std.process.args, std.mem.asBytes, std.HashMap y APIs de asignador/archivo
• Refinamientos privilegiados de std.HashMap con identidad de metadatos canónicos/almacenamiento clave/valor a través de put, get, getPtr e iteración de valores
• Seguridad de descriptores de archivo:
  • Seguimiento de posix.open/close/dup/dup2/socket/accept/epoll_create/pipe
  • Detección de uso después de cerrar (lectura/escritura/dup en fd cerrado)
  • Detección de doble cierre
  • Detección de fuga de fd en la salida de función y finalización de módulo
  • Seguimiento de identificadores locales descontextualizados para que los alias que permanecen vivos supriman informes de fuga prematuros
  • Propagación de retorno y agregado para patrones de descriptor cubiertos
  • Detección de argumento fd indefinido (close/read/write con fd sin definir)

Planeado (consulte LIMITATIONS.md para más detalles):

• async/await
• Seguridad de alias (detección de referencias mutables en conflicto)
• Refinamientos de puntero de múltiples fuentes para procedencia de puntero fusionada o indirecta
• Análisis de alias de descriptor más allá de los patrones de propagación de fd actualmente cubiertos
• Resúmenes de mutación interprocedimental/global más completos
• Reconocimiento de reducción de conversión de alineación
• Seguridad de mutex (emparejamiento lock/unlock, detección de interbloqueo)
• Capacidad de coerción personalizada (reglas de refinamiento definidas por el usuario)