@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
104 lines (97 loc) • 4.4 kB
text/typescript
/**
* Reads the ALPN offer from a TLS ClientHello without terminating TLS.
*
* The picker listener uses it to send a client that offers `h2` to its HTTP/2 server and every
* other client to its HTTP/1.1 server. The ClientHello is reassembled from as many plaintext
* handshake records as it spans (RFC 8446 5.1 allows any split), within fixed byte and record
* limits. This is a routing hint, not validation: parsing stops at the ALPN decision, and the TLS
* server that receives the replayed bytes validates the handshake. Anything the parser cannot read
* up to that decision returns false, which keeps that client on HTTP/1.1, the behaviour before
* HTTP/2 existed here.
*/
/** Wire bytes the front reads before deciding; a real ClientHello is far smaller. */
export const CLIENT_HELLO_MAX_BYTES = 64 * 1024;
/** Handshake records one ClientHello may span. */
export const CLIENT_HELLO_MAX_RECORDS = 16;
const RECORD_HEADER_BYTES = 5;
const RECORD_HANDSHAKE = 0x16;
const MAX_RECORD_PAYLOAD = 16_384;
const HANDSHAKE_CLIENT_HELLO = 0x01;
const EXTENSION_ALPN = 0x0010;
/**
* Whether the ClientHello at the start of `data` offers `h2` in ALPN. Returns null while more
* bytes are needed to decide, and false for anything else (not TLS, malformed, over a limit).
*/
export function clientHelloOffersH2(data: Uint8Array): boolean | null {
const handshake: Uint8Array[] = [];
let handshakeBytes = 0;
let at = 0;
for (let records = 0; ; records++) {
if (handshakeBytes >= 4) {
const first = concat(handshake, 4);
if (first[0] !== HANDSHAKE_CLIENT_HELLO) return false;
const needed = 4 + ((first[1]! << 16) | (first[2]! << 8) | first[3]!);
if (needed > CLIENT_HELLO_MAX_BYTES) return false;
if (handshakeBytes >= needed) return helloOffersH2(concat(handshake, needed).subarray(4));
}
if (records >= CLIENT_HELLO_MAX_RECORDS || at >= CLIENT_HELLO_MAX_BYTES) return false;
if (data.length < at + RECORD_HEADER_BYTES) return null;
if (data[at] !== RECORD_HANDSHAKE || data[at + 1] !== 0x03) return false;
const length = (data[at + 3]! << 8) | data[at + 4]!;
if (length === 0 || length > MAX_RECORD_PAYLOAD) return false;
const end = at + RECORD_HEADER_BYTES + length;
if (end > CLIENT_HELLO_MAX_BYTES) return false;
if (data.length < end) return null;
handshake.push(data.subarray(at + RECORD_HEADER_BYTES, end));
handshakeBytes += length;
at = end;
}
}
function concat(parts: readonly Uint8Array[], bytes: number): Uint8Array {
const out = new Uint8Array(bytes);
let offset = 0;
for (const part of parts) {
if (offset >= bytes) break;
const take = part.subarray(0, bytes - offset);
out.set(take, offset);
offset += take.length;
}
return out;
}
function helloOffersH2(hello: Uint8Array): boolean {
let at = 2 + 32; // legacy_version, random
const skip = (lengthBytes: 1 | 2): boolean => {
if (at + lengthBytes > hello.length) return false;
const length = lengthBytes === 1 ? hello[at]! : (hello[at]! << 8) | hello[at + 1]!;
at += lengthBytes + length;
return at <= hello.length;
};
if (!skip(1) || !skip(2) || !skip(1)) return false; // session id, cipher suites, compression
if (at + 2 > hello.length) return false; // no extensions block: no ALPN
const extensionsEnd = at + 2 + ((hello[at]! << 8) | hello[at + 1]!);
if (extensionsEnd > hello.length) return false;
at += 2;
// Unknown and GREASE extensions are skipped by their declared length, in any order.
while (at + 4 <= extensionsEnd) {
const type = (hello[at]! << 8) | hello[at + 1]!;
const length = (hello[at + 2]! << 8) | hello[at + 3]!;
const body = at + 4;
if (body + length > extensionsEnd) return false;
if (type === EXTENSION_ALPN) return alpnListOffersH2(hello.subarray(body, body + length));
at = body + length;
}
return false;
}
function alpnListOffersH2(extension: Uint8Array): boolean {
if (extension.length < 2) return false;
const end = 2 + ((extension[0]! << 8) | extension[1]!);
if (end > extension.length) return false;
for (let at = 2; at < end;) {
const length = extension[at]!;
const name = at + 1;
if (length === 0 || name + length > end) return false;
if (length === 2 && extension[name] === 0x68 && extension[name + 1] === 0x32) return true; // "h2"
at = name + length;
}
return false;
}