Add M10.3b session login over QUIC
Foundation / checks (deploy) (push) Successful in 5s
Foundation / checks (ecs) (push) Successful in 3m13s
Foundation / checks (client) (push) Successful in 12m12s
Foundation / checks (network) (push) Successful in 8m56s
Foundation / checks (tsan) (push) Successful in 7m42s
Foundation / postgres-tools (push) Canceled after 0s
Foundation / server-image (push) Canceled after 0s
Foundation / image (push) Canceled after 0s
Foundation / checks (postgres) (push) Canceled after 19m14s
Foundation / checks (checks) (push) Canceled after 31m28s

Session protocol v1 session messages (Hello with grant, Welcome, Refresh,
RefreshResult, Close with reasons) on the QUIC reliable stream. RegionSessions
verifies grants with the issuer public keys and admits them through SessionControl:
a newer grant closes the account's old connection as superseded, expiry and epoch
advances close sessions, every close is announced and flushed. RegionSessionClient
logs in, refreshes in place and reports why a session ended. ADR-0091.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
dingo
2026-10-03 21:12:00 -04:00
co-authored by Claude Opus 5.5
parent 01b4b06a09
commit 7956143cd8
17 changed files with 1262 additions and 7 deletions
+134
View File
@@ -0,0 +1,134 @@
#include "evo/network/session_protocol.hpp"
#include <algorithm>
namespace evo::network {
namespace {
constexpr std::size_t hello_bytes = 4 + session_grant_wire_bytes;
constexpr std::size_t welcome_bytes = std::size_t{7} * 8;
constexpr std::size_t refresh_bytes = session_grant_wire_bytes;
constexpr std::size_t refresh_result_bytes = 1 + 8;
constexpr std::size_t close_bytes = 1;
void put(std::vector<std::uint8_t>& out, std::uint64_t v, std::size_t count) {
for (std::size_t i = 0; i < count; ++i)
out.push_back(static_cast<std::uint8_t>(v >> (8 * i)));
}
std::uint64_t get(std::span<const std::uint8_t> in, std::size_t at, std::size_t count) {
std::uint64_t v = 0;
for (std::size_t i = 0; i < count; ++i)
v |= static_cast<std::uint64_t>(in[at + i]) << (8 * i);
return v;
}
std::vector<std::uint8_t> header(SessionMessageType type, std::size_t payload) {
std::vector<std::uint8_t> out;
out.reserve(session_header_bytes + payload);
put(out, session_magic, 4);
put(out, session_protocol_version, 2);
out.push_back(static_cast<std::uint8_t>(type));
out.push_back(0);
return out;
}
bool wire_reason(std::uint64_t v) {
return v >= static_cast<std::uint8_t>(SessionCloseReason::client_closed) &&
v <= static_cast<std::uint8_t>(SessionCloseReason::shutdown);
}
WireGrant grant_at(std::span<const std::uint8_t> in, std::size_t at) {
WireGrant g{};
std::copy_n(in.begin() + static_cast<std::ptrdiff_t>(at), g.size(), g.begin());
return g;
}
} // namespace
std::vector<std::uint8_t> encode_session(const SessionMessage& message) {
struct Encoder {
std::vector<std::uint8_t> operator()(const SessionHello& m) const {
auto out = header(SessionMessageType::hello, hello_bytes);
put(out, m.required_features, 4);
out.insert(out.end(), m.grant.begin(), m.grant.end());
return out;
}
std::vector<std::uint8_t> operator()(const SessionWelcome& m) const {
auto out = header(SessionMessageType::welcome, welcome_bytes);
for (const auto v :
{m.session, m.epoch, m.world, m.frame, m.region, m.expires_at, m.server_seconds})
put(out, v, 8);
return out;
}
std::vector<std::uint8_t> operator()(const SessionRefresh& m) const {
auto out = header(SessionMessageType::refresh, refresh_bytes);
out.insert(out.end(), m.grant.begin(), m.grant.end());
return out;
}
std::vector<std::uint8_t> operator()(const SessionRefreshResult& m) const {
auto out = header(SessionMessageType::refresh_result, refresh_result_bytes);
out.push_back(m.status);
put(out, m.expires_at, 8);
return out;
}
std::vector<std::uint8_t> operator()(const SessionClose& m) const {
auto out = header(SessionMessageType::close, close_bytes);
out.push_back(static_cast<std::uint8_t>(m.reason));
return out;
}
};
return std::visit(Encoder{}, message);
}
std::expected<SessionMessage, SessionCodecError>
decode_session(std::span<const std::uint8_t> bytes) {
if (bytes.size() < session_header_bytes)
return std::unexpected(SessionCodecError::truncated);
if (get(bytes, 0, 4) != session_magic)
return std::unexpected(SessionCodecError::bad_magic);
if (get(bytes, 4, 2) != session_protocol_version)
return std::unexpected(SessionCodecError::unsupported_version);
if (bytes[7] != 0)
return std::unexpected(SessionCodecError::reserved_flags);
const auto payload = bytes.subspan(session_header_bytes);
const auto expect = [&](std::size_t n) { return payload.size() == n; };
switch (bytes[6]) {
case static_cast<std::uint8_t>(SessionMessageType::hello): {
if (!expect(hello_bytes))
return std::unexpected(SessionCodecError::wrong_length);
SessionHello m;
m.required_features = static_cast<std::uint32_t>(get(payload, 0, 4));
m.grant = grant_at(payload, 4);
return m;
}
case static_cast<std::uint8_t>(SessionMessageType::welcome): {
if (!expect(welcome_bytes))
return std::unexpected(SessionCodecError::wrong_length);
SessionWelcome m;
std::uint64_t* fields[] = {&m.session, &m.epoch, &m.world, &m.frame,
&m.region, &m.expires_at, &m.server_seconds};
for (std::size_t i = 0; i < std::size(fields); ++i)
*fields[i] = get(payload, 8 * i, 8);
if (m.session == 0 || m.epoch == 0)
return std::unexpected(SessionCodecError::invalid_value);
return m;
}
case static_cast<std::uint8_t>(SessionMessageType::refresh): {
if (!expect(refresh_bytes))
return std::unexpected(SessionCodecError::wrong_length);
return SessionRefresh{grant_at(payload, 0)};
}
case static_cast<std::uint8_t>(SessionMessageType::refresh_result): {
if (!expect(refresh_result_bytes))
return std::unexpected(SessionCodecError::wrong_length);
SessionRefreshResult m{payload[0], get(payload, 1, 8)};
if (m.status != 0 && !wire_reason(m.status))
return std::unexpected(SessionCodecError::invalid_value);
return m;
}
case static_cast<std::uint8_t>(SessionMessageType::close): {
if (!expect(close_bytes))
return std::unexpected(SessionCodecError::wrong_length);
if (!wire_reason(payload[0]))
return std::unexpected(SessionCodecError::invalid_value);
return SessionClose{static_cast<SessionCloseReason>(payload[0])};
}
default:
return std::unexpected(SessionCodecError::unknown_type);
}
}
} // namespace evo::network