mirror of
https://github.com/Govor-team/Govor.git
synced 2026-11-16 20:56:03 +00:00
Add E2EE recovery and device rotation
Add signed, encrypted recovery archives with revision checks, account-certified device enrollment and key rotation, and historical signer lookup. Include the database migration, API endpoints, tests, and updated E2EE documentation.
This commit is contained in:
@@ -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<IActionResult> Recovery() => Ok(await e2ee.GetRecoveryAsync(user.GetCurrentUserId()));
|
||||
|
||||
[HttpGet("devices")]
|
||||
public async Task<IActionResult> Devices() => Ok(await e2ee.GetOwnDevicesAsync(user.GetCurrentUserId()));
|
||||
|
||||
[HttpPut("devices/certificate")]
|
||||
public async Task<IActionResult> 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<IActionResult> 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<IActionResult> 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."); }
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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<ArchivePayload>(
|
||||
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);
|
||||
}
|
||||
@@ -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<OneTimePreKey>()
|
||||
};
|
||||
context.UserCryptoSessions.Add(crypto);
|
||||
ApplyCertificate(crypto, key);
|
||||
session.CryptoSession = crypto;
|
||||
await context.SaveChangesAsync();
|
||||
}
|
||||
|
||||
public async Task<RecoveryState> 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<RecoveryVault> 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<DeviceKey[]> 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<DeviceKey?> 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<EncryptedMessage?> 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
|
||||
};
|
||||
}
|
||||
|
||||
@@ -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<E2eeRecoveryVault>
|
||||
{
|
||||
public void Configure(EntityTypeBuilder<E2eeRecoveryVault> 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<User>().WithOne().HasForeignKey<E2eeRecoveryVault>(v => v.UserId).OnDelete(DeleteBehavior.Cascade);
|
||||
}
|
||||
}
|
||||
@@ -9,6 +9,10 @@ public class UserCryptoSessionConfiguration : IEntityTypeConfiguration<UserCrypt
|
||||
public void Configure(EntityTypeBuilder<UserCryptoSession> 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<UserCrypt
|
||||
builder.Property(ucs => ucs.PublicIdentityKey)
|
||||
.IsRequired();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -14,6 +14,7 @@ public class GovorDbContext(DbContextOptions<GovorDbContext> options) : DbContex
|
||||
public virtual DbSet<UserSession> UserSessions { get; set; }
|
||||
public virtual DbSet<UserPushToken> UserPushTokens { get; set; }
|
||||
public virtual DbSet<UserCryptoSession> UserCryptoSessions { get; set; }
|
||||
public virtual DbSet<E2eeRecoveryVault> E2eeRecoveryVaults { get; set; }
|
||||
public virtual DbSet<SignedPreKey> SignedPreKeys { get; set; }
|
||||
public virtual DbSet<OneTimePreKey> OneTimePreKeys { get; set; }
|
||||
public virtual DbSet<Friendship> Friendships { get; set; }
|
||||
@@ -41,6 +42,7 @@ public class GovorDbContext(DbContextOptions<GovorDbContext> options) : DbContex
|
||||
|
||||
protected override void OnModelCreating(ModelBuilder modelBuilder)
|
||||
{
|
||||
modelBuilder.ApplyConfiguration(new E2eeRecoveryVaultConfiguration());
|
||||
modelBuilder.ApplyConfiguration(new UserSessionConfiguration());
|
||||
modelBuilder.ApplyConfiguration(new FriendshipConfiguration());
|
||||
modelBuilder.ApplyConfiguration(new UserConfiguration());
|
||||
|
||||
+1407
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,87 @@
|
||||
using System;
|
||||
using Microsoft.EntityFrameworkCore.Migrations;
|
||||
|
||||
#nullable disable
|
||||
|
||||
namespace Govor.Domain.Migrations
|
||||
{
|
||||
/// <inheritdoc />
|
||||
public partial class E2eeRecoveryAndRotation : Migration
|
||||
{
|
||||
/// <inheritdoc />
|
||||
protected override void Up(MigrationBuilder migrationBuilder)
|
||||
{
|
||||
migrationBuilder.AddColumn<string>(
|
||||
name: "AccountIdentityKey",
|
||||
table: "UserCryptoSessions",
|
||||
type: "character varying(200)",
|
||||
maxLength: 200,
|
||||
nullable: true);
|
||||
|
||||
migrationBuilder.AddColumn<string>(
|
||||
name: "AccountSignature",
|
||||
table: "UserCryptoSessions",
|
||||
type: "character varying(100)",
|
||||
maxLength: 100,
|
||||
nullable: true);
|
||||
|
||||
migrationBuilder.AddColumn<long>(
|
||||
name: "Generation",
|
||||
table: "UserCryptoSessions",
|
||||
type: "bigint",
|
||||
nullable: false,
|
||||
defaultValue: 0L);
|
||||
|
||||
migrationBuilder.AddColumn<string>(
|
||||
name: "PreviousFingerprint",
|
||||
table: "UserCryptoSessions",
|
||||
type: "character varying(64)",
|
||||
maxLength: 64,
|
||||
nullable: true);
|
||||
|
||||
migrationBuilder.CreateTable(
|
||||
name: "E2eeRecoveryVaults",
|
||||
columns: table => new
|
||||
{
|
||||
UserId = table.Column<Guid>(type: "uuid", nullable: false),
|
||||
Revision = table.Column<long>(type: "bigint", nullable: false),
|
||||
IdentityKey = table.Column<string>(type: "character varying(200)", maxLength: 200, nullable: false),
|
||||
Ciphertext = table.Column<string>(type: "character varying(4000000)", maxLength: 4000000, nullable: false),
|
||||
Signature = table.Column<string>(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);
|
||||
});
|
||||
}
|
||||
|
||||
/// <inheritdoc />
|
||||
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");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -797,6 +797,35 @@ namespace Govor.Domain.Migrations
|
||||
b.ToTable("Admins");
|
||||
});
|
||||
|
||||
modelBuilder.Entity("Govor.Domain.Models.Users.Crypto.E2eeRecoveryVault", b =>
|
||||
{
|
||||
b.Property<Guid>("UserId")
|
||||
.HasColumnType("uuid");
|
||||
|
||||
b.Property<string>("Ciphertext")
|
||||
.IsRequired()
|
||||
.HasMaxLength(4000000)
|
||||
.HasColumnType("character varying(4000000)");
|
||||
|
||||
b.Property<string>("IdentityKey")
|
||||
.IsRequired()
|
||||
.HasMaxLength(200)
|
||||
.HasColumnType("character varying(200)");
|
||||
|
||||
b.Property<long>("Revision")
|
||||
.IsConcurrencyToken()
|
||||
.HasColumnType("bigint");
|
||||
|
||||
b.Property<string>("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<Guid>("Id")
|
||||
@@ -858,6 +887,22 @@ namespace Govor.Domain.Migrations
|
||||
.ValueGeneratedOnAdd()
|
||||
.HasColumnType("uuid");
|
||||
|
||||
b.Property<string>("AccountIdentityKey")
|
||||
.HasMaxLength(200)
|
||||
.HasColumnType("character varying(200)");
|
||||
|
||||
b.Property<string>("AccountSignature")
|
||||
.HasMaxLength(100)
|
||||
.HasColumnType("character varying(100)");
|
||||
|
||||
b.Property<long>("Generation")
|
||||
.IsConcurrencyToken()
|
||||
.HasColumnType("bigint");
|
||||
|
||||
b.Property<string>("PreviousFingerprint")
|
||||
.HasMaxLength(64)
|
||||
.HasColumnType("character varying(64)");
|
||||
|
||||
b.Property<byte[]>("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")
|
||||
|
||||
@@ -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; } = "";
|
||||
}
|
||||
@@ -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<OneTimePreKey> OneTimePreKeys { get; set; }
|
||||
|
||||
+136
-108
@@ -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).
|
||||
|
||||
@@ -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<RecoveryState>("/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<RecoveryState>("/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<DeviceKey[]>("/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<DeviceKey>($"/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));
|
||||
}
|
||||
}
|
||||
@@ -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<RecoveryVault> 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<DeviceKey> 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<CryptographicException>(() => 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<InvalidOperationException>(() => Save(_db.Alice, 2));
|
||||
Assert.ThrowsAsync<InvalidOperationException>(() => 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<CryptographicException>(() => _service.RegisterAsync(_db.Alice, second.SessionId,
|
||||
device with { SessionId = second.SessionId }));
|
||||
var wrongRoot = E2eeRecoveryProtocol.Certify(second, E2eeRecoveryProtocol.GenerateIdentity());
|
||||
Assert.ThrowsAsync<UnauthorizedAccessException>(() => _service.RegisterAsync(_db.Alice, second.SessionId, wrongRoot));
|
||||
Assert.ThrowsAsync<UnauthorizedAccessException>(() => _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<InvalidOperationException>(() => _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<ArgumentException>(() => _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<CryptographicException>(() => _service.SaveRecoveryAsync(_db.Bob,
|
||||
new(0, saved.IdentityKey, saved.Ciphertext, saved.Signature)));
|
||||
Assert.ThrowsAsync<CryptographicException>(() => _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));
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user