← Comunicación entre ProcesosBloque 8 · Sockets de dominio Unix · Tema 35 de 52

Tema 35

Enviar descriptores y verificar credenciales

Un proceso puede abrir un recurso y entregar una referencia utilizable a otro proceso por un socket Unix. Vas a construir los datos de control de SCM_RIGHTS, recibir y validar los descriptores sin filtrarlos, comprobar quién estableció el canal y observar qué estado comparten ambas referencias. El ejemplo abre el archivo después de fork para que su llegada al hijo dependa realmente de recvmsg.

1. Contrato del intercambio

El tema 34 estudió un par de sockets conectados, su herencia y el cierre por dirección. Ahora usaremos ese canal para entregar un archivo abierto. El padre crea el par y hace fork; recién después abre el archivo. Por lo tanto, el hijo no hereda ese descriptor de archivo.

El padre adjunta exactamente un descriptor de solo lectura a un byte F. El hijo valida el control, exige un archivo regular y lee hasta cinco bytes desde el desplazamiento actual. Después cierra su descriptor y devuelve una confirmación K seguida de la cantidad leída, codificada en un byte. El padre comprueba que su propio desplazamiento avanzó esa misma cantidad.

SCM_RIGHTS permite instalar en el receptor un descriptor que referencia la misma descripción de archivo abierto. El número local puede cambiar; el recurso y parte de su estado siguen compartidos.

ElementoContrato del laboratorioMotivo
Canal.AF_UNIX, SOCK_STREAM, un solo intercambio.Continuar sobre el par del tema anterior.
Mensaje de entrega.Un byte F y un descriptor con SCM_RIGHTS.No asociar el recurso a un bloque de longitud ambigua.
Control permitido.Un único bloque SOL_SOCKET/SCM_RIGHTS con un int.Rechazar cantidades y tipos inesperados.
Recurso.Archivo regular abierto con acceso de solo lectura.No leer una FIFO ni aceptar un canal o directorio por error.
Confirmación.Dos bytes: K y un número de 0 a 5.Comprobar aplicación y desplazamiento, no solo envío.
Identidad.Credenciales del creador del par, comprobadas en ambos extremos.Mostrar el alcance real de SO_PEERCRED en este escenario.

Ejecuta los ensayos con un archivo de prueba estable, bajo tu control y sin modificaciones concurrentes. Este laboratorio no cambia de usuario ni demuestra aislamiento de privilegios: padre e hijo pertenecen al mismo usuario y conservan sus permisos normales.

2. Qué se transfiere y qué permanece compartido

Enviar el entero 7 como datos ordinarios solo entrega bytes. El número siete en la tabla del receptor puede estar libre o corresponder a un recurso distinto. SCM_RIGHTS hace que el núcleo interprete los descriptores del emisor y cree referencias válidas en el proceso receptor.

Dos descriptores locales apuntan a una descripción de archivo abierto El descriptor del padre y el instalado por recvmsg en el hijo pueden tener números distintos. Ambos apuntan a una descripción compartida que contiene el desplazamiento y el modo de acceso. Cada descriptor tiene su propio indicador de cierre en exec. Padre · fd localFD_CLOEXEC propioDescripción abiertadesplazamientomodo de accesoflags de estadoHijo · fd localFD_CLOEXEC propioLeer en el hijo puede avanzar la posición observada por el padre.
La transferencia agrega una referencia; no mueve automáticamente la referencia original ni copia el contenido del archivo.
PropiedadRelación tras la transferenciaConsecuencia
Número de descriptor.Es local a cada proceso.No exigir igualdad entre los números.
Desplazamiento de archivo.Compartido por la descripción abierta.read y lseek en uno afectan la posición del otro.
Flags de estado, como O_NONBLOCK.Compartidos por esa descripción.Cambiarlos con F_SETFL puede afectar al emisor.
FD_CLOEXEC.Propiedad de cada descriptor.El receptor debe instalar su propia protección.
Referencia original.Permanece abierta hasta que el emisor la cierre.El envío no equivale a close.

La distinción entre descriptor y descripción abierta se explica en open(2) y dup(2). Para leer sin desplazar la posición compartida, una alternativa sobre archivos que lo admitan es pread(2) con un offset explícito.

El receptor utiliza el acceso que ya permite la descripción recibida. Cambiar los permisos de la ruta después no constituye un mecanismo general para revocar una referencia abierta. Si se necesita revocación, debe diseñarse otra mediación del acceso.

3. Datos ordinarios y datos de control

sendmsg y recvmsg reciben un msghdr. Su nombre no significa que STREAM preserve automáticamente mensajes: describe los búferes de una operación. El contenido ordinario y el control viajan por rutas de interpretación distintas dentro de esa operación.

CampoUso en este ejemploRegla
msg_name y msg_namelen.Cero; el socket ya está conectado.No hace falta una dirección de destino.
msg_iov y msg_iovlen.Un iovec para el byte F.Describe los datos ordinarios.
msg_control y msg_controllen.Búfer de datos auxiliares y su tamaño.Reservar espacio con las macros de control.
msg_flags.Resultado de la recepción.Examinar truncamiento antes de aceptar el mensaje.

El retorno positivo de sendmsg o recvmsg cuenta bytes ordinarios, no la longitud del control ni la cantidad de descriptores. Recibir un byte no prueba por sí solo que llegó un descriptor.

En AF_UNIX STREAM sobre Linux, la transferencia auxiliar se acompaña de datos ordinarios. Nuestro byte F cumple esa función y además identifica la entrega. No enviamos una estructura C nativa como cabecera de aplicación.

4. Construir el control con las macros CMSG

Un bloque de control comienza con cmsghdr, que indica longitud, nivel y tipo. El búfer completo puede contener varios bloques separados por el relleno de alineación correspondiente. No se deben inventar sus offsets sumando tamaños a mano.

C · espacio, alineación y longitud del bloque
union {
    struct cmsghdr alineacion;
    unsigned char bytes[CMSG_SPACE(sizeof(int))];
} control = {0};

struct msghdr msg = {0};
msg.msg_control = control.bytes;
msg.msg_controllen = sizeof control.bytes;

struct cmsghdr *c = CMSG_FIRSTHDR(&msg);
c->cmsg_level = SOL_SOCKET;
c->cmsg_type = SCM_RIGHTS;
c->cmsg_len = CMSG_LEN(sizeof(int));
memcpy(CMSG_DATA(c), &fd, sizeof fd);

CMSG_SPACE calcula el espacio ocupado incluyendo el relleno necesario; CMSG_LEN calcula la longitud que se coloca en cmsg_len. CMSG_FIRSTHDR localiza el primer bloque y CMSG_NXTHDR permite recorrer los siguientes. CMSG_DATA accede a su carga. Estas macros se documentan en cmsg(3).

La unión proporciona alineación para el encabezado. Para cargar o extraer los enteros se usa memcpy a partir de CMSG_DATA, sin suponer que un cast a un tipo arbitrario resuelve todos los requisitos de alineación.

El control se inicializa a cero. Antes de cada recvmsg se restaura msg_controllen a la capacidad disponible, porque la llamada lo utiliza también como salida. El ejemplo crea un msghdr nuevo en cada reintento por EINTR.

5. Enviar un descriptor con SCM_RIGHTS

El programa coloca un descriptor válido en el control SOL_SOCKET/SCM_RIGHTS y pide enviar exactamente un byte ordinario. Un retorno de uno significa que esta operación aceptó la entrega. El padre conserva su descriptor para observar después el desplazamiento compartido.

Se usa MSG_NOSIGNAL para gestionar los errores de envío sin la acción predeterminada de SIGPIPE. Si sendmsg retorna −1 con EINTR se reintenta; otros errores hacen fallar este intercambio. Las reglas generales están en sendmsg(2).

El byte único evita un prefijo positivo parcial de datos ordinarios en esta función. Si se ampliara a una cabecera grande, no sería correcto volver a enviar ciegamente el mismo control después de un retorno positivo parcial: podría duplicarse la entrega de recursos. Habría que conservar por separado el estado de los bytes y el estado de la transferencia auxiliar.

sendmsg no garantiza que la aplicación receptora haya validado o utilizado el recurso. Por eso el protocolo añade una confirmación. Tampoco hay una «mudanza» automática: para abandonar su copia, el emisor debe cerrarla explícitamente cuando su contrato lo permita.

6. Recibir, recorrer y asumir propiedad

  1. Reservar datos y control acotados. El ejemplo admite espacio de control para cuatro descriptores, aunque el contrato acepta solo uno.
  2. Recibir con MSG_CMSG_CLOEXEC. Los descriptores instalados quedan marcados para cierre al completar exec.
  3. Recorrer todos los bloques devueltos. Identificar nivel, tipo y longitud antes de interpretar la carga.
  4. Registrar o cerrar cada descriptor instalado. No retornar al ver un error si aún hay referencias por limpiar.
  5. Exigir el contrato completo. Byte F, ausencia de truncamiento y un solo bloque de derechos con un solo descriptor.
  6. Validar el recurso. Examinar fstat y fcntl antes de leer o delegar autoridad a otro componente.

Desde que recvmsg instala un descriptor, el receptor debe tratarlo como un recurso propio. Un error posterior de formato o de autorización no lo cierra automáticamente. La rutina conserva un candidato y cierra los adicionales; si se rechaza el mensaje, cierra también el candidato.

MSG_CMSG_CLOEXEC es una opción de recepción de Linux que evita la ventana entre recibir y ejecutar un fcntl posterior. Marcar el socket con SOCK_CLOEXEC protege el socket; no sustituye la marca de cada descriptor recibido. Véase recvmsg(2).

FD_CLOEXEC tampoco impide heredar mediante fork. Solo actúa cuando se completa exec. Un receptor que vaya a crear trabajadores debe seguir controlando explícitamente qué referencias heredan.

7. Truncamiento, límites y cierre de rechazos

MSG_CTRUNC significa que no se pudo entregar todo el control. En Linux, el núcleo cierra los descriptores de SCM_RIGHTS que no caben en el control del receptor; los que sí se instalaron y se devolvieron deben cerrarse si la aplicación rechaza el mensaje.

El receptor no acepta «el primero que quepa» como resultado correcto. Rechaza la operación completa, recorre el control visible y libera sus referencias. También rechaza MSG_TRUNC, cantidades incorrectas, marca equivocada y tipos de control ajenos al contrato.

No confundas capacidad de almacenamiento con cantidad permitida. CMSG_SPACE puede incluir padding suficiente para alojar otro int en ciertas plataformas. La cantidad se calcula a partir de cmsg_len y se compara con uno; no se deduce de cuánto espacio se reservó.

Además del límite del mensaje existen límites de descriptores abiertos y de recursos en tránsito. Una aplicación con clientes independientes debe limitar conexiones, solicitudes pendientes y derechos recibidos, y rechazar recursos sin acumularlos indefinidamente.

La función de este tema recorre el control que construye y devuelve el núcleo tras recvmsg; no es un parser para un búfer de cmsghdr arbitrario cargado desde un archivo. La validación de longitudes protege su interpretación del contrato, pero no convierte una memoria corrupta en datos de control válidos.

8. SO_PEERCRED y autorización

C en Linux · consultar una identidad asociada al canal
#define _GNU_SOURCE
#include <sys/socket.h>

struct ucred cred;
socklen_t largo = sizeof cred;
if (getsockopt(socket_conectado, SOL_SOCKET, SO_PEERCRED,
               &cred, &largo) == -1) {
    /* Informar el fallo y no dar por conocida la identidad. */
}
/* Comprobar largo y aplicar una politica a cred.pid, cred.uid, cred.gid. */

La información proviene del núcleo, a diferencia de un UID escrito por el interlocutor dentro de un cuerpo ordinario. La aplicación debe decidir qué identidades autoriza y para qué operaciones. Conocer un UID no equivale a conceder cualquier acceso.

En un servidor con ruta se consulta el descriptor conectado devuelto por accept, antes de aceptar trabajo sensible. El cliente puede aplicar su propia política al servidor. Los permisos del directorio y del socket ayudan a controlar el encuentro, pero no reemplazan una política de autorización.

struct ucred expone PID, UID y GID. No contiene toda la lista de grupos suplementarios ni un certificado del programa ejecutado. El ejemplo compara los valores efectivos guardados al crear el par y el PID del creador. No hace una búsqueda insegura de ejecutables a partir de un PID recibido como texto.

Los identificadores deben interpretarse en el contexto de los espacios de nombres y del modelo de despliegue. Una política real no debería aceptar cualquier UID que el cliente declare ni suponer que un PID identifica de forma permanente a un proceso.

9. La instantánea de credenciales y fork

SO_PEERCRED devuelve credenciales asociadas al establecimiento del canal, no una actualización continua de quién realiza cada write. En un par creado antes de fork, ambos extremos se establecieron en el creador. Por eso el padre no debe exigir que el PID obtenido sea el PID del hijo.

La semántica de SO_PEERCRED y de SCM_RIGHTS está documentada en unix(7). Este detalle explica por qué el programa guarda getpid, geteuid y getegid antes de crear el par y compara esa instantánea en los dos procesos.

MecanismoPregunta que ayuda a contestarLímite
SO_PEERCRED.¿Qué credenciales quedaron asociadas al establecer este canal?No identifica de nuevo al autor de cada mensaje posterior.
SO_PASSCRED y SCM_CREDENTIALS.¿Qué credenciales entrega el núcleo con esta recepción?Necesita control adicional, validación y asociación con los datos.
UID/PID en datos ordinarios.¿Qué valores declara la aplicación remota?Por sí solos no autentican.

SO_PASSCRED habilita la recepción de SCM_CREDENTIALS. Si no se proporcionan credenciales explícitas, Linux genera las predeterminadas del emisor, con su PID y sus identificadores reales de usuario y grupo. Los envíos explícitos se comprueban según las reglas de capacidades del sistema.

El código completo no habilita SO_PASSCRED y rechaza bloques ajenos a SCM_RIGHTS. Añadir credenciales por mensaje exigiría ampliar el control disponible, reconocer el bloque nuevo y definir la política; no basta con activar una opción y mantener las mismas validaciones.

10. Programa completo de transferencia

Guarda transferir35.c. Es un programa autónomo para Linux y glibc. El hijo recibe el archivo, verifica el tipo y el acceso, lee como máximo cinco bytes y muestra su representación hexadecimal. No utiliza la ruta del archivo para abrirlo.

El padre usa O_NOFOLLOW para rechazar un enlace simbólico en el último componente y O_NONBLOCK para no quedarse esperando al abrir por error una FIFO. Después exige archivo regular. O_NOFOLLOW no valida todos los directorios de una ruta; en este ensayo la ruta la administra el mismo usuario.

transferir35.c · control validado, credenciales y desplazamiento compartido
#define _GNU_SOURCE
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_CONTROL 4u
#define MUESTRA 5u

static int cerrar(int fd)
{
    if (close(fd) == -1) { perror("close"); return -1; }
    return 0; /* En Linux no reintentar close con el mismo numero. */
}

static int limitar(int fd)
{
    struct timeval tv = { .tv_sec = 3, .tv_usec = 0 };
    if (setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof tv) == -1 ||
        setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof tv) == -1) {
        perror("setsockopt"); return -1;
    }
    return 0;
}

static int autorizar(int canal, const struct ucred *esperada)
{
    struct ucred c;
    socklen_t n = sizeof c;
    if (getsockopt(canal, SOL_SOCKET, SO_PEERCRED, &c, &n) == -1) {
        perror("SO_PEERCRED"); return -1;
    }
    if (n != sizeof c || c.pid != esperada->pid ||
        c.uid != esperada->uid || c.gid != esperada->gid) {
        fprintf(stderr, "Credenciales del canal no autorizadas\n");
        return -1;
    }
    return 0;
}

static int enviar_fd(int canal, int fd)
{
    unsigned char marca = 'F';
    struct iovec io = { .iov_base = &marca, .iov_len = 1 };
    union {
        struct cmsghdr alineacion;
        unsigned char bytes[CMSG_SPACE(sizeof(int))];
    } control = {0};
    struct msghdr msg = {0};
    msg.msg_iov = &io;
    msg.msg_iovlen = 1;
    msg.msg_control = control.bytes;
    msg.msg_controllen = sizeof control.bytes;
    struct cmsghdr *c = CMSG_FIRSTHDR(&msg);
    c->cmsg_level = SOL_SOCKET;
    c->cmsg_type = SCM_RIGHTS;
    c->cmsg_len = CMSG_LEN(sizeof fd);
    memcpy(CMSG_DATA(c), &fd, sizeof fd);
    ssize_t n;
    do { n = sendmsg(canal, &msg, MSG_NOSIGNAL); }
    while (n == -1 && errno == EINTR);
    if (n != 1) {
        if (n >= 0) errno = EIO;
        perror("sendmsg"); return -1;
    }
    return 0;
}

static int recibir_fd(int canal)
{
    unsigned char marca = 0;
    union {
        struct cmsghdr alineacion;
        unsigned char bytes[CMSG_SPACE(MAX_CONTROL * sizeof(int))];
    } control;
    struct msghdr msg;
    struct iovec io = { .iov_base = &marca, .iov_len = 1 };
    ssize_t n;
    do {
        memset(&control, 0, sizeof control);
        memset(&msg, 0, sizeof msg);
        msg.msg_iov = &io;
        msg.msg_iovlen = 1;
        msg.msg_control = control.bytes;
        msg.msg_controllen = sizeof control.bytes;
        n = recvmsg(canal, &msg, MSG_CMSG_CLOEXEC);
    } while (n == -1 && errno == EINTR);
    if (n == -1) { perror("recvmsg"); return -1; }

    int elegido = -1;
    unsigned bloques = 0, cantidad = 0;
    int malo = n != 1 || marca != 'F' ||
               (msg.msg_flags & (MSG_CTRUNC | MSG_TRUNC)) != 0;
    for (struct cmsghdr *c = CMSG_FIRSTHDR(&msg); c != NULL;
         c = CMSG_NXTHDR(&msg, c)) {
        if (c->cmsg_level != SOL_SOCKET || c->cmsg_type != SCM_RIGHTS) {
            malo = 1;
            continue;
        }
        ++bloques;
        if (c->cmsg_len < CMSG_LEN(0)) { malo = 1; continue; }
        size_t bytes = c->cmsg_len - CMSG_LEN(0);
        if (bytes % sizeof(int) != 0) malo = 1;
        for (size_t i = 0; i < bytes / sizeof(int); ++i) {
            int recibido;
            memcpy(&recibido, CMSG_DATA(c) + i * sizeof(int), sizeof recibido);
            ++cantidad;
            if (elegido == -1) elegido = recibido;
            else if (cerrar(recibido) == -1) malo = 1;
        }
    }
    if (bloques != 1 || cantidad != 1) malo = 1;
    if (malo) {
        if (elegido != -1) cerrar(elegido);
        fprintf(stderr, "Entrega rechazada: datos o control incompatibles\n");
        return -1;
    }
    return elegido;
}

static int comprobar_archivo(int fd)
{
    struct stat st;
    if (fstat(fd, &st) == -1) { perror("fstat"); return -1; }
    int estado = fcntl(fd, F_GETFL);
    int descriptor = fcntl(fd, F_GETFD);
    if (estado == -1 || descriptor == -1) { perror("fcntl"); return -1; }
    if (!S_ISREG(st.st_mode) || (estado & O_PATH) != 0 ||
        (estado & O_ACCMODE) != O_RDONLY ||
        (descriptor & FD_CLOEXEC) == 0) {
        fprintf(stderr, "Se requiere archivo regular, solo lectura y CLOEXEC\n");
        return -1;
    }
    return 0;
}

static int enviar_bytes(int fd, const unsigned char *p, size_t total)
{
    size_t hechos = 0;
    while (hechos < total) {
        ssize_t n = send(fd, p + hechos, total - hechos, MSG_NOSIGNAL);
        if (n > 0) hechos += (size_t)n;
        else if (n == -1 && errno == EINTR) continue;
        else { if (n == 0) errno = EIO; perror("send"); return -1; }
    }
    return 0;
}

static int recibir_bytes(int fd, unsigned char *p, size_t total)
{
    size_t hechos = 0;
    while (hechos < total) {
        ssize_t n = recv(fd, p + hechos, total - hechos, 0);
        if (n > 0) hechos += (size_t)n;
        else if (n == -1 && errno == EINTR) continue;
        else {
            if (n == 0) fprintf(stderr, "Confirmacion truncada\n");
            else perror("recv");
            return -1;
        }
    }
    return 0;
}

static int trabajar(int canal, const struct ucred *esperada)
{
    if (autorizar(canal, esperada) == -1) return -1;
    int fd = recibir_fd(canal);
    if (fd == -1) return -1;
    int fallo = comprobar_archivo(fd) == -1;
    unsigned char datos[MUESTRA];
    size_t usados = 0;
    while (!fallo && usados < MUESTRA) {
        ssize_t n = read(fd, datos + usados, MUESTRA - usados);
        if (n > 0) usados += (size_t)n;
        else if (n == 0) break;
        else if (errno != EINTR) { perror("read"); fallo = 1; }
    }
    if (cerrar(fd) == -1) fallo = 1;
    if (fallo) return -1;
    char hex[3 * MUESTRA + 1];
    for (size_t i = 0; i < usados; ++i)
        snprintf(hex + 3 * i, 4, "%02x ", (unsigned)datos[i]);
    hex[3 * usados] = '\0';
    if (dprintf(STDOUT_FILENO, "Hijo: %zu bytes: %s\n", usados, hex) < 0)
        return -1;
    unsigned char ack[2] = { 'K', (unsigned char)usados };
    return enviar_bytes(canal, ack, sizeof ack);
}

int main(int argc, char **argv)
{
    if (argc != 2) {
        fprintf(stderr, "Uso: %s archivo_regular\n", argv[0]);
        return EXIT_FAILURE;
    }
    struct ucred creador = { .pid = getpid(), .uid = geteuid(), .gid = getegid() };
    int par[2];
    if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, par) == -1) {
        perror("socketpair"); return EXIT_FAILURE;
    }
    if (limitar(par[0]) == -1 || limitar(par[1]) == -1) {
        cerrar(par[0]); cerrar(par[1]); return EXIT_FAILURE;
    }
    pid_t hijo = fork();
    if (hijo == -1) {
        perror("fork"); cerrar(par[0]); cerrar(par[1]); return EXIT_FAILURE;
    }
    if (hijo == 0) {
        int fallo = cerrar(par[0]) == -1;
        if (!fallo && trabajar(par[1], &creador) == -1) fallo = 1;
        if (cerrar(par[1]) == -1) fallo = 1;
        _exit(fallo ? EXIT_FAILURE : EXIT_SUCCESS);
    }

    int fallo = cerrar(par[1]) == -1;
    int fd = -1;
    if (!fallo && autorizar(par[0], &creador) == -1) fallo = 1;
    if (!fallo) {
        /* Se abre DESPUES de fork: el hijo no heredo este archivo. */
        fd = open(argv[1], O_RDONLY | O_CLOEXEC | O_NOFOLLOW | O_NONBLOCK);
        if (fd == -1) { perror("open"); fallo = 1; }
    }
    if (!fallo && comprobar_archivo(fd) == -1) fallo = 1;
    if (!fallo && enviar_fd(par[0], fd) == -1) fallo = 1;
    unsigned char ack[2];
    off_t posicion = -1;
    if (!fallo && recibir_bytes(par[0], ack, sizeof ack) == -1) fallo = 1;
    if (!fallo) {
        posicion = lseek(fd, 0, SEEK_CUR);
        if (posicion == (off_t)-1) { perror("lseek"); fallo = 1; }
        else if (ack[0] != 'K' || ack[1] > MUESTRA || posicion != (off_t)ack[1]) {
            fprintf(stderr, "Confirmacion o posicion incompatible\n");
            fallo = 1;
        }
    }
    if (fd != -1 && cerrar(fd) == -1) fallo = 1;
    if (cerrar(par[0]) == -1) fallo = 1;
    int estado;
    pid_t r;
    do { r = waitpid(hijo, &estado, 0); } while (r == -1 && errno == EINTR);
    if (r == -1) { perror("waitpid"); fallo = 1; }
    else if (!WIFEXITED(estado) || WEXITSTATUS(estado) != EXIT_SUCCESS) {
        fprintf(stderr, "El hijo no termino correctamente\n"); fallo = 1;
    }
    if (fallo) return EXIT_FAILURE;
    printf("Padre: desplazamiento compartido = %jd\n", (intmax_t)posicion);
    if (fflush(stdout) == EOF) { perror("salida"); return EXIT_FAILURE; }
    return EXIT_SUCCESS;
}

Qué valida el programa y qué queda fuera

El hijo comprueba el canal antes de recibir y no tiene ninguna ruta para reabrir el archivo dentro de la función de trabajo. También rechaza O_PATH: una referencia para operaciones sobre la ruta no es un archivo abierto para leer, aunque O_ACCMODE no indique escritura. El padre conserva su descriptor hasta comprobar el offset. El hijo cierra el suyo antes de confirmar, por lo que el cierre de la copia recibida tampoco borra la referencia original del padre.

La confirmación comprueba la cantidad informada y el desplazamiento observado. No es una prueba criptográfica ni valida el contenido completo del archivo. El resultado hexadecimal permite contrastar los primeros bytes con un archivo de prueba conocido.

Los timeouts de tres segundos se aplican a las llamadas de socket. No limitan read sobre cualquier sistema de archivos, open ni waitpid. Si el hijo queda detenido o un sistema de archivos deja de responder, se necesita supervisión externa y una política de cancelación.

11. Compilar y observar el desplazamiento

Bash en Linux · archivo privado de prueba y transferencia
$ gcc -std=c11 -Wall -Wextra -Wpedantic -O2 transferir35.c -o transferir35
$ ensayo=$(mktemp -d)
$ printf 'abcdefghi' > "$ensayo/datos"
$ timeout 10s ./transferir35 "$ensayo/datos"
Hijo: 5 bytes: 61 62 63 64 65 
Padre: desplazamiento compartido = 5
$ echo $?
0
$ printf 'xy' > "$ensayo/datos"
$ ./transferir35 "$ensayo/datos"
Hijo: 2 bytes: 78 79 
Padre: desplazamiento compartido = 2
$ : > "$ensayo/datos"
$ ./transferir35 "$ensayo/datos"
Hijo: 0 bytes: 
Padre: desplazamiento compartido = 0

El archivo se abre de nuevo en cada invocación, de modo que el desplazamiento inicial de esa descripción es cero. Dentro de cada ejecución, leer en el hijo avanza la posición del padre. No se transmite el contenido del archivo por el socket: se transmite la referencia y el hijo lee el recurso.

Bash · contenido binario y rechazos locales
$ printf 'a\000b\377c' > "$ensayo/datos"
$ ./transferir35 "$ensayo/datos"
Hijo: 5 bytes: 61 00 62 ff 63 
Padre: desplazamiento compartido = 5
$ ./transferir35 "$ensayo"
Se requiere archivo regular, solo lectura y CLOEXEC
$ ln -s datos "$ensayo/enlace"
$ ./transferir35 "$ensayo/enlace"
open: Too many levels of symbolic links
$ rm -- "$ensayo/datos" "$ensayo/enlace"
$ rmdir -- "$ensayo"

El texto de perror depende del idioma del sistema. En un rechazo del padre también puede aparecer un diagnóstico del hijo al encontrar el canal cerrado. Lo exigido es un retorno de fallo, limpieza de referencias y recogida del hijo; no un orden exacto de mensajes.

12. Experimento independiente de credenciales

Guarda credenciales35.c. El padre espera al hijo para que las dos líneas se impriman en orden. Ambos consultan SO_PEERCRED y comparan la identidad con el creador original. No se necesitan archivos ni privilegios especiales.

credenciales35.c · PID actual y PID asociado al par
#define _GNU_SOURCE
#include <sys/socket.h>
#include <sys/wait.h>
#include <unistd.h>
#include <errno.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>

static int mostrar(int fd, const char *rol, const struct ucred *original)
{
    struct ucred c;
    socklen_t n = sizeof c;
    if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &c, &n) == -1) {
        perror("getsockopt"); return -1;
    }
    if (n != sizeof c || c.pid != original->pid ||
        c.uid != original->uid || c.gid != original->gid) {
        fprintf(stderr, "Instantanea inesperada\n"); return -1;
    }
    return dprintf(STDOUT_FILENO,
                   "%s: PID actual=%jd; peer PID=%jd UID=%ju GID=%ju\n",
                   rol, (intmax_t)getpid(), (intmax_t)c.pid,
                   (uintmax_t)c.uid, (uintmax_t)c.gid) < 0 ? -1 : 0;
}

int main(void)
{
    struct ucred original = { .pid = getpid(), .uid = geteuid(), .gid = getegid() };
    int par[2];
    if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, par) == -1) {
        perror("socketpair"); return EXIT_FAILURE;
    }
    pid_t hijo = fork();
    if (hijo == -1) {
        perror("fork"); close(par[0]); close(par[1]); return EXIT_FAILURE;
    }
    if (hijo == 0) {
        int fallo = close(par[0]) == -1;
        if (!fallo && mostrar(par[1], "Hijo", &original) == -1) fallo = 1;
        if (close(par[1]) == -1) fallo = 1;
        _exit(fallo ? EXIT_FAILURE : EXIT_SUCCESS);
    }
    int fallo = close(par[1]) == -1;
    int estado;
    pid_t r;
    do { r = waitpid(hijo, &estado, 0); } while (r == -1 && errno == EINTR);
    if (r == -1) { perror("waitpid"); fallo = 1; }
    else if (!WIFEXITED(estado) || WEXITSTATUS(estado) != EXIT_SUCCESS) fallo = 1;
    if (!fallo && mostrar(par[0], "Padre", &original) == -1) fallo = 1;
    if (close(par[0]) == -1) fallo = 1;
    return fallo ? EXIT_FAILURE : EXIT_SUCCESS;
}
Bash · los números son ilustrativos
$ gcc -std=c11 -Wall -Wextra -Wpedantic -O2 credenciales35.c -o credenciales35
$ ./credenciales35
Hijo: PID actual=4201; peer PID=4200 UID=1000 GID=1000
Padre: PID actual=4200; peer PID=4200 UID=1000 GID=1000

El PID actual del hijo es distinto del PID mostrado como peer en el padre. Ese resultado no indica una consulta fallida: el par se creó en el padre antes de fork. Si se quiere autenticar a un cliente independiente que establece su conexión después de arrancar, debe estudiarse ese otro establecimiento y su política.

13. Validar el recurso y la autoridad delegada

Recibir un descriptor de un canal autorizado no basta para saber qué objeto representa. El receptor debe definir qué tipos admite, qué acceso necesita y qué operaciones ejecutará. Un descriptor puede referirse a un archivo, directorio, socket, tubería u otro objeto.

ControlPreguntaLímite
SO_PEERCRED y política.¿El canal tiene una identidad aceptable?Una identidad permitida puede enviar un recurso equivocado.
fstat.¿Qué tipo de objeto se recibió?Un archivo regular no es necesariamente un archivo autorizado para toda tarea.
F_GETFL y O_ACCMODE.¿La descripción permite lectura, escritura o ambas?SCM_RIGHTS no reduce por sí solo el modo de acceso.
F_GETFD.¿Esta entrada tiene FD_CLOEXEC?No impide fork ni sustituye el cierre explícito.
Límite de operaciones.¿Cuánto trabajo se hará con el recurso?El tipo no asegura latencia ni ausencia de modificaciones concurrentes.

Un descriptor abierto con escritura sigue concediendo escritura al transferirlo. Un campo ordinario que diga «solo lectura» no reduce esa autoridad. Para delegar menos capacidad debe prepararse desde el principio un recurso con el acceso apropiado o mediar las operaciones mediante otro servicio.

Los flags de estado compartidos también importan: el receptor no debería cambiar O_NONBLOCK, O_APPEND o el desplazamiento sin considerar al emisor. El ejemplo mantiene O_NONBLOCK tal como se abrió; en un archivo regular no convierte la lectura en un sistema con plazo garantizado.

Un proceso puede recibir acceso a un archivo aunque no pueda abrirlo por su ruta, siempre sujeto a los controles adicionales del sistema. Esa delegación es una razón para utilizar SCM_RIGHTS. Nuestro ejemplo evita cambios de privilegios para observar primero el mecanismo y la propiedad de los recursos.

14. Enmarcado, confirmaciones y fallos

Los datos auxiliares tienen una asociación con el flujo de datos, pero no convierten todo STREAM en una secuencia de registros. Un diseño que intercala cabeceras, cuerpos y transferencias debe usar recvmsg donde pueda aparecer control y conservar el estado del parser.

No conviene mezclar read o recv para «saltar unos bytes» de una zona que puede llevar derechos: esas llamadas no ofrecen el búfer auxiliar necesario para recuperar los descriptores. El contrato de este ejemplo reserva una recepción de un byte con recvmsg para la única entrega y usa el resto del canal solo para la confirmación de un hijo de confianza.

La marca F no es autenticación y no resincroniza por sí sola el flujo. Si el byte o el control son incompatibles, el receptor cierra todas las referencias recibidas y termina esa conversación. No busca otra F dentro de datos arbitrarios.

secuencia · transferencia y confirmación de aplicación
PADRE                                  HIJO
crear par y fork --------------------> cerrar extremo sobrante
abrir archivo despues de fork          verificar credenciales del canal
sendmsg(F + SCM_RIGHTS) --------------> recvmsg + CLOEXEC
                                       validar control y recurso
                                       leer hasta cinco bytes
                                       cerrar descriptor recibido
recibir K y cantidad <---------------- confirmar lectura
comprobar desplazamiento               cerrar canal y terminar
cerrar archivo y canal
waitpid(hijo)

Si el emisor cierra su descriptor después de un envío exitoso, la referencia en tránsito permite que el receptor lo obtenga mientras el mensaje siga disponible. Si el mensaje se descarta al destruir el canal, el núcleo libera esa referencia pendiente.

Si el receptor utilizó el recurso y se perdió la confirmación, el emisor no puede deducir que no se usó. Reintentar puede instalar otra referencia y repetir trabajo. Un servicio persistente necesita identificadores, reglas de duplicados y un límite de recursos pendientes.

La recepción de K no es una transferencia de propiedad «exactamente una vez». Aquí significa que el hijo validó, leyó, cerró su copia y completó su confirmación. El padre exige también un estado de salida exitoso del hijo.

15. Explorar referencias y recursos rechazados

El modelo representa un archivo con abcdefghi y desplazamiento inicial cero. Envía su referencia, cierra si quieres la original antes de recibir y observa cómo progresa la posición compartida. Prepara también una entrega excesiva o un truncamiento para seguir la limpieza.

Descriptor del padreAbierto

Descriptor del hijoSin recibir

Referencias en tránsito0

Desplazamiento compartido0

Última lecturaNinguna

Referencias totales del recurso1

El archivo se mantiene abierto mientras exista una referencia local o en tránsito.

Para observar estado compartido, envía y recibe una entrega válida. Lee dos bytes en el hijo y después dos en el padre: obtendrán ab y cd. No son dos lecturas independientes desde cero.

El caso de truncamiento fuerza una capacidad didáctica que deja un descriptor visible y otro descartado; no presupone los tamaños reales de padding de una máquina. El modelo tampoco ejecuta llamadas al sistema, comprueba credenciales ni representa límites de recursos del núcleo.

16. Pruebas y diagnóstico

Resultados correctos y límites del recurso

Preparar entradas incompatibles sin filtrar descriptores

Un controlador de prueba puede crear un par y enviar al receptor: F sin control, una marca incorrecta con un descriptor, dos descriptores o una lista mayor que el control disponible. No basta con cambiar un texto: hay que construir SCM_RIGHTS real para probar las referencias que instala el núcleo.

Cuenta las entradas de /proc/self/fd antes y después de cientos de rechazos dentro del mismo receptor de prueba. La cuenta debe mantenerse estable. Un programa que sale después de cada mensaje puede ocultar una fuga, porque la terminación cierra sus descriptores.

Prueba un descriptor de escritura y un directorio enviados directamente por un emisor de laboratorio para ejercitar la validación del hijo. La comprobación del padre normal evita esos envíos, así que ese rechazo local no demuestra que el receptor esté validando el recurso.

Fuerza el ACK a enviarse y recibirse de un byte por llamada. Los bucles deben reconstruir K y cantidad sin duplicaciones. No reutilices esa estrategia mecánicamente para volver a adjuntar SCM_RIGHTS tras avances positivos de mensajes mayores.

Haz terminar al hijo después de cerrar su copia y antes de confirmar. El padre debe fallar y cerrar su propia referencia. Cambia la identidad esperada en una copia de pruebas: la autorización debe rechazar el canal, no continuar con una credencial asumida.

Bash · observar derechos, credenciales y cierres en ambos procesos
$ archivo_de_prueba=$(mktemp)
$ printf 'abcdefghi' > "$archivo_de_prueba"
$ strace -f -yy -s 80 -e trace=socketpair,getsockopt,openat,sendmsg,recvmsg,read,lseek,fcntl,close,wait4 ./transferir35 "$archivo_de_prueba"
$ rm -- "$archivo_de_prueba"

Busca el openat posterior a fork, SCM_RIGHTS en sendmsg y recvmsg, MSG_CMSG_CLOEXEC en la recepción, las comprobaciones con fcntl y el cierre en cada proceso. Los números de descriptor pueden coincidir por casualidad; la traza debe demostrar la transferencia y el estado, no depender de que los números sean distintos.

Un controlador necesita su propio límite externo y debe terminar y recoger los procesos que lanzó si el ensayo falla. El timeout del socket no es un presupuesto total de vida de los participantes.

17. Errores frecuentes

ErrorConsecuenciaCorrección
Enviar el entero del descriptor como cuerpo.El receptor recibe un número sin una referencia instalada.Construir control SCM_RIGHTS.
Confundir CMSG_LEN con CMSG_SPACE.Longitud o capacidad incorrectas.Usar cada macro en su campo correspondiente.
Leer solo el primer bloque y retornar al fallar.Pueden quedar descriptores recibidos sin cerrar.Recorrer el control completo y limpiar todos los derechos instalados.
Ignorar MSG_CTRUNC.Se acepta una entrega incompleta.Rechazar y cerrar las referencias visibles.
Suponer que el kernel cierra todo al rechazar.Fuga de descriptores que sí fueron devueltos.La aplicación cierra los instalados que no acepta.
Confiar en el CLOEXEC del emisor.El descriptor recibido puede filtrarse a exec.Usar MSG_CMSG_CLOEXEC y verificar el indicador.
Abrir antes de fork para demostrar transferencia.El hijo ya podría tener una copia heredada.Abrir después o cerrar explícitamente esa copia en el experimento.
Exigir el PID del hijo en SO_PEERCRED del par.Se rechaza una instantánea correcta del creador.Relacionar credenciales con el momento de establecimiento.
Confiar en un UID escrito en el mensaje.Se acepta una declaración no autenticada.Consultar credenciales del núcleo y aplicar una política.
Creer que transferir reduce permisos.Se delega más autoridad de la prevista.Preparar y validar el acceso del recurso.
Suponer offsets independientes.Lecturas o lseek interfieren entre participantes.Coordinar o usar operaciones con posición explícita.
Reenviar derechos después de perder el ACK.Se instalan copias y se puede repetir trabajo.Diseñar identificadores, recuperación y límites.

18. Resumen

19. Preguntas de repaso y práctica

Responde distinguiendo número local, descripción abierta, referencia en tránsito y política de autorización.

1. ¿Por qué no basta con enviar un entero con el número del descriptor?

Porque cada proceso tiene su propia tabla. SCM_RIGHTS solicita al núcleo que instale una referencia válida en el receptor.

2. ¿La transferencia cierra automáticamente el descriptor original?

No. Agrega una referencia. El emisor conserva la suya hasta que la cierre explícitamente.

3. ¿Qué cuenta el retorno de recvmsg?

Bytes ordinarios recibidos. La presencia y cantidad de descriptores se determinan recorriendo el control.

4. ¿Para qué sirven CMSG_SPACE y CMSG_LEN?

La primera calcula la capacidad que ocupa un bloque con su relleno. La segunda calcula la longitud que se almacena en cmsg_len.

5. ¿Por qué hay que recorrer el control incluso si la marca es inválida?

Porque recvmsg puede haber instalado descriptores antes de que la aplicación rechace el mensaje. Debe identificarlos y cerrarlos.

6. ¿El kernel cierra todos los descriptores cuando hay MSG_CTRUNC?

Cierra los que no pudo entregar. Los que sí devolvió siguen siendo responsabilidad de la aplicación, que debe cerrarlos al rechazar.

7. ¿SOCK_CLOEXEC protege también el archivo recibido?

No. Protege el socket creado. El archivo recibido necesita su propio indicador, instalado aquí con MSG_CMSG_CLOEXEC.

8. ¿Por qué se abre el archivo después de fork?

Para que el hijo no lo herede. Así su descriptor de archivo debe proceder de la transferencia auxiliar.

9. ¿Por qué avanza el desplazamiento del padre cuando lee el hijo?

Ambos referencian la misma descripción de archivo abierto, que contiene el desplazamiento compartido.

10. ¿SO_PEERCRED identifica siempre al proceso que acaba de escribir?

No. Devuelve una instantánea asociada al establecimiento del canal. Un extremo puede heredarse o transferirse después.

11. ¿Qué PID se espera en un socketpair creado antes de fork?

El del creador del par en la instantánea, incluso cuando el padre consulta el extremo cuyo interlocutor operativo es el hijo.

12. ¿Un UID de confianza vuelve seguro cualquier descriptor recibido?

No. Aún se debe comprobar el tipo del recurso, el acceso, el contrato y las operaciones que se autorizarán.

13. ¿Enviar con SCM_RIGHTS un descriptor de escritura lo vuelve de solo lectura?

No. Conserva el acceso de la descripción recibida. La reducción de autoridad debe prepararse mediante otro diseño del recurso.

14. ¿Por qué no se reenvía el mismo control tras cualquier avance parcial?

Porque la entrega de derechos puede haber ocurrido con los bytes ya aceptados. Repetir el control puede instalar referencias adicionales.

15. ¿Perder la confirmación demuestra que el recurso no se utilizó?

No. El receptor puede haberlo utilizado antes de perderse la respuesta. La recuperación necesita reglas de aplicación.

Para practicar y ampliar

  1. Dibuja las referencias antes de enviar, durante el tránsito, después de recibir y después de cada close.
  2. Ejecuta los programas con archivo vacío, corto, largo y binario y comprueba los offsets.
  3. Cierra el original después de un envío exitoso en una variante y demuestra que el hijo aún puede leer.
  4. Reemplaza read por pread con offset explícito y comprueba que ya no avanza la posición del padre.
  5. Construye mensajes con dos derechos y con control truncado y cuenta descriptores después de rechazos repetidos.
  6. Envía directamente un descriptor de escritura y uno de directorio a un receptor de laboratorio.
  7. Fuerza la confirmación a circular de un byte por llamada.
  8. Compara la instantánea del par con las credenciales de una conexión de clientes independientes del tema 32.
  9. Diseña una ampliación con SO_PASSCRED: capacidad, tipos permitidos, validación y asociación con el cuerpo.
  10. Propón un servicio que entregue archivos de solo lectura y define quién puede solicitar cada uno y cómo evita acumular derechos pendientes.
Próximo paso

El tema 36 abre el bloque de multiplexación: configurar O_NONBLOCK, gestionar EAGAIN y distinguir preparación de finalización. El estado de cada conexión y sus recursos pendientes deberán conservarse entre operaciones que no siempre pueden avanzar.