Principio de Mínimo Privilegio: qué acceso le das al cliente en tu repo de GitHub durante su desarrollo

Hace tiempo que quería investigar sobre este tema. Como desarrollador, entiendo que es normal encontrarse en este tipo de nuevas situaciones y no saber cómo gestionarlas de primera mano. El contexto es el siguiente: estás llevando a cabo el desarrollo de un software (llamémoslo Ajile) para un cliente (llamémoslo Uartec) y durante la contratación nos comprometimos a realizar una transferencia tecnológica (del desarrollo de Ajiile, en este caso). Uartec nos pide acceso al repositorio privado en el que se lleva a cabo este desarrollo, lo que nos hace preguntarnos: ¿qué nivel de acceso le damos?

Digamos que Ajile está subido en un repositorio de GitHub privado dentro de mi organización, Devsoft. Se acordó desde el principio que así sería, por razones de comodidad y organizativas. Para que Uartec tenga acceso al código necesita permisos de lectura, como mínimo. Pero, ¿solo de lectura? ¿O algo más?

Antes de tomar ninguna decisión, conviene tener clara la tabla de permisos que ofrece GitHub para colaboradores en un repositorio privado dentro de una organización:

• Lectura: se recomienda para colaboradores que no trabajan en el código, pero que quieren ver el proyecto o hablar sobre él
• Evaluación de prioridades: se recomienda para colaboradores que necesitan administrar de forma proactiva problemas, discusiones y solicitudes de incorporación de cambios sin acceso de escritura
• Escritura: se recomienda para los colaboradores que insertan cambios activamente en el proyecto
• Mantenimiento: se recomienda para los jefes de proyecto que necesiten administrar el repositorio sin acceder a acciones confidenciales o destructivas
• Administración: se recomienda para usuarios que necesitan acceso total al proyecto, incluidas acciones confidenciales y destructivas, como administrar la seguridad o eliminar un repositorio

Como puede uno imaginar, el rol asignado a cada colaborador debe ser estrictamente el de menor responsabilidad necesaria. Esto se define en el Principio de Mínimo Privilegio. Este fue formulado por primera vez por Jerome Howard "Jerry" Saltzer en su publicación titulada "The protection of information in computer systems", en 1975.

Su cita "Every program and every privileged user of the system should operate using the least amount of privilege necessary to complete the job." recoge muy bien la idea que quiero transmitir con esta entrada.

En ocasiones veo sockets raw: cómo trabaja el kernel de Linux a nivel de red

Creo que este post puede ser muy interesante y además un buen ejercicio para recordar las capas del modelo TCP/IP. Surge de una necesidad de gestionar a nivel de bit paquetes de red: identificar y parsear cabeceras de las capas L3 y L4 (red y transporte). Esto hecho en C++ desde un host Linux usando la API de sockets estándar pero a un nivel más bajo de lo habitual.

Mi intención es reflejar con claridad las diferencias entre distintos tipos de sockets que podemos crear y qué aporta cada uno, para poder elegir con criterio según las necesidades de cada quien. Primero repasaremos conceptualmente dos o tres tipos de sockets y el nivel de la pila en el que trabajan; después lo aterrizaremos con ejemplos de código en C++ y algún diagrama sencillo para entender exactamente qué bytes llegan a nuestro recvfrom() en cada escenario.

Configurando un socket para recibir datagramas UDP en un puerto concreto

Una necesidad my común como la de recibir datagramas UDP en un puerto concreto puede llevarnos a crear sockets como:

#include <sys/socket.h>

int s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);

Donde lo importante está en i) AF_INET especificando que la comunicación usará direcciones IPv4, en ii) SOCK_DGRAM especificando que las comunicaciones estarán basadas en datagramas, y en iii) IPPROTO_UDP que dice al kernel que solo nos interesan datagramas UDP. Se definien así parámetros asociados al direccionamiento IP (capa de red) y al tipo de transporte basado en datagramas. Opcionalmente, también podríamos bindear el socket a un puerto fijo en el que recibir los datagramas:

Un vistazo a SCHC para entender cómo facilita el envío de paquetes IP comprimidos en enlaces restringidos

SCHC (Static Context Header Compression) es un estándar definido en el RFC 8724 que especifica un mecanismo de compresión y fragmentación de paquetes diseñado para entornos con recursos extremadamente limitados. Su objetivo principal es reducir el tamaño de las cabeceras de protocolos de las capas de red, transporte o aplicación mediante el uso de contextos estáticos previamente compartidos entre cada nodo de la comunicación.

Más allá de la compresión de cabeceras, el esquema de fragmentación adaptado a enlaces con tamaño de trama muy reducido, como en redes LPWAN, incorpora modos de operación con confirmación (ACK-on-Error y ACK-Always). Esto permite controlar la fragmentación y recuperar fragmentos perdidos en el propio enlace, mediante confirmaciones y retransmisiones, algo especialmente útil en radioenlaces/LPWAN con pérdidas.

Cabecera IPv6 sin extensiones (40 bytes - 320 bits)

Tras la compresión/fragmentación de paquetes con SCHC, lo que viaja por el enlace no es un paquete IP/IPv6 válido, puesto que su cabecera ha sido comprimida y ya no contiene toda la información necesaria. En su lugar, es un residuo SCHC + RuleID + fragmentos (si hay), por lo que solo un receptor SCHC con el mismo contexto puede reconstruir el paquete IP/IPv6 original.

Esto se vuelve útil, incluso necesario en redes LPWAN porque las restricciones en el enlace suelen ser muy limitantes, con tamaños máximos de transferencia de unas cuantas decenas de bytes (50-200 aprox.). Teniendo en cuenta que el par de cabeceras IPv6+UDP sin extensiones ya ocupa 48 bytes, la compresión se hace muy necesaria.