net10, the refactor finished, and federation that works

The tree had not compiled since its first commit: Group, DmGroup and
IGroupUsersService were referenced and never written, an IDE rename had
turned the user-settings DTO into the ViewAvatarServer enum, and the settings
were saved as an entity they no longer were.

Built now:
- Group (an ActivityPub Group actor with its own keys, members, invitation
  code and optional password) and DmGroup (a conversation), with
  /clientapi/group/{list,insert,update,join,leave,approve}.
- Posts and DMs: /clientapi/post/{list,insert,delete}, /clientapi/dm/{list,insert};
  DM recipients are local usernames or user@host handles resolved by WebFinger.
- Invitation sign-up and login against the group's invitation code, checking
  the password before any account is created.
- Federation: WebFinger, NodeInfo 2.0, actors at /peasants/{name} (Person,
  Group, and an Application instance actor) with SPKI keys, draft-cavage
  RSA-SHA256 HTTP signatures both ways, an inbox handling Follow (+Accept),
  Undo, Create, Delete and Update, an outbox, notes at /posts/{id}, and a
  persisted, retried, signed delivery queue. A post to a group is announced
  by the group to its followers (FEP-1b12).
- The unused, broken typed ActivityPub models are replaced by a renderer;
  NSign's HMAC setup, which could not federate, is gone.

Upgrade: net10.0, MongoDB.Entities 25.1 (instance DB API, Standard GUIDs),
Swashbuckle 10 / OpenApi 2, Serilog.AspNetCore 10, MailKit 4.18,
PasswordGenerator 3. The JWT keys are 64 bytes (IdentityModel 8 refuses
shorter for HS512). Production runs its own mongod on 127.0.0.1:27022, as
Sintopia's apps do, and deploys to privapub.thepra.dev from the build runner.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012CzABvBkbcFqoHdmi8b9WB

PrivaPub/Services/Federation/HttpSignatures.cs

@@ -0,0 +1,183 @@
+using System.Globalization;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace PrivaPub.Services.Federation
+{
+	public sealed record SignatureParameters(string KeyId, string Algorithm, string[] Headers, byte[] Signature,
+		string Created, string Expires);
+
+	public static class HttpSignatures
+	{
+		static readonly TimeSpan AllowedClockSkew = TimeSpan.FromHours(12);
+
+		public static string Digest(byte[] body) => "SHA-256=" + Convert.ToBase64String(SHA256.HashData(body));
+
+		public static void Sign(HttpRequestMessage request, LocalActor signer, byte[] body)
+		{
+			var date = DateTime.UtcNow.ToString("r", CultureInfo.InvariantCulture);
+			var signed = new List<(string Name, string Value)>
+			{
+				("(request-target)", $"{request.Method.Method.ToLowerInvariant()} {request.RequestUri.PathAndQuery}"),
+				("host", request.RequestUri.IsDefaultPort ? request.RequestUri.Host : request.RequestUri.Authority),
+				("date", date)
+			};
+			request.Headers.TryAddWithoutValidation("Date", date);
+
+			if (body != null)
+			{
+				var digest = Digest(body);
+				request.Headers.TryAddWithoutValidation("Digest", digest);
+				signed.Add(("digest", digest));
+			}
+
+			var signingString = string.Join("\n", signed.Select(h => $"{h.Name}: {h.Value}"));
+			using var rsa = RSA.Create();
+			rsa.ImportFromPem(signer.PrivateKeyPem);
+			var signature = Convert.ToBase64String(rsa.SignData(Encoding.UTF8.GetBytes(signingString),
+				HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1));
+
+			request.Headers.TryAddWithoutValidation("Signature",
+				$"keyId=\"{signer.KeyId}\",algorithm=\"rsa-sha256\",headers=\"{string.Join(' ', signed.Select(h => h.Name))}\",signature=\"{signature}\"");
+		}
+
+		public static SignatureParameters Parse(string header)
+		{
+			if (string.IsNullOrWhiteSpace(header))
+				return default;
+
+			var values = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+			var i = 0;
+			while (i < header.Length)
+			{
+				while (i < header.Length && (header[i] == ',' || header[i] == ' '))
+					i++;
+				var equals = header.IndexOf('=', i);
+				if (equals < 0)
+					break;
+				var key = header[i..equals].Trim();
+				i = equals + 1;
+				string value;
+				if (i < header.Length && header[i] == '"')
+				{
+					var close = header.IndexOf('"', i + 1);
+					if (close < 0)
+						return default;
+					value = header[(i + 1)..close];
+					i = close + 1;
+				}
+				else
+				{
+					var comma = header.IndexOf(',', i);
+					value = comma < 0 ? header[i..] : header[i..comma];
+					i = comma < 0 ? header.Length : comma;
+				}
+				values[key] = value.Trim();
+			}
+
+			if (!values.TryGetValue("keyId", out var keyId) || !values.TryGetValue("signature", out var signature))
+				return default;
+
+			byte[] signatureBytes;
+			try
+			{
+				signatureBytes = Convert.FromBase64String(signature);
+			}
+			catch (FormatException)
+			{
+				return default;
+			}
+
+			var headers = values.TryGetValue("headers", out var headerList)
+				? headerList.Split(' ', StringSplitOptions.RemoveEmptyEntries).Select(h => h.ToLowerInvariant()).ToArray()
+				: new[] { "date" };
+
+			return new(keyId, values.GetValueOrDefault("algorithm") ?? "hs2019", headers, signatureBytes,
+				values.GetValueOrDefault("created"), values.GetValueOrDefault("expires"));
+		}
+
+		public static string SigningString(HttpRequest request, SignatureParameters parameters)
+		{
+			var lines = new List<string>();
+			foreach (var header in parameters.Headers)
+			{
+				switch (header)
+				{
+					case "(request-target)":
+						lines.Add($"(request-target): {request.Method.ToLowerInvariant()} {request.PathBase}{request.Path}{request.QueryString}");
+						break;
+					case "(created)":
+						lines.Add($"(created): {parameters.Created}");
+						break;
+					case "(expires)":
+						lines.Add($"(expires): {parameters.Expires}");
+						break;
+					case "host":
+						lines.Add($"host: {request.Host.Value}");
+						break;
+					default:
+						if (!request.Headers.TryGetValue(header, out var value))
+							return default;
+						lines.Add($"{header}: {string.Join(", ", value.Select(v => v.Trim()))}");
+						break;
+				}
+			}
+			return string.Join("\n", lines);
+		}
+
+		public static string CheckRequest(HttpRequest request, SignatureParameters parameters, byte[] body)
+		{
+			if (parameters.Algorithm is not ("rsa-sha256" or "hs2019"))
+				return $"unsupported signature algorithm '{parameters.Algorithm}'";
+
+			if (body is { Length: > 0 })
+			{
+				if (!parameters.Headers.Contains("digest"))
+					return "the digest is not signed";
+				var expectedHash = Convert.ToBase64String(SHA256.HashData(body));
+				var matches = request.Headers["Digest"].ToString().Split(',').Select(d => d.Trim())
+					.Any(d => d.StartsWith("SHA-256=", StringComparison.OrdinalIgnoreCase) && d[8..] == expectedHash);
+				if (!matches)
+					return "the digest does not match the body";
+			}
+
+			if (parameters.Headers.Contains("date"))
+			{
+				if (!DateTimeOffset.TryParse(request.Headers["Date"].ToString(), CultureInfo.InvariantCulture,
+						DateTimeStyles.AssumeUniversal, out var date))
+					return "unreadable Date header";
+				if ((DateTimeOffset.UtcNow - date).Duration() > AllowedClockSkew)
+					return "the Date header is outside the allowed window";
+			}
+			else if (!parameters.Headers.Contains("(created)"))
+				return "neither date nor (created) is signed";
+
+			if (!string.IsNullOrEmpty(parameters.Expires) && long.TryParse(parameters.Expires, out var expires)
+				&& DateTimeOffset.FromUnixTimeSeconds(expires) < DateTimeOffset.UtcNow - AllowedClockSkew)
+				return "the signature has expired";
+
+			return default;
+		}
+
+		public static bool Verify(string publicKeyPem, string signingString, byte[] signature)
+		{
+			if (string.IsNullOrEmpty(publicKeyPem) || signingString == null)
+				return false;
+			try
+			{
+				using var rsa = RSA.Create();
+				rsa.ImportFromPem(publicKeyPem);
+				return rsa.VerifyData(Encoding.UTF8.GetBytes(signingString), signature,
+					HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
+			}
+			catch (CryptographicException)
+			{
+				return false;
+			}
+			catch (ArgumentException)
+			{
+				return false;
+			}
+		}
+	}
+}