provablyfine 0.1.0__py3-none-any.whl

provablyfine/anet/__init__.py

@@ -0,0 +1,5 @@
+"""Async socket library."""
+
+from . import base, exceptions, http, mux, socket, sockets, ssl, stream
+
+__all__ = ["base", "exceptions", "http", "mux", "socket", "sockets", "ssl", "stream"]

provablyfine/anet/base.py

@@ -0,0 +1,52 @@
+import abc
+import enum
+import socket as _socket
+import typing
+
+
+class Shut(enum.IntEnum):
+    RD = _socket.SHUT_RD
+    WR = _socket.SHUT_WR
+    RDWR = _socket.SHUT_RDWR
+
+
+class Socket(abc.ABC):
+    @abc.abstractmethod
+    def fileno(self) -> int:
+        pass
+
+    @abc.abstractmethod
+    def detach(self) -> int:
+        pass
+
+    @abc.abstractmethod
+    async def send(self, data: bytes) -> int:
+        pass
+
+    @abc.abstractmethod
+    async def recv(self, n: int) -> bytes:
+        pass
+
+    @abc.abstractmethod
+    async def shutdown(self, flag: Shut) -> None:
+        pass
+
+    @abc.abstractmethod
+    def close(self) -> None:
+        pass
+
+    @abc.abstractmethod
+    def getsockname(self) -> typing.Any:
+        pass
+
+    @abc.abstractmethod
+    async def bind(self, address: typing.Any) -> None:
+        pass
+
+    @abc.abstractmethod
+    async def listen(self, n: int) -> None:
+        pass
+
+    @abc.abstractmethod
+    async def accept(self) -> tuple["Socket", typing.Any]:
+        pass

provablyfine/anet/conftest.py

@@ -0,0 +1,137 @@
+"""Shared fixtures and helpers for anet tests."""
+
+from __future__ import annotations
+
+import asyncio
+import collections.abc
+import datetime
+import ipaddress
+import os
+
+import cryptography
+import cryptography.hazmat.primitives.asymmetric.rsa as crypto_rsa
+import cryptography.hazmat.primitives.hashes as crypto_hashes
+import cryptography.hazmat.primitives.serialization as crypto_serialization
+import cryptography.x509
+import cryptography.x509.oid as crypto_oid
+import pytest
+
+from . import socket as anet_socket
+from . import ssl as anet_ssl
+
+
+def _create_server_context(
+    certfile: str | os.PathLike[str],
+    keyfile: str | os.PathLike[str],
+) -> anet_ssl.SSLContext:
+    """Create server-side SSL context from certificate and key files."""
+    ctx = anet_ssl.SSLContext(anet_ssl.ContextProtocol.SERVER)
+    ctx.load_cert_chain(str(certfile), str(keyfile))
+    return ctx
+
+
+def _create_client_context(
+    cafile: str | os.PathLike[str],
+    check_hostname: bool = True,
+) -> anet_ssl.SSLContext:
+    """Create client-side SSL context with CA verification."""
+    ctx = anet_ssl.SSLContext(anet_ssl.ContextProtocol.CLIENT)
+    ctx.load_verify_locations(str(cafile))
+    ctx.check_hostname = check_hostname
+    ctx.verify_mode = anet_ssl.VerifyMode.REQUIRED
+    return ctx
+
+
+@pytest.fixture(scope="session")
+def ssl_contexts(tmp_path_factory: pytest.TempPathFactory) -> tuple[anet_ssl.SSLContext, anet_ssl.SSLContext]:
+    """Generate self-signed CA and server certificate; return (server_ctx, client_ctx)."""
+    tmpdir = tmp_path_factory.mktemp("ssl")
+
+    # Generate CA key and cert
+    ca_key = crypto_rsa.generate_private_key(public_exponent=65537, key_size=2048)
+    ca_subject = cryptography.x509.Name([cryptography.x509.NameAttribute(crypto_oid.NameOID.COMMON_NAME, "Test CA")])
+    now = datetime.datetime.now(datetime.UTC)
+    ca_cert = (
+        cryptography.x509.CertificateBuilder()
+        .subject_name(ca_subject)
+        .issuer_name(ca_subject)
+        .public_key(ca_key.public_key())
+        .serial_number(1)
+        .not_valid_before(now)
+        .not_valid_after(now + datetime.timedelta(days=365))
+        .add_extension(
+            cryptography.x509.BasicConstraints(ca=True, path_length=None),
+            critical=True,
+        )
+        .sign(ca_key, crypto_hashes.SHA256())
+    )
+
+    # Generate server key and cert
+    server_key = crypto_rsa.generate_private_key(public_exponent=65537, key_size=2048)
+    server_subject = cryptography.x509.Name(
+        [cryptography.x509.NameAttribute(crypto_oid.NameOID.COMMON_NAME, "127.0.0.1")]
+    )
+    server_cert = (
+        cryptography.x509.CertificateBuilder()
+        .subject_name(server_subject)
+        .issuer_name(ca_subject)
+        .public_key(server_key.public_key())
+        .serial_number(2)
+        .not_valid_before(now)
+        .not_valid_after(now + datetime.timedelta(days=365))
+        .add_extension(
+            cryptography.x509.SubjectAlternativeName([cryptography.x509.IPAddress(ipaddress.IPv4Address("127.0.0.1"))]),
+            critical=False,
+        )
+        .sign(ca_key, crypto_hashes.SHA256())
+    )
+
+    # Write to temp files
+    ca_cert_file = tmpdir / "ca.pem"
+    server_cert_file = tmpdir / "server.pem"
+    server_key_file = tmpdir / "server.key"
+
+    ca_cert_file.write_bytes(ca_cert.public_bytes(crypto_serialization.Encoding.PEM))
+    server_cert_file.write_bytes(server_cert.public_bytes(crypto_serialization.Encoding.PEM))
+    server_key_file.write_bytes(
+        server_key.private_bytes(
+            encoding=crypto_serialization.Encoding.PEM,
+            format=crypto_serialization.PrivateFormat.PKCS8,
+            encryption_algorithm=crypto_serialization.NoEncryption(),
+        )
+    )
+
+    # Create SSL contexts
+    server_ctx = _create_server_context(server_cert_file, server_key_file)
+    client_ctx = _create_client_context(ca_cert_file, check_hostname=False)
+
+    return server_ctx, client_ctx
+
+
+@pytest.fixture
+async def anet_socketpair() -> collections.abc.AsyncGenerator[tuple[anet_socket.Socket, anet_socket.Socket], None]:
+    """Create a connected AF_UNIX socketpair wrapped in anet.socket.Socket."""
+    a, b = anet_socket.socketpair(anet_socket.Family.UNIX, anet_socket.Type.STREAM)
+    yield a, b
+    a.close()
+    b.close()
+
+
+@pytest.fixture
+async def tls_socketpair(
+    anet_socketpair: tuple[anet_socket.Socket, anet_socket.Socket],
+    ssl_contexts: tuple[anet_ssl.SSLContext, anet_ssl.SSLContext],
+) -> collections.abc.AsyncGenerator[tuple[anet_ssl.Socket, anet_ssl.Socket], None]:
+    """Create a TLS-wrapped socketpair with completed handshake."""
+    raw_client, raw_server = anet_socketpair
+    server_ctx, client_ctx = ssl_contexts
+
+    ssl_server = await server_ctx.wrap_socket(raw_server, server_side=True)
+    ssl_client = await client_ctx.wrap_socket(raw_client, server_side=False, server_hostname=None)
+
+    # Handshake must be concurrent
+    await asyncio.gather(ssl_server.handshake(), ssl_client.handshake())
+
+    yield ssl_client, ssl_server
+    ssl_client.close()
+    ssl_server.close()

provablyfine/anet/exceptions.py

@@ -0,0 +1,2 @@
+class Error(Exception):
+    pass

provablyfine/anet/http.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+import dataclasses
+import logging
+
+from . import base, exceptions, stream
+
+logger = logging.getLogger(__name__)
+
+
+@dataclasses.dataclass
+class Message:
+    start_line: str
+    headers: dict[str, str]
+    body: bytes
+
+    @classmethod
+    async def deserialize(cls, sock: base.Socket) -> Message:
+        reader = stream.Reader(sock)
+        try:
+            start_line = (await reader.read_until(b"\r\n"))[:-2].decode("ascii")
+        except EOFError:
+            raise exceptions.Error("Unable to read start line before connection was closed")
+        headers: dict[str, str] = {}
+        while True:
+            try:
+                line = (await reader.read_until(b"\r\n"))[:-2].decode("ascii")
+            except EOFError:
+                raise exceptions.Error("Unable to last line before connection was closed")
+            if line == "":
+                break
+            colon = line.find(":")
+            if colon == -1:
+                logger.warning(f"Invalid header: {line}")
+                raise exceptions.Error("Invalid header")
+            key = line[:colon].lower()
+            value = line[colon + 1 :].lstrip()
+            headers[key] = value
+        if "content-length" in headers:
+            length = headers["content-length"].strip()
+            if not length.isdigit():
+                logger.warning(f"Invalid Content-Length: {length}")
+                raise exceptions.Error("Invalid Content-Length")
+            body = await reader.read(int(length))
+        else:
+            # We do not support chunk encoding
+            body = b""
+        return Message(start_line=start_line, headers=headers, body=body)
+
+    async def serialize(self, sock: base.Socket) -> None:
+        lines = [self.start_line]
+        for name, value in self.headers.items():
+            lines.append(f"{name}: {value}")
+        lines.extend(["", ""])
+        data = b"\r\n".join(line.encode("ascii") for line in lines) + self.body
+        await sock.send(data)
+
+
+@dataclasses.dataclass
+class Request:
+    method: str
+    resource_target: str
+    version: str
+    headers: dict[str, str]
+    body: bytes
+
+    @classmethod
+    async def deserialize(cls, sock: base.Socket) -> Request:
+        message = await Message.deserialize(sock)
+        start_line = message.start_line
+        space = start_line.find(" ")
+        if space == -1:
+            raise exceptions.Error(f"Invalid request start line: {message.start_line}")
+        method = start_line[:space]
+        start_line = start_line[space + 1 :]
+        space = start_line.find(" ")
+        if space == -1:
+            raise exceptions.Error(f"Invalid request start line: {message.start_line}")
+        resource_target = start_line[:space]
+        version = start_line[space + 1 :]
+        return Request(
+            method=method,
+            resource_target=resource_target,
+            version=version,
+            headers=message.headers,
+            body=message.body,
+        )
+
+    async def serialize(self, sock: base.Socket) -> None:
+        start = f"{self.method} {self.resource_target} {self.version}"
+        message = Message(start_line=start, headers=self.headers, body=self.body)
+        await message.serialize(sock)
+
+
+@dataclasses.dataclass
+class Response:
+    version: str
+    status_code: int
+    reason: str
+    headers: dict[str, str]
+    body: bytes
+
+    @classmethod
+    async def deserialize(cls, sock: base.Socket) -> Response:
+        message = await Message.deserialize(sock)
+        status_line = message.start_line
+        space1 = status_line.find(" ")
+        if space1 == -1:
+            raise exceptions.Error(f"Invalid status_line={status_line}")
+        version = status_line[:space1]
+        remainder = status_line[space1 + 1 :]
+        space2 = remainder.find(" ")
+        if space2 == -1:
+            raise exceptions.Error(f"Invalid status_line={status_line}")
+        status_code = remainder[:space2]
+        reason = remainder[space2 + 1 :]
+        if not status_code.isdigit():
+            raise exceptions.Error(f"Invalid status_code={status_code}")
+        return Response(
+            version=version,
+            status_code=int(status_code),
+            reason=reason,
+            headers=message.headers,
+            body=message.body,
+        )
+
+    async def serialize(self, sock: base.Socket) -> None:
+        start = f"{self.version} {self.status_code} {self.reason}"
+        message = Message(start_line=start, headers=self.headers, body=self.body)
+        await message.serialize(sock)