Finger: het sociale netwerk uit 1971 dat nooit stierf

Geen accounts, geen algoritme, geen centrale server. Je volledige profiel past in één enkel plat tekstbestand dat jij beheert. John Carmack (mede-oprichter van id Software en programmeur van Doom en Quake) gebruikte het als een ontwikkelingsdagboek. En de kans is groot dat je al een cliënt op je besturingssysteem hebt geïnstalleerd zonder dat je het weet.

Het meest ongelooflijke is dat het, een halve eeuw later, nog steeds werkt. En sluit een comeback niet uit.

De naam is Finger, en je kunt het nu meteen proberen.

De Finger-cliënt is vooraf geïnstalleerd op macOS en de meeste Unix-systemen. Op Debian of Ubuntu installeer je het met apt install finger. Windows levert ook een finger.exe. En als je Emacs gebruikt, heb je M-x finger, standaard inbegrepen in net-utils.el.

finger random@happynetbox.com

Dit zal willekeurig een Finger-account tonen die wordt gehost op happynetbox.com, een van de vele directories (of hosts) die publiceren gemakkelijk maken als je geen eigen server hebt. Leuk, toch?

Maar de oorsprong is minstens zo interessant.

Oorsprong

In 1971 deelden onderzoekers bij het Stanford Artificial Intelligence Laboratory (SAIL) een computer die draaide op het WAITS time-sharing systeem. De enige manier om te weten wie er verbonden was, was het WHO-commando, dat een eindeloze, moeilijk leesbare lijst uitspuugde.

Les Earnest, een van de ingenieurs van het lab, zag dagelijks hetzelfde tafereel:

"Ik zag vaak mensen met hun vingers over het WHO-scherm gaan terwijl ze dingen zeiden als: 'Daar is Don en dat is Pattie, maar ik weet niet wanneer Tom voor het laatst is gezien'."

Mensen reden met hun vingers over het scherm, vandaar de naam. Earnest schreef een programma dat deze informatie in een menselijk formaat teruggaf: echte namen, locaties en, belangrijker nog, hoe lang elke terminal inactief was geweest. Hij was een praktische ingenieur die liever persoonlijk praatte dan via de computer. Hij wilde weten of het de moeite waard was om op te staan en de gang af te lopen om iemand te zoeken.

Als bijproduct had hij de 'netwerkstatus' (network presence), of het sociale netwerk, uitgevonden.

In 1977 werd het protocol geformaliseerd in RFC 742, geschreven door Ken Harrenstien. Het was zo primitief dat slechts drie sites het ondersteunden: SAIL, SRI en de ITS-machines van MIT. Kort daarna werd de netwerkimplementatie verzorgd door Earl Killian bij MIT en Brian Harvey bij Stanford.

In 1991 werd RFC 1288 geschreven, de definitieve specificatie, waardoor eerdere versies verouderd werden.

Het eerste microblog: de .plan en .project bestanden

Bovenop het protocol kwam de inhoud. Naast het melden of je verbonden was, toonde Finger de inhoud van twee tekstbestanden in je thuismap: .plan en .project. Het oorspronkelijke idee was om aan te kondigen waar je aan werkte en wat je van plan was te doen. Een soort statische professionele "status", zonder interacties zoals likes of reacties. Alsof het een changelog was van je dagelijkse bezigheden of je project.

Mensen deden wat we altijd doen: ze maakten het menselijk. Ze begonnen gedichten, grappen, persoonlijke dagboeken, ASCII-kunst en artikelen toe te voegen... werkelijk alles! Iedereen ter wereld kon je .plan lezen met een simpel commando: finger jouw-gebruiker@jouw-host. Velen beschouwen dit, terecht, als het eerste microblog op het internet.

Het beroemdste voorbeeld is de .plan van John Carmack. Jarenlang kon elke fan finger johnc@idsoftware.com typen (tegenwoordig offline) en rechtstreeks van de bron lezen waar de graphics engine van hun favoriete games aan toe was. Hij schreef van 1996 tot 2010. Vandaag de dag zijn deze bestanden bewaard gebleven en gearchiveerd op GitHub. Het is een van de meest waardevolle technische documenten in de geschiedenis van videogames, en het werd verspreid via een protocol uit 1971. TOO ANGRY TO DIE!

Verwacht overigens geen proza dat tranen in je ogen brengt. Zijn stijl was telegrafisch: takenlijsten en bugs zonder een woord te verspillen. Maar af en toe viel er een bom. Zo kondigde hij op 18 augustus 1997 via zijn .plan, en niet via een website of persconferentie, aan dat hij van plan was de broncode van Doom vrij te geven:

John Carmack's .plan van 18 aug 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!

Het eerste IoT-apparaat sprak Finger

Rond 1982 waren enkele studenten aan de Carnegie Mellon University (Mike Kazar, David Nichols, John Zsarnay en Ivor Durham) het zat om naar het Coca-Cola apparaat van de afdeling te lopen en het leeg of met warme flesjes aan te treffen. Ze installeerden microschakelaars om te detecteren hoeveel flesjes er in elke kolom zaten en hoe lang ze al koelden.

Ze verbonden dit alles met het netwerk en stelden de status beschikbaar via Finger. Vanaf elke computer kon men finger coke@cmu.edu uitvoeren (de exacte naam van de machine veranderde door de jaren heen) en niet alleen ontdekken of er frisdrank was, maar ook welke knop het koudste flesje zou geven. Dit wordt beschouwd als een van de eerste connected objects in de geschiedenis, de grootvader van het Internet of Things. En de interface was, wederom, Finger.

Het protocol

Finger is zo eenvoudig dat het in één alinea kan worden uitgelegd. De cliënt opent een TCP-verbinding op poort 79 van de server. Hij stuurt een regel tekst (de gebruikersnaam die hij zoekt, of een lege regel om iedereen op te sommen) die wordt afgesloten door een carriage return en line feed (CRLF). De server antwoordt met platte tekst en sluit de verbinding. Dat is alles!

Geen versleuteling, geen headers, geen sessies. Pure eenvoud.

Interactie-diagram:

1. Client (finger) → Server (fingerd, poort 79): Opent TCP-verbinding op poort 79.
2. Client → Server: Verstuurt "johnc" + CRLF.
3. Server → Client: Stuurt inhoud van ~johnc/.plan (platte tekst).
4. Server → Client: Sluit de verbinding.

Het basiscommando is: finger gebruiker@server

Omdat het protocol geen geheimen heeft, kun je het handmatig bedienen met netcat. We sturen de gebruikersnaam via standard input naar poort 79 en lezen wat er terugkomt: echo "random" | nc happynetbox.com 79

Het voelt vertrouwd omdat het werkt als andere protocollen zoals Whois, Gopher of SMTP: verbinden, in platte tekst vragen en het antwoord lezen.

Wat er in een .plan staat

Een .plan is geen muur van berichten. Het is een enkel tekstbestand waarin je kunt schrijven wat je wilt. Wanneer iemand jou "fingert", stuurt de server het hele bestand terug, precies zoals het is. Er is geen formaat dat gevolgd moet worden; het is het Wilde Westen.

Betekent dit dat je maar één bericht kunt hebben? Nee. Sinds de jaren '80 is het gebruikelijk om een soort dagboek in datzelfde bestand bij te houden, waarbij gedateerde vermeldingen worden toegevoegd, meestal met de meest recente bovenaan. Dat is hoe John Carmack jaren aan ontwikkeling publiceerde. Zijn .plan was een bestand dat groeide met vermeldingen gescheiden door streepjeslijnen:

John Carmack's .plan van 02 jan 1998 Wired magazine does something that almost no other print magazine...

Jouw eigen bestand zou er eenvoudiger uit kunnen zien, met een profielkop en diverse vermeldingen:

Emily Carter

Mariene bioloog. Koffie, kajakken en oude kaarten.

--- 2026-08-14 ---

Terug van het bemonsteren aan de kust. Drie potten vol plankton om te analyseren.

--- 2026-08-05 ---

Eindelijk "Dune" uitgelezen. Nu begrijp ik de helft van de memes op internet.

--- 2026-07-30 ---

Weet iemand hoe je een fietsketting repareert die steeds eraf loopt? Tips welkom.

Wanneer het bestand te lang wordt, trim je zelf de oude vermeldingen. Er is geen database achter die je geschiedenis opslaat: de .plan is mutabel en ongeversioneerd; wat je verwijdert, is weg. Er is geen manier om van het ene profiel naar het andere te "klikken". Alles is handmatig.

Vergelijking: Moderne Sociale Media vs. Finger

Kenmerk	Mastodon / X / Reddit	Finger (.plan)
Publiceren	Een nieuw bericht per idee	Je bewerkt één enkel tekstbestand
Meerdere vermeldingen	Automatisch, elk bericht is een rij	Handmatig: gedateerde vermeldingen in hetzelfde bestand
Geschiedenis	Alles wordt bewaard met een permalink	Alleen wat je in het bestand laat staan, geen permalink
Iemand volgen	Volgknop en unified feed	Je fingert ze handmatig, of een cliënt verzamelt meerdere
Antwoorden en threads	Ja	Niet standaard
Likes en meldingen	Ja	Nee
Gestructureerd profiel	Ja	Nee
Navigeren tussen profielen	Links en mentions	Nee
Mensen ontdekken	Algoritme en trends	Mond-tot-mondreclame en community-lijsten

Het ziet er wat "decaf" uit naast de sociale netwerken van vandaag. Moderne diensten hebben de ruwe randjes gladgestreken. Maar dit is geen functiestrijd; het is gewoon jouw bestand met jouw status.

Verval en wederopstanding

Finger raakte niet in het vergetten door mode, maar door veiligheid.

Op 2 november 1988 verscheen de Morris-worm, een van de eerste worms die zich over het internet verspreidde. Een van de vectoren was een fout in de fingerd-daemon. De worm stuurde een aanvraag die de buffer deed overlopen (buffer overflow) en erin slaagde code uit te voeren op de externe machine. Dit was waarschijnlijk de eerste kwaadaardige buffer overflow in de geschiedenis. Het infecteerde ongeveer 6.000 computers, circa 10% van het toenmalige internet!

Daarnaast was er een dieper ontwerpprobleem. Finger onthult informatie over mensen: namen, e-mails, schema's en wanneer ze voor het laatst zijn ingelogd. RFC 1288 bevat zelf een waarschuwing:

Warning!! Finger discloses information about users; moreover, such information may be considered sensitive.

Tegen het einde van de jaren 90 hadden de meeste beheerders de service uitgeschakeld. Het protocol werd een relikwie na bijna 20 jaar gebruik, wat overigens niet slecht is.

En dan volgt de onverwachte wending. Finger is zo vergeten, en tegelijkertijd zo aanwezig, dat in 2020 werd ontdekt dat bepaalde aanvallers de finger.exe die standaard in Windows zit, gebruikten om malware te downloaden zonder argwaan te wekken. Dit is een techniek genaamd living-off-the-land: het binary-bestand is al aanwezig, wordt vertrouwd en bijna niemand houdt het in de gaten. De Astaroth-malware gebruikte dit om zijn payload op te halen. Dat een protocol uit de jaren '70 nog steeds op elke Windows-machine staat, zegt veel over het ontwerp.

Eenvoudige, functionele ideeën zijn erg moeilijk te doden. Kijk maar naar hoeveel Unix-commando's er zijn, waarvan velen geschreven zijn voordat je geboren was. En met de heropleving van het 'small web' — een stroming van minimalistische, gedecentraliseerde protocollen (Gemini, IRC, RSS, NNTP, etc.) — is Finger weer opgedoken:

• Happy Net Box, door Ben Brown. Een reïncarnatie van de .plan met een webinterface om je tekst te bewerken en een daemon die het veiligheidsrisico beperkt. Probeer finger benbrown@happynetbox.com of finger random@happynetbox.com.
• Finger.Farm, door Jon Roig. Een andere open-source Finger-implementatie geschreven in Node, met updates via web, REST API of cURL, ontworpen voor self-hosting.
• plan.cat, een andere publieke server die ook een brug slaat naar ActivityPub, zodat je .plan gelezen kan worden via Mastodon.

Het is een levend protocol, klein en hackbaar, in stand gehouden door mensen die het leuk vinden. Er zijn zelfs directories van actieve accounts, zoals de gecureerde kaart van het Fingerverse of de finger ring van epoch: finger ring@thebackupbox.net.

Eerste stappen zetten

Makkelijk: een host zoals Happy Net Box

Je hoeft niets te installeren. Meld je gratis aan op happynetbox.com, schrijf je tekst in het webvenster en sla het op. Vanaf dat moment kan iedereen ter wereld je lezen: finger jouw-gebruiker@happynetbox.com De service regelt de server en de beveiliging. Dit is de perfecte manier om binnen een minuut een publieke .plan te hebben zonder een console aan te raken.

Gemiddeld: de Finger-daemon op je Linux

Als je al een server hebt (een VPS, een Raspberry Pi), kun je de klassieke daemon draaien: fingerd. Deze leest het ~/.plan bestand van de gebruiker die wordt opgevraagd. Op Debian is het aanbevolen om ffingerd te gebruiken, een beveiligde reimplementatie. Deze wordt gelanceerd vanuit een super-server zoals inetd, die luistert op poort 79.

sudo apt install openbsd-inetd ffingerd

Voeg deze regel toe aan /etc/inetd.conf en herlaad de service: finger stream tcp nowait nobody /usr/sbin/tcpd /usr/sbin/ffingerd

sudo systemctl reload openbsd-inetd

Maak nu je plan aan, maak het wereldwijd leesbaar en test het:

echo "Hoi, ik ben Bob. Vandaag werk ik aan mijn Finger-server." > ~/.plan
chmod a+r ~/.plan
finger jouw-gebruiker@jouw-server

Vergeet niet poort 79 in de firewall te openen. Gebruik ffingerd en beperk het aantal processen om de beveiliging te waarborgen.

Moeilijk: je eigen fingerd in Python

Als je volledige controle wilt, kun je je eigen server schrijven. Omdat Finger platte tekst over een socket is, past dit in een paar regels. Hier is het script dat ik gebruik:

import asyncio

PLAN_FILE = "plan.txt"

async def handle(reader, writer):
    # Lees de query van de client en negeer deze: we serveren één plan.
    await reader.readline()
    try:
        with open(PLAN_FILE, encoding="utf-8") as file:
            body = file.read()
    except FileNotFoundError:
        body = "Nog geen plan beschikbaar.\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())

Maak een plan.txt bestand aan en start de server. Poort 79 is een geprivilegieerde poort, dus er zijn root-rechten nodig: sudo python3 fingerd.py

Test het vanuit een andere terminal: finger anyone@localhost

Slotopmerkingen

Finger is vandaag de dag nog steeds in leven en gepatcht. Moderne implementaties stellen de thuismap niet bloot, gebruiken geen gets() en isoleren het proces. De geest van de Morris-worm was een fout in een specifieke implementatie uit 1988, niet in de architectuur. Het is eenvoudig, praktisch en veilig. Bovendien maakt het jou de eigenaar van je aanwezigheid op het netwerk.

Dat gezegd hebbende, er zijn tegenwoordig completere oplossingen:

Alternatief	Wat je schrijft	Verkeer via	Lezen met
Finger	Een .plan bestand	Finger (poort 79)	finger user@host
Org Social	Berichten in social.org	HTTP	Org Social cliënt, of curl + grep
RSS / Atom	XML feed vanuit Markdown	HTTP	Elke feed-reader
Gemlog	.gmi pagina's in gemtext	Gemini (poort 1965)	Gemini cliënt (Lagrange, Elpher)
Phlog	Tekstbestanden en gophermap	Gopher (poort 70)	Gopher cliënt, of curl gopher://
/now pagina	Tekst- of HTML-pagina	HTTP	Browser, of curl

Dit extreme minimalisme, zonder regels of vastgelegde formaten, is precies wat het zo moeilijk maakt om te doden en zo plezierig om te gebruiken. Het zal waarschijnlijk nooit meer mainstream worden, maar dat maakt niet uit. Het zal voortbestaan in de marges van een steeds complexer internet, in stand gehouden door de nieuwsgierigen.

***

Bronnen

• RFC 742: NAME/FINGER Protocol (Ken Harrenstien, 1977). De eerste specificatie.
• RFC 1288: The Finger User Information Protocol (D. Zimmerman, 1991). De definitieve specificatie inclusief beveiligingswaarschuwingen.
• Wikipedia: Finger (protocol). Geschiedenis, RFC's en verval.
• Stanford University: Les Earnest, goudmedaille voor FINGER, en zijn verslag over de oorsprong van de naam.
• GitHub: Het archief van de .plan bestanden van John Carmack.
• Hackaday: The ARPANET Of Things And CMU's History Of Networked Soda Machines.
• Rapid7: The Ghost of Exploits Past: A Deep Dive into the Morris Worm.
• BleepingComputer: Windows 10 'Finger' command can be abused to download or steal files.
• Ben Brown: Happy Net Box.
• Jon Roig: Finger.Farm.
• plan.cat: Publieke Finger-server met ActivityPub brug.
• The Fingerverse: Gecureerde directory van het huidige Finger-ecosysteem.
• Derek Sivers: How and why to make a /now page (nownownow.com).
• Hackaday: Forgotten Internet: Giving (or Getting) The Finger.
• Debian Security Manual: Sectie 5.9 over het beveiligen van Finger (ffingerd, cfingerd, efingerd).