Cannot correctly set content length after modify the request content

[qiangxinglin]

I need an interceptor to implement the req/rep encryption. For the decrypt part, I've managed it worked, but encryption still struggling.
All the requests and responses are in JSON format, but maybe with data field encryted (depending on the header).

class CryptoInterceptor(httpx.AsyncBaseTransport):
    def __init__(self, cipher, **kwargs):
        self._wrapper = httpx.AsyncHTTPTransport(**kwargs)
        self._cipher = cipher

    async def handle_async_request(self, request):
        # pass public key in header, remote will encrypt the response
        if request.headers.get('response_encrypt', False):
            request.headers['client_public_key'] = local_public_key

        # request public key from remote, sign and encrypt the request body
        if request.headers.get('request_encrypt', False):
            remote_public_key = await self._cipher.get_public_key()
            # sign and encrypt the request body
            data = await request.aread()
            data = {
                'token': token,
                'data': encrypted_data
            }
            request._content = json.dumps(data).encode()
            request.headers['Content-Length'] = str(len(request._content))   # <-- here's the problem

        response = await self._wrapper.handle_async_request(request)
        content = await response.aread()

        if request.headers.get('response_encrypt', False):
            # decrypt by local_private_key...
            response._content = decrypted_content

        return response

If I modify the content of the request in this transport, the system would throw LocalProtocolError: Too little data for declared Content-Length, how to deal with it?

[widechaos]

The length calculation is for the new bytes, but request._content = ... does not replace request.stream. The wrapped HTTP transport sends the stream, so it still sends the original JSON body with the new body's Content-Length.

After producing your encrypted envelope, construct a replacement request through the public API:

# Inside handle_async_request, after reading/encrypting the original body:
data = {"token": token, "data": encrypted_data}
headers = request.headers.copy()
headers.pop("content-length", None)
headers.pop("transfer-encoding", None)

outgoing = httpx.Request(
    method=request.method,
    url=request.url,
    headers=headers,
    json=data,
    extensions=request.extensions,
)
response = await self._wrapper.handle_async_request(outgoing)

Removing the old framing headers lets HTTPX generate a length matching the newly serialized JSON. Keeping extensions preserves request settings such as timeout values. This assumes the envelope contains JSON-serializable values, as in your example.

I checked this on HTTPX 0.28.1: changing only _content left the stream unchanged and reproduced Too little data for declared Content-Length when passed through h11's HTTP/1.1 framing. The replacement request's stream matched its content and declared length, and framing succeeded. This tests body replacement, not your encryption protocol or server.

Also forward cleanup to the wrapped transport:

async def aclose(self):
    await self._wrapper.aclose()

See Request.aread() for how the content cache and stream are maintained, and custom transports for the wrapper pattern.