boring-http 1.2.0__tar.gz → 2.0.0__tar.gz

{boring_http-1.2.0 → boring_http-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: boring-http
-Version: 1.2.0
+Version: 2.0.0
 Summary: Asyncio HTTP client on BoringSSL: HTTP/1.1, HTTP/2 and HTTP/3 over QUIC v1 and v2, WebSocket on all three, HTTP and SOCKS proxies, headers in your order
 Requires-Dist: boring-ssl2>=1.2.0
 Requires-Dist: ssl2>=1.2.0
@@ -21,11 +21,14 @@ uv add boring-http
 ```python
 import asyncio
 
-from boring_http import Client
+from boring_http import Client, Http2Settings
+from ssl2 import AkamaiFingerprint
+
+http2 = Http2Settings(AkamaiFingerprint.parse("1:65536;2:0;4:6291456;6:262144|15663105|0|m,a,s,p"))
 
 
 async def main() -> None:
-    async with Client(headers=[("User-Agent", "boring-http/0.1"), ("Accept", "application/json")]) as client:
+    async with Client(http2=http2, headers=[("User-Agent", "boring-http/0.1"), ("Accept", "application/json")]) as client:
         response = await client.get("https://pingly.us.kg/api/all", params={"page": 2})
         print(response.status, response.version, response.content_type)  # 200 h2 application/json
         report = response.json()
@@ -46,11 +49,14 @@ Certificates are checked against the system trust store, or against `trust_store
 ```python
 import asyncio
 
-from boring_http import Client
+from boring_http import Client, Http2Settings
+from ssl2 import AkamaiFingerprint
+
+http2 = Http2Settings(AkamaiFingerprint.parse("1:65536;2:0;4:6291456;6:262144|15663105|0|m,a,s,p"))
 
 
 async def main() -> None:
-    async with Client() as client:
+    async with Client(http2=http2) as client:
         response = await client.get("https://httpbingo.org/redirect/2")
         print(response.status, response.url.path, [step.status for step in response.history])  # 200 /get [302, 302]
 
@@ -71,11 +77,14 @@ asyncio.run(main())
 ```python
 import asyncio
 
-from boring_http import Client, Timeout, TimeoutError
+from boring_http import Client, Http2Settings, Timeout, TimeoutError
+from ssl2 import AkamaiFingerprint
+
+http2 = Http2Settings(AkamaiFingerprint.parse("1:65536;2:0;4:6291456;6:262144|15663105|0|m,a,s,p"))
 
 
 async def main() -> None:
-    async with Client(timeout=Timeout(connect=5, read=10, write=10, total=30)) as client:
+    async with Client(http2=http2, timeout=Timeout(connect=5, read=10, write=10, total=30)) as client:
         async with client.stream("GET", "https://httpbingo.org/stream-bytes/100000") as response:
             size = sum([len(chunk) async for chunk in response.aiter_bytes()])
         print(response.status, size)  # 200 100000
@@ -95,17 +104,47 @@ A single number sets every phase and the total, so the request gives up after th
 
 ```python
 import asyncio
-
-from boring_http import Client, Http3Profile, QuicVersion
+from dataclasses import replace
+
+from boring_http import Client, Http2Settings, Http3Settings, Parameter, QuicVersion, Setting, TransportParameters
+from ssl2 import AkamaiFingerprint, PseudoHeader
+
+http2 = Http2Settings(AkamaiFingerprint.parse("1:65536;2:0;4:6291456;6:262144|15663105|0|m,a,s,p"))
+http3 = Http3Settings(
+    settings=((Setting.QPACK_MAX_TABLE_CAPACITY, 65536), (Setting.MAX_FIELD_SECTION_SIZE, 262144), (Setting.QPACK_BLOCKED_STREAMS, 100)),
+    pseudo_header_order=(PseudoHeader.METHOD, PseudoHeader.AUTHORITY, PseudoHeader.SCHEME, PseudoHeader.PATH),
+    transport=TransportParameters(
+        max_idle_timeout=30000,
+        max_udp_payload_size=1472,
+        initial_max_data=15728640,
+        initial_max_stream_data_bidi_local=6291456,
+        initial_max_stream_data_bidi_remote=6291456,
+        initial_max_stream_data_uni=6291456,
+        initial_max_streams_bidi=100,
+        initial_max_streams_uni=100,
+        order=(
+            Parameter.MAX_IDLE_TIMEOUT,
+            Parameter.MAX_UDP_PAYLOAD_SIZE,
+            Parameter.INITIAL_MAX_DATA,
+            Parameter.INITIAL_MAX_STREAM_DATA_BIDI_LOCAL,
+            Parameter.INITIAL_MAX_STREAM_DATA_BIDI_REMOTE,
+            Parameter.INITIAL_MAX_STREAM_DATA_UNI,
+            Parameter.INITIAL_MAX_STREAMS_BIDI,
+            Parameter.INITIAL_MAX_STREAMS_UNI,
+            Parameter.INITIAL_SOURCE_CONNECTION_ID,
+            Parameter.VERSION_INFORMATION,
+        ),
+    ),
+)
 
 
 async def main() -> None:
-    async with Client(versions=("h3", "h2", "h1")) as client:
+    async with Client(versions=("h3", "h2", "h1"), http2=http2, http3=http3) as client:
         first = await client.get("https://pingly.us.kg/api/all")
         second = await client.get("https://pingly.us.kg/api/all")
         print(first.version, second.version)  # h2 h3, the Alt-Svc header taught the client that this origin speaks HTTP/3
 
-    async with Client(versions=("h3",), http3=Http3Profile(quic_version=QuicVersion.V2)) as client:
+    async with Client(versions=("h3",), http3=replace(http3, quic_version=QuicVersion.V2)) as client:
         response = await client.get("https://pingly.us.kg/api/all")
         print(response.version, response.json()["http_version"])  # h3 HTTP/3.0
 
@@ -113,30 +152,58 @@ async def main() -> None:
 asyncio.run(main())
 ```
 
-The default is `versions=("h2", "h1")`. With `"h3"` in the list the client switches an origin to QUIC after an `Alt-Svc: h3` header and falls back to TCP when the QUIC route stops answering; `versions=("h3",)` goes straight to QUIC. QUIC v1 is the default; `quic_version=QuicVersion.V2` offers v2 through compatible version negotiation (RFC 9368), so the first packet is still v1 and a server that speaks v2, such as aioquic, ngtcp2, haproxy or haskell quic, switches to it, while every other server simply stays on v1. Retry packets, version negotiation, loss recovery, pacing, flow control, key updates, path MTU probing from 1200 up to 1452 bytes with the don't-fragment flag set, QPACK with a 64 KiB dynamic table on the decoding side and 0-RTT are handled; connection migration is not. A second connection to an origin resumes the TLS session and sends GET, HEAD and OPTIONS requests before the handshake has finished, under the limits and SETTINGS the server gave last time; other methods wait for the handshake, a 425 answer is retried after it, and a server that declines the early data gets it again under the 1-RTT keys. The transport parameters are Chrome 155's set, in a fresh random order with a GREASE entry, a GREASE version, Chrome's connection options and, on a resumed connection, the round trip time measured last time; `TransportParameters` on the `Http3Profile` changes any of it. The control stream carries SETTINGS with a GREASE entry, a GREASE frame, and a PRIORITY_UPDATE for every request that has a `priority` header, as Chrome sends them.
+The default is `versions=("h2", "h1")`. With `"h3"` in the list the client switches an origin to QUIC after an `Alt-Svc: h3` header and falls back to TCP when the QUIC route stops answering; `versions=("h3",)` goes straight to QUIC. QUIC v1 is the default; `quic_version=QuicVersion.V2` offers v2 through compatible version negotiation (RFC 9368), so the first packet is still v1 and a server that speaks v2, such as aioquic, ngtcp2, haproxy or haskell quic, switches to it, while every other server simply stays on v1. Retry packets, version negotiation, loss recovery, pacing, flow control, key updates, path MTU probing from 1200 up to 1452 bytes with the don't-fragment flag set, QPACK with the dynamic table the SETTINGS allow on the decoding side and 0-RTT are handled; connection migration is not. A second connection to an origin resumes the TLS session and sends GET, HEAD and OPTIONS requests before the handshake has finished, under the limits and SETTINGS the server gave last time; other methods wait for the handshake, a 425 answer is retried after it, and a server that declines the early data gets it again under the 1-RTT keys. `TransportParameters` sends the parameters in `order`, in that order; `grease=True` adds a GREASE entry, `grease_version=True` a GREASE version, `shuffle=True` a fresh random order on every connection, and `INITIAL_ROUND_TRIP_TIME` in `order` sends the round trip time measured last time on a resumed connection. The control stream carries the SETTINGS of the `Http3Settings`, a GREASE entry and a GREASE frame with `grease=True`, and a PRIORITY_UPDATE for every request that has a `priority` header.
 
 ## Proxies
 
 ```python
 import asyncio
 
-from boring_http import Client
-from ssl2 import ProxyError
+from boring_http import Client, Http2Settings, Http3Settings, Parameter, Setting, TransportParameters
+from ssl2 import AkamaiFingerprint, ProxyError, PseudoHeader
+
+http2 = Http2Settings(AkamaiFingerprint.parse("1:65536;2:0;4:6291456;6:262144|15663105|0|m,a,s,p"))
+http3 = Http3Settings(
+    settings=((Setting.QPACK_MAX_TABLE_CAPACITY, 65536), (Setting.MAX_FIELD_SECTION_SIZE, 262144), (Setting.QPACK_BLOCKED_STREAMS, 100)),
+    pseudo_header_order=(PseudoHeader.METHOD, PseudoHeader.AUTHORITY, PseudoHeader.SCHEME, PseudoHeader.PATH),
+    transport=TransportParameters(
+        max_idle_timeout=30000,
+        max_udp_payload_size=1472,
+        initial_max_data=15728640,
+        initial_max_stream_data_bidi_local=6291456,
+        initial_max_stream_data_bidi_remote=6291456,
+        initial_max_stream_data_uni=6291456,
+        initial_max_streams_bidi=100,
+        initial_max_streams_uni=100,
+        order=(
+            Parameter.MAX_IDLE_TIMEOUT,
+            Parameter.MAX_UDP_PAYLOAD_SIZE,
+            Parameter.INITIAL_MAX_DATA,
+            Parameter.INITIAL_MAX_STREAM_DATA_BIDI_LOCAL,
+            Parameter.INITIAL_MAX_STREAM_DATA_BIDI_REMOTE,
+            Parameter.INITIAL_MAX_STREAM_DATA_UNI,
+            Parameter.INITIAL_MAX_STREAMS_BIDI,
+            Parameter.INITIAL_MAX_STREAMS_UNI,
+            Parameter.INITIAL_SOURCE_CONNECTION_ID,
+            Parameter.VERSION_INFORMATION,
+        ),
+    ),
+)
 
 
 async def main() -> None:
-    async with Client(proxy="socks5h://alice:secret@127.0.0.1:1080") as client:
+    async with Client(http2=http2, proxy="socks5h://alice:secret@127.0.0.1:1080") as client:
         response = await client.get("https://pingly.us.kg/api/all")  # SOCKS5 CONNECT, HTTP/2 inside
         print(response.version, response.json()["http_version"])  # h2 HTTP/2.0
         response = await client.get("https://pingly.us.kg/api/all", proxy="http://alice:secret@127.0.0.1:3128")  # per request
         print(response.version)  # h2
 
-    async with Client(versions=("h3",), proxy="socks5h://alice:secret@127.0.0.1:1080") as client:
+    async with Client(versions=("h3",), http3=http3, proxy="socks5h://alice:secret@127.0.0.1:1080") as client:
         response = await client.get("https://pingly.us.kg/api/all")  # SOCKS5 UDP ASSOCIATE, QUIC datagrams through the relay
         print(response.version, response.json()["http_version"])  # h3 HTTP/3.0
 
     try:
-        async with Client(proxy="socks5h://alice:wrong@127.0.0.1:1080") as client:
+        async with Client(http2=http2, proxy="socks5h://alice:wrong@127.0.0.1:1080") as client:
             await client.get("https://pingly.us.kg/api/all")
     except ProxyError as refusal:
         print(refusal)  # the SOCKS5 proxy rejected the username and password
@@ -152,14 +219,16 @@ asyncio.run(main())
 ```python
 import asyncio
 
-from boring_http import CHROME_HTTP2, Client
+from boring_http import Client, Http2Settings
 from ssl2 import (
     JA4,
+    AkamaiFingerprint,
     CertificateCompressionAlgorithm,
     CipherSuite,
     ClientHelloBuilder,
     ECPointFormat,
     ExtensionType,
+    Http2Priority,
     NamedGroup,
     NextProtocol,
     ProtocolVersion,
@@ -167,7 +236,7 @@ from ssl2 import (
     SignatureScheme,
 )
 
-profile = (
+hello = (
     ClientHelloBuilder()
     .supported_versions(ProtocolVersion.TLS_1_3, ProtocolVersion.TLS_1_2)
     .cipher_suites(
@@ -224,13 +293,17 @@ profile = (
     .psk_key_exchange_modes(PskKeyExchangeMode.psk_dhe_ke)
     .build()
 )
+http2 = Http2Settings(
+    AkamaiFingerprint.parse("1:65536;2:0;4:6291456;6:262144|15663105|0|m,a,s,p"),
+    headers_priority=Http2Priority(stream_id=0, exclusive=True, dependency=0, weight=256),
+)
 
 
 async def main() -> None:
-    async with Client(tls=profile, http2=CHROME_HTTP2) as client:
+    async with Client(tls=hello, http2=http2) as client:
         report = (await client.get("https://pingly.us.kg/api/all")).json()
-        print(report["tls"]["ja4"] == JA4.of(profile).text, report["tls"]["ja4"])  # True t13d1516h2_8daaf6152771_d8a2da3f94cd
-        print(report["http2"]["akamai_fingerprint"] == CHROME_HTTP2.fingerprint.text, report["http2"]["akamai_fingerprint"])  # True 1:65536;2:0;4:6291456;6:262144|15663105|0|m,a,s,p
+        print(report["tls"]["ja4"] == JA4.of(hello).text, report["tls"]["ja4"])  # True t13d1516h2_8daaf6152771_d8a2da3f94cd
+        print(report["http2"]["akamai_fingerprint"] == http2.fingerprint.text, report["http2"]["akamai_fingerprint"])  # True 1:65536;2:0;4:6291456;6:262144|15663105|0|m,a,s,p
 
 
 asyncio.run(main())
@@ -241,9 +314,8 @@ Over HTTP/3 the same holds, with the ClientHello Chrome 155 sends on QUIC: TLS 1
 ```python
 import asyncio
 
-from boring_http import Client, Http3Profile
+from boring_http import Client, Http3Settings, Parameter, Setting, TransportParameters
 from ssl2 import (
-    CHROME_TRUST_ANCHOR_IDS,
     JA4,
     CertificateCompressionAlgorithm,
     CipherSuite,
@@ -253,11 +325,12 @@ from ssl2 import (
     NamedGroup,
     NextProtocol,
     ProtocolVersion,
+    PseudoHeader,
     PskKeyExchangeMode,
     SignatureScheme,
 )
 
-quic_profile = (
+quic_hello = (
     ClientHelloBuilder()
     .supported_versions(ProtocolVersion.TLS_1_3)
     .cipher_suites(CipherSuite.TLS_AES_128_GCM_SHA256, CipherSuite.TLS_AES_256_GCM_SHA384, CipherSuite.TLS_CHACHA20_POLY1305_SHA256)
@@ -293,37 +366,80 @@ quic_profile = (
     .application_settings(NextProtocol.H3)
     .certificate_compression(CertificateCompressionAlgorithm.brotli)
     .psk_key_exchange_modes(PskKeyExchangeMode.psk_dhe_ke)
-    .trust_anchor_ids(*CHROME_TRUST_ANCHOR_IDS)
+    .trust_anchor_ids(
+        "44947.2.1", "44947.2.6", "44947.2.13", "44947.2.14", "44947.2.15", "44947.2.18", "44947.2.19", "44947.2.20",
+        "52580.200109.1.7", "52580.200109.1.8", "52580.200109.1.9", "52580.200109.1.10", "52580.200109.1.11", "52580.200109.1.12", "52580.200109.1.13", "52580.200109.1.18", "52580.200109.1.19",
+        "11129.9.1", "11129.9.4", "11129.9.5", "11129.9.6", "11129.9.7", "11129.9.8", "11129.9.10", "11129.9.11", "11129.9.12", "11129.9.13", "11129.9.15",
+    )
     .grease()
     .permute_extensions()
     .build()
 )
+http3 = Http3Settings(
+    settings=((Setting.QPACK_MAX_TABLE_CAPACITY, 65536), (Setting.MAX_FIELD_SECTION_SIZE, 262144), (Setting.QPACK_BLOCKED_STREAMS, 100), (Setting.H3_DATAGRAM, 1)),
+    pseudo_header_order=(PseudoHeader.METHOD, PseudoHeader.AUTHORITY, PseudoHeader.SCHEME, PseudoHeader.PATH),
+    transport=TransportParameters(
+        max_idle_timeout=30000,
+        max_udp_payload_size=1472,
+        initial_max_data=15728640,
+        initial_max_stream_data_bidi_local=6291456,
+        initial_max_stream_data_bidi_remote=6291456,
+        initial_max_stream_data_uni=6291456,
+        initial_max_streams_bidi=100,
+        initial_max_streams_uni=103,
+        order=(
+            Parameter.MAX_IDLE_TIMEOUT,
+            Parameter.MAX_UDP_PAYLOAD_SIZE,
+            Parameter.INITIAL_MAX_DATA,
+            Parameter.INITIAL_MAX_STREAM_DATA_BIDI_LOCAL,
+            Parameter.INITIAL_MAX_STREAM_DATA_BIDI_REMOTE,
+            Parameter.INITIAL_MAX_STREAM_DATA_UNI,
+            Parameter.INITIAL_MAX_STREAMS_BIDI,
+            Parameter.INITIAL_MAX_STREAMS_UNI,
+            Parameter.INITIAL_SOURCE_CONNECTION_ID,
+            Parameter.VERSION_INFORMATION,
+            Parameter.MAX_DATAGRAM_FRAME_SIZE,
+            Parameter.GOOGLE_CONNECTION_OPTIONS,
+            Parameter.INITIAL_ROUND_TRIP_TIME,
+        ),
+        max_datagram_frame_size=65536,
+        google_connection_options=(b"ORIG",),
+        grease=True,
+        grease_version=True,
+        shuffle=True,
+    ),
+    tls=quic_hello,
+    grease=True,
+)
 
 
 async def main() -> None:
-    async with Client(versions=("h3",), http3=Http3Profile(tls=quic_profile), headers=[("priority", "u=0, i")]) as client:
+    async with Client(versions=("h3",), http3=http3, headers=[("priority", "u=0, i")]) as client:
         _ = await client.get("https://pingly.us.kg/api/all")
         await client.close()  # the next request opens a new connection, which resumes the session
         report = (await client.get("https://pingly.us.kg/api/all")).json()
-        print(report["tls"]["ja4"] == JA4.of(quic_profile, JA4Transport.QUIC).text, report["tls"]["ja4"])  # True q13d0313h3_55b375c5d22e_b0954bf1abdf
+        print(report["tls"]["ja4"] == JA4.of(quic_hello, JA4Transport.QUIC).text, report["tls"]["ja4"])  # True q13d0313h3_55b375c5d22e_b0954bf1abdf
         print(report["http3"]["h3_text"])  # 1:65536;6:262144;7:100;51:1;GREASE|m,a,s,p
 
 
 asyncio.run(main())
 ```
 
-`tls` is a `ssl2.ClientHello`; BoringSSL sends it byte for byte or the client refuses it with the reason. `http2` is an `Http2Profile` with the SETTINGS, WINDOW_UPDATE, priorities and pseudo-header order; `CHROME_HTTP2` is the default. `http3` is an `Http3Profile` with the HTTP/3 SETTINGS, QUIC transport parameters and QUIC version; `CHROME_HTTP3` is the default.
+`tls` is a `ssl2.ClientHello`; BoringSSL sends it byte for byte or the client refuses it with the reason. `http2` is an `Http2Settings` with the SETTINGS, WINDOW_UPDATE, priorities and pseudo-header order. `http3` is an `Http3Settings` with the HTTP/3 SETTINGS, pseudo-header order, QUIC transport parameters and QUIC version. Neither has a default: `h2` in `versions` or in the ClientHello needs `http2`, and `h3` in `versions` needs `http3`.
 
 ## WebSocket
 
 ```python
 import asyncio
 
-from boring_http import Client
+from boring_http import Client, Http2Settings
+from ssl2 import AkamaiFingerprint
+
+http2 = Http2Settings(AkamaiFingerprint.parse("1:65536;2:0;4:6291456;6:262144|15663105|0|m,a,s,p"))
 
 
 async def main() -> None:
-    async with Client() as client:
+    async with Client(http2=http2) as client:
         websocket = await client.websocket("wss://echo.websocket.org/")
         print((await websocket.receive())[:17])  # Request served by
         await websocket.send("hello")
@@ -344,11 +460,39 @@ Over HTTP/1.1 this is the Upgrade handshake. Over HTTP/2 and HTTP/3 it is Extend
 ```python
 import uvloop
 
-from boring_http import Client
+from boring_http import Client, Http3Settings, Parameter, Setting, TransportParameters
+from ssl2 import PseudoHeader
+
+http3 = Http3Settings(
+    settings=((Setting.QPACK_MAX_TABLE_CAPACITY, 65536), (Setting.MAX_FIELD_SECTION_SIZE, 262144), (Setting.QPACK_BLOCKED_STREAMS, 100)),
+    pseudo_header_order=(PseudoHeader.METHOD, PseudoHeader.AUTHORITY, PseudoHeader.SCHEME, PseudoHeader.PATH),
+    transport=TransportParameters(
+        max_idle_timeout=30000,
+        max_udp_payload_size=1472,
+        initial_max_data=15728640,
+        initial_max_stream_data_bidi_local=6291456,
+        initial_max_stream_data_bidi_remote=6291456,
+        initial_max_stream_data_uni=6291456,
+        initial_max_streams_bidi=100,
+        initial_max_streams_uni=100,
+        order=(
+            Parameter.MAX_IDLE_TIMEOUT,
+            Parameter.MAX_UDP_PAYLOAD_SIZE,
+            Parameter.INITIAL_MAX_DATA,
+            Parameter.INITIAL_MAX_STREAM_DATA_BIDI_LOCAL,
+            Parameter.INITIAL_MAX_STREAM_DATA_BIDI_REMOTE,
+            Parameter.INITIAL_MAX_STREAM_DATA_UNI,
+            Parameter.INITIAL_MAX_STREAMS_BIDI,
+            Parameter.INITIAL_MAX_STREAMS_UNI,
+            Parameter.INITIAL_SOURCE_CONNECTION_ID,
+            Parameter.VERSION_INFORMATION,
+        ),
+    ),
+)
 
 
 async def main() -> None:
-    async with Client(versions=("h3",)) as client:
+    async with Client(versions=("h3",), http3=http3) as client:
         print((await client.get("https://pingly.us.kg/api/all")).version)  # h3
 
 

{boring_http-1.2.0 → boring_http-2.0.0}/README.md

@@ -11,11 +11,14 @@ uv add boring-http
 ```python
 import asyncio
 
-from boring_http import Client
+from boring_http import Client, Http2Settings
+from ssl2 import AkamaiFingerprint
+
+http2 = Http2Settings(AkamaiFingerprint.parse("1:65536;2:0;4:6291456;6:262144|15663105|0|m,a,s,p"))
 
 
 async def main() -> None:
-    async with Client(headers=[("User-Agent", "boring-http/0.1"), ("Accept", "application/json")]) as client:
+    async with Client(http2=http2, headers=[("User-Agent", "boring-http/0.1"), ("Accept", "application/json")]) as client:
         response = await client.get("https://pingly.us.kg/api/all", params={"page": 2})
         print(response.status, response.version, response.content_type)  # 200 h2 application/json
         report = response.json()
@@ -36,11 +39,14 @@ Certificates are checked against the system trust store, or against `trust_store
 ```python
 import asyncio
 
-from boring_http import Client
+from boring_http import Client, Http2Settings
+from ssl2 import AkamaiFingerprint
+
+http2 = Http2Settings(AkamaiFingerprint.parse("1:65536;2:0;4:6291456;6:262144|15663105|0|m,a,s,p"))
 
 
 async def main() -> None:
-    async with Client() as client:
+    async with Client(http2=http2) as client:
         response = await client.get("https://httpbingo.org/redirect/2")
         print(response.status, response.url.path, [step.status for step in response.history])  # 200 /get [302, 302]
 
@@ -61,11 +67,14 @@ asyncio.run(main())
 ```python
 import asyncio
 
-from boring_http import Client, Timeout, TimeoutError
+from boring_http import Client, Http2Settings, Timeout, TimeoutError
+from ssl2 import AkamaiFingerprint
+
+http2 = Http2Settings(AkamaiFingerprint.parse("1:65536;2:0;4:6291456;6:262144|15663105|0|m,a,s,p"))
 
 
 async def main() -> None:
-    async with Client(timeout=Timeout(connect=5, read=10, write=10, total=30)) as client:
+    async with Client(http2=http2, timeout=Timeout(connect=5, read=10, write=10, total=30)) as client:
         async with client.stream("GET", "https://httpbingo.org/stream-bytes/100000") as response:
             size = sum([len(chunk) async for chunk in response.aiter_bytes()])
         print(response.status, size)  # 200 100000
@@ -85,17 +94,47 @@ A single number sets every phase and the total, so the request gives up after th
 
 ```python
 import asyncio
-
-from boring_http import Client, Http3Profile, QuicVersion
+from dataclasses import replace
+
+from boring_http import Client, Http2Settings, Http3Settings, Parameter, QuicVersion, Setting, TransportParameters
+from ssl2 import AkamaiFingerprint, PseudoHeader
+
+http2 = Http2Settings(AkamaiFingerprint.parse("1:65536;2:0;4:6291456;6:262144|15663105|0|m,a,s,p"))
+http3 = Http3Settings(
+    settings=((Setting.QPACK_MAX_TABLE_CAPACITY, 65536), (Setting.MAX_FIELD_SECTION_SIZE, 262144), (Setting.QPACK_BLOCKED_STREAMS, 100)),
+    pseudo_header_order=(PseudoHeader.METHOD, PseudoHeader.AUTHORITY, PseudoHeader.SCHEME, PseudoHeader.PATH),
+    transport=TransportParameters(
+        max_idle_timeout=30000,
+        max_udp_payload_size=1472,
+        initial_max_data=15728640,
+        initial_max_stream_data_bidi_local=6291456,
+        initial_max_stream_data_bidi_remote=6291456,
+        initial_max_stream_data_uni=6291456,
+        initial_max_streams_bidi=100,
+        initial_max_streams_uni=100,
+        order=(
+            Parameter.MAX_IDLE_TIMEOUT,
+            Parameter.MAX_UDP_PAYLOAD_SIZE,
+            Parameter.INITIAL_MAX_DATA,
+            Parameter.INITIAL_MAX_STREAM_DATA_BIDI_LOCAL,
+            Parameter.INITIAL_MAX_STREAM_DATA_BIDI_REMOTE,
+            Parameter.INITIAL_MAX_STREAM_DATA_UNI,
+            Parameter.INITIAL_MAX_STREAMS_BIDI,
+            Parameter.INITIAL_MAX_STREAMS_UNI,
+            Parameter.INITIAL_SOURCE_CONNECTION_ID,
+            Parameter.VERSION_INFORMATION,
+        ),
+    ),
+)
 
 
 async def main() -> None:
-    async with Client(versions=("h3", "h2", "h1")) as client:
+    async with Client(versions=("h3", "h2", "h1"), http2=http2, http3=http3) as client:
         first = await client.get("https://pingly.us.kg/api/all")
         second = await client.get("https://pingly.us.kg/api/all")
         print(first.version, second.version)  # h2 h3, the Alt-Svc header taught the client that this origin speaks HTTP/3
 
-    async with Client(versions=("h3",), http3=Http3Profile(quic_version=QuicVersion.V2)) as client:
+    async with Client(versions=("h3",), http3=replace(http3, quic_version=QuicVersion.V2)) as client:
         response = await client.get("https://pingly.us.kg/api/all")
         print(response.version, response.json()["http_version"])  # h3 HTTP/3.0
 
@@ -103,30 +142,58 @@ async def main() -> None:
 asyncio.run(main())
 ```
 
-The default is `versions=("h2", "h1")`. With `"h3"` in the list the client switches an origin to QUIC after an `Alt-Svc: h3` header and falls back to TCP when the QUIC route stops answering; `versions=("h3",)` goes straight to QUIC. QUIC v1 is the default; `quic_version=QuicVersion.V2` offers v2 through compatible version negotiation (RFC 9368), so the first packet is still v1 and a server that speaks v2, such as aioquic, ngtcp2, haproxy or haskell quic, switches to it, while every other server simply stays on v1. Retry packets, version negotiation, loss recovery, pacing, flow control, key updates, path MTU probing from 1200 up to 1452 bytes with the don't-fragment flag set, QPACK with a 64 KiB dynamic table on the decoding side and 0-RTT are handled; connection migration is not. A second connection to an origin resumes the TLS session and sends GET, HEAD and OPTIONS requests before the handshake has finished, under the limits and SETTINGS the server gave last time; other methods wait for the handshake, a 425 answer is retried after it, and a server that declines the early data gets it again under the 1-RTT keys. The transport parameters are Chrome 155's set, in a fresh random order with a GREASE entry, a GREASE version, Chrome's connection options and, on a resumed connection, the round trip time measured last time; `TransportParameters` on the `Http3Profile` changes any of it. The control stream carries SETTINGS with a GREASE entry, a GREASE frame, and a PRIORITY_UPDATE for every request that has a `priority` header, as Chrome sends them.
+The default is `versions=("h2", "h1")`. With `"h3"` in the list the client switches an origin to QUIC after an `Alt-Svc: h3` header and falls back to TCP when the QUIC route stops answering; `versions=("h3",)` goes straight to QUIC. QUIC v1 is the default; `quic_version=QuicVersion.V2` offers v2 through compatible version negotiation (RFC 9368), so the first packet is still v1 and a server that speaks v2, such as aioquic, ngtcp2, haproxy or haskell quic, switches to it, while every other server simply stays on v1. Retry packets, version negotiation, loss recovery, pacing, flow control, key updates, path MTU probing from 1200 up to 1452 bytes with the don't-fragment flag set, QPACK with the dynamic table the SETTINGS allow on the decoding side and 0-RTT are handled; connection migration is not. A second connection to an origin resumes the TLS session and sends GET, HEAD and OPTIONS requests before the handshake has finished, under the limits and SETTINGS the server gave last time; other methods wait for the handshake, a 425 answer is retried after it, and a server that declines the early data gets it again under the 1-RTT keys. `TransportParameters` sends the parameters in `order`, in that order; `grease=True` adds a GREASE entry, `grease_version=True` a GREASE version, `shuffle=True` a fresh random order on every connection, and `INITIAL_ROUND_TRIP_TIME` in `order` sends the round trip time measured last time on a resumed connection. The control stream carries the SETTINGS of the `Http3Settings`, a GREASE entry and a GREASE frame with `grease=True`, and a PRIORITY_UPDATE for every request that has a `priority` header.
 
 ## Proxies
 
 ```python
 import asyncio
 
-from boring_http import Client
-from ssl2 import ProxyError
+from boring_http import Client, Http2Settings, Http3Settings, Parameter, Setting, TransportParameters
+from ssl2 import AkamaiFingerprint, ProxyError, PseudoHeader
+
+http2 = Http2Settings(AkamaiFingerprint.parse("1:65536;2:0;4:6291456;6:262144|15663105|0|m,a,s,p"))
+http3 = Http3Settings(
+    settings=((Setting.QPACK_MAX_TABLE_CAPACITY, 65536), (Setting.MAX_FIELD_SECTION_SIZE, 262144), (Setting.QPACK_BLOCKED_STREAMS, 100)),
+    pseudo_header_order=(PseudoHeader.METHOD, PseudoHeader.AUTHORITY, PseudoHeader.SCHEME, PseudoHeader.PATH),
+    transport=TransportParameters(
+        max_idle_timeout=30000,
+        max_udp_payload_size=1472,
+        initial_max_data=15728640,
+        initial_max_stream_data_bidi_local=6291456,
+        initial_max_stream_data_bidi_remote=6291456,
+        initial_max_stream_data_uni=6291456,
+        initial_max_streams_bidi=100,
+        initial_max_streams_uni=100,
+        order=(
+            Parameter.MAX_IDLE_TIMEOUT,
+            Parameter.MAX_UDP_PAYLOAD_SIZE,
+            Parameter.INITIAL_MAX_DATA,
+            Parameter.INITIAL_MAX_STREAM_DATA_BIDI_LOCAL,
+            Parameter.INITIAL_MAX_STREAM_DATA_BIDI_REMOTE,
+            Parameter.INITIAL_MAX_STREAM_DATA_UNI,
+            Parameter.INITIAL_MAX_STREAMS_BIDI,
+            Parameter.INITIAL_MAX_STREAMS_UNI,
+            Parameter.INITIAL_SOURCE_CONNECTION_ID,
+            Parameter.VERSION_INFORMATION,
+        ),
+    ),
+)
 
 
 async def main() -> None:
-    async with Client(proxy="socks5h://alice:secret@127.0.0.1:1080") as client:
+    async with Client(http2=http2, proxy="socks5h://alice:secret@127.0.0.1:1080") as client:
         response = await client.get("https://pingly.us.kg/api/all")  # SOCKS5 CONNECT, HTTP/2 inside
         print(response.version, response.json()["http_version"])  # h2 HTTP/2.0
         response = await client.get("https://pingly.us.kg/api/all", proxy="http://alice:secret@127.0.0.1:3128")  # per request
         print(response.version)  # h2
 
-    async with Client(versions=("h3",), proxy="socks5h://alice:secret@127.0.0.1:1080") as client:
+    async with Client(versions=("h3",), http3=http3, proxy="socks5h://alice:secret@127.0.0.1:1080") as client:
         response = await client.get("https://pingly.us.kg/api/all")  # SOCKS5 UDP ASSOCIATE, QUIC datagrams through the relay
         print(response.version, response.json()["http_version"])  # h3 HTTP/3.0
 
     try:
-        async with Client(proxy="socks5h://alice:wrong@127.0.0.1:1080") as client:
+        async with Client(http2=http2, proxy="socks5h://alice:wrong@127.0.0.1:1080") as client:
             await client.get("https://pingly.us.kg/api/all")
     except ProxyError as refusal:
         print(refusal)  # the SOCKS5 proxy rejected the username and password
@@ -142,14 +209,16 @@ asyncio.run(main())
 ```python
 import asyncio
 
-from boring_http import CHROME_HTTP2, Client
+from boring_http import Client, Http2Settings
 from ssl2 import (
     JA4,
+    AkamaiFingerprint,
     CertificateCompressionAlgorithm,
     CipherSuite,
     ClientHelloBuilder,
     ECPointFormat,
     ExtensionType,
+    Http2Priority,
     NamedGroup,
     NextProtocol,
     ProtocolVersion,
@@ -157,7 +226,7 @@ from ssl2 import (
     SignatureScheme,
 )
 
-profile = (
+hello = (
     ClientHelloBuilder()
     .supported_versions(ProtocolVersion.TLS_1_3, ProtocolVersion.TLS_1_2)
     .cipher_suites(
@@ -214,13 +283,17 @@ profile = (
     .psk_key_exchange_modes(PskKeyExchangeMode.psk_dhe_ke)
     .build()
 )
+http2 = Http2Settings(
+    AkamaiFingerprint.parse("1:65536;2:0;4:6291456;6:262144|15663105|0|m,a,s,p"),
+    headers_priority=Http2Priority(stream_id=0, exclusive=True, dependency=0, weight=256),
+)
 
 
 async def main() -> None:
-    async with Client(tls=profile, http2=CHROME_HTTP2) as client:
+    async with Client(tls=hello, http2=http2) as client:
         report = (await client.get("https://pingly.us.kg/api/all")).json()
-        print(report["tls"]["ja4"] == JA4.of(profile).text, report["tls"]["ja4"])  # True t13d1516h2_8daaf6152771_d8a2da3f94cd
-        print(report["http2"]["akamai_fingerprint"] == CHROME_HTTP2.fingerprint.text, report["http2"]["akamai_fingerprint"])  # True 1:65536;2:0;4:6291456;6:262144|15663105|0|m,a,s,p
+        print(report["tls"]["ja4"] == JA4.of(hello).text, report["tls"]["ja4"])  # True t13d1516h2_8daaf6152771_d8a2da3f94cd
+        print(report["http2"]["akamai_fingerprint"] == http2.fingerprint.text, report["http2"]["akamai_fingerprint"])  # True 1:65536;2:0;4:6291456;6:262144|15663105|0|m,a,s,p
 
 
 asyncio.run(main())
@@ -231,9 +304,8 @@ Over HTTP/3 the same holds, with the ClientHello Chrome 155 sends on QUIC: TLS 1
 ```python
 import asyncio
 
-from boring_http import Client, Http3Profile
+from boring_http import Client, Http3Settings, Parameter, Setting, TransportParameters
 from ssl2 import (
-    CHROME_TRUST_ANCHOR_IDS,
     JA4,
     CertificateCompressionAlgorithm,
     CipherSuite,
@@ -243,11 +315,12 @@ from ssl2 import (
     NamedGroup,
     NextProtocol,
     ProtocolVersion,
+    PseudoHeader,
     PskKeyExchangeMode,
     SignatureScheme,
 )
 
-quic_profile = (
+quic_hello = (
     ClientHelloBuilder()
     .supported_versions(ProtocolVersion.TLS_1_3)
     .cipher_suites(CipherSuite.TLS_AES_128_GCM_SHA256, CipherSuite.TLS_AES_256_GCM_SHA384, CipherSuite.TLS_CHACHA20_POLY1305_SHA256)
@@ -283,37 +356,80 @@ quic_profile = (
     .application_settings(NextProtocol.H3)
     .certificate_compression(CertificateCompressionAlgorithm.brotli)
     .psk_key_exchange_modes(PskKeyExchangeMode.psk_dhe_ke)
-    .trust_anchor_ids(*CHROME_TRUST_ANCHOR_IDS)
+    .trust_anchor_ids(
+        "44947.2.1", "44947.2.6", "44947.2.13", "44947.2.14", "44947.2.15", "44947.2.18", "44947.2.19", "44947.2.20",
+        "52580.200109.1.7", "52580.200109.1.8", "52580.200109.1.9", "52580.200109.1.10", "52580.200109.1.11", "52580.200109.1.12", "52580.200109.1.13", "52580.200109.1.18", "52580.200109.1.19",
+        "11129.9.1", "11129.9.4", "11129.9.5", "11129.9.6", "11129.9.7", "11129.9.8", "11129.9.10", "11129.9.11", "11129.9.12", "11129.9.13", "11129.9.15",
+    )
     .grease()
     .permute_extensions()
     .build()
 )
+http3 = Http3Settings(
+    settings=((Setting.QPACK_MAX_TABLE_CAPACITY, 65536), (Setting.MAX_FIELD_SECTION_SIZE, 262144), (Setting.QPACK_BLOCKED_STREAMS, 100), (Setting.H3_DATAGRAM, 1)),
+    pseudo_header_order=(PseudoHeader.METHOD, PseudoHeader.AUTHORITY, PseudoHeader.SCHEME, PseudoHeader.PATH),
+    transport=TransportParameters(
+        max_idle_timeout=30000,
+        max_udp_payload_size=1472,
+        initial_max_data=15728640,
+        initial_max_stream_data_bidi_local=6291456,
+        initial_max_stream_data_bidi_remote=6291456,
+        initial_max_stream_data_uni=6291456,
+        initial_max_streams_bidi=100,
+        initial_max_streams_uni=103,
+        order=(
+            Parameter.MAX_IDLE_TIMEOUT,
+            Parameter.MAX_UDP_PAYLOAD_SIZE,
+            Parameter.INITIAL_MAX_DATA,
+            Parameter.INITIAL_MAX_STREAM_DATA_BIDI_LOCAL,
+            Parameter.INITIAL_MAX_STREAM_DATA_BIDI_REMOTE,
+            Parameter.INITIAL_MAX_STREAM_DATA_UNI,
+            Parameter.INITIAL_MAX_STREAMS_BIDI,
+            Parameter.INITIAL_MAX_STREAMS_UNI,
+            Parameter.INITIAL_SOURCE_CONNECTION_ID,
+            Parameter.VERSION_INFORMATION,
+            Parameter.MAX_DATAGRAM_FRAME_SIZE,
+            Parameter.GOOGLE_CONNECTION_OPTIONS,
+            Parameter.INITIAL_ROUND_TRIP_TIME,
+        ),
+        max_datagram_frame_size=65536,
+        google_connection_options=(b"ORIG",),
+        grease=True,
+        grease_version=True,
+        shuffle=True,
+    ),
+    tls=quic_hello,
+    grease=True,
+)
 
 
 async def main() -> None:
-    async with Client(versions=("h3",), http3=Http3Profile(tls=quic_profile), headers=[("priority", "u=0, i")]) as client:
+    async with Client(versions=("h3",), http3=http3, headers=[("priority", "u=0, i")]) as client:
         _ = await client.get("https://pingly.us.kg/api/all")
         await client.close()  # the next request opens a new connection, which resumes the session
         report = (await client.get("https://pingly.us.kg/api/all")).json()
-        print(report["tls"]["ja4"] == JA4.of(quic_profile, JA4Transport.QUIC).text, report["tls"]["ja4"])  # True q13d0313h3_55b375c5d22e_b0954bf1abdf
+        print(report["tls"]["ja4"] == JA4.of(quic_hello, JA4Transport.QUIC).text, report["tls"]["ja4"])  # True q13d0313h3_55b375c5d22e_b0954bf1abdf
         print(report["http3"]["h3_text"])  # 1:65536;6:262144;7:100;51:1;GREASE|m,a,s,p
 
 
 asyncio.run(main())
 ```
 
-`tls` is a `ssl2.ClientHello`; BoringSSL sends it byte for byte or the client refuses it with the reason. `http2` is an `Http2Profile` with the SETTINGS, WINDOW_UPDATE, priorities and pseudo-header order; `CHROME_HTTP2` is the default. `http3` is an `Http3Profile` with the HTTP/3 SETTINGS, QUIC transport parameters and QUIC version; `CHROME_HTTP3` is the default.
+`tls` is a `ssl2.ClientHello`; BoringSSL sends it byte for byte or the client refuses it with the reason. `http2` is an `Http2Settings` with the SETTINGS, WINDOW_UPDATE, priorities and pseudo-header order. `http3` is an `Http3Settings` with the HTTP/3 SETTINGS, pseudo-header order, QUIC transport parameters and QUIC version. Neither has a default: `h2` in `versions` or in the ClientHello needs `http2`, and `h3` in `versions` needs `http3`.
 
 ## WebSocket
 
 ```python
 import asyncio
 
-from boring_http import Client
+from boring_http import Client, Http2Settings
+from ssl2 import AkamaiFingerprint
+
+http2 = Http2Settings(AkamaiFingerprint.parse("1:65536;2:0;4:6291456;6:262144|15663105|0|m,a,s,p"))
 
 
 async def main() -> None:
-    async with Client() as client:
+    async with Client(http2=http2) as client:
         websocket = await client.websocket("wss://echo.websocket.org/")
         print((await websocket.receive())[:17])  # Request served by
         await websocket.send("hello")
@@ -334,11 +450,39 @@ Over HTTP/1.1 this is the Upgrade handshake. Over HTTP/2 and HTTP/3 it is Extend
 ```python
 import uvloop
 
-from boring_http import Client
+from boring_http import Client, Http3Settings, Parameter, Setting, TransportParameters
+from ssl2 import PseudoHeader
+
+http3 = Http3Settings(
+    settings=((Setting.QPACK_MAX_TABLE_CAPACITY, 65536), (Setting.MAX_FIELD_SECTION_SIZE, 262144), (Setting.QPACK_BLOCKED_STREAMS, 100)),
+    pseudo_header_order=(PseudoHeader.METHOD, PseudoHeader.AUTHORITY, PseudoHeader.SCHEME, PseudoHeader.PATH),
+    transport=TransportParameters(
+        max_idle_timeout=30000,
+        max_udp_payload_size=1472,
+        initial_max_data=15728640,
+        initial_max_stream_data_bidi_local=6291456,
+        initial_max_stream_data_bidi_remote=6291456,
+        initial_max_stream_data_uni=6291456,
+        initial_max_streams_bidi=100,
+        initial_max_streams_uni=100,
+        order=(
+            Parameter.MAX_IDLE_TIMEOUT,
+            Parameter.MAX_UDP_PAYLOAD_SIZE,
+            Parameter.INITIAL_MAX_DATA,
+            Parameter.INITIAL_MAX_STREAM_DATA_BIDI_LOCAL,
+            Parameter.INITIAL_MAX_STREAM_DATA_BIDI_REMOTE,
+            Parameter.INITIAL_MAX_STREAM_DATA_UNI,
+            Parameter.INITIAL_MAX_STREAMS_BIDI,
+            Parameter.INITIAL_MAX_STREAMS_UNI,
+            Parameter.INITIAL_SOURCE_CONNECTION_ID,
+            Parameter.VERSION_INFORMATION,
+        ),
+    ),
+)
 
 
 async def main() -> None:
-    async with Client(versions=("h3",)) as client:
+    async with Client(versions=("h3",), http3=http3) as client:
         print((await client.get("https://pingly.us.kg/api/all")).version)  # h3
 
 

{boring_http-1.2.0 → boring_http-2.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "boring-http"
-version = "1.2.0"
+version = "2.0.0"
 description = "Asyncio HTTP client on BoringSSL: HTTP/1.1, HTTP/2 and HTTP/3 over QUIC v1 and v2, WebSocket on all three, HTTP and SOCKS proxies, headers in your order"
 readme = "README.md"
 requires-python = ">=3.14"

{boring_http-1.2.0 → boring_http-2.0.0}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "boring-http"
-version = "1.2.0"
+version = "2.0.0"
 description = "Asyncio HTTP client on BoringSSL: HTTP/1.1, HTTP/2 and HTTP/3 over QUIC v1 and v2, WebSocket on all three, HTTP and SOCKS proxies, headers in your order"
 readme = "README.md"
 requires-python = ">=3.14"

{boring_http-1.2.0 → boring_http-2.0.0}/src/boring_http/__init__.py

@@ -14,8 +14,8 @@ from boring_http.errors import (
     TooManyRedirects,
     WebSocketClosed,
 )
-from boring_http.http2 import CHROME_HTTP2, Http2Profile
-from boring_http.http3 import CHROME_HTTP3, Http3Profile
+from boring_http.http2 import Http2Settings
+from boring_http.http3 import Http3Settings, Setting
 from boring_http.message import (
     URL,
     Body,
@@ -25,14 +25,12 @@ from boring_http.message import (
     Request,
     Response,
 )
-from boring_http.quic.connection import TransportParameters
+from boring_http.quic.connection import Parameter, TransportParameters
 from boring_http.revocation import Revocation
 from boring_http.timing import Timeout
 from boring_http.websocket import WebSocket
 
 __all__ = (
-    "CHROME_HTTP2",
-    "CHROME_HTTP3",
     "URL",
     "Body",
     "Client",
@@ -43,8 +41,9 @@ __all__ = (
     "HTTPStatusError",
     "HTTPVersion",
     "Headers",
-    "Http2Profile",
-    "Http3Profile",
+    "Http2Settings",
+    "Http3Settings",
+    "Parameter",
     "ProtocolError",
     "QuicVersion",
     "RemoteDisconnected",
@@ -52,6 +51,7 @@ __all__ = (
     "Response",
     "Revocation",
     "RevocationError",
+    "Setting",
     "StreamRefused",
     "StreamResetError",
     "Timeout",

{boring_http-1.2.0 → boring_http-2.0.0}/src/boring_http/client.py

@@ -35,8 +35,8 @@ from boring_http.errors import (
     TooManyRedirects,
 )
 from boring_http.http1 import Http1Connection
-from boring_http.http2 import CHROME_HTTP2, Http2Connection, Http2Profile
-from boring_http.http3 import CHROME_HTTP3, Http3Connection, Http3Profile
+from boring_http.http2 import Http2Connection, Http2Settings
+from boring_http.http3 import Http3Connection, Http3Settings
 from boring_http.message import (
     URL,
     Body,
@@ -94,8 +94,8 @@ class Client:
         timeout: float | Timeout | None = DEFAULT_TIMEOUT,
         proxy: Proxy | str | None = None,
         tls: ClientHello | None = None,
-        http2: Http2Profile = CHROME_HTTP2,
-        http3: Http3Profile = CHROME_HTTP3,
+        http2: Http2Settings | None = None,
+        http3: Http3Settings | None = None,
         versions: Sequence[HTTPVersion | str] = (
             HTTPVersion.HTTP_2,
             HTTPVersion.HTTP_1,
@@ -119,6 +119,13 @@ class Client:
         self._http3 = http3
         self._alt_svc: dict[tuple[str, int], float] = {}
         self._versions = tuple(HTTPVersion(version) for version in versions)
+        if http2 is None and (
+            HTTPVersion.HTTP_2 in self._versions
+            or (tls is not None and NextProtocol.H2.value in tls.application_protocols)
+        ):
+            raise ValueError("h2 is offered, so http2= needs an Http2Settings")
+        if http3 is None and HTTPVersion.HTTP_3 in self._versions:
+            raise ValueError("h3 is in versions, so http3= needs an Http3Settings")
         self._trust_store = trust_store
         self._verify = verify
         self._revocations = Revocations(revocation, self._fetch_crl)
@@ -418,7 +425,7 @@ class Client:
         if protocols not in self._contexts:
             hello = (
                 self._http3.tls
-                if protocols == (NextProtocol.H3,)
+                if protocols == (NextProtocol.H3,) and self._http3 is not None
                 else self._adapted(protocols)
             )
             if hello is None:
@@ -451,7 +458,7 @@ class Client:
     ) -> ClientHello | None:
         if self._tls is None or protocols is None:
             return self._tls
-        # an HTTP/1.1-only connection keeps the profile but can offer only its own protocol
+        # an HTTP/1.1-only connection keeps the ClientHello but can offer only its own protocol
         names = tuple(protocol.value for protocol in protocols)
         return replace(
             self._tls,
@@ -483,7 +490,7 @@ class Client:
         http1_only: bool = False,
     ) -> Connection:
         try:
-            if quic:
+            if quic and self._http3 is not None:
                 memory = self._memory.setdefault(url.address, OriginMemory())
                 client = await QuicClient.connect(
                     self._context((NextProtocol.H3,)),
@@ -511,7 +518,10 @@ class Client:
                     proxy=proxy,
                 )
                 await self._checked(stream, url.authority)
-                if stream.negotiated_protocol() is NextProtocol.H2:
+                if (
+                    stream.negotiated_protocol() is NextProtocol.H2
+                    and self._http2 is not None
+                ):
                     connection = Http2Connection(stream, self._http2)
                     await connection.start()
                     return connection

{boring_http-1.2.0 → boring_http-2.0.0}/src/boring_http/http2.py

@@ -8,7 +8,6 @@ from ssl2 import (
     AkamaiFingerprint,
     AsyncTransport,
     Http2Priority,
-    Http2Setting,
     Http2SettingIdentifier,
     PseudoHeader,
 )
@@ -78,7 +77,7 @@ class ErrorCode(IntEnum):
 
 
 @dataclass(frozen=True, slots=True)
-class Http2Profile:
+class Http2Settings:
     fingerprint: AkamaiFingerprint
     headers_priority: Http2Priority | None = None
 
@@ -93,29 +92,6 @@ class Http2Profile:
         )
 
 
-CHROME_HTTP2 = Http2Profile(
-    AkamaiFingerprint(
-        settings=(
-            Http2Setting(Http2SettingIdentifier.HEADER_TABLE_SIZE, 65536),
-            Http2Setting(Http2SettingIdentifier.ENABLE_PUSH, 0),
-            Http2Setting(Http2SettingIdentifier.INITIAL_WINDOW_SIZE, 6291456),
-            Http2Setting(Http2SettingIdentifier.MAX_HEADER_LIST_SIZE, 262144),
-        ),
-        window_update=15663105,
-        priorities=(),
-        pseudo_header_order=(
-            PseudoHeader.METHOD,
-            PseudoHeader.AUTHORITY,
-            PseudoHeader.SCHEME,
-            PseudoHeader.PATH,
-        ),
-    ),
-    headers_priority=Http2Priority(
-        stream_id=0, exclusive=True, dependency=0, weight=256
-    ),
-)
-
-
 class Http2Stream:
     def __init__(self, identifier: int, send_window: int) -> None:
         self.identifier = identifier
@@ -156,15 +132,15 @@ class Http2Stream:
 
 
 class Http2Connection:
-    def __init__(self, transport: AsyncTransport, profile: Http2Profile) -> None:
+    def __init__(self, transport: AsyncTransport, settings: Http2Settings) -> None:
         self._transport = transport
-        self._profile = profile
+        self._local_settings = settings
         self._encoder = Encoder()
         self._decoder = Decoder(
-            profile.setting(
+            settings.setting(
                 Http2SettingIdentifier.HEADER_TABLE_SIZE, DEFAULT_TABLE_SIZE
             ),
-            profile.setting(
+            settings.setting(
                 Http2SettingIdentifier.MAX_HEADER_LIST_SIZE, DEFAULT_HEADER_LIST_SIZE
             ),
         )
@@ -177,10 +153,10 @@ class Http2Connection:
         self._peer_frame_size = DEFAULT_FRAME_SIZE
         self._peer_window = DEFAULT_WINDOW
         self._peer_max_streams = 2**31
-        self._local_window = profile.setting(
+        self._local_window = settings.setting(
             Http2SettingIdentifier.INITIAL_WINDOW_SIZE, DEFAULT_WINDOW
         )
-        self._connection_window = DEFAULT_WINDOW + profile.fingerprint.window_update
+        self._connection_window = DEFAULT_WINDOW + settings.fingerprint.window_update
         self._connection_received = 0
         self._goaway: int | None = None
         self._reader: asyncio.Task[None] | None = None
@@ -208,7 +184,7 @@ class Http2Connection:
         pass
 
     async def start(self) -> None:
-        fingerprint = self._profile.fingerprint
+        fingerprint = self._local_settings.fingerprint
         settings = b"".join(
             struct.pack("!HI", int(setting.identifier), setting.value)
             for setting in fingerprint.settings
@@ -241,9 +217,11 @@ class Http2Connection:
             Flag.END_STREAM if request.body is None else Flag(0)
         )
         payload = block
-        if self._profile.headers_priority is not None:
+        if self._local_settings.headers_priority is not None:
             flags |= Flag.PRIORITY
-            payload = self._priority_bytes(self._profile.headers_priority) + block
+            payload = (
+                self._priority_bytes(self._local_settings.headers_priority) + block
+            )
         try:
             async with deadline.phase("write"):
                 await self._write_headers(stream.identifier, payload, flags)
@@ -359,7 +337,8 @@ class Http2Connection:
             PseudoHeader.PATH: (b":path", request.url.target.encode()),
         }
         fields = [
-            pseudo[header] for header in self._profile.fingerprint.pseudo_header_order
+            pseudo[header]
+            for header in self._local_settings.fingerprint.pseudo_header_order
         ]
         if protocol is not None:
             fields.insert(1, (b":protocol", protocol))

{boring_http-1.2.0 → boring_http-2.0.0}/src/boring_http/http3.py

@@ -1,7 +1,7 @@
 import asyncio
 import secrets
 from collections.abc import AsyncGenerator, Callable
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from enum import IntEnum
 
 from boring_ssl2 import QuicVersion
@@ -68,32 +68,20 @@ class ErrorCode(IntEnum):
 
 
 @dataclass(frozen=True, slots=True)
-class Http3Profile:
-    settings: tuple[tuple[int, int], ...] = (
-        (Setting.QPACK_MAX_TABLE_CAPACITY, 65536),
-        (Setting.MAX_FIELD_SECTION_SIZE, 262144),
-        (Setting.QPACK_BLOCKED_STREAMS, 100),
-        (Setting.H3_DATAGRAM, 1),
-    )
+class Http3Settings:
+    settings: tuple[tuple[int, int], ...]
+    pseudo_header_order: tuple[PseudoHeader, ...]
+    transport: TransportParameters
+    quic_version: QuicVersion = QuicVersion.V1
+    tls: ClientHello | None = None
+    grease: bool = False
 
     def setting(self, identifier: Setting, default: int) -> int:
         return next(
             (value for key, value in self.settings if key == identifier), default
         )
 
-    pseudo_header_order: tuple[PseudoHeader, ...] = (
-        PseudoHeader.METHOD,
-        PseudoHeader.AUTHORITY,
-        PseudoHeader.SCHEME,
-        PseudoHeader.PATH,
-    )
-    transport: TransportParameters = field(default_factory=TransportParameters)
-    quic_version: QuicVersion = QuicVersion.V1
-    tls: ClientHello | None = None
-    grease: bool = True
-
 
-CHROME_HTTP3 = Http3Profile()
 # RFC 8470 section 5.2: the requests a client may send before the handshake, since a server may see them twice
 SAFE_METHODS = frozenset({"GET", "HEAD", "OPTIONS"})
 
@@ -152,12 +140,12 @@ class Http3Connection:
     def __init__(
         self,
         quic: QuicClient,
-        profile: Http3Profile,
+        settings: Http3Settings,
         memory: OriginMemory | None = None,
     ) -> None:
         self._quic = quic
-        self._profile = profile
-        self._qpack = Qpack(profile.setting(Setting.QPACK_MAX_TABLE_CAPACITY, 0))
+        self._local_settings = settings
+        self._qpack = Qpack(settings.setting(Setting.QPACK_MAX_TABLE_CAPACITY, 0))
         self._control_stream = -1
         self._decoder_stream = -1
         self._peer_settings: dict[int, int] = {}
@@ -197,9 +185,9 @@ class Http3Connection:
         writer = Writer()
         writer.varint(StreamType.CONTROL)
         settings = Writer()
-        entries = list(self._profile.settings)
-        if self._profile.grease:
-            # RFC 9114 section 7.2.4.1: a reserved identifier the peer must ignore, placed at random like Chrome does
+        entries = list(self._local_settings.settings)
+        if self._local_settings.grease:
+            # RFC 9114 section 7.2.4.1: a reserved identifier the peer must ignore, placed at random
             entries.insert(
                 secrets.randbelow(len(entries) + 1),
                 (0x1F * secrets.randbelow(1 << 16) + 0x21, secrets.randbelow(1 << 20)),
@@ -210,8 +198,8 @@ class Http3Connection:
         writer.varint(FrameType.SETTINGS)
         writer.varint(len(settings))
         writer.put(settings.finish())
-        if self._profile.grease:
-            # RFC 9114 section 7.2.8: an empty frame of a reserved type right after SETTINGS, as Chrome sends it
+        if self._local_settings.grease:
+            # RFC 9114 section 7.2.8: an empty frame of a reserved type right after SETTINGS
             writer.varint(0x1F * secrets.randbelow(1 << 32) + 0x21)
             writer.varint(0)
         self._quic.send(self._control_stream, writer.finish())
@@ -252,7 +240,7 @@ class Http3Connection:
         stream_id = self._quic.open_stream()
         priority = request.headers.get("priority")
         if priority is not None:
-            # RFC 9218 section 7.2: Chrome announces a request's priority on the control stream before its HEADERS
+            # RFC 9218 section 7.2: a request's priority goes on the control stream before its HEADERS
             self._quic.send(
                 self._control_stream,
                 self._frame(
@@ -341,7 +329,7 @@ class Http3Connection:
             PseudoHeader.SCHEME: (b":scheme", scheme.encode()),
             PseudoHeader.PATH: (b":path", request.url.target.encode()),
         }
-        fields = [pseudo[header] for header in self._profile.pseudo_header_order]
+        fields = [pseudo[header] for header in self._local_settings.pseudo_header_order]
         if protocol is not None:
             fields.insert(1, (b":protocol", protocol))
         return fields + [(name.encode(), value.encode()) for name, value in wire]

{boring_http-1.2.0 → boring_http-2.0.0}/src/boring_http/quic/connection.py

@@ -48,7 +48,7 @@ from boring_http.quic.recovery import GRANULARITY, Recovery, SentPacket
 from boring_http.quic.streams import ReceiveStream, SendStream
 
 DATAGRAM_SIZE = 1200
-# RFC 9000 section 14.2: what a 1500 byte link carries under IPv6 and UDP headers; Chrome probes up to this size too
+# RFC 9000 section 14.2: what a 1500 byte link carries under IPv6 and UDP headers
 PROBED_DATAGRAM_SIZE = 1452
 TAG_LENGTH = 16
 SAMPLE_LENGTH = 16
@@ -117,40 +117,25 @@ NEVER_REMEMBERED = (
 
 @dataclass(frozen=True, slots=True)
 class TransportParameters:
-    max_idle_timeout: int = 30000
-    max_udp_payload_size: int = 1472
-    initial_max_data: int = 15728640
-    initial_max_stream_data_bidi_local: int = 6291456
-    initial_max_stream_data_bidi_remote: int = 6291456
-    initial_max_stream_data_uni: int = 6291456
-    initial_max_streams_bidi: int = 100
-    initial_max_streams_uni: int = 103
+    max_idle_timeout: int
+    max_udp_payload_size: int
+    initial_max_data: int
+    initial_max_stream_data_bidi_local: int
+    initial_max_stream_data_bidi_remote: int
+    initial_max_stream_data_uni: int
+    initial_max_streams_bidi: int
+    initial_max_streams_uni: int
+    order: tuple[Parameter, ...]
+    # RFC 9000 section 18.2 and RFC 9221 section 3: the values a peer assumes when a parameter is absent
     ack_delay_exponent: int = 3
     max_ack_delay: int = 25
-    active_connection_id_limit: int = 8
-    max_datagram_frame_size: int = 65536
-    # Chrome's connection option tags; a remembered round trip time goes out with them on a resumed connection
-    google_connection_options: tuple[bytes, ...] = (b"ORIG",)
+    active_connection_id_limit: int = 2
+    max_datagram_frame_size: int = 0
+    google_connection_options: tuple[bytes, ...] = ()
     initial_round_trip_time: int | None = None
-    grease: bool = True
-    grease_version: bool = True
-    shuffle: bool = True
-    # the set Chrome 155 sends: the parameters at their defaults and grease_quic_bit are left out
-    order: tuple[Parameter, ...] = (
-        Parameter.MAX_IDLE_TIMEOUT,
-        Parameter.MAX_UDP_PAYLOAD_SIZE,
-        Parameter.INITIAL_MAX_DATA,
-        Parameter.INITIAL_MAX_STREAM_DATA_BIDI_LOCAL,
-        Parameter.INITIAL_MAX_STREAM_DATA_BIDI_REMOTE,
-        Parameter.INITIAL_MAX_STREAM_DATA_UNI,
-        Parameter.INITIAL_MAX_STREAMS_BIDI,
-        Parameter.INITIAL_MAX_STREAMS_UNI,
-        Parameter.INITIAL_SOURCE_CONNECTION_ID,
-        Parameter.VERSION_INFORMATION,
-        Parameter.MAX_DATAGRAM_FRAME_SIZE,
-        Parameter.GOOGLE_CONNECTION_OPTIONS,
-        Parameter.INITIAL_ROUND_TRIP_TIME,
-    )
+    grease: bool = False
+    grease_version: bool = False
+    shuffle: bool = False
 
     def encode(
         self,
@@ -183,7 +168,7 @@ class TransportParameters:
             elif parameter is Parameter.VERSION_INFORMATION:
                 available: list[int] = list(versions)
                 if self.grease_version:
-                    # RFC 9368 section 2.1 / Chrome: a reserved version at a random place among the available ones
+                    # RFC 9368 section 2.1: a reserved version at a random place among the available ones
                     available.insert(
                         secrets.randbelow(len(available) + 1),
                         secrets.randbits(32) & 0xF0F0F0F0 | 0x0A0A0A0A,
@@ -204,7 +189,7 @@ class TransportParameters:
                 raise ValueError(f"{parameter.name} is not a parameter a client sends")
             pairs.append((parameter, value))
         if self.grease:
-            # RFC 9000 section 18.1: a reserved identifier the peer must ignore, drawn the way Chrome draws it
+            # RFC 9000 section 18.1: a reserved identifier the peer must ignore
             pairs.insert(
                 secrets.randbelow(len(pairs) + 1),
                 (
@@ -213,7 +198,6 @@ class TransportParameters:
                 ),
             )
         if self.shuffle:
-            # Chrome sends its transport parameters in a fresh random order on every connection
             secrets.SystemRandom().shuffle(pairs)
         for identifier, value in pairs:
             writer.varint(identifier)