Hoe WebSockets werken: één verbinding die openblijft
Een chatvenster dat een nieuw bericht toont zodra iemand het verstuurt: HTTP is daar niet voor gemaakt. Bij HTTP stelt de browser een vraag en geeft de server antwoord. Heeft de server iets nieuws, dan moet hij wachten op de volgende vraag. WebSockets lossen dat op met één verbinding die openblijft en waarover beide kanten op elk moment iets kunnen sturen.
In dit artikel bouw ik met een klein Python-script zelf een WebSocket-verbinding op met de openbare echoserver echo.websocket.org. Je ziet hoe een HTTP-vraag in een WebSocket verandert, hoe een bericht er op de draad uitziet en waarom de browser alles wat hij verstuurt door elkaar husselt. De regels komen uit RFC 6455, de standaard uit december 2011.
Het probleem: pollen
Voor WebSockets moest een pagina volgens RFC 6455 HTTP misbruiken door te pollen. Bij gewoon pollen vraagt de browser elke paar seconden of er iets nieuws is. RFC 6202 (april 2011) beschrijft long polling als de slimmere variant: de server houdt de vraag vast en antwoordt pas als er iets is of als een time-out verloopt. Daarna stuurt de browser meteen een nieuwe vraag.
Beide kosten iets. Elke vraag heeft volledige HTTP-headers. Toen ik met curl de pagina van de echoserver ophaalde, was de vraag 85 bytes en de kop van het antwoord 222 bytes. Ruim 300 bytes aan headers, terwijl curl nog weinig meestuurt. Een nieuwe HTTPS-verbinding kostte vanaf een Nederlandse verbinding bovendien 177 tot 192 milliseconden, waarvan het grootste deel de TLS-handshake was. Hoe die handshake werkt, staat in Wat er gebeurt vóór de eerste byte.
De WebSocket-handshake: een HTTP-vraag die van protocol wisselt
Een WebSocket begint als gewone HTTP/1.1-vraag, over poort 80 voor ws:// of poort 443 voor wss://. Zo kan hij volgens de RFC gebruikmaken van de bestaande webinfrastructuur, inclusief proxy's. Mijn script stuurde deze 157 bytes:
GET / HTTP/1.1
Host: echo.websocket.org
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: dMSw7GDcukjpb+LTuj4eDg==
Sec-WebSocket-Version: 13
Over de al opgezette TLS-verbinding kwam na 53,3 milliseconden het antwoord terug:
HTTP/1.1 101 Switching Protocols
upgrade: websocket
connection: Upgrade
sec-websocket-accept: 9UVnKAfUM0vQdLsDSnxrUpLygEA=
Met statuscode 101 schakelt de server over en is het geen HTTP meer. Bij elke andere code is de handshake volgens de RFC mislukt.
Waarom de server een rekensom terugstuurt
Sec-WebSocket-Key is volgens de RFC een willekeurige waarde van 16 bytes, base64-gecodeerd en per verbinding nieuw. De server plakt daar een vaste tekenreeks achter, 258EAFA5-E914-47DA-95CA-C5AB0DC85B11, berekent de SHA-1-hash en stuurt die base64-gecodeerd terug als Sec-WebSocket-Accept. Mijn script rekende hetzelfde uit en kwam op exact die waarde.
Geheim is dat niet: iedereen kan de rekensom maken. Het doel volgens de RFC: de server bewijst dat hij echt een WebSocket-handshake heeft ontvangen. Zo kan een aanvaller hem niet misleiden met een nagemaakt formulier of XMLHttpRequest.
Een bericht op de draad: het frame
Na de handshake gaan er frames over de verbinding. De eerste byte bevat onder meer het FIN-bit (is dit het laatste stuk van het bericht?) en een opcode van 4 bits die het soort frame aangeeft: 0x1 voor tekst, 0x2 voor binaire data, 0x8 voor sluiten, 0x9 voor ping en 0xA voor pong. De tweede byte bevat het MASK-bit en een lengte van 7 bits.
Ik stuurde het woord Hallo, 5 bytes. Het frame was 11 bytes:
81 85 36 fb c3 be + 5 gemaskeerde bytes
81 is FIN plus opcode 1 (tekst). 85 is het MASK-bit plus lengte 5. Dan volgen 4 bytes maskersleutel en de tekst. Het antwoord van de server begon met 81 05: zelfde type, geen masker, 7 bytes in totaal.
Past de lengte niet in 7 bits, dan geldt een trucje. De waarde 126 betekent dat de echte lengte in de volgende 2 bytes staat, 127 dat die in de volgende 8 bytes staat. Bij een bericht van 300 bytes zag ik 81 fe 01 2c: lengte 126 plus MASK-bit, en daarna 01 2c, hexadecimaal voor 300.
Grote berichten mogen in stukken: FIN uit, vervolgframes met opcode 0x0, het laatste frame FIN aan. Een ping mag daartussen, anders zou hij volgens de RFC achter een groot bericht blijven hangen. Zulke besturingsframes zijn hooguit 125 bytes en worden zelf nooit opgeknipt.
Waarom de client alles maskeert
Elk frame van client naar server moet gemaskeerd zijn, ook over TLS. De client kiest per frame een nieuwe willekeurige sleutel van 4 bytes en doet een XOR van elke byte met sleutelbyte i mod 4. De server mag juist niet maskeren. Terugrekenen is eenvoudig. In het voorbeeld uit de RFC: XOR 7f 9f 4d 51 58 met sleutel 37 fa 21 3d en je krijgt Hello.
De reden staat in sectie 10.3. Tijdens het ontwerp lieten onderzoekers (Huang en anderen, "Talking to Yourself for Fun and Profit") zien dat sommige caching-proxy's in de praktijk een vergelijkbare upgrade niet snapten. Een script kon dan bytes sturen die eruitzagen als een HTTP-vraag voor een bekend script, en de server van de aanvaller gaf een nep-antwoord dat de proxy opsloeg. Ook andere gebruikers achter die proxy konden daarna het verkeerde script krijgen. Doordat de browser de sleutel kiest en niet het script, kan een aanvaller niet bepalen welke bytes er echt over de lijn gaan.
Ping, pong en verbindingen die stil sterven
Een stille verbinding is van buiten niet te onderscheiden van een verbinding waarvan de andere kant al weg is. Daarvoor zijn ping en pong. Wie een ping krijgt, moet een pong terugsturen met dezelfde inhoud. Mijn ping met de tekst ping! kwam na 24,4 milliseconden terug als frame 8a 05 met ping! erin. De RFC noemt ping uitdrukkelijk als keepalive en als manier om te controleren of de andere kant nog reageert.
Een geregelde ping laat ook tussenstations zien dat de verbinding leeft. Je router houdt per verbinding een regel bij in de NAT-tabel, zie NAT: hoe twintig apparaten één IPv4-adres delen. RFC 5382 (oktober 2008) staat een NAT toe om een stille TCP-verbinding op te ruimen, maar niet binnen 2 uur en 4 minuten. TCP heeft zelf ook keepalives, maar die gaan volgens diezelfde RFC standaard eens per 2 uur, en alleen als ze aan staan. Een WebSocket-ping stuurt de applicatie wanneer zij wil.
Netjes afsluiten
Sluiten gaat met een frame met opcode 0x8, met eventueel een statuscode van 2 bytes. 1000 is een normale afsluiting, 1001 betekent dat een kant weggaat, bijvoorbeeld omdat je de pagina verlaat. De andere kant stuurt een close terug, waarna de server de TCP-verbinding dichtdoet. Ik stuurde 1000 met de tekst klaar en kreeg code 1000 terug. Code 1006 mag nooit in een frame staan. Software gebruikt hem om te melden dat de verbinding wegviel zonder close-frame.
Wanneer pollen volstaat
Tien korte berichten heen en terug kostten 17,5 tot 25,9 milliseconden, vlak boven de 16,3 milliseconden die ping gemiddeld gaf. Een tweede HTTP-vraag over een al open verbinding duurde 38 tot 53 milliseconden, met wel een pagina van 13 kB als antwoord.
Volgens RFC 6202 hangt wat pollen kost af van hoe snel een update moet aankomen. Verandert iets eens per minuut en maakt een paar seconden vertraging niet uit, dan is een vraag per halve minuut eenvoudiger te bouwen en hoeft de server geen verbinding per bezoeker open te houden. WebSockets lonen als de server zelf het initiatief moet nemen, als berichten vaak en klein zijn of als beide kanten tegelijk praten, zoals bij chat.
HTTP/2 kent overigens geen Upgrade en geen 101. Daarvoor bestaat RFC 8441 (september 2018), waarmee een WebSocket als één stroom binnen een HTTP/2-verbinding loopt.
Zelf proberen
De handshake kun je met curl doen. Met de sleutel uit de RFC moet de server het antwoord uit de RFC teruggeven:
curl -4 -s -i --http1.1 --max-time 3 \
-H "Connection: Upgrade" -H "Upgrade: websocket" \
-H "Sec-WebSocket-Version: 13" \
-H "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==" \
https://echo.websocket.org/ | head -4
HTTP/1.1 101 Switching Protocols
upgrade: websocket
connection: Upgrade
sec-websocket-accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=
Dezelfde waarde zelf uitrekenen:
python3 -c "import base64,hashlib; print(base64.b64encode(hashlib.sha1(b'dGhlIHNhbXBsZSBub25jZQ==258EAFA5-E914-47DA-95CA-C5AB0DC85B11').digest()).decode())"
s3pPLMBiTxaQ9kYGzzhZRbK+xOo=
Tot slot
Twee dingen verrasten me. De voorbeeldsleutel uit de RFC, dGhlIHNhbXBsZSBub25jZQ==, is gedecodeerd gewoon de tekst the sample nonce. En het maskeren, dat op versleuteling lijkt, beschermt de gebruiker helemaal niet tegen meekijken. De sleutel staat gewoon in het frame. Het beschermt slecht gebouwde proxy's tegen zichzelf: apparatuur die het protocol niet eens hoeft te kennen.