Saltar a contenido

Versiones de HTTP

El servidor habla HTTP/0.9, 1.0, 1.1, 2 y 3. Las cuatro primeras comparten el puerto TCP; HTTP/3 necesita un listener UDP aparte, porque QUIC no corre sobre TCP.

Como se elige la version

Version Como se detecta
0.9 linea de peticion sin token de version (GET /ruta)
1.0 / 1.1 token de version en la linea de peticion
2 sobre TLS ALPN negocia h2
2 en claro la conexion abre con el preface de HTTP/2
3 datagrama QUIC en el socket UDP, ALPN h3

request.version dice cual llego, asi que un handler puede distinguirlas sin mirar cabeceras.

@app.api("/version")
def version(request):
    return {"http": request.version}

HTTP/0.9

La peticion es una linea y la respuesta es el cuerpo desnudo: sin linea de estado, sin cabeceras. El final lo marca el cierre de la conexion. Solo define GET.

printf 'GET /version\r\n' | nc localhost 8000

HTTP/1.1

Completo: cuerpos chunked con seccion de trailers, y conexiones persistentes segun RFC 9112 seccion 9.3 -- por defecto en 1.1, opt-in en 1.0.

@app.api("/subir", methods=("POST",))
def subir(request):
    # Un cuerpo chunked llega ya reensamblado.
    return {"bytes": len(request.body), "trailers": request.trailers}
Atributo Uso
HTTPServer.KEEPALIVE_TIMEOUT_SECONDS espera entre peticiones reutilizadas
HTTPServer.MAX_KEEPALIVE_REQUESTS peticiones por conexion; 1 desactiva la reutilizacion

HTTP/2

Tramas binarias multiplexadas con compresion HPACK. Se activa solo.

server = HTTPServer("0.0.0.0", 8443, app, ssl_context=app.tls)
server.MAX_CONCURRENT_STREAMS = 100   # lo que anunciamos en SETTINGS
server.ENABLE_HTTP2 = False           # si prefieres solo HTTP/1

Para que ALPN ofrezca h2, dilo al construir el material TLS:

manager = CertificateManager(
    ca=ca, common_name="localhost",
    alpn_protocols=["h2", "http/1.1"],
)

Notas de comportamiento que conviene conocer:

  • Un handler que lanza responde 500, igual que en HTTP/1, en vez de RST_STREAM. Se mantiene la coherencia con el resto del framework.
  • Los handlers se ejecutan fuera del bucle que lee frames, en un pool por conexion (como mucho MAX_HANDLER_THREADS, 16, y nunca mas que MAX_CONCURRENT_STREAMS). Un handler lento no bloquea PING, WINDOW_UPDATE ni los demas streams. Un stream que el cliente resetea mientras su handler trabaja no recibe respuesta, y una respuesta que no se puede codificar termina en RST_STREAM INTERNAL_ERROR.
  • Los campos repetidos de la peticion se combinan como en HTTP/1: cookie con "; " y el resto con ", ". Un host o content-length repetido con valores distintos es una peticion malformada. Los nombres deben ser tokens en minuscula y los valores no pueden contener CR, LF ni NUL ni empezar o acabar en espacio; si no, el stream se resetea con PROTOCOL_ERROR (en HTTP/3, H3_MESSAGE_ERROR). Un content-length que no coincide con los DATA recibidos tambien es PROTOCOL_ERROR.
  • Una respuesta mayor que la ventana del par se encola y sale cuando llega credito. Bloquear pararia todos los demas streams de la conexion.
  • PRIORITY se valida pero no se usa: RFC 9113 lo declara obsoleto.
  • El push del servidor esta desactivado (ENABLE_PUSH: 0).

HTTP/3

QUIC sobre UDP, con TLS 1.3 integrado en el transporte.

from wsbuilder.http3_server import Http3Server, alt_svc_header

h3 = Http3Server("0.0.0.0", 8443, app, app.tls)
threading.Thread(target=h3.serve_forever, daemon=True).start()

Un cliente no descubre HTTP/3 solo: llega por la cabecera Alt-Svc que anuncia una respuesta HTTP/1 o HTTP/2.

Una peticion HTTP/3 con Content-Length debe usar digitos ASCII y coincidir con los DATA recibidos al finalizar. Una longitud invalida termina ese stream con H3_MESSAGE_ERROR, sin ejecutar el handler ni interrumpir las otras peticiones.

@app.api("/algo")
def algo(request):
    return Response.json({"ok": True}, headers={"Alt-Svc": alt_svc_header(8443)})

Streaming y WebSocket sobre HTTP/3

  • Una respuesta con stream= se envia por trozos a medida que el generador los produce, en lugar de unirse en memoria. Sirve para SSE y respuestas largas. El productor espera cuando el stream tiene mas de Http3Server.MAX_PENDING_STREAM_BYTES (256 KiB) sin enviar; si no hay sitio en STREAM_STALL_TIMEOUT_SECONDS (30 s), o el generador falla, el stream se abandona con RESET_STREAM (H3_INTERNAL_ERROR) en vez de un FIN que haria pasar la respuesta truncada por completa.
  • Un CONNECT con :protocol: websocket (RFC 9220) se responde 200 y el stream queda abierto en ambos sentidos. Las rutas @app.ws(...) se ejecutan sobre ese stream con la misma API que en HTTP/1.1, asi que el handler no cambia.
  • El servidor anuncia SETTINGS_ENABLE_CONNECT_PROTOCOL en su control stream (RFC 9114 section 6.2.1); sin eso un cliente no sabe que puede hacer CONNECT.

Un cliente HTTP/3 que no soporte RFC 9220 no podra abrir WebSockets, pero sigue pudiendo hacer peticiones normales y recibir respuestas en streaming.

Por que TLS 1.3 esta escrito a mano

QUIC no transporta registros TLS. Los mensajes de handshake viajan dentro de frames CRYPTO, y el transporte deriva sus claves de proteccion de paquete del key schedule de TLS. Hace falta introducir octetos de handshake y extraer secretos de trafico en cada etapa, y el modulo ssl de Python no expone ninguna de las dos cosas. Por eso existe wsbuilder/quic/tls.py.

Limites que debes conocer antes de usarlo

Esto importa mas que la lista de lo que funciona:

  • Sin 0-RTT ni reanudacion de sesion. Cada conexion hace el handshake completo. Es la unica pieza grande que falta, y es la mas delicada: los datos de 0-RTT son reproducibles por definicion, asi que exigen que la aplicacion decida que peticiones toleran repetirse.
  • TLS 1.3 solo del lado servidor, sin certificados de cliente sobre QUIC.

Validacion de direccion y migracion

Un servidor que responde a un Initial falsificado con un vuelo grande se convierte en un amplificador apuntando a la victima. Por eso, hasta validar la direccion, no se envia mas del triple de lo recibido.

require_address_validation=True va un paso mas alla: el primer Initial recibe un Retry con un token, y solo un cliente que realmente escuche en esa direccion puede devolverlo. El token es un MAC sobre la direccion y el id de conexion original, asi que no se puede falsificar ni reutilizar desde otro sitio.

h3 = Http3Server("0.0.0.0", 8443, app, app.tls, require_address_validation=True)

Cuando llegan paquetes desde una direccion nueva, la conexion no se mueve todavia: se envia un PATH_CHALLENGE con datos impredecibles y solo se migra cuando el par los devuelve desde esa misma direccion. Sin eso, falsificar un paquete bastaria para redirigir el trafico.

Suites y grupos

Suite Hash Secretos
TLS_AES_128_GCM_SHA256 SHA-256 32 octetos
TLS_CHACHA20_POLY1305_SHA256 SHA-256 32 octetos
TLS_AES_256_GCM_SHA384 SHA-384 48 octetos

Grupos: X25519 y secp256r1. Manda la preferencia del servidor, no el orden del cliente. Lo que no este en esas listas se rechaza; no hay camino de respaldo a nada mas debil.

QPACK con tabla dinamica

La tabla esta implementada, sobre su propio stream ordenado. El codificador solo referencia entradas que ya empujo, asi que una seccion nunca queda bloqueada esperando estado de tabla -- que es justo el bloqueo de cabeza de linea que QPACK existe para acotar.

En una seccion repetida de cuatro campos con cabeceras propias, la diferencia es de 45 a 6 octetos. authorization, cookie y set-cookie nunca entran en la tabla: un intermediario la comparte entre conexiones.

Capacidad cero sigue siendo valido y desactiva la tabla por completo.

Recuperacion de perdidas

Implementada segun RFC 9002. Un paquete se declara perdido por orden -- tres paquetes posteriores acusados, que es evidencia mas rapida que un reloj -- o por tiempo, pasado 9/8 del mayor entre el RTT suavizado y el ultimo medido. Los espacios de numeracion son independientes: acusar un paquete 1-RTT no dice nada de uno Initial.

Recuperar significa meter los frames del paquete perdido en uno nuevo, no reenviar el paquete: un numero de paquete se usa una sola vez. Los frames que solo describian el pasado, como un ACK, se descartan al retransmitir.

El control de congestion es NewReno: slow start hasta la primera perdida, luego crecimiento lineal, con la ventana partida por la mitad y un unico evento de congestion por RTT. Los datos nuevos de los streams solo salen mientras bytes_in_flight cabe en la ventana; las retransmisiones y los probes de PTO no esperan. No hay deteccion de congestion persistente ni pacing.

El emisor tambien respeta el control de flujo del par: initial_max_data, initial_max_stream_data_* y los MAX_DATA / MAX_STREAM_DATA que llegan despues. Un stream bloqueado no frena a los demas, y el bloqueo se anuncia una vez por limite con DATA_BLOCKED o STREAM_DATA_BLOCKED.

app.enable_metrics()   # el snapshot incluye rtt, ventana y perdidas

Un paquete que solo lleva un ACK nunca arma un temporizador: el par no debe acuse por el, asi que sondearlo no terminaria nunca.

Trata esto como una implementacion correcta del camino comun, con recuperacion de perdidas real, pero sin las piezas que listo arriba.

Que se verifico contra los RFC

Capa Comprobacion
HPACK vectores del apendice C de RFC 7541, incluido el desalojo
varints QUIC apendice A.1 de RFC 9000, incluida la forma no canonica
Proteccion de paquetes apendice A de RFC 9001: secretos, claves AES y ChaCha20, mascaras de cabecera
TLS 1.3 ClientHellos reales de OpenSSL; key schedule contra las constantes publicadas
HTTP/3 peticion y respuesta sobre UDP real
HTTP/3 streaming y WebSocket respuesta por trozos y CONNECT extendido (RFC 9220) sobre UDP real