diff --git a/Govor.API/Controllers/E2eeController.cs b/Govor.API/Controllers/E2eeController.cs index 180b1eb..58abc99 100644 --- a/Govor.API/Controllers/E2eeController.cs +++ b/Govor.API/Controllers/E2eeController.cs @@ -10,7 +10,9 @@ namespace Govor.API.Controllers; [ApiController] [Authorize(Roles = "User,Admin")] [Route("api/e2ee")] -public sealed class E2eeController(E2eeService e2ee, ICurrentUserService user, +public sealed class E2eeController( + E2eeService e2ee, + ICurrentUserService user, ICurrentUserSessionService session) : ControllerBase { [HttpPut("device")] @@ -21,10 +23,58 @@ public sealed class E2eeController(E2eeService e2ee, ICurrentUserService user, await e2ee.RegisterAsync(user.GetCurrentUserId(), session.GetUserSessionId(), key); return Ok(new { registered = true }); } - catch (UnauthorizedAccessException) { return Forbid(); } - catch (InvalidOperationException) { return Conflict("Device keys already exist for this session."); } + catch (UnauthorizedAccessException) + { + return Forbid(); + } + catch (Exception ex) when (ex is InvalidOperationException or Microsoft.EntityFrameworkCore.DbUpdateException) + { + return Conflict("Device generation changed. Reload the recovery archive and retry."); + } catch (Exception ex) when (ex is CryptographicException or ArgumentException or FormatException) - { return BadRequest("Invalid E2EE public keys."); } + { + return BadRequest("Invalid E2EE public keys."); + } + } + + [HttpGet("recovery")] + public async Task Recovery() => Ok(await e2ee.GetRecoveryAsync(user.GetCurrentUserId())); + + [HttpGet("devices")] + public async Task Devices() => Ok(await e2ee.GetOwnDevicesAsync(user.GetCurrentUserId())); + + [HttpPut("devices/certificate")] + public async Task CertifyHistory(DeviceKey key) + { + try { await e2ee.CertifyHistoricalDeviceAsync(user.GetCurrentUserId(), key); return Ok(new { certified = true }); } + catch (UnauthorizedAccessException) { return Forbid(); } + catch (Exception ex) when (ex is InvalidOperationException or Microsoft.EntityFrameworkCore.DbUpdateException) + { return Conflict(); } + catch (Exception ex) when (ex is CryptographicException or ArgumentException or FormatException) + { return BadRequest(); } + } + + [HttpGet("conversations/{type:int}/{conversationId:guid}/signers/{deviceSession:guid}")] + public async Task HistoricalSigner(int type, Guid conversationId, Guid deviceSession) + { + if (type is < 0 or > 1) return BadRequest(); + try + { + var key = await e2ee.GetHistoricalSignerAsync(user.GetCurrentUserId(), conversationId, (RecipientType)type, deviceSession); + return key is null ? NotFound() : Ok(key); + } + catch (UnauthorizedAccessException) { return Forbid(); } + } + + [HttpPut("recovery")] + [RequestSizeLimit(4_100_000)] + public async Task SaveRecovery(SaveRecoveryVault request) + { + try { return Ok(await e2ee.SaveRecoveryAsync(user.GetCurrentUserId(), request)); } + catch (InvalidOperationException) { return Conflict("Recovery archive revision changed; merge and retry."); } + catch (Exception ex) when (ex is CryptographicException or ArgumentException or FormatException or + System.Text.Json.JsonException or KeyNotFoundException) + { return BadRequest("Invalid signed recovery archive."); } } [HttpGet("conversations/{type:int}/{conversationId:guid}/keys")] @@ -33,10 +83,17 @@ public sealed class E2eeController(E2eeService e2ee, ICurrentUserService user, if (type is < 0 or > 1 || conversationId == Guid.Empty) return BadRequest(); try { - return Ok(await e2ee.GetConversationKeysAsync(user.GetCurrentUserId(), conversationId, (RecipientType)type)); + return Ok(await e2ee.GetConversationKeysAsync(user.GetCurrentUserId(), conversationId, + (RecipientType)type)); + } + catch (UnauthorizedAccessException) + { + return Forbid(); + } + catch (Exception ex) when (ex is InvalidOperationException or CryptographicException or ArgumentException + or FormatException) + { + return Conflict("Every participant must have valid E2EE keys. Update clients and register their devices."); } - catch (UnauthorizedAccessException) { return Forbid(); } - catch (Exception ex) when (ex is InvalidOperationException or CryptographicException or ArgumentException or FormatException) - { return Conflict("Every participant must have valid E2EE keys. Update clients and register their devices."); } } } diff --git a/Govor.Application/E2ee/E2eeProtocol.cs b/Govor.Application/E2ee/E2eeProtocol.cs index 5143ea8..c36b945 100644 --- a/Govor.Application/E2ee/E2eeProtocol.cs +++ b/Govor.Application/E2ee/E2eeProtocol.cs @@ -17,6 +17,10 @@ public sealed record DeviceKey( string Signature) { public string Fingerprint => E2eeProtocol.Fingerprint(IdentityKey, EncryptionKey); + public string? AccountIdentityKey { get; init; } + public string? AccountSignature { get; init; } + public long Generation { get; init; } + public string? PreviousFingerprint { get; init; } } public sealed record ConversationKeys( @@ -50,6 +54,7 @@ public static class E2eeProtocol public const int MaxEnvelopeLength = 1_000_000; public const int MaxDevices = 500; public const string EncryptedMimeType = "application/vnd.govor.encrypted"; + public const string DevicesChangedError = "E2EE_DEVICES_CHANGED"; public static readonly JsonSerializerOptions Json = new() { PropertyNameCaseInsensitive = true }; public static bool IsEncrypted(string? value) @@ -91,6 +96,8 @@ public static class E2eeProtocol !signing.VerifyData(KeyBinding(key.EncryptionKey), Convert.FromBase64String(key.Signature), HashAlgorithmName.SHA256, DSASignatureFormat.IeeeP1363FixedFieldConcatenation)) throw new CryptographicException("Invalid E2EE key binding signature."); + if (key.AccountIdentityKey is not null || key.AccountSignature is not null) + E2eeRecoveryProtocol.VerifyCertificate(key); } public static string Fingerprint(string identity, string encryption) @@ -187,17 +194,26 @@ public static class E2eeProtocol public static MessagePlaintext Decrypt(string value, DevicePrivateKeys keys, Guid expectedMessage, Guid expectedConversation, int expectedType, Guid expectedAuthor, Guid? expectedReply = null, bool? expectedEdit = null) + { + using var signing = SigningPrivateKey(keys); + return DecryptHistory(value, new HistoryKey(Convert.ToBase64String(signing.ExportSubjectPublicKeyInfo()), + keys.EncryptionKey), expectedMessage, expectedConversation, expectedType, expectedAuthor, expectedReply, expectedEdit); + } + + public static MessagePlaintext DecryptHistory(string value, HistoryKey keys, Guid expectedMessage, + Guid expectedConversation, int expectedType, Guid expectedAuthor, Guid? expectedReply = null, + bool? expectedEdit = null) { var envelope = Verify(value); if (envelope.MessageId != expectedMessage || envelope.ConversationId != expectedConversation || envelope.RecipientType != expectedType || envelope.Sender.UserId != expectedAuthor || - envelope.ReplyToMessageId != expectedReply || - (expectedEdit.HasValue && envelope.IsEdit != expectedEdit)) + envelope.ReplyToMessageId != expectedReply || (expectedEdit.HasValue && envelope.IsEdit != expectedEdit)) throw new CryptographicException("E2EE message context does not match."); - using var rsa = EncryptionPrivateKey(keys); - using var signing = SigningPrivateKey(keys); - var fingerprint = Fingerprint(Convert.ToBase64String(signing.ExportSubjectPublicKeyInfo()), - Convert.ToBase64String(rsa.ExportSubjectPublicKeyInfo())); + var fingerprint = keys.Fingerprint; + using var rsa = RSA.Create(); + var privateBytes = Convert.FromBase64String(keys.EncryptionKey); + try { rsa.ImportPkcs8PrivateKey(privateBytes, out _); } + finally { CryptographicOperations.ZeroMemory(privateBytes); } if (!envelope.Recipients.Contains(fingerprint, StringComparer.Ordinal)) throw new CryptographicException("This device cannot decrypt this message."); // Select our recipient explicitly. In particular Windows CNG can throw an @@ -336,4 +352,4 @@ public static class E2eeProtocol throw; } } -} \ No newline at end of file +} diff --git a/Govor.Application/E2ee/E2eeRecoveryProtocol.cs b/Govor.Application/E2ee/E2eeRecoveryProtocol.cs new file mode 100644 index 0000000..f8602ca --- /dev/null +++ b/Govor.Application/E2ee/E2eeRecoveryProtocol.cs @@ -0,0 +1,159 @@ +using System.Security.Cryptography; +using System.Text; +using System.Text.Json; +using System.Text.Json.Serialization; +using Jose; + +namespace Govor.Application.E2ee; + +public sealed record RecoveryVault(Guid UserId, long Revision, string IdentityKey, string Ciphertext, string Signature); +public sealed record RecoveryState(RecoveryVault? Vault); +public sealed record SaveRecoveryVault(long ExpectedRevision, string IdentityKey, string Ciphertext, string Signature); +public sealed record HistoryKey(string IdentityKey, string EncryptionKey) +{ + private string? _fingerprint; + [JsonIgnore] + public string Fingerprint + { + get + { + if (_fingerprint is not null) return _fingerprint; + using var rsa = RSA.Create(); + var bytes = Convert.FromBase64String(EncryptionKey); + try { rsa.ImportPkcs8PrivateKey(bytes, out _); } + finally { CryptographicOperations.ZeroMemory(bytes); } + return _fingerprint = E2eeProtocol.Fingerprint(IdentityKey, Convert.ToBase64String(rsa.ExportSubjectPublicKeyInfo())); + } + } +} + +// Recovery is a separate security domain from message encryption. Possession of +// the random 256-bit recovery code authorizes enrollment and archive recovery. +public static class E2eeRecoveryProtocol +{ + public const int MaxVaultLength = 4_000_000; + public static string GenerateCode() => Base64Url.Encode(RandomNumberGenerator.GetBytes(32)); + + public static string GenerateIdentity() + { + using var key = ECDsa.Create(ECCurve.NamedCurves.nistP256); + return Convert.ToBase64String(key.ExportPkcs8PrivateKey()); + } + + public static string PublicIdentity(string privateKey) + { + using var key = PrivateIdentity(privateKey); + return Convert.ToBase64String(key.ExportSubjectPublicKeyInfo()); + } + + public static string AccountFingerprint(string identity) => + Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes("govor-account-v1\n" + identity))); + + public static DeviceKey Certify(DeviceKey device, string privateIdentity, long generation = 0, + string? previousFingerprint = null) + { + var certified = device with { AccountIdentityKey = PublicIdentity(privateIdentity), + Generation = generation, PreviousFingerprint = previousFingerprint }; + using var key = PrivateIdentity(privateIdentity); + return certified with { AccountSignature = Sign(key, DeviceBinding(certified)) }; + } + + public static void VerifyCertificate(DeviceKey device) + { + if (device.AccountIdentityKey is null || device.AccountSignature is null || device.Generation < 0 || + (device.Generation == 0 ? device.PreviousFingerprint is not null : device.PreviousFingerprint?.Length != 64)) + throw new CryptographicException("Invalid account device certificate."); + using var key = PublicIdentityKey(device.AccountIdentityKey); + Verify(key, DeviceBinding(device), device.AccountSignature); + } + + public static RecoveryVault Seal(Guid user, long revision, string privateIdentity, string code, string plaintext) + { + if (user == Guid.Empty || revision < 1) throw new CryptographicException("Invalid archive context."); + var secret = CodeBytes(code); + string encrypted; + try { encrypted = JWT.Encode(new ArchivePayload(1, user, revision, plaintext), secret, JweAlgorithm.DIR, JweEncryption.A256GCM); } + finally { CryptographicOperations.ZeroMemory(secret); } + var vault = new RecoveryVault(user, revision, PublicIdentity(privateIdentity), encrypted, ""); + using var identity = PrivateIdentity(privateIdentity); + return vault with { Signature = Sign(identity, VaultBinding(vault)) }; + } + + public static string Open(RecoveryVault vault, Guid user, string code) + { + Validate(vault); + if (vault.UserId != user) throw new CryptographicException("Archive belongs to another account."); + var secret = CodeBytes(code); + try + { + var payload = JsonSerializer.Deserialize( + JWT.Decode(vault.Ciphertext, secret, JweAlgorithm.DIR, JweEncryption.A256GCM), E2eeProtocol.Json) + ?? throw new CryptographicException("Invalid archive."); + if (payload.Version != 1 || payload.UserId != user || payload.Revision != vault.Revision) + throw new CryptographicException("Archive context mismatch."); + return payload.Plaintext; + } + finally { CryptographicOperations.ZeroMemory(secret); } + } + + public static void Validate(RecoveryVault vault) + { + if (vault.UserId == Guid.Empty || vault.Revision < 1 || vault.Ciphertext is null || + vault.Ciphertext.Length is < 50 or > MaxVaultLength || vault.Signature is null) + throw new CryptographicException("Invalid archive."); + // Fix the algorithms even on the server, which cannot decrypt the archive. + var parts = vault.Ciphertext.Split('.'); + if (parts.Length != 5 || parts[1].Length != 0) throw new CryptographicException("Invalid archive JWE."); + using var header = JsonDocument.Parse(Base64Url.Decode(parts[0])); + if (header.RootElement.EnumerateObject().Count() != 2 || + header.RootElement.GetProperty("alg").GetString() != "dir" || + header.RootElement.GetProperty("enc").GetString() != "A256GCM") + throw new CryptographicException("Unsupported archive encryption."); + using var key = PublicIdentityKey(vault.IdentityKey); + Verify(key, VaultBinding(vault), vault.Signature); + } + + private static byte[] CodeBytes(string code) + { + var bytes = Base64Url.Decode(code.Trim()); + if (bytes.Length == 32) return bytes; + CryptographicOperations.ZeroMemory(bytes); + throw new CryptographicException("Invalid recovery code."); + } + + private static byte[] DeviceBinding(DeviceKey key) => JsonSerializer.SerializeToUtf8Bytes(new + { purpose = "govor-account-device-v1", key.UserId, key.SessionId, key.Fingerprint, key.Generation, key.PreviousFingerprint }); + private static byte[] VaultBinding(RecoveryVault vault) => JsonSerializer.SerializeToUtf8Bytes(new + { purpose = "govor-recovery-v1", vault.UserId, vault.Revision, vault.IdentityKey, vault.Ciphertext }); + private static string Sign(ECDsa key, byte[] bytes) => Convert.ToBase64String(key.SignData(bytes, + HashAlgorithmName.SHA256, DSASignatureFormat.IeeeP1363FixedFieldConcatenation)); + private static void Verify(ECDsa key, byte[] bytes, string signature) + { + if (signature.Length > 100 || !key.VerifyData(bytes, Convert.FromBase64String(signature), + HashAlgorithmName.SHA256, DSASignatureFormat.IeeeP1363FixedFieldConcatenation)) + throw new CryptographicException("Invalid account signature."); + } + private static ECDsa PublicIdentityKey(string encoded) + { + if (encoded is null || encoded.Length > 200) throw new CryptographicException("Invalid account identity."); + var key = ECDsa.Create(); + try + { + var bytes = Convert.FromBase64String(encoded); + key.ImportSubjectPublicKeyInfo(bytes, out var read); + if (read != bytes.Length || key.ExportParameters(false).Curve.Oid.Value != "1.2.840.10045.3.1.7") + throw new CryptographicException("Invalid account identity curve."); + return key; + } + catch { key.Dispose(); throw; } + } + private static ECDsa PrivateIdentity(string encoded) + { + var bytes = Convert.FromBase64String(encoded); + var key = ECDsa.Create(); + try { key.ImportPkcs8PrivateKey(bytes, out _); return key; } + catch { key.Dispose(); throw; } + finally { CryptographicOperations.ZeroMemory(bytes); } + } + private sealed record ArchivePayload(int Version, Guid UserId, long Revision, string Plaintext); +} diff --git a/Govor.Application/E2ee/E2eeService.cs b/Govor.Application/E2ee/E2eeService.cs index 75f04ff..28ea179 100644 --- a/Govor.Application/E2ee/E2eeService.cs +++ b/Govor.Application/E2ee/E2eeService.cs @@ -33,7 +33,8 @@ public sealed class E2eeService(GovorDbContext context) // remain available for offline devices until their session is explicitly revoked. var sessions = await context.UserCryptoSessions.AsNoTracking().Include(c => c.SignedPreKey) .Include(c => c.UserSession) - .Where(c => members.Contains(c.UserSession.UserId) && !c.UserSession.IsRevoked) + .Where(c => members.Contains(c.UserSession.UserId) && !c.UserSession.IsRevoked && + (c.AccountIdentityKey != null || !context.E2eeRecoveryVaults.Any(v => v.UserId == c.UserSession.UserId))) .Take(E2eeProtocol.MaxDevices + 1).ToListAsync(); var devices = sessions.Select(s => ToDeviceKey(s)).ToArray(); if (devices.Length > E2eeProtocol.MaxDevices) @@ -49,6 +50,11 @@ public sealed class E2eeService(GovorDbContext context) if (key.UserId != user || key.SessionId != sessionId) throw new UnauthorizedAccessException("E2EE key must belong to the current session."); E2eeProtocol.ValidatePublicKey(key); + var account = await context.E2eeRecoveryVaults.AsNoTracking().SingleOrDefaultAsync(v => v.UserId == user); + if (account is not null && key.AccountIdentityKey != account.IdentityKey) + throw new UnauthorizedAccessException("Restore the account archive before enrolling this device."); + if (key.AccountIdentityKey is not null && account is null) + throw new InvalidOperationException("Upload the encrypted recovery archive before registering device keys."); var session = await context.UserSessions.Include(s => s.CryptoSession) .ThenInclude(c => c.SignedPreKey).SingleOrDefaultAsync(s => s.Id == sessionId && s.UserId == user && !s.IsRevoked && s.ExpiresAt > DateTime.UtcNow) @@ -56,10 +62,30 @@ public sealed class E2eeService(GovorDbContext context) if (session.CryptoSession is not null) { var existing = ToDeviceKey(session.CryptoSession, user); - if (existing.Fingerprint != key.Fingerprint) - throw new InvalidOperationException("Session keys are immutable. Create a new session to change devices."); + if (existing.Fingerprint == key.Fingerprint) + { + if (existing.AccountIdentityKey is null && key.AccountIdentityKey is not null && key.Generation == 0) + { + ApplyCertificate(session.CryptoSession, key); + await context.SaveChangesAsync(); + } + else if (existing.Generation != key.Generation || existing.AccountIdentityKey != key.AccountIdentityKey) + throw new InvalidOperationException("Device generation mismatch."); + return; + } + if (account is null || key.AccountIdentityKey != account.IdentityKey || + key.Generation != existing.Generation + 1 || key.PreviousFingerprint != existing.Fingerprint || + key.IdentityKey != existing.IdentityKey) + throw new InvalidOperationException("A signed, consecutive device key rotation is required."); + var rotating = session.CryptoSession; + rotating.SignedPreKey.PublicSignedPreKey = Convert.FromBase64String(key.EncryptionKey); + rotating.SignedPreKey.SignedPreKeySignature = Convert.FromBase64String(key.Signature); + ApplyCertificate(rotating, key); + await context.SaveChangesAsync(); return; } + if (key.Generation != 0 || key.PreviousFingerprint is not null) + throw new InvalidOperationException("A newly enrolled device must start at generation zero."); var cryptoId = Guid.NewGuid(); var crypto = new UserCryptoSession { @@ -74,10 +100,82 @@ public sealed class E2eeService(GovorDbContext context) OneTimePreKeys = new List() }; context.UserCryptoSessions.Add(crypto); + ApplyCertificate(crypto, key); session.CryptoSession = crypto; await context.SaveChangesAsync(); } + public async Task GetRecoveryAsync(Guid user) + { + var value = await context.E2eeRecoveryVaults.AsNoTracking().SingleOrDefaultAsync(v => v.UserId == user); + return new(value is null ? null : new(user, value.Revision, value.IdentityKey, value.Ciphertext, value.Signature)); + } + + public async Task SaveRecoveryAsync(Guid user, SaveRecoveryVault request) + { + if (request.ExpectedRevision < 0 || request.ExpectedRevision == long.MaxValue) + throw new ArgumentException("Invalid archive revision."); + var value = new RecoveryVault(user, request.ExpectedRevision + 1, request.IdentityKey, request.Ciphertext, request.Signature); + E2eeRecoveryProtocol.Validate(value); + var existing = await context.E2eeRecoveryVaults.SingleOrDefaultAsync(v => v.UserId == user); + if (existing is null) + { + if (request.ExpectedRevision != 0) throw new InvalidOperationException("Archive revision conflict."); + context.E2eeRecoveryVaults.Add(new E2eeRecoveryVault { UserId = user, Revision = value.Revision, + IdentityKey = value.IdentityKey, Ciphertext = value.Ciphertext, Signature = value.Signature }); + } + else + { + if (existing.IdentityKey != request.IdentityKey || existing.Revision != request.ExpectedRevision) + throw new InvalidOperationException("Archive identity or revision conflict."); + existing.Revision = value.Revision; + existing.Ciphertext = value.Ciphertext; + existing.Signature = value.Signature; + } + try { await context.SaveChangesAsync(); } + catch (DbUpdateException) { context.ChangeTracker.Clear(); throw new InvalidOperationException("Archive revision conflict."); } + return value; + } + + private static void ApplyCertificate(UserCryptoSession crypto, DeviceKey key) + { + crypto.AccountIdentityKey = key.AccountIdentityKey; + crypto.AccountSignature = key.AccountSignature; + crypto.Generation = key.Generation; + crypto.PreviousFingerprint = key.PreviousFingerprint; + } + + public async Task GetOwnDevicesAsync(Guid user) => + (await context.UserCryptoSessions.AsNoTracking().Include(c => c.SignedPreKey).Include(c => c.UserSession) + .Where(c => c.UserSession.UserId == user).ToListAsync()).Select(c => ToDeviceKey(c)).ToArray(); + + public async Task CertifyHistoricalDeviceAsync(Guid user, DeviceKey key) + { + E2eeProtocol.ValidatePublicKey(key); + E2eeRecoveryProtocol.VerifyCertificate(key); + var root = await context.E2eeRecoveryVaults.AsNoTracking().SingleOrDefaultAsync(v => v.UserId == user); + var crypto = await context.UserCryptoSessions.Include(c => c.SignedPreKey).Include(c => c.UserSession) + .SingleOrDefaultAsync(c => c.UserSessionId == key.SessionId && c.UserSession.UserId == user); + if (root is null || root.IdentityKey != key.AccountIdentityKey || key.UserId != user || crypto is null) + throw new UnauthorizedAccessException("Only the account owner may certify historical device keys."); + var stored = ToDeviceKey(crypto); + if (stored.Fingerprint != key.Fingerprint || stored.Generation != key.Generation || + stored.PreviousFingerprint != key.PreviousFingerprint) + throw new InvalidOperationException("Historical device keys cannot be changed."); + ApplyCertificate(crypto, key); + await context.SaveChangesAsync(); + } + + public async Task GetHistoricalSignerAsync(Guid user, Guid conversation, RecipientType type, Guid session) + { + if (!await context.HasChatAccessAsync(user, conversation, type)) throw new UnauthorizedAccessException(); + var crypto = await context.UserCryptoSessions.AsNoTracking().Include(c => c.SignedPreKey).Include(c => c.UserSession) + .SingleOrDefaultAsync(c => c.UserSessionId == session); + if (crypto is null || !await context.Messages.AnyAsync(m => m.RecipientId == conversation && + m.RecipientType == type && m.SenderId == crypto.UserSession.UserId)) return null; + return ToDeviceKey(crypto); + } + public async Task ValidateAsync(string content, Guid sender, Guid conversation, RecipientType type, Guid? replyTo, Guid[] media, Guid? editedMessage = null) { @@ -104,12 +202,14 @@ public sealed class E2eeService(GovorDbContext context) .ThenInclude(c => c.SignedPreKey).SingleOrDefaultAsync(s => s.Id == envelope.Sender.SessionId && s.UserId == sender && !s.IsRevoked && s.ExpiresAt > DateTime.UtcNow); if (signingSession?.CryptoSession is null || - ToDeviceKey(signingSession.CryptoSession, sender).Fingerprint != envelope.Sender.Fingerprint) + ToDeviceKey(signingSession.CryptoSession, sender).Fingerprint != envelope.Sender.Fingerprint || + signingSession.CryptoSession.AccountIdentityKey != envelope.Sender.AccountIdentityKey || + signingSession.CryptoSession.Generation != envelope.Sender.Generation) throw new UnauthorizedAccessException("E2EE signing device is unknown or revoked."); var directory = await GetConversationKeysAsync(sender, conversation, type); var expected = directory.Devices.Select(k => k.Fingerprint).Distinct().Order(StringComparer.Ordinal); if (!expected.SequenceEqual(envelope.Recipients.Order(StringComparer.Ordinal))) - throw new ArgumentException("Conversation devices changed. Reload and verify the recipient keys."); + throw new ArgumentException(E2eeProtocol.DevicesChangedError); return envelope; } @@ -117,5 +217,9 @@ public sealed class E2eeService(GovorDbContext context) new(user ?? session.UserSession.UserId, session.UserSessionId, Convert.ToBase64String(session.PublicIdentityKey), Convert.ToBase64String(session.SignedPreKey.PublicSignedPreKey), - Convert.ToBase64String(session.SignedPreKey.SignedPreKeySignature)); + Convert.ToBase64String(session.SignedPreKey.SignedPreKeySignature)) + { + AccountIdentityKey = session.AccountIdentityKey, AccountSignature = session.AccountSignature, + Generation = session.Generation, PreviousFingerprint = session.PreviousFingerprint + }; } diff --git a/Govor.Domain/Configurations/E2eeRecoveryVaultConfiguration.cs b/Govor.Domain/Configurations/E2eeRecoveryVaultConfiguration.cs new file mode 100644 index 0000000..71f1d7d --- /dev/null +++ b/Govor.Domain/Configurations/E2eeRecoveryVaultConfiguration.cs @@ -0,0 +1,20 @@ +using Govor.Domain.Models.Users; +using Govor.Domain.Models.Users.Crypto; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Metadata.Builders; + +namespace Govor.Domain.Configurations; + +public class E2eeRecoveryVaultConfiguration : IEntityTypeConfiguration +{ + public void Configure(EntityTypeBuilder builder) + { + builder.HasKey(v => v.UserId); + var b = builder; + b.Property(v => v.Revision).IsConcurrencyToken(); + b.Property(v => v.IdentityKey).HasMaxLength(200); + b.Property(v => v.Signature).HasMaxLength(100); + b.Property(v => v.Ciphertext).HasMaxLength(4_000_000); + b.HasOne().WithOne().HasForeignKey(v => v.UserId).OnDelete(DeleteBehavior.Cascade); + } +} \ No newline at end of file diff --git a/Govor.Domain/Configurations/UserCryptoSessionConfiguration.cs b/Govor.Domain/Configurations/UserCryptoSessionConfiguration.cs index a326bcd..fa5d34c 100644 --- a/Govor.Domain/Configurations/UserCryptoSessionConfiguration.cs +++ b/Govor.Domain/Configurations/UserCryptoSessionConfiguration.cs @@ -9,6 +9,10 @@ public class UserCryptoSessionConfiguration : IEntityTypeConfiguration builder) { builder.HasKey(ucs => ucs.Id); + builder.Property(c => c.Generation).IsConcurrencyToken(); + builder.Property(c => c.AccountIdentityKey).HasMaxLength(200); + builder.Property(c => c.AccountSignature).HasMaxLength(100); + builder.Property(c => c.PreviousFingerprint).HasMaxLength(64); builder.HasOne(ucs => ucs.UserSession) .WithOne(us => us.CryptoSession) @@ -34,4 +38,4 @@ public class UserCryptoSessionConfiguration : IEntityTypeConfiguration ucs.PublicIdentityKey) .IsRequired(); } -} \ No newline at end of file +} diff --git a/Govor.Domain/GovorDbContext.cs b/Govor.Domain/GovorDbContext.cs index 081cba1..0a070b2 100644 --- a/Govor.Domain/GovorDbContext.cs +++ b/Govor.Domain/GovorDbContext.cs @@ -14,6 +14,7 @@ public class GovorDbContext(DbContextOptions options) : DbContex public virtual DbSet UserSessions { get; set; } public virtual DbSet UserPushTokens { get; set; } public virtual DbSet UserCryptoSessions { get; set; } + public virtual DbSet E2eeRecoveryVaults { get; set; } public virtual DbSet SignedPreKeys { get; set; } public virtual DbSet OneTimePreKeys { get; set; } public virtual DbSet Friendships { get; set; } @@ -41,6 +42,7 @@ public class GovorDbContext(DbContextOptions options) : DbContex protected override void OnModelCreating(ModelBuilder modelBuilder) { + modelBuilder.ApplyConfiguration(new E2eeRecoveryVaultConfiguration()); modelBuilder.ApplyConfiguration(new UserSessionConfiguration()); modelBuilder.ApplyConfiguration(new FriendshipConfiguration()); modelBuilder.ApplyConfiguration(new UserConfiguration()); diff --git a/Govor.Domain/Migrations/20261024084524_E2eeRecoveryAndRotation.Designer.cs b/Govor.Domain/Migrations/20261024084524_E2eeRecoveryAndRotation.Designer.cs new file mode 100644 index 0000000..119e02c --- /dev/null +++ b/Govor.Domain/Migrations/20261024084524_E2eeRecoveryAndRotation.Designer.cs @@ -0,0 +1,1407 @@ +// +using System; +using Govor.Domain; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Migrations; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata; + +#nullable disable + +namespace Govor.Domain.Migrations +{ + [DbContext(typeof(GovorDbContext))] + [Migration("20261024084524_E2eeRecoveryAndRotation")] + partial class E2eeRecoveryAndRotation + { + /// + protected override void BuildTargetModel(ModelBuilder modelBuilder) + { +#pragma warning disable 612, 618 + modelBuilder + .HasAnnotation("ProductVersion", "10.0.10") + .HasAnnotation("Relational:MaxIdentifierLength", 63); + + NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder); + + modelBuilder.Entity("Govor.Domain.Models.ChatGroup", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("CreatedAt") + .HasColumnType("timestamp with time zone"); + + b.Property("Description") + .IsRequired() + .HasMaxLength(500) + .HasColumnType("character varying(500)"); + + b.Property("ImageId") + .HasColumnType("uuid"); + + b.Property("IsChannel") + .HasColumnType("boolean"); + + b.Property("IsPrivate") + .HasColumnType("boolean"); + + b.Property("Name") + .IsRequired() + .HasMaxLength(100) + .HasColumnType("character varying(100)"); + + b.Property("OwnerUserId") + .HasColumnType("uuid"); + + b.Property("ReactionMode") + .HasColumnType("integer"); + + b.Property("ReactionPolicyVersion") + .HasColumnType("bigint"); + + b.HasKey("Id"); + + b.HasIndex("OwnerUserId"); + + b.ToTable("ChatGroups"); + }); + + modelBuilder.Entity("Govor.Domain.Models.Friendship", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("AddresseeId") + .HasColumnType("uuid"); + + b.Property("RequesterId") + .HasColumnType("uuid"); + + b.Property("Status") + .HasColumnType("integer"); + + b.HasKey("Id"); + + b.HasIndex("AddresseeId"); + + b.HasIndex("RequesterId"); + + b.ToTable("Friendships"); + }); + + modelBuilder.Entity("Govor.Domain.Models.GroupAdmins", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("GroupId") + .HasColumnType("uuid"); + + b.Property("UserId") + .HasColumnType("uuid"); + + b.HasKey("Id"); + + b.HasIndex("UserId"); + + b.HasIndex("GroupId", "UserId") + .IsUnique(); + + b.ToTable("GroupAdmins"); + }); + + modelBuilder.Entity("Govor.Domain.Models.GroupInvitation", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("CreatedAt") + .HasColumnType("timestamp with time zone"); + + b.Property("Description") + .IsRequired() + .HasMaxLength(500) + .HasColumnType("character varying(500)"); + + b.Property("EndDate") + .HasColumnType("timestamp with time zone"); + + b.Property("GroupId") + .HasColumnType("uuid"); + + b.Property("InvitationCode") + .IsRequired() + .HasMaxLength(200) + .HasColumnType("character varying(200)"); + + b.Property("IsRevoked") + .HasColumnType("boolean"); + + b.Property("MaxParticipants") + .HasColumnType("integer"); + + b.Property("UsedCount") + .HasColumnType("integer"); + + b.Property("UserMakerId") + .HasColumnType("uuid"); + + b.HasKey("Id"); + + b.HasIndex("GroupId"); + + b.HasIndex("InvitationCode") + .IsUnique(); + + b.HasIndex("UserMakerId"); + + b.ToTable("GroupInvitations"); + }); + + modelBuilder.Entity("Govor.Domain.Models.GroupMembership", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("GroupId") + .HasColumnType("uuid"); + + b.Property("InvitationId") + .HasColumnType("uuid"); + + b.Property("IsBanned") + .HasColumnType("boolean"); + + b.Property("MemberSince") + .HasColumnType("timestamp with time zone"); + + b.Property("UserId") + .HasColumnType("uuid"); + + b.HasKey("Id"); + + b.HasIndex("InvitationId"); + + b.HasIndex("UserId"); + + b.HasIndex("GroupId", "UserId") + .IsUnique(); + + b.ToTable("GroupMemberships"); + }); + + modelBuilder.Entity("Govor.Domain.Models.Invitation", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("Code") + .IsRequired() + .HasColumnType("text"); + + b.Property("DateCreated") + .HasColumnType("timestamp with time zone"); + + b.Property("Description") + .IsRequired() + .HasColumnType("text"); + + b.Property("EndDate") + .HasColumnType("timestamp with time zone"); + + b.Property("IsActive") + .HasColumnType("boolean"); + + b.Property("IsAdmin") + .HasColumnType("boolean"); + + b.Property("MaxParticipants") + .HasColumnType("integer"); + + b.Property("Participants") + .HasColumnType("integer"); + + b.HasKey("Id"); + + b.ToTable("Invitations"); + }); + + modelBuilder.Entity("Govor.Domain.Models.MediaFile", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("DateCreated") + .HasColumnType("timestamp with time zone"); + + b.Property("MediaType") + .IsRequired() + .HasColumnType("text"); + + b.Property("MineType") + .IsRequired() + .HasMaxLength(128) + .HasColumnType("character varying(128)"); + + b.Property("OwnerId") + .HasColumnType("uuid"); + + b.Property("OwnerType") + .HasColumnType("integer"); + + b.Property("UploaderId") + .HasColumnType("uuid"); + + b.Property("Url") + .IsRequired() + .HasColumnType("text"); + + b.HasKey("Id"); + + b.ToTable("MediaFiles"); + }); + + modelBuilder.Entity("Govor.Domain.Models.Messages.ChatPushNotification", b => + { + b.Property("MessageId") + .HasColumnType("uuid"); + + b.Property("Attempts") + .HasColumnType("integer"); + + b.Property("NextAttemptAt") + .HasColumnType("timestamp with time zone"); + + b.HasKey("MessageId"); + + b.HasIndex("NextAttemptAt"); + + b.ToTable("ChatPushNotifications"); + }); + + modelBuilder.Entity("Govor.Domain.Models.Messages.MediaAttachments", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("MediaFileId") + .HasColumnType("uuid"); + + b.Property("MessageId") + .HasColumnType("uuid"); + + b.HasKey("Id"); + + b.HasIndex("MediaFileId"); + + b.HasIndex("MessageId"); + + b.ToTable("MediaAttachments"); + }); + + modelBuilder.Entity("Govor.Domain.Models.Messages.Message", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("ChatGroupId") + .HasColumnType("uuid"); + + b.Property("EditedAt") + .HasColumnType("timestamp with time zone"); + + b.Property("EncryptedContent") + .IsRequired() + .HasColumnType("text"); + + b.Property("IsEdited") + .HasColumnType("boolean"); + + b.Property("PrivateChatId") + .HasColumnType("uuid"); + + b.Property("ReactionsVersion") + .HasColumnType("bigint"); + + b.Property("RecipientId") + .HasColumnType("uuid"); + + b.Property("RecipientType") + .HasColumnType("integer"); + + b.Property("ReplyToMessageId") + .HasColumnType("uuid"); + + b.Property("SenderId") + .HasColumnType("uuid"); + + b.Property("SentAt") + .HasColumnType("timestamp with time zone"); + + b.HasKey("Id"); + + b.HasIndex("ChatGroupId"); + + b.HasIndex("PrivateChatId"); + + b.HasIndex("RecipientId"); + + b.ToTable("Messages"); + }); + + modelBuilder.Entity("Govor.Domain.Models.Messages.MessageReaction", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("MessageId") + .HasColumnType("uuid"); + + b.Property("ReactedAt") + .HasColumnType("timestamp with time zone"); + + b.Property("ReactionCode") + .IsRequired() + .HasMaxLength(64) + .HasColumnType("character varying(64)"); + + b.Property("ReactionId") + .HasColumnType("uuid"); + + b.Property("UserId") + .HasColumnType("uuid"); + + b.HasKey("Id"); + + b.HasIndex("ReactionId"); + + b.HasIndex("UserId"); + + b.HasIndex("MessageId", "UserId") + .IsUnique(); + + b.ToTable("MessageReactions"); + }); + + modelBuilder.Entity("Govor.Domain.Models.Messages.MessageView", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("MessageId") + .HasColumnType("uuid"); + + b.Property("UserId") + .HasColumnType("uuid"); + + b.Property("ViewedAt") + .HasColumnType("timestamp with time zone"); + + b.HasKey("Id"); + + b.HasIndex("MessageId", "UserId") + .IsUnique(); + + b.ToTable("MessageViews"); + }); + + modelBuilder.Entity("Govor.Domain.Models.PrivateChat", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("UserAId") + .HasColumnType("uuid"); + + b.Property("UserBId") + .HasColumnType("uuid"); + + b.HasKey("Id"); + + b.ToTable("PrivateChats"); + }); + + modelBuilder.Entity("Govor.Domain.Models.Reactions.ChannelAllowedReaction", b => + { + b.Property("GroupId") + .HasColumnType("uuid"); + + b.Property("ReactionId") + .HasColumnType("uuid"); + + b.HasKey("GroupId", "ReactionId"); + + b.HasIndex("ReactionId"); + + b.ToTable("ChannelAllowedReactions"); + }); + + modelBuilder.Entity("Govor.Domain.Models.Reactions.ReactionItem", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("Code") + .IsRequired() + .HasMaxLength(64) + .HasColumnType("character varying(64)"); + + b.Property("CreatedAt") + .HasColumnType("timestamp with time zone"); + + b.Property("DurationMilliseconds") + .HasColumnType("integer"); + + b.Property("Emoji") + .HasMaxLength(64) + .HasColumnType("character varying(64)"); + + b.Property("Height") + .HasColumnType("integer"); + + b.Property("IsEnabled") + .HasColumnType("boolean"); + + b.Property("Kind") + .HasColumnType("integer"); + + b.Property("MediaFileId") + .HasColumnType("uuid"); + + b.Property("Name") + .IsRequired() + .HasMaxLength(100) + .HasColumnType("character varying(100)"); + + b.Property("PackId") + .HasColumnType("uuid"); + + b.Property("SizeBytes") + .HasColumnType("integer"); + + b.Property("Width") + .HasColumnType("integer"); + + b.HasKey("Id"); + + b.HasIndex("Code") + .IsUnique(); + + b.HasIndex("MediaFileId"); + + b.HasIndex("PackId"); + + b.ToTable("ReactionItems"); + + b.HasData( + new + { + Id = new Guid("b3000000-0000-0000-0001-000000000001"), + Code = "👍", + CreatedAt = new DateTime(2026, 10, 3, 0, 0, 0, 0, DateTimeKind.Utc), + DurationMilliseconds = 0, + Emoji = "👍", + Height = 0, + IsEnabled = true, + Kind = 0, + Name = "👍", + PackId = new Guid("b3000000-0000-0000-0000-000000000001"), + SizeBytes = 0, + Width = 0 + }, + new + { + Id = new Guid("b3000000-0000-0000-0001-000000000002"), + Code = "👎", + CreatedAt = new DateTime(2026, 10, 3, 0, 0, 0, 0, DateTimeKind.Utc), + DurationMilliseconds = 0, + Emoji = "👎", + Height = 0, + IsEnabled = true, + Kind = 0, + Name = "👎", + PackId = new Guid("b3000000-0000-0000-0000-000000000001"), + SizeBytes = 0, + Width = 0 + }, + new + { + Id = new Guid("b3000000-0000-0000-0001-000000000003"), + Code = "❤️", + CreatedAt = new DateTime(2026, 10, 3, 0, 0, 0, 0, DateTimeKind.Utc), + DurationMilliseconds = 0, + Emoji = "❤️", + Height = 0, + IsEnabled = true, + Kind = 0, + Name = "❤️", + PackId = new Guid("b3000000-0000-0000-0000-000000000001"), + SizeBytes = 0, + Width = 0 + }, + new + { + Id = new Guid("b3000000-0000-0000-0001-000000000004"), + Code = "🔥", + CreatedAt = new DateTime(2026, 10, 3, 0, 0, 0, 0, DateTimeKind.Utc), + DurationMilliseconds = 0, + Emoji = "🔥", + Height = 0, + IsEnabled = true, + Kind = 0, + Name = "🔥", + PackId = new Guid("b3000000-0000-0000-0000-000000000001"), + SizeBytes = 0, + Width = 0 + }, + new + { + Id = new Guid("b3000000-0000-0000-0001-000000000005"), + Code = "🥰", + CreatedAt = new DateTime(2026, 10, 3, 0, 0, 0, 0, DateTimeKind.Utc), + DurationMilliseconds = 0, + Emoji = "🥰", + Height = 0, + IsEnabled = true, + Kind = 0, + Name = "🥰", + PackId = new Guid("b3000000-0000-0000-0000-000000000001"), + SizeBytes = 0, + Width = 0 + }, + new + { + Id = new Guid("b3000000-0000-0000-0001-000000000006"), + Code = "👏", + CreatedAt = new DateTime(2026, 10, 3, 0, 0, 0, 0, DateTimeKind.Utc), + DurationMilliseconds = 0, + Emoji = "👏", + Height = 0, + IsEnabled = true, + Kind = 0, + Name = "👏", + PackId = new Guid("b3000000-0000-0000-0000-000000000001"), + SizeBytes = 0, + Width = 0 + }, + new + { + Id = new Guid("b3000000-0000-0000-0001-000000000007"), + Code = "😁", + CreatedAt = new DateTime(2026, 10, 3, 0, 0, 0, 0, DateTimeKind.Utc), + DurationMilliseconds = 0, + Emoji = "😁", + Height = 0, + IsEnabled = true, + Kind = 0, + Name = "😁", + PackId = new Guid("b3000000-0000-0000-0000-000000000001"), + SizeBytes = 0, + Width = 0 + }, + new + { + Id = new Guid("b3000000-0000-0000-0001-000000000008"), + Code = "🤔", + CreatedAt = new DateTime(2026, 10, 3, 0, 0, 0, 0, DateTimeKind.Utc), + DurationMilliseconds = 0, + Emoji = "🤔", + Height = 0, + IsEnabled = true, + Kind = 0, + Name = "🤔", + PackId = new Guid("b3000000-0000-0000-0000-000000000001"), + SizeBytes = 0, + Width = 0 + }, + new + { + Id = new Guid("b3000000-0000-0000-0001-000000000009"), + Code = "😢", + CreatedAt = new DateTime(2026, 10, 3, 0, 0, 0, 0, DateTimeKind.Utc), + DurationMilliseconds = 0, + Emoji = "😢", + Height = 0, + IsEnabled = true, + Kind = 0, + Name = "😢", + PackId = new Guid("b3000000-0000-0000-0000-000000000001"), + SizeBytes = 0, + Width = 0 + }, + new + { + Id = new Guid("b3000000-0000-0000-0001-000000000010"), + Code = "🎉", + CreatedAt = new DateTime(2026, 10, 3, 0, 0, 0, 0, DateTimeKind.Utc), + DurationMilliseconds = 0, + Emoji = "🎉", + Height = 0, + IsEnabled = true, + Kind = 0, + Name = "🎉", + PackId = new Guid("b3000000-0000-0000-0000-000000000001"), + SizeBytes = 0, + Width = 0 + }, + new + { + Id = new Guid("b3000000-0000-0000-0001-000000000011"), + Code = "🤯", + CreatedAt = new DateTime(2026, 10, 3, 0, 0, 0, 0, DateTimeKind.Utc), + DurationMilliseconds = 0, + Emoji = "🤯", + Height = 0, + IsEnabled = true, + Kind = 0, + Name = "🤯", + PackId = new Guid("b3000000-0000-0000-0000-000000000001"), + SizeBytes = 0, + Width = 0 + }, + new + { + Id = new Guid("b3000000-0000-0000-0001-000000000012"), + Code = "🙏", + CreatedAt = new DateTime(2026, 10, 3, 0, 0, 0, 0, DateTimeKind.Utc), + DurationMilliseconds = 0, + Emoji = "🙏", + Height = 0, + IsEnabled = true, + Kind = 0, + Name = "🙏", + PackId = new Guid("b3000000-0000-0000-0000-000000000001"), + SizeBytes = 0, + Width = 0 + }); + }); + + modelBuilder.Entity("Govor.Domain.Models.Reactions.ReactionPack", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("CreatedAt") + .HasColumnType("timestamp with time zone"); + + b.Property("CreatedByUserId") + .HasColumnType("uuid"); + + b.Property("Description") + .IsRequired() + .HasMaxLength(500) + .HasColumnType("character varying(500)"); + + b.Property("IsDefault") + .HasColumnType("boolean"); + + b.Property("IsEnabled") + .HasColumnType("boolean"); + + b.Property("Name") + .IsRequired() + .HasMaxLength(100) + .HasColumnType("character varying(100)"); + + b.Property("ShareCode") + .IsRequired() + .HasMaxLength(32) + .HasColumnType("character varying(32)"); + + b.HasKey("Id"); + + b.HasIndex("CreatedByUserId"); + + b.HasIndex("IsDefault") + .IsUnique() + .HasFilter("\"IsDefault\" = TRUE"); + + b.HasIndex("ShareCode") + .IsUnique(); + + b.ToTable("ReactionPacks"); + + b.HasData( + new + { + Id = new Guid("b3000000-0000-0000-0000-000000000001"), + CreatedAt = new DateTime(2026, 10, 3, 0, 0, 0, 0, DateTimeKind.Utc), + Description = "Default public emoji reactions", + IsDefault = true, + IsEnabled = true, + Name = "Emoji", + ShareCode = "default" + }); + }); + + modelBuilder.Entity("Govor.Domain.Models.Reactions.UserReactionPack", b => + { + b.Property("UserId") + .HasColumnType("uuid"); + + b.Property("PackId") + .HasColumnType("uuid"); + + b.HasKey("UserId", "PackId"); + + b.HasIndex("PackId"); + + b.ToTable("UserReactionPacks"); + }); + + modelBuilder.Entity("Govor.Domain.Models.ServerCommunitySettings", b => + { + b.Property("Id") + .HasColumnType("integer"); + + b.Property("AllowLeave") + .HasColumnType("boolean"); + + b.Property("RequiredChannelId") + .HasColumnType("uuid"); + + b.HasKey("Id"); + + b.HasIndex("RequiredChannelId"); + + b.ToTable("ServerCommunitySettings"); + + b.HasData( + new + { + Id = 1, + AllowLeave = true + }); + }); + + modelBuilder.Entity("Govor.Domain.Models.Users.Admin", b => + { + b.Property("UserId") + .HasColumnType("uuid"); + + b.HasKey("UserId"); + + b.ToTable("Admins"); + }); + + modelBuilder.Entity("Govor.Domain.Models.Users.Crypto.E2eeRecoveryVault", b => + { + b.Property("UserId") + .HasColumnType("uuid"); + + b.Property("Ciphertext") + .IsRequired() + .HasMaxLength(4000000) + .HasColumnType("character varying(4000000)"); + + b.Property("IdentityKey") + .IsRequired() + .HasMaxLength(200) + .HasColumnType("character varying(200)"); + + b.Property("Revision") + .IsConcurrencyToken() + .HasColumnType("bigint"); + + b.Property("Signature") + .IsRequired() + .HasMaxLength(100) + .HasColumnType("character varying(100)"); + + b.HasKey("UserId"); + + b.ToTable("E2eeRecoveryVaults"); + }); + + modelBuilder.Entity("Govor.Domain.Models.Users.Crypto.OneTimePreKey", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("IsUsed") + .ValueGeneratedOnAdd() + .HasColumnType("boolean") + .HasDefaultValue(false); + + b.Property("PublicKey") + .IsRequired() + .HasColumnType("bytea"); + + b.Property("UploadedAt") + .HasColumnType("timestamp with time zone"); + + b.Property("UserCryptoSessionId") + .HasColumnType("uuid"); + + b.HasKey("Id"); + + b.HasIndex("UploadedAt"); + + b.HasIndex("UserCryptoSessionId", "IsUsed"); + + b.ToTable("OneTimePreKeys"); + }); + + modelBuilder.Entity("Govor.Domain.Models.Users.Crypto.SignedPreKey", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("PublicSignedPreKey") + .IsRequired() + .HasColumnType("bytea"); + + b.Property("SignedPreKeySignature") + .IsRequired() + .HasColumnType("bytea"); + + b.Property("UserCryptoSessionId") + .HasColumnType("uuid"); + + b.HasKey("Id"); + + b.HasIndex("UserCryptoSessionId") + .IsUnique(); + + b.ToTable("SignedPreKeys"); + }); + + modelBuilder.Entity("Govor.Domain.Models.Users.Crypto.UserCryptoSession", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("AccountIdentityKey") + .HasMaxLength(200) + .HasColumnType("character varying(200)"); + + b.Property("AccountSignature") + .HasMaxLength(100) + .HasColumnType("character varying(100)"); + + b.Property("Generation") + .IsConcurrencyToken() + .HasColumnType("bigint"); + + b.Property("PreviousFingerprint") + .HasMaxLength(64) + .HasColumnType("character varying(64)"); + + b.Property("PublicIdentityKey") + .IsRequired() + .HasColumnType("bytea"); + + b.Property("UserSessionId") + .HasColumnType("uuid"); + + b.HasKey("Id"); + + b.HasIndex("UserSessionId") + .IsUnique(); + + b.ToTable("UserCryptoSessions"); + }); + + modelBuilder.Entity("Govor.Domain.Models.Users.User", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("CreatedOn") + .HasColumnType("date"); + + b.Property("Description") + .HasMaxLength(500) + .HasColumnType("character varying(500)"); + + b.Property("IconId") + .HasColumnType("uuid"); + + b.Property("InviteId") + .HasColumnType("uuid"); + + b.Property("PasswordHash") + .IsRequired() + .HasMaxLength(128) + .HasColumnType("character varying(128)"); + + b.Property("Username") + .IsRequired() + .HasMaxLength(50) + .HasColumnType("character varying(50)"); + + b.Property("WasOnline") + .HasColumnType("timestamp with time zone"); + + b.HasKey("Id"); + + b.HasIndex("CreatedOn"); + + b.HasIndex("InviteId"); + + b.HasIndex("Username") + .IsUnique(); + + b.HasIndex("WasOnline"); + + b.ToTable("Users"); + }); + + modelBuilder.Entity("Govor.Domain.Models.Users.UserPushToken", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("CreatedAt") + .HasColumnType("timestamp with time zone"); + + b.Property("IsActive") + .HasColumnType("boolean"); + + b.Property("LastUsedAt") + .HasColumnType("timestamp with time zone"); + + b.Property("Platform") + .IsRequired() + .HasMaxLength(50) + .HasColumnType("character varying(50)"); + + b.Property("Provider") + .IsRequired() + .HasMaxLength(50) + .HasColumnType("character varying(50)"); + + b.Property("Token") + .IsRequired() + .HasMaxLength(512) + .HasColumnType("character varying(512)"); + + b.Property("UpdatedAt") + .HasColumnType("timestamp with time zone"); + + b.Property("UserId") + .HasColumnType("uuid"); + + b.Property("UserSessionId") + .HasColumnType("uuid"); + + b.HasKey("Id"); + + b.HasIndex("Token") + .IsUnique(); + + b.HasIndex("UserSessionId") + .IsUnique(); + + b.HasIndex("UserId", "IsActive"); + + b.ToTable("UserPushTokens"); + }); + + modelBuilder.Entity("Govor.Domain.Models.Users.UserSession", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("uuid"); + + b.Property("CreatedAt") + .HasColumnType("timestamp with time zone"); + + b.Property("DeviceInfo") + .IsRequired() + .HasMaxLength(256) + .HasColumnType("character varying(256)"); + + b.Property("ExpiresAt") + .HasColumnType("timestamp with time zone"); + + b.Property("IsRevoked") + .HasColumnType("boolean"); + + b.Property("RefreshTokenHash") + .IsRequired() + .HasColumnType("text"); + + b.Property("UserId") + .HasColumnType("uuid"); + + b.HasKey("Id"); + + b.HasIndex("RefreshTokenHash") + .IsUnique(); + + b.HasIndex("UserId"); + + b.ToTable("UserSessions"); + }); + + modelBuilder.Entity("Govor.Domain.Models.ChatGroup", b => + { + b.HasOne("Govor.Domain.Models.Users.User", null) + .WithMany() + .HasForeignKey("OwnerUserId") + .OnDelete(DeleteBehavior.Restrict); + }); + + modelBuilder.Entity("Govor.Domain.Models.Friendship", b => + { + b.HasOne("Govor.Domain.Models.Users.User", "Addressee") + .WithMany("ReceivedFriendRequests") + .HasForeignKey("AddresseeId") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + + b.HasOne("Govor.Domain.Models.Users.User", "Requester") + .WithMany("SentFriendRequests") + .HasForeignKey("RequesterId") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + + b.Navigation("Addressee"); + + b.Navigation("Requester"); + }); + + modelBuilder.Entity("Govor.Domain.Models.GroupAdmins", b => + { + b.HasOne("Govor.Domain.Models.ChatGroup", null) + .WithMany("Admins") + .HasForeignKey("GroupId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.HasOne("Govor.Domain.Models.Users.User", null) + .WithMany() + .HasForeignKey("UserId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + }); + + modelBuilder.Entity("Govor.Domain.Models.GroupInvitation", b => + { + b.HasOne("Govor.Domain.Models.ChatGroup", null) + .WithMany("InviteCodes") + .HasForeignKey("GroupId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.HasOne("Govor.Domain.Models.Users.User", "UserMaker") + .WithMany() + .HasForeignKey("UserMakerId") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + + b.Navigation("UserMaker"); + }); + + modelBuilder.Entity("Govor.Domain.Models.GroupMembership", b => + { + b.HasOne("Govor.Domain.Models.ChatGroup", "ChatGroup") + .WithMany("Members") + .HasForeignKey("GroupId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.HasOne("Govor.Domain.Models.GroupInvitation", null) + .WithMany() + .HasForeignKey("InvitationId") + .OnDelete(DeleteBehavior.SetNull); + + b.HasOne("Govor.Domain.Models.Users.User", null) + .WithMany() + .HasForeignKey("UserId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.Navigation("ChatGroup"); + }); + + modelBuilder.Entity("Govor.Domain.Models.Messages.ChatPushNotification", b => + { + b.HasOne("Govor.Domain.Models.Messages.Message", null) + .WithMany() + .HasForeignKey("MessageId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + }); + + modelBuilder.Entity("Govor.Domain.Models.Messages.MediaAttachments", b => + { + b.HasOne("Govor.Domain.Models.MediaFile", "MediaFile") + .WithMany() + .HasForeignKey("MediaFileId") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + + b.HasOne("Govor.Domain.Models.Messages.Message", "Message") + .WithMany("MediaAttachments") + .HasForeignKey("MessageId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.Navigation("MediaFile"); + + b.Navigation("Message"); + }); + + modelBuilder.Entity("Govor.Domain.Models.Messages.Message", b => + { + b.HasOne("Govor.Domain.Models.ChatGroup", null) + .WithMany("Messages") + .HasForeignKey("ChatGroupId"); + + b.HasOne("Govor.Domain.Models.PrivateChat", null) + .WithMany("Messages") + .HasForeignKey("PrivateChatId"); + }); + + modelBuilder.Entity("Govor.Domain.Models.Messages.MessageReaction", b => + { + b.HasOne("Govor.Domain.Models.Messages.Message", "Message") + .WithMany("Reactions") + .HasForeignKey("MessageId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.HasOne("Govor.Domain.Models.Reactions.ReactionItem", null) + .WithMany() + .HasForeignKey("ReactionId") + .OnDelete(DeleteBehavior.Restrict); + + b.HasOne("Govor.Domain.Models.Users.User", "User") + .WithMany() + .HasForeignKey("UserId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.Navigation("Message"); + + b.Navigation("User"); + }); + + modelBuilder.Entity("Govor.Domain.Models.Messages.MessageView", b => + { + b.HasOne("Govor.Domain.Models.Messages.Message", null) + .WithMany("MessageViews") + .HasForeignKey("MessageId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + }); + + modelBuilder.Entity("Govor.Domain.Models.Reactions.ChannelAllowedReaction", b => + { + b.HasOne("Govor.Domain.Models.ChatGroup", null) + .WithMany() + .HasForeignKey("GroupId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.HasOne("Govor.Domain.Models.Reactions.ReactionItem", null) + .WithMany() + .HasForeignKey("ReactionId") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + }); + + modelBuilder.Entity("Govor.Domain.Models.Reactions.ReactionItem", b => + { + b.HasOne("Govor.Domain.Models.MediaFile", null) + .WithMany() + .HasForeignKey("MediaFileId") + .OnDelete(DeleteBehavior.Restrict); + + b.HasOne("Govor.Domain.Models.Reactions.ReactionPack", "Pack") + .WithMany("Reactions") + .HasForeignKey("PackId") + .OnDelete(DeleteBehavior.Restrict) + .IsRequired(); + + b.Navigation("Pack"); + }); + + modelBuilder.Entity("Govor.Domain.Models.Reactions.ReactionPack", b => + { + b.HasOne("Govor.Domain.Models.Users.User", null) + .WithMany() + .HasForeignKey("CreatedByUserId") + .OnDelete(DeleteBehavior.SetNull); + }); + + modelBuilder.Entity("Govor.Domain.Models.Reactions.UserReactionPack", b => + { + b.HasOne("Govor.Domain.Models.Reactions.ReactionPack", null) + .WithMany() + .HasForeignKey("PackId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.HasOne("Govor.Domain.Models.Users.User", null) + .WithMany() + .HasForeignKey("UserId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + }); + + modelBuilder.Entity("Govor.Domain.Models.ServerCommunitySettings", b => + { + b.HasOne("Govor.Domain.Models.ChatGroup", null) + .WithMany() + .HasForeignKey("RequiredChannelId") + .OnDelete(DeleteBehavior.Restrict); + }); + + modelBuilder.Entity("Govor.Domain.Models.Users.Admin", b => + { + b.HasOne("Govor.Domain.Models.Users.User", "User") + .WithOne() + .HasForeignKey("Govor.Domain.Models.Users.Admin", "UserId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.Navigation("User"); + }); + + modelBuilder.Entity("Govor.Domain.Models.Users.Crypto.E2eeRecoveryVault", b => + { + b.HasOne("Govor.Domain.Models.Users.User", null) + .WithOne() + .HasForeignKey("Govor.Domain.Models.Users.Crypto.E2eeRecoveryVault", "UserId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + }); + + modelBuilder.Entity("Govor.Domain.Models.Users.Crypto.OneTimePreKey", b => + { + b.HasOne("Govor.Domain.Models.Users.Crypto.UserCryptoSession", "UserCryptoSession") + .WithMany("OneTimePreKeys") + .HasForeignKey("UserCryptoSessionId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.Navigation("UserCryptoSession"); + }); + + modelBuilder.Entity("Govor.Domain.Models.Users.Crypto.SignedPreKey", b => + { + b.HasOne("Govor.Domain.Models.Users.Crypto.UserCryptoSession", "UserCryptoSession") + .WithOne("SignedPreKey") + .HasForeignKey("Govor.Domain.Models.Users.Crypto.SignedPreKey", "UserCryptoSessionId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.Navigation("UserCryptoSession"); + }); + + modelBuilder.Entity("Govor.Domain.Models.Users.Crypto.UserCryptoSession", b => + { + b.HasOne("Govor.Domain.Models.Users.UserSession", "UserSession") + .WithOne("CryptoSession") + .HasForeignKey("Govor.Domain.Models.Users.Crypto.UserCryptoSession", "UserSessionId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.Navigation("UserSession"); + }); + + modelBuilder.Entity("Govor.Domain.Models.Users.User", b => + { + b.HasOne("Govor.Domain.Models.Invitation", "Invite") + .WithMany("Users") + .HasForeignKey("InviteId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.Navigation("Invite"); + }); + + modelBuilder.Entity("Govor.Domain.Models.Users.UserSession", b => + { + b.HasOne("Govor.Domain.Models.Users.User", "User") + .WithMany() + .HasForeignKey("UserId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.Navigation("User"); + }); + + modelBuilder.Entity("Govor.Domain.Models.ChatGroup", b => + { + b.Navigation("Admins"); + + b.Navigation("InviteCodes"); + + b.Navigation("Members"); + + b.Navigation("Messages"); + }); + + modelBuilder.Entity("Govor.Domain.Models.Invitation", b => + { + b.Navigation("Users"); + }); + + modelBuilder.Entity("Govor.Domain.Models.Messages.Message", b => + { + b.Navigation("MediaAttachments"); + + b.Navigation("MessageViews"); + + b.Navigation("Reactions"); + }); + + modelBuilder.Entity("Govor.Domain.Models.PrivateChat", b => + { + b.Navigation("Messages"); + }); + + modelBuilder.Entity("Govor.Domain.Models.Reactions.ReactionPack", b => + { + b.Navigation("Reactions"); + }); + + modelBuilder.Entity("Govor.Domain.Models.Users.Crypto.UserCryptoSession", b => + { + b.Navigation("OneTimePreKeys"); + + b.Navigation("SignedPreKey") + .IsRequired(); + }); + + modelBuilder.Entity("Govor.Domain.Models.Users.User", b => + { + b.Navigation("ReceivedFriendRequests"); + + b.Navigation("SentFriendRequests"); + }); + + modelBuilder.Entity("Govor.Domain.Models.Users.UserSession", b => + { + b.Navigation("CryptoSession") + .IsRequired(); + }); +#pragma warning restore 612, 618 + } + } +} diff --git a/Govor.Domain/Migrations/20261024084524_E2eeRecoveryAndRotation.cs b/Govor.Domain/Migrations/20261024084524_E2eeRecoveryAndRotation.cs new file mode 100644 index 0000000..98265e5 --- /dev/null +++ b/Govor.Domain/Migrations/20261024084524_E2eeRecoveryAndRotation.cs @@ -0,0 +1,87 @@ +using System; +using Microsoft.EntityFrameworkCore.Migrations; + +#nullable disable + +namespace Govor.Domain.Migrations +{ + /// + public partial class E2eeRecoveryAndRotation : Migration + { + /// + protected override void Up(MigrationBuilder migrationBuilder) + { + migrationBuilder.AddColumn( + name: "AccountIdentityKey", + table: "UserCryptoSessions", + type: "character varying(200)", + maxLength: 200, + nullable: true); + + migrationBuilder.AddColumn( + name: "AccountSignature", + table: "UserCryptoSessions", + type: "character varying(100)", + maxLength: 100, + nullable: true); + + migrationBuilder.AddColumn( + name: "Generation", + table: "UserCryptoSessions", + type: "bigint", + nullable: false, + defaultValue: 0L); + + migrationBuilder.AddColumn( + name: "PreviousFingerprint", + table: "UserCryptoSessions", + type: "character varying(64)", + maxLength: 64, + nullable: true); + + migrationBuilder.CreateTable( + name: "E2eeRecoveryVaults", + columns: table => new + { + UserId = table.Column(type: "uuid", nullable: false), + Revision = table.Column(type: "bigint", nullable: false), + IdentityKey = table.Column(type: "character varying(200)", maxLength: 200, nullable: false), + Ciphertext = table.Column(type: "character varying(4000000)", maxLength: 4000000, nullable: false), + Signature = table.Column(type: "character varying(100)", maxLength: 100, nullable: false) + }, + constraints: table => + { + table.PrimaryKey("PK_E2eeRecoveryVaults", x => x.UserId); + table.ForeignKey( + name: "FK_E2eeRecoveryVaults_Users_UserId", + column: x => x.UserId, + principalTable: "Users", + principalColumn: "Id", + onDelete: ReferentialAction.Cascade); + }); + } + + /// + protected override void Down(MigrationBuilder migrationBuilder) + { + migrationBuilder.DropTable( + name: "E2eeRecoveryVaults"); + + migrationBuilder.DropColumn( + name: "AccountIdentityKey", + table: "UserCryptoSessions"); + + migrationBuilder.DropColumn( + name: "AccountSignature", + table: "UserCryptoSessions"); + + migrationBuilder.DropColumn( + name: "Generation", + table: "UserCryptoSessions"); + + migrationBuilder.DropColumn( + name: "PreviousFingerprint", + table: "UserCryptoSessions"); + } + } +} diff --git a/Govor.Domain/Migrations/GovorDbContextModelSnapshot.cs b/Govor.Domain/Migrations/GovorDbContextModelSnapshot.cs index b5ba60d..f7f51db 100644 --- a/Govor.Domain/Migrations/GovorDbContextModelSnapshot.cs +++ b/Govor.Domain/Migrations/GovorDbContextModelSnapshot.cs @@ -797,6 +797,35 @@ namespace Govor.Domain.Migrations b.ToTable("Admins"); }); + modelBuilder.Entity("Govor.Domain.Models.Users.Crypto.E2eeRecoveryVault", b => + { + b.Property("UserId") + .HasColumnType("uuid"); + + b.Property("Ciphertext") + .IsRequired() + .HasMaxLength(4000000) + .HasColumnType("character varying(4000000)"); + + b.Property("IdentityKey") + .IsRequired() + .HasMaxLength(200) + .HasColumnType("character varying(200)"); + + b.Property("Revision") + .IsConcurrencyToken() + .HasColumnType("bigint"); + + b.Property("Signature") + .IsRequired() + .HasMaxLength(100) + .HasColumnType("character varying(100)"); + + b.HasKey("UserId"); + + b.ToTable("E2eeRecoveryVaults"); + }); + modelBuilder.Entity("Govor.Domain.Models.Users.Crypto.OneTimePreKey", b => { b.Property("Id") @@ -858,6 +887,22 @@ namespace Govor.Domain.Migrations .ValueGeneratedOnAdd() .HasColumnType("uuid"); + b.Property("AccountIdentityKey") + .HasMaxLength(200) + .HasColumnType("character varying(200)"); + + b.Property("AccountSignature") + .HasMaxLength(100) + .HasColumnType("character varying(100)"); + + b.Property("Generation") + .IsConcurrencyToken() + .HasColumnType("bigint"); + + b.Property("PreviousFingerprint") + .HasMaxLength(64) + .HasColumnType("character varying(64)"); + b.Property("PublicIdentityKey") .IsRequired() .HasColumnType("bytea"); @@ -1234,6 +1279,15 @@ namespace Govor.Domain.Migrations b.Navigation("User"); }); + modelBuilder.Entity("Govor.Domain.Models.Users.Crypto.E2eeRecoveryVault", b => + { + b.HasOne("Govor.Domain.Models.Users.User", null) + .WithOne() + .HasForeignKey("Govor.Domain.Models.Users.Crypto.E2eeRecoveryVault", "UserId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + }); + modelBuilder.Entity("Govor.Domain.Models.Users.Crypto.OneTimePreKey", b => { b.HasOne("Govor.Domain.Models.Users.Crypto.UserCryptoSession", "UserCryptoSession") diff --git a/Govor.Domain/Models/Users/Crypto/E2eeRecoveryVault.cs b/Govor.Domain/Models/Users/Crypto/E2eeRecoveryVault.cs new file mode 100644 index 0000000..7614467 --- /dev/null +++ b/Govor.Domain/Models/Users/Crypto/E2eeRecoveryVault.cs @@ -0,0 +1,10 @@ +namespace Govor.Domain.Models.Users.Crypto; + +public sealed class E2eeRecoveryVault +{ + public Guid UserId { get; set; } + public long Revision { get; set; } + public string IdentityKey { get; set; } = ""; + public string Ciphertext { get; set; } = ""; + public string Signature { get; set; } = ""; +} diff --git a/Govor.Domain/Models/Users/Crypto/UserCryptoSession.cs b/Govor.Domain/Models/Users/Crypto/UserCryptoSession.cs index a6a7c09..ad04cdf 100644 --- a/Govor.Domain/Models/Users/Crypto/UserCryptoSession.cs +++ b/Govor.Domain/Models/Users/Crypto/UserCryptoSession.cs @@ -8,6 +8,10 @@ public class UserCryptoSession public UserSession UserSession { get; set; } public byte[] PublicIdentityKey { get; set; } + public string? AccountIdentityKey { get; set; } + public string? AccountSignature { get; set; } + public long Generation { get; set; } + public string? PreviousFingerprint { get; set; } public SignedPreKey SignedPreKey { get; set; } public ICollection OneTimePreKeys { get; set; } diff --git a/docs/e2ee.md b/docs/e2ee.md index ffc7d05..d51f91e 100644 --- a/docs/e2ee.md +++ b/docs/e2ee.md @@ -1,133 +1,161 @@ -# E2EE v1 +# E2EE: автоматическое доверие, ротация и перенос истории -Новые личные сообщения и сообщения приватных групп/каналов требуют E2EE. -Сервер проверяет подпись и права доступа, сохраняет и пересылает зашифрованный -конверт. Он не получает приватные ключи устройств или ключи файлов. -Новый мобильный клиент шифрует сообщения всех чатов, включая публичные группы; -сервер сохраняет совместимость с открытыми сообщениями публичных групп. +## Поведение для пользователя -## Протокол +После входа актуальный клиент автоматически создаёт ключи, публикует только +публичные данные и регистрирует устройство. После добавления друга или вступления +в группу сообщения и файлы шифруются без диалогов сверки ключей или состава чата. +На новом физическом устройстве нужно один раз ввести код с доверенного устройства +(Настройки → Перенос истории / резервный код) либо сохранённый резервный код. +После этого клиент скачивает зашифрованный архив и расшифровывает прежние сообщения +и ключи вложений. Передача кода выполняется пользователем между своими устройствами; +отдельного протокола QR-сопряжения или удалённого одобрения устройства пока нет. -Используется `jose-jwt` 5.3.0: JWE JSON Serialization (RFC 7516), -RSA-OAEP-256 с RSA 3072 для передачи ключа каждому устройству, AES-256-GCM для -содержимого и JWS ES256 (RFC 7515) для подписи полного конверта. -Алгоритмы фиксированы; сжатие, незашифрованный режим и выбор алгоритма сервером -не поддерживаются. Это прикладной протокол на JOSE, а не Signal/MLS. +Это расширение существующего протокола JOSE, **не реализация Signal/MLS**. +Ротация ограничивает использование отдельного украденного ключа шифрования после +его замены. Она не устраняет компрометацию работающего устройства и не обеспечивает +forward secrecy или post-compromise security. Восстанавливаемый архив намеренно +сохраняет возможность расшифровки истории. Кража резервного кода вместе с доступом +к архиву раскрывает эту историю и ключ доверия аккаунта. -Поле `EncryptedContent` содержит `govor.e2ee.v1:` и компактный JWS. В подписанном -конверте находятся версия, ID сообщения и чата, тип чата, публичный ключ автора, -ID сессии, ссылка на ответ, время, признак редактирования, отпечатки устройств, -ID вложений и JWE. Текст и секреты вложений находятся только внутри JWE. -Публичный ключ RSA подписан ключом ES256 с отдельным контекстом -`govor-key-binding-v1`. Отпечаток SHA-256 связывает оба публичных ключа. +## Три вида ключей -Код `Govor.Application/E2ee/E2eeProtocol.cs` и его копия в мобильном репозитории -`Govor.Mobile/Services/E2ee/E2eeProtocol.cs` должны оставаться идентичными. -Изменение формата требует новой версии протокола и совместимых клиентов. +- Ключ аккаунта: ECDSA P-256, единый для устройств. Подписывает сертификаты + устройств и архив; его публичный отпечаток доступен в настройках. +- Ключи сессии устройства: ECDSA P-256 для сообщений и RSA-3072 для получения + случайного ключа содержимого. Ключ подписи каждого устройства остаётся локальным + и не экспортируется в архив. Используется существующий идентификатор UserSession, + отдельного постоянного идентификатора физического устройства пока нет. +- Резервный код: случайные 256 бит в Base64URL. Шифрует архив JWE dir/A256GCM; + код не передаётся серверу и не выводится из пароля входа. -## Устройства и доверие +MAUI SecureStorage хранит приватные ключи устройств, резервный код, ключ аккаунта, +архив ключей расшифровки и отпечатки известных аккаунтов. Область хранения разделена +по адресу сервера и пользователю. Пароль аккаунта сам по себе не восстанавливает +историю. При потере всех устройств и резервного кода восстановление невозможно. -Клиент генерирует отдельную пару ключей шифрования/подписи для каждой сессии. -Приватные ключи хранятся только в MAUI SecureStorage, раздельно для сервера, -аккаунта и сессии. Ключи предыдущих сессий остаются локально для чтения истории. -Ошибка записи или регистрации останавливает отправку; отката к открытому тексту нет. +Сервер хранит публичные ключи, сертификаты, номера поколений и зашифрованный архив. +В архив входят приватный ключ аккаунта, прежние RSA-ключи расшифровки с публичными +ключами подписи для вычисления отпечатков и известные ключи аккаунтов собеседников. +Приватные ключи подписи устройств в архив не входят. Ключи/имена/MIME вложений +восстанавливаются из содержимого расшифрованных сообщений. -Каждый новый отпечаток нужно сверить лично или по независимому доверенному -каналу. Приложение показывает свой отпечаток и отпечаток другого устройства. -Простое нажатие подтверждения без сверки не защищает от подстановки устройства -скомпрометированным сервером. Дополнительно подтверждается состав получателей -каждого чата при первом использовании и изменении списка устройств/участников. -Эти подтверждения хранятся локально, а не на сервере. +## Автоматическое доверие -Это не система прозрачности ключей и не подписанный участниками протокол -управления составом групп. Сервер остаётся источником списка участников и -статуса сессий. Если он скрывает изменения/отзыв устройств, это невозможно -независимо обнаружить без дополнительного протокола. Не следует заявлять -защиту уровня Signal/MLS или защиту от любых действий злонамеренного сервера. -До публичного релиза требуется независимый аудит протокола и интеграции. +Первый ключ аккаунта собеседника запоминается автоматически (TOFU). Сертификат +связывает UserId, SessionId, отпечаток устройства, поколение и предыдущий отпечаток +с этим ключом аккаунта. Новое устройство или ротация с тем же ключом аккаунта +не требуют ручной сверки. Подмена уже известного ключа аккаунта блокирует отправку +и отображение новых неподтверждённых данных. Автоматического сброса доверия нет; +безопасный UX намеренной замены ключа аккаунта — отдельная будущая функция. -## Серверные API +**Первая встреча доверяет каталогу сервера.** Прозрачности ключей нет. Состав группы +и право вступления по-прежнему сообщает сервер; состав не подписывается участниками. +Злонамеренный сервер способен подставить ключ при первой встрече или добавить +своего участника в группу. Удаление прежних диалогов сверки изменяет модель доверия; +эта версия не даёт полной защиты от активного злонамеренного сервера. +Для такой гарантии нужен отдельный протокол аутентификации состава групп +и прозрачности аккаунтов; для FS/PCS — проверенная реализация ratchet/MLS. +Не следует позиционировать эту реализацию как эквивалент Signal. -- `PUT /api/e2ee/device`: публичный `DeviceKey` текущего пользователя/сессии. - Повторная регистрация тех же ключей допустима; смена ключей внутри сессии - запрещена. Истёкшая или отозванная сессия не может регистрировать ключи. -- `GET /api/e2ee/conversations/{type}/{conversationId}/keys`: список участников - и зарегистрированных устройств; `type=0` — личный чат, `type=1` — группа. - Требуется доступ к чату. Возвращаются только публичные данные. -- SignalR `Send`/`Edit` и HTTP загрузки истории сохраняют существующие поля DTO. - `MessageEditResponse` дополнительно возвращает `ReplyToMessageId` для проверки - подписанного контекста редактирования. +## Ротация -Для офлайн-доставки устройства с истёкшей, но не отозванной сессией остаются -получателями. Отозванные сессии исключаются. При изменении набора устройств -необходимо заново получить ключи, подтвердить состав и перешифровать сообщение. -В группах это проверяется под существующей блокировкой модерации, чтобы бан -не мог гоняться с сохранением сообщения. Каждый отправляемый конверт получает -новый случайный ключ содержимого. Исключённый участник сохраняет доступ к уже -полученным сообщениям, но его ключ больше не включается в новые конверты. +Клиент проверяет возраст текущего RSA-ключа при использовании E2EE. Через семь суток +активности создаётся новый RSA-3072; ключ подписи устройства остаётся прежним. +У офлайн-устройства ротация происходит при следующем обращении к E2EE. -ID сообщения генерируется клиентом и подписывается. Повторная отправка того же -конверта не создаёт второй записи/задания push. Редактирование проверяет ID, -автора, чат, ответ, вложения и время версии. Клиент хранит принятые версии, -отклоняет откат к старой версии и проверяет подпись перед показом текста. +1. Новый ключ записывается в локальный журнал pending. +2. Старый и новый ключи включаются в зашифрованный архив, который сохраняется сервером. +3. Ключ аккаунта подписывает сертификат следующего поколения с предыдущим отпечатком. +4. Сервер проверяет владельца, сертификат, последовательность поколений и меняет + публичный RSA-ключ. Старый ключ исключается из будущих конвертов. +5. Клиент активирует сохранённый ключ и завершает журнал. При сбое повторяет тот же + ключ, а не генерирует ещё одно поколение. -## Вложения +Ключ содержимого AES-256-GCM новый у каждого сообщения; у каждого вложения также +свой случайный ключ и nonce. Новые личные сообщения и сообщения приватных групп +требуют E2EE на сервере. Клиент шифрует также публичные группы; сервер сохраняет +прежнюю совместимость с открытыми сообщениями публичных групп. -Клиент шифрует файл AES-256-GCM с новым случайным 32-байтовым ключом и 12-байтовым -nonce. Формат: `nonce || ciphertext || tag(16)`; AAD — `govor-attachment-v1`. -Сервер получает случайное имя `.bin`, тип `application/vnd.govor.encrypted` и -байты шифротекста. Исходное имя, MIME-тип и ключ передаются только внутри -зашифрованного сообщения. Поле `EncryptedKey` загрузки должно быть пустым. -Незашифрованные загрузки типа Message отклоняются; аватары остаются открытыми. +Отзыв сессии исключает её из новых получателей, но не отзывает уже прочитанное, +украденные секреты или ранее выгруженный архив. Резервный код и ключ аккаунта пока +не ротируются автоматически. После компрометации всего устройства недостаточно +обычной недельной ротации RSA; это требует отдельной процедуры восстановления +доверия, отзыва сессий и замены секретов аккаунта. -Получатель сначала проверяет и расшифровывает сообщение, сохраняет секреты -вложений локально, затем загружает и проверяет файл. Предельный размер исходного -файла — 19 MB, текста — 20 000 символов, устройств — 500, конверта — 1 000 000 -символов. Ограничения предотвращают неограниченный рост RSA-конверта. +## Архив и несколько устройств -## Обновление и ограничения +Каждая версия архива подписана ключом аккаунта; подпись связывает UserId, Revision, +IdentityKey и шифротекст. Внутри JWE также проверяются владелец и версия. Алгоритмы +зафиксированы; сервер проверяет публичную подпись, не расшифровывая содержимое. -1. Собрать и согласованно обновить сервер и клиенты всех участников. Старые - клиенты не смогут отправлять сообщения в защищаемые чаты. Автоматического - временного перехода на открытый текст нет. -2. Пользователям нужно войти в новый клиент для регистрации устройств. Пока - хотя бы у одного участника нет ключа, новый клиент блокирует отправку. -3. Сверить отпечатки и состав получателей. Проверить личный чат, приватную - группу/канал, редактирование, вложения, новое устройство и исключение участника - на реальных устройствах перед развёртыванием. +Обновление использует compare-and-swap по Revision. При конфликте клиент скачивает +актуальную версию, объединяет ключи и известные аккаунты, затем повторяет запись +(не более четырёх попыток). Ключ аккаунта на сервере неизменяем. Известная локально +версия запрещает откат архива; новое устройство без сохранённого номера версии +не способно доказать полноту истории при сокрытии последнего архива сервером. +Обычная синхронизация выполняется не чаще раза в минуту, а регистрация нового +ключа, ротация, запрос кода и отсутствие ключа истории вызывают немедленную синхронизацию. -Новая миграция БД не требуется: используются существующие таблицы CryptoSession -и SignedPreKey, в которых хранятся только публичные данные. Старые заготовки -Signal prekeys не превращаются автоматически в совместимые ключи JOSE; если -они уже были привязаны к сессии, нужна новая сессия. +Архив ограничен 4 000 000 символов JWE; имеются пределы 1500 ключей и 10 000 +закреплённых аккаунтов. При исчерпании лимита запись/ротация останавливаются; +молчаливого удаления ключей истории нет. Сегментированный архив не реализован. -Уже сохранённая открытая история и старые файлы не становятся секретными задним -числом. Они не удаляются; клиент помечает открытую историю `[Без E2EE]`. -При невозможности расшифровки показывается статус без шифротекста и вложений; -неуспешный результат не сохраняется вместо исходной записи локального кэша. +## HTTP API -Новый физический аппарат не получает прошлые ключи автоматически. После удаления -SecureStorage или потери устройства зашифрованная история без другого устройства -с нужными ключами недоступна. Серверного восстановления/экспорта ключей нет. -Локальный кэш сообщений пока хранит уже расшифрованный текст, как и раньше. +Все маршруты требуют действующую авторизацию; пользователь определяется из JWT. HTTPS обязателен для защиты авторизации и первоначального обмена публичными ключами. -В v1 нет forward secrecy/post-compromise security и Double Ratchet/MLS: -компрометация приватного ключа устройства позволяет расшифровать сохранённые -сообщения, адресованные этому ключу. Отзыв сессии исключает её из будущих -получателей; украденные ключи и уже прочитанные сообщения отозвать невозможно. -Метаданные, участники, размеры и время сообщений видны серверу. Скомпрометированное -устройство участника и копирование текста самим участником за пределами модели -защиты. HTTPS по-прежнему требуется для авторизации и защиты транспорта. +| Метод и маршрут | Назначение | +| --- | --- | +| PUT /api/e2ee/device | Регистрация/идемпотентный повтор/последовательная подписанная ротация текущей сессии | +| GET /api/e2ee/recovery | Архив только текущего аккаунта; { vault: null } до первой настройки | +| PUT /api/e2ee/recovery | ExpectedRevision, IdentityKey, Ciphertext, Signature; 409 при конфликте | +| GET /api/e2ee/devices | Публичные ключи всех собственных сессий, включая отозванные, для миграции истории | +| PUT /api/e2ee/devices/certificate | Добавление сертификата аккаунта к собственному историческому ключу; не меняет ключ и не возобновляет сессию | +| GET /api/e2ee/conversations/{type}/{id}/keys | Участники и неотозванные устройства чата, с проверкой доступа | +| GET /api/e2ee/conversations/{type}/{id}/signers/{session} | Сертификат исторического автора в доступном чате; проверяется наличие сообщения автора | -## Проверка +Нельзя зачислить новое устройство аккаунта с архивом без сертификата его ключа +аккаунта. Нельзя использовать сертификат для другого пользователя/сессии или +пропустить поколение. Изменение поколения использует EF concurrency token. +Истёкшие, но не отозванные сертифицированные сессии остаются получателями для офлайн-доставки. После настройки архива аккаунта его старые несертифицированные сессии исключаются из новых получателей до обновления этих устройств. Клиент не отправляет сообщения участникам без сертификата аккаунта. -```powershell -dotnet test tests/Govor.Server.Tests/Govor.Server.Tests.csproj -# В мобильном репозитории: -dotnet test Govor.Mobile.Tests/Govor.Mobile.Tests.csproj -dotnet build Govor.Mobile/Govor.Mobile.csproj -f net10.0-android -p:TargetFrameworks=net10.0-android -``` +## Обновление существующих установок -Тесты проверяют совместимость шифрования/расшифровки, подписи и контекст, -доступ посторонних, отзыв устройств, смену состава группы, версии сообщений, -секреты вложений, отказ сверки ключей и отказ записи приватного ключа. +1. Применить миграцию `20261024084524_E2eeRecoveryAndRotation` до обновления клиентов. + Сервер и клиенты должны обновляться согласованно. Старые клиенты не умеют + сертифицировать устройства аккаунта с настроенным восстановлением. +2. Открыть обновлённый клиент на устройстве, где ещё есть прежние ключи. Они входят + в архив до публикации нового ключа; сохранить предложенный резервный код. +3. На остальных устройствах ввести этот код и синхронизировать историю. Каждое + старое устройство с уникальными, ещё не выгруженными ключами должно обновиться + хотя бы один раз: отсутствующие приватные ключи сервер восстановить не может. +4. Перед использованием с реальными данными проверить новый вход, восстановление, + файлы, редактирование, группу, отзыв устройства и бан на физических устройствах. + +Для проверки подписей старых v1-сообщений клиент сертифицирует только те исторические +ключи, приватные ключи расшифровки которых уже есть в его локальном/восстановленном +архиве. Произвольные предложенные сервером старые устройства не сертифицируются. +Сертификат исторического ключа не отменяет его отзыв. Получатель связывает старую +подпись сообщения с сертификатом того же публичного ключа подписи и той же сессии. + +Открытая история остаётся помеченной `[Без E2EE]` и не становится секретной задним +числом. Локальный SQLite-кэш всё ещё содержит расшифрованный текст. Метаданные, +участники, время и размеры видны серверу; аватары, реакции и профиль не включены +в зашифрованное содержимое сообщения. При неподходящем коде, подмене архива, +недостающем ключе или ошибке хранения отката на открытый текст нет. + +## Проверка и источники + +Сервер: `dotnet test Govor.Server.slnx`. +Мобильные алгоритмы/сервисы: `dotnet test Govor.Mobile.Tests/Govor.Mobile.Tests.csproj`. +Android: `dotnet build Govor.Mobile/Govor.Mobile.csproj -f net10.0-android -p:TargetFrameworks=net10.0-android`. +Windows CNG требует обычного пользовательского профиля для импорта приватных ключей. +Серверные и мобильные копии E2eeProtocol/E2eeRecoveryProtocol должны совпадать +за исключением namespace; тесты проверяют сообщения, сертификаты, архив, права +доступа, конфликт версий, сбой ротации и восстановление на чистом хранилище. + +Перед публичным релизом необходим независимый аудит прикладного протокола и +интеграции. Спецификации для следующего этапа: +[Signal Sesame](https://signal.org/docs/specifications/sesame/), +[MLS RFC 9420](https://www.rfc-editor.org/rfc/rfc9420.html). diff --git a/tests/Govor.Server.Tests/Api/E2eeRecoveryHttpTests.cs b/tests/Govor.Server.Tests/Api/E2eeRecoveryHttpTests.cs new file mode 100644 index 0000000..50bf95d --- /dev/null +++ b/tests/Govor.Server.Tests/Api/E2eeRecoveryHttpTests.cs @@ -0,0 +1,39 @@ +using System.Net; +using System.Net.Http.Json; +using Govor.Application.E2ee; +using Govor.Domain.Models.Messages; + +namespace Govor.Server.Tests; + +public partial class ReadApiTests +{ + [Test] + public async Task RecoveryHttpEndpointsAuthenticateScopeArchivesAndValidateCertificates() + { + Assert.That((await _client.GetAsync("/api/e2ee/recovery")).StatusCode, Is.EqualTo(HttpStatusCode.Unauthorized)); + Authorize(); + Assert.That((await _client.GetFromJsonAsync("/api/e2ee/recovery"))!.Vault, Is.Null); + var identity = E2eeRecoveryProtocol.GenerateIdentity(); + var code = E2eeRecoveryProtocol.GenerateCode(); + var vault = E2eeRecoveryProtocol.Seal(_db.Bob, 1, identity, code, "history secret"); + var request = new SaveRecoveryVault(0, vault.IdentityKey, vault.Ciphertext, vault.Signature); + Assert.That((await _client.PutAsJsonAsync("/api/e2ee/recovery", request)).StatusCode, Is.EqualTo(HttpStatusCode.OK)); + Assert.That((await _client.PutAsJsonAsync("/api/e2ee/recovery", request)).StatusCode, Is.EqualTo(HttpStatusCode.Conflict)); + Assert.That((await _client.PutAsJsonAsync("/api/e2ee/recovery", request with { Signature = "AAAA" })).StatusCode, Is.EqualTo(HttpStatusCode.BadRequest)); + var restored = (await _client.GetFromJsonAsync("/api/e2ee/recovery"))!.Vault!; + Assert.That(E2eeRecoveryProtocol.Open(restored, _db.Bob, code), Is.EqualTo("history secret")); + var device = E2eeRecoveryProtocol.Certify(E2eeProtocol.PublicKey(E2eeProtocol.GenerateKeys(), _db.Bob, _session), identity); + Assert.That((await _client.PutAsJsonAsync("/api/e2ee/device", device)).StatusCode, Is.EqualTo(HttpStatusCode.OK)); + var own = await _client.GetFromJsonAsync("/api/e2ee/devices"); + Assert.That(own, Has.Length.EqualTo(1)); + Assert.That((await _client.PutAsJsonAsync("/api/e2ee/devices/certificate", device)).StatusCode, Is.EqualTo(HttpStatusCode.OK)); + Assert.That((await _client.PutAsJsonAsync("/api/e2ee/devices/certificate", device with { UserId = _db.Alice })).StatusCode, Is.EqualTo(HttpStatusCode.BadRequest)); + _db.Context.Messages.Add(new Message { Id = Guid.NewGuid(), SenderId = _db.Bob, RecipientId = _db.ChatId, + RecipientType = RecipientType.User, EncryptedContent = "legacy", SentAt = DateTime.UtcNow }); + await _db.Context.SaveChangesAsync(); + var signer = await _client.GetFromJsonAsync($"/api/e2ee/conversations/0/{_db.ChatId}/signers/{_session}"); + Assert.That(signer!.AccountIdentityKey, Is.EqualTo(device.AccountIdentityKey)); + Assert.That((await _client.GetAsync($"/api/e2ee/conversations/0/{Guid.NewGuid()}/signers/{_session}")).StatusCode, + Is.EqualTo(HttpStatusCode.Forbidden)); + } +} diff --git a/tests/Govor.Server.Tests/Security/E2eeRecoveryTests.cs b/tests/Govor.Server.Tests/Security/E2eeRecoveryTests.cs new file mode 100644 index 0000000..c5fbf44 --- /dev/null +++ b/tests/Govor.Server.Tests/Security/E2eeRecoveryTests.cs @@ -0,0 +1,138 @@ +using System.Security.Cryptography; +using Govor.Application.E2ee; +using Govor.Domain.Models.Messages; +using Govor.Domain.Models.Users; +using Microsoft.EntityFrameworkCore; + +namespace Govor.Server.Tests; + +[TestFixture] +public class E2eeRecoveryTests +{ + private TestDatabase _db = null!; + private E2eeService _service = null!; + private DevicePrivateKeys _keys = null!; + private DevicePrivateKeys _bobKeys = null!; + private string _identity = null!, _code = null!; + [OneTimeSetUp] + public void Keys() + { + _keys = E2eeProtocol.GenerateKeys(); + _bobKeys = E2eeProtocol.GenerateKeys(); + _identity = E2eeRecoveryProtocol.GenerateIdentity(); + _code = E2eeRecoveryProtocol.GenerateCode(); + } + [SetUp] public void Setup() { _db = new(); _service = new(_db.Context); } + [TearDown] public void Cleanup() => _db.Dispose(); + + private async Task Save(Guid user, long revision = 1, string? identity = null) + { + var vault = E2eeRecoveryProtocol.Seal(user, revision, identity ?? _identity, _code, "private archive"); + return await _service.SaveRecoveryAsync(user, new(revision - 1, vault.IdentityKey, vault.Ciphertext, vault.Signature)); + } + private async Task Device(Guid user) + { + var session = new UserSession { UserId = user, RefreshTokenHash = Guid.NewGuid().ToString(), ExpiresAt = DateTime.UtcNow.AddDays(30) }; + _db.Context.UserSessions.Add(session); + await _db.Context.SaveChangesAsync(); + return E2eeRecoveryProtocol.Certify(E2eeProtocol.PublicKey(user == _db.Bob ? _bobKeys : _keys, user, session.Id), _identity); + } + + [Test] + public async Task OnlyEncryptedArchiveIsStoredAndOtherAccountsCannotReadIt() + { + var saved = await Save(_db.Alice); + Assert.That(E2eeRecoveryProtocol.Open(saved, _db.Alice, _code), Is.EqualTo("private archive")); + var stored = await _db.Context.E2eeRecoveryVaults.SingleAsync(); + Assert.That(stored.Ciphertext, Does.Not.Contain("private archive").And.Not.Contain(_code).And.Not.Contain(_identity)); + Assert.That((await _service.GetRecoveryAsync(_db.Bob)).Vault, Is.Null); + Assert.Throws(() => E2eeRecoveryProtocol.Open(saved, _db.Bob, _code)); + Assert.Catch(() => E2eeRecoveryProtocol.Open(saved, _db.Alice, E2eeRecoveryProtocol.GenerateCode())); + } + + [Test] + public async Task ArchiveCompareAndSwapRejectsStaleWritesAndIdentityReplacement() + { + await Save(_db.Alice); + await Save(_db.Alice, 2); + Assert.ThrowsAsync(() => Save(_db.Alice, 2)); + Assert.ThrowsAsync(() => Save(_db.Alice, 3, E2eeRecoveryProtocol.GenerateIdentity())); + Assert.That((await _service.GetRecoveryAsync(_db.Alice)).Vault!.Revision, Is.EqualTo(2)); + } + + [Test] + public async Task DeviceEnrollmentRequiresAccountCertificateAndCannotReuseItForAnotherSession() + { + await Save(_db.Alice); + var device = await Device(_db.Alice); + await _service.RegisterAsync(_db.Alice, device.SessionId, device); + var second = await Device(_db.Alice); + Assert.ThrowsAsync(() => _service.RegisterAsync(_db.Alice, second.SessionId, + device with { SessionId = second.SessionId })); + var wrongRoot = E2eeRecoveryProtocol.Certify(second, E2eeRecoveryProtocol.GenerateIdentity()); + Assert.ThrowsAsync(() => _service.RegisterAsync(_db.Alice, second.SessionId, wrongRoot)); + Assert.ThrowsAsync(() => _service.RegisterAsync(_db.Alice, second.SessionId, + E2eeProtocol.PublicKey(_keys, _db.Alice, second.SessionId))); + } + + [Test] + public async Task ConsecutiveRotationIsIdempotentAndOldRecipientKeysAreExcluded() + { + await Save(_db.Alice); await Save(_db.Bob); + var a = await Device(_db.Alice); var b = await Device(_db.Bob); + await _service.RegisterAsync(_db.Alice, a.SessionId, a); + await _service.RegisterAsync(_db.Bob, b.SessionId, b); + var before = await _service.GetConversationKeysAsync(_db.Alice, _db.ChatId, RecipientType.User); + var oldContent = E2eeProtocol.Encrypt(new("before", []), _keys, a, before, Guid.NewGuid()); + var generated = E2eeProtocol.GenerateKeys(); + var rotatedPrivate = new DevicePrivateKeys(_bobKeys.IdentityKey, generated.EncryptionKey); + var rotated = E2eeRecoveryProtocol.Certify(E2eeProtocol.PublicKey(rotatedPrivate, _db.Bob, b.SessionId), _identity, 1, b.Fingerprint); + Assert.ThrowsAsync(() => _service.RegisterAsync(_db.Bob, b.SessionId, + E2eeRecoveryProtocol.Certify(rotated, _identity, 2, b.Fingerprint))); + await _service.RegisterAsync(_db.Bob, b.SessionId, rotated); + await _service.RegisterAsync(_db.Bob, b.SessionId, rotated); + var after = await _service.GetConversationKeysAsync(_db.Alice, _db.ChatId, RecipientType.User); + Assert.That(after.Devices.Select(d => d.Fingerprint), Does.Not.Contain(b.Fingerprint)); + Assert.ThrowsAsync(() => _service.ValidateAsync(oldContent, _db.Alice, _db.ChatId, RecipientType.User, null, [])); + var encrypted = E2eeProtocol.Encrypt(new("after", []), _keys, a, after, Guid.NewGuid()); + Assert.That(E2eeProtocol.Decrypt(encrypted, rotatedPrivate, E2eeProtocol.Inspect(encrypted).MessageId, + _db.ChatId, 0, _db.Alice).Text, Is.EqualTo("after")); + } + + [Test] + public async Task TamperedArchiveCannotBeSavedOrReassignedToAnotherAccount() + { + var saved = await Save(_db.Alice); + Assert.ThrowsAsync(() => _service.SaveRecoveryAsync(_db.Bob, + new(0, saved.IdentityKey, saved.Ciphertext, saved.Signature))); + Assert.ThrowsAsync(() => _service.SaveRecoveryAsync(_db.Alice, + new(1, saved.IdentityKey, saved.Ciphertext + "x", saved.Signature))); + } + + [Test] + public async Task LegacyDeviceCanUpgradeItsExistingKeyWithoutLosingHistory() + { + var device = await Device(_db.Alice); + var legacy = E2eeProtocol.PublicKey(_keys, _db.Alice, device.SessionId); + await _service.RegisterAsync(_db.Alice, device.SessionId, legacy); + await Save(_db.Alice); + await _service.RegisterAsync(_db.Alice, device.SessionId, device); + var stored = await _db.Context.UserCryptoSessions.SingleAsync(); + Assert.That(stored.AccountIdentityKey, Is.EqualTo(device.AccountIdentityKey)); + Assert.That(Convert.ToBase64String(stored.PublicIdentityKey), Is.EqualTo(legacy.IdentityKey)); + } + + [Test] + public async Task UncertifiedLegacySessionIsNotARecipientAfterAccountUpgrade() + { + var old = await Device(_db.Alice); + await _service.RegisterAsync(_db.Alice, old.SessionId, E2eeProtocol.PublicKey(_keys, _db.Alice, old.SessionId)); + await Save(_db.Alice); await Save(_db.Bob); + var current = await Device(_db.Alice); var bob = await Device(_db.Bob); + await _service.RegisterAsync(_db.Alice, current.SessionId, current); + await _service.RegisterAsync(_db.Bob, bob.SessionId, bob); + var directory = await _service.GetConversationKeysAsync(_db.Alice, _db.ChatId, RecipientType.User); + Assert.That(directory.Devices.Select(d => d.SessionId), Does.Not.Contain(old.SessionId)); + Assert.That(directory.Devices.Select(d => d.SessionId), Does.Contain(current.SessionId)); + } +}