Finger: la red social de 1971 que nunca llegó a morir

Sorprenderé a más de uno si te digo que la primera red social es de 1971.

No tiene cuentas, ni algoritmo, ni servidor central. Todo tu perfil cabe en un único fichero de texto plano que controlas tú. La usó John Carmack (cofundador de id Software y programador de Doom y Quake) como diario de desarrollo. Y lo más probable es que ya tengas instalado un cliente en tu sistema operativo sin saberlo.

Pero lo más increíble es que, después de medio siglo, sigue funcionando. Y no descartes que vuelva a ponerse de moda.

Su nombre es Finger, y puedes probarlo ahora mismo.

El cliente finger viene preinstalado en macOS y en la mayoría de sistemas Unix. En Debian o Ubuntu lo instalas con apt install finger. Windows también trae su finger.exe. Y si vives en Emacs, tienes M-x finger, incluido en net-utils.el de serie.

finger random@happynetbox.com

Aleatoriamente te mostrará una cuenta Finger alojada en happynetbox.com, uno de los muchos directorios (o hostings) que te facilitan la publicación en caso de no tener un servidor propio. Divertido, ¿no crees?

Pero su origen es igual de interesante.

Origen

En 1971, en el Stanford Artificial Intelligence Laboratory (SAIL), los investigadores compartían un ordenador con el sistema de tiempo compartido WAITS. La única forma de saber quién estaba conectado era el comando WHO, que escupía una lista interminable y difícil de leer.

Pues Les Earnest, uno de los ingenieros del laboratorio, no dejaba de ver una escena que se repetía a diario.

Veía a la gente recorrer con el dedo la salida del comando WHO diciendo cosas como "ahí está Don, y esa es Pattie, pero no sé cuándo se vio a Tom por última vez".

La gente pasaba el dedo (finger) por la pantalla, de ahí su nombre. Earnest escribió un programa que devolvía esa información en un formato humano, con nombres reales, ubicaciones y, lo más importante, cuánto tiempo llevaba inactivo cada terminal. Era un ingeniero práctico, prefería hablar en persona antes que por el ordenador. Quería saber si merecía la pena levantarse y caminar por el pasillo para hablar con alguien.

Colateralmente había inventado la presencia en la red, o red social.

En 1977 el protocolo se formalizó en el RFC 742, redactado por Ken Harrenstien. Era tan primitivo que solo lo soportaban 3 sitios: SAIL, SRI y las máquinas ITS del MIT. Un poco más tarde, la implementación en red corrió a cargo de Earl Killian en el MIT y Brian Harvey en Stanford.

En 1991, se redactó el RFC 1288, la especificación definitiva, dejando obsoletas las versiones anteriores.

El primer microblog: los ficheros .plan y .project

Encima del protocolo, había contenido. Además de decir si estabas conectado, Finger mostraba el contenido de dos ficheros de texto de tu carpeta personal: .plan y .project. La idea original era anunciar en qué estabas trabajando y qué pensabas hacer. Una especie de "estado" profesional estático, sin interacciones como likes o comentarios. Como si fuera un Changelog de tu día a día o tu proyecto.

La gente hizo lo que hacemos siempre: humanizarlo. Se empezó a incluir poemas, chistes, diarios personales, arte ASCII, artículos... ¡lo que fuera! Cualquiera en el mundo podía leer tu .plan con un simple finger tu-usuario@tu-host. Muchos lo consideran, con razón, el primer microblog de internet.

Como te adelantaba, el ejemplo más célebre es el .plan de John Carmack. Durante años, cualquier fan podía teclear finger johnc@idsoftware.com (hoy en día muerto) y leer, directamente de la fuente, en qué estaba trabajando el motor gráfico de sus juegos favoritos. Estuvo escribiendo desde 1996 hasta 2010. A día de hoy se conservan archivados en GitHub. Es uno de los documentos técnicos más valiosos de la historia del videojuego, y se distribuía por un protocolo de 1971. ¡TOO ANGRY TO DIE!

Tampoco esperes una prosa que te haga saltar las lágrimas. Su estilo era telegráfico, listas de tareas y bugs sin una palabra de más. Pero de vez en cuando caía una bomba. Por ejemplo, el 18 de agosto de 1997 anunció por su .plan, no por una web ni una rueda de prensa, que pensaba liberar el código fuente de Doom:

-----------------------------------------
John Carmack's .plan for Aug 18, 1997
-----------------------------------------

I get asked about the DOOM source code every once in a while, so here is a
full status update:

[...]

The DOOM code should be a lot more interesting. It is better written, 32 bit,
and portable. There are several interesting projects that immediately present
themselves for working with the code. GLDOOM and a packet server based
internet DOOM spring to mind.

¡Glory kill!

El primer IoT hablaba Finger

Hacia 1982, unos estudiantes de la Carnegie Mellon University (Mike Kazar, David Nichols, John Zsarnay e Ivor Durham) se cansaron de bajar hasta la máquina de Coca-Cola del departamento y encontrarla vacía o con las botellas calientes. Le instalaron microinterruptores para detectar cuántas botellas había en cada columna y cuánto tiempo llevaban enfriándose.

Conectaron todo aquello a la red y expusieron el estado por Finger. Desde cualquier ordenador podías hacer finger coke@cmu.edu (el nombre exacto de la máquina fue cambiando con los años) y saber no solo si había refrescos, sino qué botón te daría el más frío. Se considera uno de los primeros objetos conectados de la historia, el abuelo del Internet de las Cosas. Y su interfaz era, otra vez, Finger.

El protocolo

Finger es tan sencillo que se explica en un párrafo. El cliente abre una conexión TCP al puerto 79 del servidor. Envía una línea de texto (el nombre de usuario que busca, o una línea vacía para listar a todos) terminada en retorno de carro y salto de línea. El servidor responde con texto plano y cierra la conexión. ¡Eso es todo!

Sin cifrado, sin cabeceras, sin sesiones. Pura simplicidad.

sequenceDiagram
    participant C as Cliente (finger)
    participant S as Servidor (fingerd, puerto 79)
    C->>S: Abre conexión TCP al puerto 79
    C->>S: "johnc" + CRLF
    S->>C: Contenido de ~johnc/.plan (texto plano)
    S->>C: Cierra la conexión

La orden básica es esta:

finger usuario@servidor

Como el protocolo no tiene ningún secreto, puedes hablarlo a mano con netcat. Enviamos el nombre de usuario por la entrada estándar al puerto 79 y leemos lo que devuelve:

echo "random" | nc happynetbox.com 79

Te resultará familiar porque es similar a cómo funcionan otros protocolos como Whois, Gopher o SMTP: conectar, pedir en texto plano y leer la respuesta.

Contenido de .plan

Un .plan no es un muro de publicaciones. Es un único fichero de texto donde puedes escribir lo que quieras. Cuando alguien te hace finger, el servidor le devuelve el fichero entero, tal cual. No hay ningún formato a seguir, es el salvaje oeste.

¿Significa eso que solo puedes tener una publicación? No. La costumbre, desde los años 80, es llevar una especie de diario dentro de ese mismo fichero, añadiendo entradas fechadas, por lo general con la más reciente arriba. Así fue como John Carmack publicó años de desarrollo. Su .plan era un fichero que crecía con entradas separadas por líneas de guiones:

-----------------------------------------
John Carmack's .plan for Jan 02, 1998
-----------------------------------------

Wired magazine does something that almost no other print magazine...

El tuyo podría verse más sencillo, con una cabecera de perfil y varias entradas:

Emily Carter
Bióloga marina. Café, kayak y mapas antiguos.

--- 2026-08-14 ---
Vuelvo del muestreo en la costa. Tres frascos llenos de plancton por revisar.

--- 2026-08-05 ---
Por fin terminé "Dune". Ahora entiendo la mitad de los memes de internet.

--- 2026-07-30 ---
¿Alguien sabe arreglar una cadena de bici que se sale sola? Se aceptan trucos.

Cuando el fichero se hace largo, tú mismo recortas las entradas viejas. Detrás no hay una base de datos guardando tu historial: el .plan es mutable y no versionado, lo que borras desaparece. No hay forma de "hacer clic" de un perfil a otro. Todo es manual.

Para traducirlo a lo que ya conoces:

Parece un poco descafeinado respecto a las redes sociales actuales. Los servicios modernos suavizan alguna aspereza, como verás más abajo. Pero esto no es una carrera de características, solo es tu fichero con tu estado.

Su decadencia y su resurrección

Finger no cayó en el olvido por moda, cayó por seguridad.

El 2 de noviembre de 1988 llegó el gusano de Morris, uno de los primeros gusanos que se propagaron por internet. Uno de sus vectores era un fallo en el demonio fingerd. El gusano enviaba una petición que desbordaba el búfer y lograba ejecutar código en la máquina remota. Fue, probablemente, el primer desbordamiento de búfer malicioso de la historia. Infectó unos 6.000 ordenadores, ¡alrededor del 10% de todo internet en aquel momento!

A eso se sumaba un problema de diseño más de fondo. Finger revela información de las personas: nombres, correos, horarios y cuándo se conectaron por última vez. El propio RFC 1288 tiene un aviso:

¡Atención! Finger revela información sobre los usuarios; además, esa información puede considerarse sensible.

A finales de los 90, la inmensa mayoría de los administradores había desactivado el servicio. El protocolo quedó como una reliquia después de casi 20 años de uso, lo cual no está nada mal.

Y aquí llega el giro inesperado. Finger está tan olvidado, y a la vez tan presente, que en 2020 se descubrió que ciertos atacantes usaban el finger.exe que viene de fábrica en Windows para descargar malware sin levantar sospechas. Es una técnica llamada living-off-the-land: el binario ya está ahí, es de confianza y casi nadie lo vigila. El malware Astaroth lo empleó para traer su carga. Que un protocolo de los años 70 siga instalado en cada Windows habla muy bien de su diseño.

Las ideas simples y funcionales son muy difíciles de matar. Tan solo hay que ver la cantidad de comandos Unix, muchos de ellos programados antes de que nacieras. Y con el renacer de la small web, una corriente de protocolos minimalistas y descentralizados (Gemini, IRC, RSS, NNTP, etc.), Finger ha vuelto a asomar la cabeza:

• Happy Net Box, de Ben Brown. Una reencarnación del .plan con interfaz web para editar tu texto y un demonio que limita el riesgo de seguridad. Prueba finger benbrown@happynetbox.com, o finger random@happynetbox.com (mi ejemplo anterior) para leer a un usuario al azar.
• Finger.Farm, de Jon Roig. Otra implementación de Finger de código abierto escrita en Node, con actualización por web, API REST o cURL, pensada para que la despliegues tú mismo.
• plan.cat, otro servidor público que además tiende un puente con ActivityPub, así que tu .plan se puede leer desde Mastodon.

Es un protocolo vivo, pequeño y hackeable, sostenido por gente a la que le divierte.

También existen directorios de cuentas activas:

finger ring@thebackupbox.net

Y seguro que hay más comunidades que no conozco.

Dar tus primeros pasos

Fácil: un hosting como Happy Net Box

No montas nada. Te registras gratis en happynetbox.com, escribes tu texto en su caja web y guardas. A partir de ese momento, cualquiera en el mundo te lee:

finger tu-usuario@happynetbox.com

El servidor y la seguridad los pone el servicio. Es la forma perfecta de tener tu .plan público en un minuto, sin tocar una consola. Coste cero. Si vienes de Mastodon o X, este es tu equivalente a "abrir una cuenta".

Intermedio: el demonio de Finger en tu Linux

Si ya tienes un servidor (un VPS, una Raspberry Pi), puedes correr el demonio clásico, el fingerd de toda la vida. Lee el fichero ~/.plan del usuario por el que te pregunten y lo sirve. En Debian conviene usar ffingerd, una reimplementación pensada en seguridad y la recomendada para un servicio público. Se lanza desde un superservidor como inetd, que escucha en el puerto 79 y arranca el demonio en cada conexión.

sudo apt install openbsd-inetd ffingerd

Añade esta línea a /etc/inetd.conf y recarga el servicio:

finger stream tcp nowait nobody /usr/sbin/tcpd /usr/sbin/ffingerd

sudo systemctl reload openbsd-inetd

Ahora crea tu plan, legible por todos, y pruébalo:

echo "Hola, soy Bob. Hoy trabajo en mi servidor de Finger." > ~/.plan
chmod a+r ~/.plan
finger tu-usuario@tu-servidor

Solo te falta abrir el puerto 79 en el cortafuegos y apuntar un dominio. Como Finger revela información, sigue el consejo del manual de seguridad de Debian: usa ffingerd, restringe qué hosts pueden conectar y limita el número de procesos.

Difícil: tu propio fingerd en Python

Si quieres controlarlo todo y entender el protocolo por dentro, escribe tu propio servidor. Como Finger es texto plano sobre un socket, cabe en unas líneas. Este es el script que uso para servir mi .plan.

Crea un archivo llamado fingerd.py con este contenido:

import asyncio

PLAN_FILE = "plan.txt"


async def handle(reader, writer):
    # Leemos la consulta del cliente y la descartamos: servimos un solo plan.
    await reader.readline()
    try:
        with open(PLAN_FILE, encoding="utf-8") as file:
            body = file.read()
    except FileNotFoundError:
        body = "Sin plan todavía.\n"
    writer.write(body.encode("utf-8"))
    await writer.drain()
    writer.close()


async def main():
    server = await asyncio.start_server(handle, "0.0.0.0", 79)
    async with server:
        await server.serve_forever()


asyncio.run(main())

Crea un plan.txt con lo que quieras publicar y arráncalo.

El puerto 79 es privilegiado, así que necesita permisos:

sudo python3 fingerd.py

Pruébalo desde otra terminal:

finger cualquiera@localhost

El servidor ignora el nombre que envíes y devuelve tu plan.

Para que sobreviva a los reinicios, envuélvelo en un servicio de systemd.

Cualquier mejora que quieras incluir, ya depende de ti.

Apuntes finales

A día de hoy sigue vivo y está parcheado. Las implementaciones modernas no exponen la carpeta personal, no usan gets() y aíslan el proceso. El fantasma del gusano de Morris fue un fallo de una implementación concreta en 1988, no de arquitectura. Es sencillo, práctico y seguro. Y, además, te hace propietario de tu presencia en la red.

Eso sí, hoy existen soluciones más completas, más accesibles o que viajan sobre otros protocolos:

Si vienes de una red social al uso, RSS es la puerta más suave: escribes en tu blog y cualquiera te sigue desde su lector. El gemlog de Gemini y el phlog de Gopher son primos de la small web, con clientes propios y la misma vocación de calma. La página /now (el movimiento que arrancó Derek Sivers en 2015 y que cataloga nownownow.com) es, en la práctica, el .plan mudado a la web: una sola página que responde "¿en qué andas ahora?". Y Org Social es casi Finger de nacimiento: microblog en un fichero de texto que tú alojas.

Ese minimalismo extremo, sin reglas ni formatos definidos, es justo lo que lo hace difícil de matar y realmente disfrutable.

De momento no volverá a ser masivo, ¿qué importa? Seguirá vivo en los márgenes de una internet cada vez más compleja, sostenido por curiosos, esperando a que alguien teclee finger y redescubra su huevo de pascua. Es probable que sea lo más pequeño y lo más tuyo que tengas en internet.

Por cierto, hazme finger me@andros.dev y estate atento a mi .plan. ;)

Fuentes

Cada dato de este artículo procede de estas referencias:

• RFC 742: NAME/FINGER Protocol (Ken Harrenstien, 1977). La primera especificación.
• RFC 1288: The Finger User Information Protocol (D. Zimmerman, 1991). La especificación definitiva, incluye las advertencias de seguridad.
• Finger (protocol) en Wikipedia. Historia, RFCs y declive.
• Les Earnest, gold medal for FINGER, exposición de la Universidad de Stanford, y su relato en primera persona sobre el origen del nombre.
• The Carmack Plan y el archivo de los .plan de John Carmack en GitHub.
• The ARPANET Of Things And CMU's History Of Networked Soda Machines (Hackaday) y la historia oficial de la máquina de Coca-Cola de la CMU.
• The Ghost of Exploits Past: A Deep Dive into the Morris Worm (Rapid7). Detalles del desbordamiento en fingerd, y Morris worm en Wikipedia para la fecha y el alcance.
• Windows 10 'Finger' command can be abused to download or steal files (BleepingComputer) y Guildma is now using Finger… (SANS ISC). El uso de finger.exe como herramienta de ataque, con su ficha en LOLBAS.
• Happy Net Box, de Ben Brown.
• Finger.Farm, de Jon Roig. Implementación de Finger en Node, de código abierto.
• plan.cat, servidor público de Finger con puente a ActivityPub, y el finger ring de thebackupbox, un directorio de cuentas activas (finger ring@thebackupbox.net).
• How and why to make a /now page, de Derek Sivers, y el directorio nownownow.com.
• Forgotten Internet: Giving (or Getting) The Finger (Hackaday). Panorama del Finger moderno.
• 5.9. Securing finger, manual de seguridad de Debian, sobre los demonios ffingerd, cfingerd y efingerd.