Files
Artemy 31d704712c Expose chat read positions and E2EE errors
Add optional chat activity and read-position details to the unread-count endpoint. Return stable E2EE rejection codes for stale timestamps and untrusted signing devices, with tests for both behaviors.
2026-11-15 21:26:00 +07:00

346 lines
19 KiB
C#

using System.Security.Cryptography;
using System.Text;
using Govor.Application.E2ee;
using Govor.Application.Messages;
using Govor.Application.Messages.Parameters;
using Govor.Domain.Models;
using Govor.Domain.Models.Messages;
using Govor.Domain.Models.Users;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging.Abstractions;
using NUnit.Framework;
namespace Govor.Server.Tests;
[TestFixture]
public class E2eeTests
{
private DevicePrivateKeys _alice = null!, _bob = null!, _other = null!;
private TestDatabase _db = null!;
private E2eeService _e2ee = null!;
private DeviceKey _a = null!, _b = null!;
[OneTimeSetUp]
public void Keys() { _alice = E2eeProtocol.GenerateKeys(); _bob = E2eeProtocol.GenerateKeys(); _other = E2eeProtocol.GenerateKeys(); }
[SetUp]
public async Task SetUp()
{
_db = new TestDatabase();
_e2ee = new E2eeService(_db.Context);
_a = await Register(_db.Alice, _alice);
_b = await Register(_db.Bob, _bob);
}
[TearDown] public void Cleanup() => _db.Dispose();
private async Task<DeviceKey> Register(Guid user, DevicePrivateKeys keys)
{
var session = new UserSession { UserId = user, RefreshTokenHash = Guid.NewGuid().ToString(), ExpiresAt = DateTime.UtcNow.AddDays(30) };
_db.Context.UserSessions.Add(session);
await _db.Context.SaveChangesAsync();
var key = E2eeProtocol.PublicKey(keys, user, session.Id);
await _e2ee.RegisterAsync(user, session.Id, key);
return key;
}
private async Task<string> Encrypt(Guid? id = null, bool edit = false, Guid? conversation = null, int type = 0,
AttachmentSecret[]? attachments = null) => E2eeProtocol.Encrypt(new("секретное сообщение", attachments ?? []),
_alice, _a, await _e2ee.GetConversationKeysAsync(_db.Alice, conversation ?? _db.ChatId, (RecipientType)type),
id ?? Guid.NewGuid(), isEdit: edit);
[Test]
public async Task EveryParticipantNeedsARegisteredDeviceAndDeviceCountIsBounded()
{
await _db.Context.UserCryptoSessions.Where(c => c.UserSessionId == _b.SessionId).ExecuteDeleteAsync();
Assert.ThrowsAsync<InvalidOperationException>(() => _e2ee.GetConversationKeysAsync(_db.Alice, _db.ChatId, RecipientType.User));
_b = await Register(_db.Bob, _bob);
Assert.That((await _e2ee.GetConversationKeysAsync(_db.Alice, _db.ChatId, RecipientType.User)).Devices, Has.Length.EqualTo(2));
for (var i = 0; i < E2eeProtocol.MaxDevices; i++)
{
var session = new UserSession { UserId = _db.Alice, RefreshTokenHash = "limit-" + i, ExpiresAt = DateTime.UtcNow.AddDays(1) };
var cryptoId = Guid.NewGuid();
_db.Context.UserCryptoSessions.Add(new Govor.Domain.Models.Users.Crypto.UserCryptoSession
{
Id = cryptoId, UserSession = session, UserSessionId = session.Id,
PublicIdentityKey = Convert.FromBase64String(_a.IdentityKey),
SignedPreKey = new Govor.Domain.Models.Users.Crypto.SignedPreKey
{
Id = Guid.NewGuid(), UserCryptoSessionId = cryptoId,
PublicSignedPreKey = Convert.FromBase64String(_a.EncryptionKey), SignedPreKeySignature = Convert.FromBase64String(_a.Signature)
},
OneTimePreKeys = []
});
}
await _db.Context.SaveChangesAsync();
var limitError = Assert.ThrowsAsync<InvalidOperationException>(() => _e2ee.GetConversationKeysAsync(_db.Alice, _db.ChatId, RecipientType.User));
Assert.That(limitError!.Message, Does.Contain("Too many E2EE devices"));
}
[TestCase(false)]
[TestCase(true)]
public async Task ExpiredOrRevokedSessionCannotRegisterKeys(bool revoked)
{
await _db.Context.UserSessions.Where(s => s.Id == _a.SessionId).ExecuteUpdateAsync(s => s
.SetProperty(s => s.IsRevoked, revoked).SetProperty(s => s.ExpiresAt, DateTime.UtcNow.AddDays(revoked ? 1 : -1)));
Assert.ThrowsAsync<UnauthorizedAccessException>(() => _e2ee.RegisterAsync(_db.Alice, _a.SessionId, _a));
Assert.ThrowsAsync<UnauthorizedAccessException>(() => _e2ee.RegisterAsync(_db.Alice, Guid.NewGuid(), _a));
}
[TestCase("malformed")]
[TestCase("routing")]
[TestCase("stale")]
[TestCase("future")]
public async Task InvalidEnvelopeContextIsReturnedAsValidationFailure(string reason)
{
var directory = await _e2ee.GetConversationKeysAsync(_db.Alice, _db.ChatId, RecipientType.User);
var content = reason == "malformed" ? E2eeProtocol.Prefix + "invalid" : E2eeProtocol.Encrypt(new("secret", []),
_alice, _a, directory, Guid.NewGuid(), createdAt: DateTimeOffset.UtcNow.AddMinutes(reason switch
{ "stale" => -6, "future" => 6, _ => 0 }).ToUnixTimeMilliseconds());
var failure = Assert.ThrowsAsync<ArgumentException>(() => _e2ee.ValidateAsync(content, reason == "routing" ? _db.Bob : _db.Alice,
_db.ChatId, RecipientType.User, null, []));
if (reason is "stale" or "future")
Assert.That(failure!.Message, Is.EqualTo(E2eeProtocol.TimestampOutOfRangeError));
}
[TestCase(false)]
[TestCase(true)]
public async Task EncryptedMessageRejectsPlaintextAttachmentAndLeakedKey(bool leakedKey)
{
var mediaId = Guid.NewGuid();
_db.Context.MediaFiles.Add(new MediaFile { Id = mediaId, UploaderId = _db.Alice, OwnerType = MediaOwnerType.Message,
Url = "attachment.bin", MineType = leakedKey ? E2eeProtocol.EncryptedMimeType : "image/png" });
await _db.Context.SaveChangesAsync();
var content = await Encrypt(attachments: [new(mediaId, "secret", "attachment.png", "image/png")]);
var result = await new MessageSendingService(_db.Context, NullLogger<MessageSendingService>.Instance).SendMessageAsync(
new(content, null, _db.ChatId, RecipientType.User, _db.Alice, DateTime.UtcNow, [new(mediaId, leakedKey ? "leaked" : "")]));
Assert.That(result.IsSuccess, Is.False);
Assert.That(result.Exception, Is.TypeOf<ArgumentException>());
Assert.That(await _db.Context.Messages.CountAsync(), Is.Zero);
Assert.That(await _db.Context.ChatPushNotifications.CountAsync(), Is.Zero);
}
[Test]
public async Task BothParticipantsCanDecryptButServerAndOutsiderCannot()
{
var ciphertext = await Encrypt();
var envelope = E2eeProtocol.Verify(ciphertext);
foreach (var keys in new[] { _alice, _bob })
Assert.That(E2eeProtocol.Decrypt(ciphertext, keys, envelope.MessageId, _db.ChatId, 0, _db.Alice).Text,
Is.EqualTo("секретное сообщение"));
Assert.Throws<CryptographicException>(() => E2eeProtocol.Decrypt(ciphertext, _other,
envelope.MessageId, _db.ChatId, 0, _db.Alice));
Assert.That(ciphertext, Does.Not.Contain("секретное сообщение"));
}
[Test]
public async Task ServerPersistsOnlyCiphertextAndRetriesAreIdempotent()
{
var ciphertext = await Encrypt();
var sender = new MessageSendingService(_db.Context, NullLogger<MessageSendingService>.Instance);
var request = new SendMessage(ciphertext, null, _db.ChatId, RecipientType.User, _db.Alice, DateTime.UtcNow, []);
Assert.That((await sender.SendMessageAsync(request)).IsSuccess, Is.True);
Assert.That((await sender.SendMessageAsync(request)).IsSuccess, Is.True);
Assert.That(await _db.Context.Messages.CountAsync(), Is.EqualTo(1));
Assert.That((await _db.Context.Messages.SingleAsync()).EncryptedContent, Is.EqualTo(ciphertext));
Assert.That(await _db.Context.ChatPushNotifications.CountAsync(), Is.EqualTo(1));
}
[Test]
public async Task PlaintextIsRejectedForPrivateChats()
{
var sender = new MessageSendingService(_db.Context, NullLogger<MessageSendingService>.Instance);
var result = await sender.SendMessageAsync(new("hello", null, _db.ChatId, RecipientType.User,
_db.Alice, DateTime.UtcNow, []));
Assert.That(result.IsSuccess, Is.False);
Assert.That(await _db.Context.Messages.CountAsync(), Is.Zero);
}
[Test]
public async Task ForwardRequiresFreshEncryptionForDestinationAndRetryKeepsAttribution()
{
var sender = new MessageSendingService(_db.Context, NullLogger<MessageSendingService>.Instance);
var source = await sender.SendMessageAsync(new(await Encrypt(), null, _db.ChatId, RecipientType.User, _db.Alice, DateTime.UtcNow, []));
var destination = Guid.NewGuid();
_db.Context.PrivateChats.Add(new PrivateChat { Id = destination, UserAId = _db.Alice, UserBId = _db.Outsider });
await _db.Context.SaveChangesAsync();
await Register(_db.Outsider, _other);
var replay = await sender.SendMessageAsync(new(source.Message.EncryptedContent, null, destination,
RecipientType.User, _db.Alice, DateTime.UtcNow, [], source.Message.Id));
Assert.That(replay.IsSuccess, Is.False);
var ciphertext = await Encrypt(conversation: destination);
var request = new SendMessage(ciphertext, null, destination, RecipientType.User, _db.Alice, DateTime.UtcNow, [], source.Message.Id);
var forwarded = await sender.SendMessageAsync(request);
Assert.That(forwarded.IsSuccess, Is.True);
Assert.That(forwarded.Message.ForwardedFromMessageId, Is.EqualTo(source.Message.Id));
Assert.That((await sender.SendMessageAsync(request)).Message.Id, Is.EqualTo(forwarded.Message.Id));
Assert.That((await sender.SendMessageAsync(request with { ForwardedFromMessageId = null })).IsSuccess, Is.False);
Assert.That(E2eeProtocol.Decrypt(ciphertext, _other, forwarded.Message.Id, destination, 0, _db.Alice).Text,
Is.EqualTo("секретное сообщение"));
Assert.Throws<CryptographicException>(() => E2eeProtocol.Decrypt(ciphertext, _bob, forwarded.Message.Id, destination, 0, _db.Alice));
Assert.That(await _db.Context.Messages.CountAsync(), Is.EqualTo(2));
}
[Test]
public async Task EncryptedReplyBindsReplyTargetToSignedEnvelope()
{
var sender = new MessageSendingService(_db.Context, NullLogger<MessageSendingService>.Instance);
var source = await sender.SendMessageAsync(new(await Encrypt(), null, _db.ChatId, RecipientType.User, _db.Alice, DateTime.UtcNow, []));
var ciphertext = E2eeProtocol.Encrypt(new("ответ", []), _bob, _b,
await _e2ee.GetConversationKeysAsync(_db.Bob, _db.ChatId, RecipientType.User), Guid.NewGuid(), replyTo: source.Message.Id);
var request = new SendMessage(ciphertext, source.Message.Id, _db.ChatId, RecipientType.User, _db.Bob, DateTime.UtcNow, []);
Assert.That((await sender.SendMessageAsync(request with { ReplyToMessageId = null })).IsSuccess, Is.False);
var sent = await sender.SendMessageAsync(request);
Assert.That(sent.IsSuccess, Is.True);
Assert.That(sent.Message.ReplyToMessageId, Is.EqualTo(source.Message.Id));
}
[Test]
public async Task NewDeviceMakesOldRecipientManifestInvalid()
{
var ciphertext = await Encrypt();
await Register(_db.Bob, _other);
Assert.ThrowsAsync<ArgumentException>(() => _e2ee.ValidateAsync(ciphertext,
_db.Alice, _db.ChatId, RecipientType.User, null, []));
}
[Test]
public async Task RevokedSigningDeviceCannotSend()
{
var ciphertext = await Encrypt();
await _db.Context.UserSessions.Where(s => s.Id == _a.SessionId)
.ExecuteUpdateAsync(u => u.SetProperty(s => s.IsRevoked, true));
var failure = Assert.ThrowsAsync<UnauthorizedAccessException>(() => _e2ee.ValidateAsync(ciphertext,
_db.Alice, _db.ChatId, RecipientType.User, null, []));
Assert.That(failure!.Message, Is.EqualTo(E2eeProtocol.SigningDeviceRejectedError));
}
[Test]
public async Task ExpiredOfflineDeviceStillReceivesFutureMessages()
{
await _db.Context.UserSessions.Where(s => s.Id == _b.SessionId)
.ExecuteUpdateAsync(u => u.SetProperty(s => s.ExpiresAt, DateTime.UtcNow.AddDays(-1)));
var ciphertext = await Encrypt();
var envelope = E2eeProtocol.Verify(ciphertext);
Assert.That(E2eeProtocol.Decrypt(ciphertext, _bob, envelope.MessageId, _db.ChatId, 0, _db.Alice).Text,
Is.EqualTo("секретное сообщение"));
}
[Test]
public async Task KeysAreIdempotentImmutableAndOwnedBySession()
{
await _e2ee.RegisterAsync(_db.Alice, _a.SessionId, _a);
Assert.ThrowsAsync<UnauthorizedAccessException>(() => _e2ee.RegisterAsync(_db.Bob, _a.SessionId, _a));
var replacement = E2eeProtocol.PublicKey(_other, _db.Alice, _a.SessionId);
Assert.ThrowsAsync<InvalidOperationException>(() => _e2ee.RegisterAsync(_db.Alice, _a.SessionId, replacement));
}
[Test]
public async Task OutsiderCannotRetrieveConversationKeys() =>
Assert.ThrowsAsync<UnauthorizedAccessException>(() => _e2ee.GetConversationKeysAsync(_db.Outsider, _db.ChatId, RecipientType.User));
[Test]
public async Task InvalidKeyBindingIsRejected()
{
var invalid = _a with { EncryptionKey = _b.EncryptionKey };
Assert.Throws<CryptographicException>(() => E2eeProtocol.ValidatePublicKey(invalid));
Assert.ThrowsAsync<CryptographicException>(() => _e2ee.RegisterAsync(_db.Alice, _a.SessionId, invalid));
}
[Test]
public async Task SignedMessageCannotBeMovedToAnotherAuthorChatReplyOrId()
{
var ciphertext = await Encrypt();
var envelope = E2eeProtocol.Verify(ciphertext);
Assert.Throws<CryptographicException>(() => E2eeProtocol.Decrypt(ciphertext, _bob, Guid.NewGuid(), _db.ChatId, 0, _db.Alice));
Assert.Throws<CryptographicException>(() => E2eeProtocol.Decrypt(ciphertext, _bob, envelope.MessageId, Guid.NewGuid(), 0, _db.Alice));
Assert.Throws<CryptographicException>(() => E2eeProtocol.Decrypt(ciphertext, _bob, envelope.MessageId, _db.ChatId, 0, _db.Outsider));
Assert.Throws<CryptographicException>(() => E2eeProtocol.Decrypt(ciphertext, _bob, envelope.MessageId, _db.ChatId, 0, _db.Alice, Guid.NewGuid()));
}
[Test]
public async Task TamperingWithSignedPayloadFails()
{
var ciphertext = await Encrypt();
var parts = ciphertext[E2eeProtocol.Prefix.Length..].Split('.');
var json = Encoding.UTF8.GetString(Jose.Base64Url.Decode(parts[1]));
parts[1] = Jose.Base64Url.Encode(Encoding.UTF8.GetBytes(json.Replace(_db.Alice.ToString(), _db.Outsider.ToString())));
Assert.Catch(() => E2eeProtocol.Verify(E2eeProtocol.Prefix + string.Join('.', parts)));
}
[Test]
public async Task ExcludedMemberCannotDecryptNewGroupMessagesAndStaleSendIsRejected()
{
var group = new ChatGroup { Id = Guid.NewGuid(), Name = "private", Description = "", IsPrivate = true };
_db.Context.ChatGroups.Add(group);
foreach (var user in new[] { _db.Alice, _db.Bob })
_db.Context.GroupMemberships.Add(new GroupMembership { Id = Guid.NewGuid(), GroupId = group.Id, UserId = user });
await _db.Context.SaveChangesAsync();
var old = await Encrypt(conversation: group.Id, type: 1);
await _db.Context.GroupMemberships.Where(m => m.GroupId == group.Id && m.UserId == _db.Bob)
.ExecuteUpdateAsync(u => u.SetProperty(m => m.IsBanned, true));
Assert.ThrowsAsync<ArgumentException>(() => _e2ee.ValidateAsync(old, _db.Alice, group.Id, RecipientType.Group, null, []));
var current = await Encrypt(conversation: group.Id, type: 1);
Assert.Catch(() => E2eeProtocol.Decrypt(current, _bob, E2eeProtocol.Inspect(current).MessageId, group.Id, 1, _db.Alice));
}
[Test]
public void AttachmentIsAuthenticatedAndWrongKeyOrModifiedDataFails()
{
var original = Encoding.UTF8.GetBytes("private attachment bytes");
var (encrypted, key) = E2eeProtocol.EncryptAttachment(original);
Assert.That(E2eeProtocol.DecryptAttachment(encrypted, key), Is.EqualTo(original));
Assert.Catch(() => E2eeProtocol.DecryptAttachment(encrypted, Convert.ToBase64String(RandomNumberGenerator.GetBytes(32))));
encrypted[15] ^= 1;
Assert.Catch(() => E2eeProtocol.DecryptAttachment(encrypted, key));
}
[Test]
public async Task AttachmentKeyExistsOnlyInsideEncryptedPayload()
{
var (_, key) = E2eeProtocol.EncryptAttachment("secret"u8.ToArray());
var media = new AttachmentSecret(Guid.NewGuid(), key, "secret.png", "image/png");
var ciphertext = await Encrypt(attachments: [media]);
Assert.That(ciphertext, Does.Not.Contain(key).And.Not.Contain("secret.png"));
var plaintext = E2eeProtocol.Decrypt(ciphertext, _bob, E2eeProtocol.Inspect(ciphertext).MessageId, _db.ChatId, 0, _db.Alice);
Assert.That(plaintext.Attachments.Single(), Is.EqualTo(media));
}
[Test]
public async Task EncryptedEditIsAcceptedButPlaintextAndOlderEditsAreRejected()
{
var first = await Encrypt();
var sender = new MessageSendingService(_db.Context, NullLogger<MessageSendingService>.Instance);
var sent = await sender.SendMessageAsync(new(first, null, _db.ChatId, RecipientType.User, _db.Alice, DateTime.UtcNow, []));
var editor = new MessageEditingService(_db.Context, NullLogger<MessageEditingService>.Instance,
Microsoft.Extensions.Options.Options.Create(new MessageEditingOptions { Enabled = false }));
var directory = await _e2ee.GetConversationKeysAsync(_db.Alice, _db.ChatId, RecipientType.User);
var edited = E2eeProtocol.Encrypt(new("edited secret", []), _alice, _a, directory, sent.Message.Id,
isEdit: true, createdAt: E2eeProtocol.Inspect(first).CreatedAt + 1);
var result = await editor.EditMessageAsync(new(_db.Alice, sent.Message.Id, edited, DateTime.UtcNow));
Assert.That(result.IsSuccess, Is.True);
var plaintext = await editor.EditMessageAsync(new(_db.Alice, sent.Message.Id, "leak", DateTime.UtcNow));
Assert.That(plaintext.IsSuccess, Is.False);
var replay = await editor.EditMessageAsync(new(_db.Alice, sent.Message.Id, edited, DateTime.UtcNow));
Assert.That(replay.IsSuccess, Is.False);
Assert.That((await _db.Context.Messages.SingleAsync()).EncryptedContent, Is.EqualTo(edited));
}
[Test]
public async Task PlaintextIsRejectedForPrivateGroupsAndChannels()
{
foreach (var channel in new[] { false, true })
{
var group = new ChatGroup { Id = Guid.NewGuid(), Name = "private", Description = "",
IsPrivate = true, IsChannel = channel, OwnerUserId = _db.Alice };
_db.Context.ChatGroups.Add(group);
_db.Context.GroupMemberships.Add(new GroupMembership { Id = Guid.NewGuid(), GroupId = group.Id, UserId = _db.Alice });
await _db.Context.SaveChangesAsync();
var sender = new MessageSendingService(_db.Context, NullLogger<MessageSendingService>.Instance);
Assert.That((await sender.SendMessageAsync(new("plaintext", null, group.Id,
RecipientType.Group, _db.Alice, DateTime.UtcNow, []))).IsSuccess, Is.False);
}
Assert.That(await _db.Context.Messages.CountAsync(), Is.Zero);
}
}