CultLib/src/GameCult.Mesh/CultMeshAuthorityProof.cs

349 lines
16 KiB
C#

using System;
using System.Buffers.Binary;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using GameCult.Networking;
namespace GameCult.Mesh
{
public enum CultMeshAuthorityTrustMode
{
AuthenticatedRemote,
LocalDevelopment
}
public sealed class CultMeshEcdsaP256PublicKey
{
public CultMeshEcdsaP256PublicKey(string keyId, string x, string y)
{
KeyId = Require(keyId, nameof(keyId));
X = RequireCoordinate(x, nameof(x));
Y = RequireCoordinate(y, nameof(y));
}
public string KeyId { get; }
public string X { get; }
public string Y { get; }
internal ECDsa CreateVerifier()
{
var verifier = ECDsa.Create();
verifier.ImportParameters(new ECParameters
{
Curve = ECCurve.NamedCurves.nistP256,
Q = new ECPoint { X = Convert.FromBase64String(X), Y = Convert.FromBase64String(Y) }
});
return verifier;
}
public static CultMeshEcdsaP256PublicKey From(string keyId, ECDsa key)
{
if (key == null) throw new ArgumentNullException(nameof(key));
var parameters = key.ExportParameters(false);
return new CultMeshEcdsaP256PublicKey(
keyId,
Convert.ToBase64String(parameters.Q.X ?? throw new InvalidOperationException("P-256 key has no X coordinate.")),
Convert.ToBase64String(parameters.Q.Y ?? throw new InvalidOperationException("P-256 key has no Y coordinate.")));
}
private static string RequireCoordinate(string value, string name)
{
var required = Require(value, name);
byte[] bytes;
try { bytes = Convert.FromBase64String(required); }
catch (FormatException error) { throw new ArgumentException("P-256 coordinates must be base64.", name, error); }
if (bytes.Length != 32) throw new ArgumentException("P-256 coordinates must contain 32 bytes.", name);
return required;
}
private static string Require(string value, string name) =>
string.IsNullOrWhiteSpace(value) ? throw new ArgumentException("Value must be non-empty.", name) : value.Trim();
}
public sealed class CultMeshRouteCertificate
{
public CultMeshRouteCertificate(
CultMeshEcdsaP256PublicKey providerKey,
string odinKeyId,
long issuedAtUnixMilliseconds,
long expiresAtUnixMilliseconds,
string signature)
{
ProviderKey = providerKey ?? throw new ArgumentNullException(nameof(providerKey));
OdinKeyId = string.IsNullOrWhiteSpace(odinKeyId)
? throw new ArgumentException("Odin key identity is required.", nameof(odinKeyId))
: odinKeyId.Trim();
if (issuedAtUnixMilliseconds < 0) throw new ArgumentOutOfRangeException(nameof(issuedAtUnixMilliseconds));
if (expiresAtUnixMilliseconds <= issuedAtUnixMilliseconds) throw new ArgumentOutOfRangeException(nameof(expiresAtUnixMilliseconds));
IssuedAtUnixMilliseconds = issuedAtUnixMilliseconds;
ExpiresAtUnixMilliseconds = expiresAtUnixMilliseconds;
Signature = signature?.Trim() ?? string.Empty;
}
public CultMeshEcdsaP256PublicKey ProviderKey { get; }
public string OdinKeyId { get; }
public long IssuedAtUnixMilliseconds { get; }
public long ExpiresAtUnixMilliseconds { get; }
public string Signature { get; }
}
public sealed class CultMeshAuthorityTrustPolicy
{
private readonly Dictionary<string, CultMeshEcdsaP256PublicKey> _odinRoots;
public CultMeshAuthorityTrustPolicy(
CultMeshAuthorityTrustMode mode,
IEnumerable<CultMeshEcdsaP256PublicKey>? odinRoots = null)
{
Mode = mode;
_odinRoots = (odinRoots ?? Array.Empty<CultMeshEcdsaP256PublicKey>())
.ToDictionary(key => key.KeyId, StringComparer.Ordinal);
}
public CultMeshAuthorityTrustMode Mode { get; }
public IReadOnlyCollection<CultMeshEcdsaP256PublicKey> OdinRoots => _odinRoots.Values;
/// <summary>Fails closed unless the route is valid under this consumer-owned policy.</summary>
public void Validate(string verseId, CultMeshAuthorityRoute route, DateTimeOffset now) =>
Verify(verseId, route, now);
internal CultMeshVerifiedAuthorityRoute Verify(
string verseId,
CultMeshAuthorityRoute route,
DateTimeOffset now)
{
if (route == null) throw new ArgumentNullException(nameof(route));
var certificate = route.Certificate;
if (certificate == null || string.IsNullOrWhiteSpace(certificate.Signature))
{
if (Mode == CultMeshAuthorityTrustMode.LocalDevelopment && IsLoopback(route.Endpoint))
return CultMeshVerifiedAuthorityRoute.Local(route);
throw Failure(route, "Remote CultMesh routes require an Odin-signed authority certificate.");
}
if (!IsProtected(route.Endpoint) &&
!(Mode == CultMeshAuthorityTrustMode.LocalDevelopment && IsLoopback(route.Endpoint)))
throw Failure(route, "Authenticated remote CultMesh routes require TLS or QUIC channel protection.");
if (!_odinRoots.TryGetValue(certificate.OdinKeyId, out var root))
throw Failure(route, $"Odin key '{certificate.OdinKeyId}' is not trusted by this consumer.");
var nowMs = now.ToUnixTimeMilliseconds();
if (nowMs < certificate.IssuedAtUnixMilliseconds || nowMs >= certificate.ExpiresAtUnixMilliseconds)
throw Failure(route, "The Odin route certificate is not currently valid.");
byte[] signature;
try { signature = Convert.FromBase64String(certificate.Signature); }
catch (FormatException error) { throw Failure(route, "The Odin route signature is not base64.", error); }
if (signature.Length != 64) throw Failure(route, "The Odin route signature is not IEEE P1363 P-256.");
using var verifier = root.CreateVerifier();
if (!verifier.VerifyData(
CultMeshAuthorityProof.CanonicalRoute(verseId, route),
signature,
HashAlgorithmName.SHA256))
throw Failure(route, "The Odin route certificate signature is invalid.");
return CultMeshVerifiedAuthorityRoute.Authenticated(route, certificate.ProviderKey);
}
private static bool IsLoopback(string endpoint)
{
if (!Uri.TryCreate(endpoint, UriKind.Absolute, out var uri)) return false;
return uri.IsLoopback ||
string.Equals(uri.Host, "localhost", StringComparison.OrdinalIgnoreCase) ||
string.Equals(uri.Host, "127.0.0.1", StringComparison.Ordinal) ||
string.Equals(uri.Host, "::1", StringComparison.Ordinal);
}
private static bool IsProtected(string endpoint)
{
if (!Uri.TryCreate(endpoint, UriKind.Absolute, out var uri)) return false;
return string.Equals(uri.Scheme, "wss", StringComparison.OrdinalIgnoreCase) ||
string.Equals(uri.Scheme, "https", StringComparison.OrdinalIgnoreCase) ||
uri.Scheme.IndexOf("quic", StringComparison.OrdinalIgnoreCase) >= 0;
}
private static CultMeshSessionException Failure(CultMeshAuthorityRoute route, string message, Exception? inner = null) =>
new CultMeshSessionException(new CultMeshSessionFailure(
CultMeshSessionFailureReason.Authentication,
message,
route.Endpoint), inner);
}
internal sealed class CultMeshVerifiedAuthorityRoute
{
private CultMeshVerifiedAuthorityRoute(
CultMeshAuthorityRoute route,
CultMeshEcdsaP256PublicKey? providerKey,
bool localDevelopment)
{
Route = route;
ProviderKey = providerKey;
IsLocalDevelopment = localDevelopment;
}
public CultMeshAuthorityRoute Route { get; }
public CultMeshEcdsaP256PublicKey? ProviderKey { get; }
public bool IsLocalDevelopment { get; }
public static CultMeshVerifiedAuthorityRoute Authenticated(CultMeshAuthorityRoute route, CultMeshEcdsaP256PublicKey key) => new(route, key, false);
public static CultMeshVerifiedAuthorityRoute Local(CultMeshAuthorityRoute route) => new(route, null, true);
}
public sealed class CultMeshSessionProofSigner
{
private readonly ECDsa _key;
public CultMeshSessionProofSigner(CultMeshAuthorityRoute route, ECDsa providerPrivateKey)
{
Route = route ?? throw new ArgumentNullException(nameof(route));
_key = providerPrivateKey ?? throw new ArgumentNullException(nameof(providerPrivateKey));
var certificate = route.Certificate ?? throw new ArgumentException("A session proof signer requires a certified route.", nameof(route));
ProviderKeyId = certificate.ProviderKey.KeyId;
var exported = CultMeshEcdsaP256PublicKey.From(ProviderKeyId, _key);
if (!string.Equals(exported.X, certificate.ProviderKey.X, StringComparison.Ordinal) ||
!string.Equals(exported.Y, certificate.ProviderKey.Y, StringComparison.Ordinal))
throw new ArgumentException("Provider private key does not match the certified route key.", nameof(providerPrivateKey));
}
public CultMeshAuthorityRoute Route { get; }
public string ProviderKeyId { get; }
public string Sign(CultMeshSessionOpenMessage request)
{
var bytes = CultMeshAuthorityProof.CanonicalSession(request, Route.Endpoint);
return Convert.ToBase64String(CultMeshAuthorityProof.SignP256(_key, bytes));
}
}
public static class CultMeshAuthorityProof
{
private const string RouteDomain = "gamecult.cultmesh.route-certificate.v1";
private const string SessionDomain = "gamecult.cultmesh.session-proof.v1";
public static CultMeshAuthorityRoute CreateSignedRoute(
string verseId,
string authorityRuntimeId,
string endpoint,
IEnumerable<string> protocolIds,
int priority,
string generation,
CultMeshEcdsaP256PublicKey providerKey,
string odinKeyId,
DateTimeOffset issuedAt,
DateTimeOffset expiresAt,
ECDsa odinPrivateKey)
{
if (odinPrivateKey == null) throw new ArgumentNullException(nameof(odinPrivateKey));
var unsignedCertificate = new CultMeshRouteCertificate(
providerKey,
odinKeyId,
issuedAt.ToUnixTimeMilliseconds(),
expiresAt.ToUnixTimeMilliseconds(),
string.Empty);
var unsignedRoute = new CultMeshAuthorityRoute(
authorityRuntimeId, endpoint, protocolIds, priority, generation, unsignedCertificate);
var signature = Convert.ToBase64String(SignP256(
odinPrivateKey,
CanonicalRoute(verseId, unsignedRoute)));
return new CultMeshAuthorityRoute(
authorityRuntimeId,
endpoint,
protocolIds,
priority,
generation,
new CultMeshRouteCertificate(
providerKey,
odinKeyId,
issuedAt.ToUnixTimeMilliseconds(),
expiresAt.ToUnixTimeMilliseconds(),
signature));
}
/// <summary>Verifies both the Odin route certificate and provider nonce proof.</summary>
public static bool VerifySessionProof(
CultMeshSessionOpenMessage request,
CultMeshSessionAcceptedMessage response,
string verseId,
CultMeshAuthorityRoute route,
CultMeshAuthorityTrustPolicy trust,
DateTimeOffset now)
{
if (request == null) throw new ArgumentNullException(nameof(request));
if (response == null) throw new ArgumentNullException(nameof(response));
if (trust == null) throw new ArgumentNullException(nameof(trust));
return VerifySession(request, response, trust.Verify(verseId, route, now));
}
internal static byte[] CanonicalRoute(string verseId, CultMeshAuthorityRoute route)
{
var certificate = route.Certificate ?? throw new InvalidOperationException("Route certificate is required.");
return Canonical(
RouteDomain,
verseId,
route.AuthorityRuntimeId,
route.Endpoint,
string.Join("\u001f", route.ProtocolIds.OrderBy(value => value, StringComparer.Ordinal)),
route.Priority.ToString(System.Globalization.CultureInfo.InvariantCulture),
route.Generation,
certificate.ProviderKey.KeyId,
certificate.ProviderKey.X,
certificate.ProviderKey.Y,
certificate.OdinKeyId,
certificate.IssuedAtUnixMilliseconds.ToString(System.Globalization.CultureInfo.InvariantCulture),
certificate.ExpiresAtUnixMilliseconds.ToString(System.Globalization.CultureInfo.InvariantCulture));
}
internal static byte[] CanonicalSession(CultMeshSessionOpenMessage request, string endpoint) => Canonical(
SessionDomain,
request.ClientNonce ?? string.Empty,
request.MessageId ?? string.Empty,
request.SourceRuntimeId ?? string.Empty,
request.VerseId ?? string.Empty,
request.AuthorityRuntimeId ?? string.Empty,
request.ProtocolId ?? string.Empty,
endpoint ?? string.Empty,
request.RouteGeneration ?? string.Empty);
internal static bool VerifySession(
CultMeshSessionOpenMessage request,
CultMeshSessionAcceptedMessage response,
CultMeshVerifiedAuthorityRoute route)
{
if (route.IsLocalDevelopment) return true;
if (route.ProviderKey == null ||
!string.Equals(response.ProviderKeyId, route.ProviderKey.KeyId, StringComparison.Ordinal) ||
!string.Equals(response.ClientNonce, request.ClientNonce, StringComparison.Ordinal) ||
string.IsNullOrWhiteSpace(response.ProviderSignature))
return false;
byte[] signature;
try { signature = Convert.FromBase64String(response.ProviderSignature); }
catch (FormatException) { return false; }
if (signature.Length != 64) return false;
using var verifier = route.ProviderKey.CreateVerifier();
return verifier.VerifyData(
CanonicalSession(request, route.Route.Endpoint),
signature,
HashAlgorithmName.SHA256);
}
internal static byte[] SignP256(ECDsa key, byte[] payload)
{
var signature = key.SignData(payload, HashAlgorithmName.SHA256);
if (signature.Length != 64)
throw new CryptographicException("ECDSA provider did not emit IEEE P1363 P-256 signature bytes.");
return signature;
}
private static byte[] Canonical(params string[] values)
{
using var stream = new MemoryStream();
var length = new byte[4];
foreach (var value in values)
{
var bytes = Encoding.UTF8.GetBytes(value ?? string.Empty);
BinaryPrimitives.WriteInt32BigEndian(length, bytes.Length);
stream.Write(length, 0, length.Length);
stream.Write(bytes, 0, bytes.Length);
}
return stream.ToArray();
}
}
}