mirror of
https://github.com/Govor-team/Govor.git
synced 2026-11-16 20:56:03 +00:00
Add E2EE messaging and VPS deployment
Add signed, encrypted messages and attachments with per-session device keys, conversation key discovery, and server-side validation. Extend CI to publish immutable container images and deploy to a VPS, with setup and protocol documentation.
This commit is contained in:
@@ -0,0 +1,2 @@
|
||||
*.sh text eol=lf
|
||||
deploy/Caddyfile text eol=lf
|
||||
@@ -4,14 +4,19 @@
|
||||
name: .NET
|
||||
|
||||
on:
|
||||
workflow_dispatch:
|
||||
push:
|
||||
branches: [ "master" ]
|
||||
pull_request:
|
||||
branches: [ "master" ]
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
jobs:
|
||||
build-and-test:
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 30
|
||||
strategy:
|
||||
matrix:
|
||||
database: [sqlite, postgres]
|
||||
@@ -49,4 +54,78 @@ jobs:
|
||||
- name: Run tests
|
||||
run: dotnet test Govor.Server.Tests/Govor.Server.Tests.csproj --no-build --configuration Release
|
||||
|
||||
publish:
|
||||
needs: build-and-test
|
||||
if: github.event_name != 'pull_request' && github.ref == 'refs/heads/master' && vars.VPS_DEPLOY_ENABLED == 'true'
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 20
|
||||
permissions:
|
||||
contents: read
|
||||
packages: write
|
||||
outputs:
|
||||
image: ${{ steps.image.outputs.image }}
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- name: Build and publish immutable image
|
||||
id: image
|
||||
env:
|
||||
GHCR_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
run: |
|
||||
set -Eeuo pipefail
|
||||
image="ghcr.io/${GITHUB_REPOSITORY,,}"
|
||||
printf '%s' "$GHCR_TOKEN" | docker login ghcr.io -u "$GITHUB_ACTOR" --password-stdin
|
||||
docker build --label "org.opencontainers.image.source=https://github.com/$GITHUB_REPOSITORY" \
|
||||
--label "org.opencontainers.image.revision=$GITHUB_SHA" -t "$image:$GITHUB_SHA" .
|
||||
docker push "$image:$GITHUB_SHA"
|
||||
digest="$(docker image inspect "$image:$GITHUB_SHA" --format '{{index .RepoDigests 0}}')"
|
||||
echo "image=$digest" >> "$GITHUB_OUTPUT"
|
||||
- name: Save deployment configuration for this commit
|
||||
uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: vps-deployment-${{ github.sha }}
|
||||
path: |
|
||||
deploy/compose.yaml
|
||||
deploy/Caddyfile
|
||||
deploy/deploy.sh
|
||||
retention-days: 30
|
||||
|
||||
deploy:
|
||||
needs: publish
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 20
|
||||
environment: production
|
||||
concurrency:
|
||||
group: govor-production
|
||||
cancel-in-progress: false
|
||||
steps:
|
||||
- uses: actions/download-artifact@v4
|
||||
with:
|
||||
name: vps-deployment-${{ github.sha }}
|
||||
path: deploy
|
||||
- name: Deploy over SSH
|
||||
env:
|
||||
VPS_HOST: ${{ secrets.VPS_HOST }}
|
||||
VPS_USER: ${{ secrets.VPS_USER }}
|
||||
VPS_SSH_KEY: ${{ secrets.VPS_SSH_KEY }}
|
||||
VPS_KNOWN_HOSTS: ${{ secrets.VPS_KNOWN_HOSTS }}
|
||||
VPS_SSH_PORT: ${{ vars.VPS_SSH_PORT || '22' }}
|
||||
GOVOR_IMAGE: ${{ needs.publish.outputs.image }}
|
||||
run: |
|
||||
set -Eeuo pipefail
|
||||
[[ "$VPS_HOST" =~ ^[a-zA-Z0-9][a-zA-Z0-9.:-]*$ ]]
|
||||
[[ "$VPS_USER" =~ ^[a-z_][a-z0-9_-]*$ ]]
|
||||
[[ "$VPS_SSH_PORT" =~ ^[0-9]+$ ]]
|
||||
[[ "$GITHUB_SHA" =~ ^[a-f0-9]{40}$ ]]
|
||||
[[ "$GOVOR_IMAGE" =~ ^ghcr\.io/[a-z0-9._/-]+@sha256:[a-f0-9]{64}$ ]]
|
||||
install -d -m 700 ~/.ssh
|
||||
printf '%s\n' "$VPS_SSH_KEY" > ~/.ssh/id_ed25519
|
||||
printf '%s\n' "$VPS_KNOWN_HOSTS" > ~/.ssh/known_hosts
|
||||
chmod 600 ~/.ssh/id_ed25519 ~/.ssh/known_hosts
|
||||
target="$VPS_USER@$VPS_HOST"
|
||||
release="/opt/govor/releases/$GITHUB_SHA-$GITHUB_RUN_ID-$GITHUB_RUN_ATTEMPT"
|
||||
ssh_options=(-i ~/.ssh/id_ed25519 -o BatchMode=yes -o StrictHostKeyChecking=yes -o ConnectTimeout=15 -o ServerAliveInterval=15 -o ServerAliveCountMax=4)
|
||||
ssh "${ssh_options[@]}" -p "$VPS_SSH_PORT" "$target" "mkdir -p '$release'"
|
||||
scp "${ssh_options[@]}" -P "$VPS_SSH_PORT" deploy/compose.yaml deploy/Caddyfile deploy/deploy.sh "$target:$release/"
|
||||
ssh "${ssh_options[@]}" -p "$VPS_SSH_PORT" "$target" "bash '$release/deploy.sh' '$GOVOR_IMAGE'"
|
||||
|
||||
|
||||
|
||||
@@ -32,6 +32,7 @@ public static class ConfigurationProgramExtensions
|
||||
{
|
||||
public static void AddServices(this IServiceCollection services)
|
||||
{
|
||||
services.AddScoped<Govor.Application.E2ee.E2eeService>();
|
||||
services.AddSingleton<IPasswordHasher, PasswordHasher>();
|
||||
services.AddSingleton<IUsernameValidator, UsernameValidator>();
|
||||
services.AddSingleton<IJwtTokenHasher, JwtTokenHasher>();
|
||||
|
||||
@@ -9,7 +9,8 @@ public static class ConfigurationSignalR
|
||||
{
|
||||
services.AddSignalR(options =>
|
||||
{
|
||||
options.MaximumReceiveMessageSize = 1_100_000;
|
||||
options.AddFilter<HubExceptionFilter>();
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,42 @@
|
||||
using System.Security.Cryptography;
|
||||
using Govor.Application.E2ee;
|
||||
using Govor.Application.Infrastructure.Extensions;
|
||||
using Govor.Domain.Models.Messages;
|
||||
using Microsoft.AspNetCore.Authorization;
|
||||
using Microsoft.AspNetCore.Mvc;
|
||||
|
||||
namespace Govor.API.Controllers;
|
||||
|
||||
[ApiController]
|
||||
[Authorize(Roles = "User,Admin")]
|
||||
[Route("api/e2ee")]
|
||||
public sealed class E2eeController(E2eeService e2ee, ICurrentUserService user,
|
||||
ICurrentUserSessionService session) : ControllerBase
|
||||
{
|
||||
[HttpPut("device")]
|
||||
public async Task<IActionResult> Register(DeviceKey key)
|
||||
{
|
||||
try
|
||||
{
|
||||
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 (Exception ex) when (ex is CryptographicException or ArgumentException or FormatException)
|
||||
{ return BadRequest("Invalid E2EE public keys."); }
|
||||
}
|
||||
|
||||
[HttpGet("conversations/{type:int}/{conversationId:guid}/keys")]
|
||||
public async Task<IActionResult> Keys(int type, Guid conversationId)
|
||||
{
|
||||
if (type is < 0 or > 1 || conversationId == Guid.Empty) return BadRequest();
|
||||
try
|
||||
{
|
||||
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."); }
|
||||
}
|
||||
}
|
||||
@@ -1,4 +1,5 @@
|
||||
using Govor.API.Common.Extensions;
|
||||
using Govor.Application.E2ee;
|
||||
using Govor.Application.Infrastructure.Extensions;
|
||||
using Govor.Application.Medias;
|
||||
using Govor.Contracts.Requests;
|
||||
@@ -49,6 +50,10 @@ public class MediaController : Controller
|
||||
if (string.IsNullOrWhiteSpace(request.MimeType))
|
||||
return BadRequest("Missing MIME type");
|
||||
|
||||
if (request.OwnerType == MediaOwnerType.Message &&
|
||||
(request.MimeType != E2eeProtocol.EncryptedMimeType || !string.IsNullOrEmpty(request.EncryptedKey)))
|
||||
return BadRequest("Message attachments must be encrypted on the client. Do not upload decryption keys.");
|
||||
|
||||
try
|
||||
{
|
||||
byte[] fileBytes = await ReadFileAsync(request.FromFile);
|
||||
|
||||
@@ -7,6 +7,7 @@ using Govor.Application.Infrastructure.Common;
|
||||
using Govor.Application.Messages;
|
||||
using Govor.Application.Reactions;
|
||||
using AutoMapper;
|
||||
using Govor.Application.E2ee;
|
||||
using Govor.Application.Messages.Parameters;
|
||||
using Govor.Contracts.Requests.SignalR;
|
||||
using Govor.Contracts.Responses.SignalR;
|
||||
@@ -241,6 +242,7 @@ public class ChatsHub : Hub
|
||||
RecipientId = result.OriginalMessage.RecipientId,
|
||||
RecipientType = result.OriginalMessage.RecipientType,
|
||||
NewEncryptedContent = request.NewEncryptedContent,
|
||||
ReplyToMessageId = result.OriginalMessage.ReplyToMessageId,
|
||||
EditedAt = editParams.EditedAt,
|
||||
};
|
||||
|
||||
@@ -294,7 +296,7 @@ public class ChatsHub : Hub
|
||||
{
|
||||
throw new ArgumentException("Message must contain content or media.");
|
||||
}
|
||||
if ((request.EncryptedContent?.Length ?? 0) > 50_000)
|
||||
if ((request.EncryptedContent?.Length ?? 0) > E2eeProtocol.MaxEnvelopeLength)
|
||||
{
|
||||
throw new ArgumentException("Message is too long.");
|
||||
}
|
||||
|
||||
@@ -210,6 +210,4 @@ app.MapSwagger()
|
||||
|
||||
app.Map("/", () => "Not for browsers");
|
||||
|
||||
app.Run();
|
||||
|
||||
public partial class Program { }
|
||||
app.Run();
|
||||
@@ -0,0 +1,262 @@
|
||||
using System.Security.Cryptography;
|
||||
using System.Text;
|
||||
using System.Text.Json;
|
||||
using Jose;
|
||||
using AesGcm = System.Security.Cryptography.AesGcm;
|
||||
|
||||
namespace Govor.Application.E2ee;
|
||||
|
||||
// Shared verbatim with the mobile client. JOSE implements RFC 7515/7516;
|
||||
// the application envelope binds the ciphertext to its author and conversation.
|
||||
public sealed record DeviceKey(Guid UserId, Guid SessionId, string IdentityKey,
|
||||
string EncryptionKey, string Signature)
|
||||
{
|
||||
public string Fingerprint => E2eeProtocol.Fingerprint(IdentityKey, EncryptionKey);
|
||||
}
|
||||
|
||||
public sealed record ConversationKeys(Guid ConversationId, int RecipientType,
|
||||
Guid[] Members, DeviceKey[] Devices);
|
||||
public sealed record AttachmentSecret(Guid MediaId, string Key, string FileName, string MimeType);
|
||||
public sealed record MessagePlaintext(string Text, AttachmentSecret[] Attachments);
|
||||
public sealed record EncryptedMessage(int Version, Guid MessageId, Guid ConversationId,
|
||||
int RecipientType, DeviceKey Sender, Guid? ReplyToMessageId, long CreatedAt,
|
||||
bool IsEdit, string[] Recipients, Guid[] MediaIds, string Ciphertext);
|
||||
public sealed record DevicePrivateKeys(string IdentityKey, string EncryptionKey);
|
||||
|
||||
public static class E2eeProtocol
|
||||
{
|
||||
public const string Prefix = "govor.e2ee.v1:";
|
||||
public const int MaxEnvelopeLength = 1_000_000;
|
||||
public const int MaxDevices = 500;
|
||||
public const string EncryptedMimeType = "application/vnd.govor.encrypted";
|
||||
public static readonly JsonSerializerOptions Json = new() { PropertyNameCaseInsensitive = true };
|
||||
|
||||
public static bool IsEncrypted(string? value) => value?.StartsWith(Prefix, StringComparison.Ordinal) == true;
|
||||
|
||||
public static DevicePrivateKeys GenerateKeys()
|
||||
{
|
||||
using var signing = ECDsa.Create(ECCurve.NamedCurves.nistP256);
|
||||
using var encryption = RSA.Create(3072);
|
||||
return new(Convert.ToBase64String(signing.ExportPkcs8PrivateKey()),
|
||||
Convert.ToBase64String(encryption.ExportPkcs8PrivateKey()));
|
||||
}
|
||||
|
||||
public static DeviceKey PublicKey(DevicePrivateKeys keys, Guid user, Guid session)
|
||||
{
|
||||
using var signing = SigningPrivateKey(keys);
|
||||
using var encryption = EncryptionPrivateKey(keys);
|
||||
var identity = Convert.ToBase64String(signing.ExportSubjectPublicKeyInfo());
|
||||
var publicEncryption = Convert.ToBase64String(encryption.ExportSubjectPublicKeyInfo());
|
||||
// Domain separation prevents using this signature as a message signature.
|
||||
var signature = signing.SignData(KeyBinding(publicEncryption), HashAlgorithmName.SHA256,
|
||||
DSASignatureFormat.IeeeP1363FixedFieldConcatenation);
|
||||
return new(user, session, identity, publicEncryption, Convert.ToBase64String(signature));
|
||||
}
|
||||
|
||||
public static void ValidatePublicKey(DeviceKey key)
|
||||
{
|
||||
if (key.UserId == Guid.Empty || key.SessionId == Guid.Empty ||
|
||||
key.IdentityKey is null || key.IdentityKey.Length > 200 ||
|
||||
key.EncryptionKey is null || key.EncryptionKey.Length > 1000 ||
|
||||
key.Signature is null || key.Signature.Length > 100)
|
||||
throw new CryptographicException("Invalid E2EE device key.");
|
||||
using var signing = SigningPublicKey(key);
|
||||
using var encryption = EncryptionPublicKey(key);
|
||||
if (signing.KeySize != 256 || signing.ExportParameters(false).Curve.Oid.Value != "1.2.840.10045.3.1.7" ||
|
||||
encryption.KeySize != 3072 ||
|
||||
!signing.VerifyData(KeyBinding(key.EncryptionKey), Convert.FromBase64String(key.Signature),
|
||||
HashAlgorithmName.SHA256, DSASignatureFormat.IeeeP1363FixedFieldConcatenation))
|
||||
throw new CryptographicException("Invalid E2EE key binding signature.");
|
||||
}
|
||||
|
||||
public static string Fingerprint(string identity, string encryption) =>
|
||||
Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes($"govor-device-v1\n{identity}\n{encryption}")));
|
||||
|
||||
public static string Encrypt(MessagePlaintext plaintext, DevicePrivateKeys privateKeys,
|
||||
DeviceKey sender, ConversationKeys conversation, Guid messageId, Guid? replyTo = null,
|
||||
bool isEdit = false, long? createdAt = null)
|
||||
{
|
||||
ValidatePublicKey(sender);
|
||||
if (messageId == Guid.Empty || conversation.Devices.Length is 0 or > MaxDevices ||
|
||||
plaintext.Text is null || plaintext.Text.Length > 20_000 || plaintext.Attachments is null ||
|
||||
plaintext.Attachments.Length > 100 ||
|
||||
(string.IsNullOrWhiteSpace(plaintext.Text) && plaintext.Attachments.Length == 0))
|
||||
throw new CryptographicException("E2EE message or recipient limit exceeded.");
|
||||
var devices = conversation.Devices.DistinctBy(k => k.Fingerprint).ToArray();
|
||||
var keys = new List<RSA>();
|
||||
try
|
||||
{
|
||||
var recipients = devices.Select(device =>
|
||||
{
|
||||
ValidatePublicKey(device);
|
||||
var rsa = EncryptionPublicKey(device);
|
||||
keys.Add(rsa);
|
||||
return new JweRecipient(JweAlgorithm.RSA_OAEP_256, rsa,
|
||||
new Dictionary<string, object> { ["kid"] = device.Fingerprint });
|
||||
}).ToArray();
|
||||
var ciphertext = JWE.Encrypt(JsonSerializer.Serialize(plaintext), recipients, JweEncryption.A256GCM);
|
||||
var envelope = new EncryptedMessage(1, messageId, conversation.ConversationId,
|
||||
conversation.RecipientType, sender, replyTo, createdAt ?? DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
|
||||
isEdit, devices.Select(k => k.Fingerprint).Order(StringComparer.Ordinal).ToArray(),
|
||||
plaintext.Attachments.Select(a => a.MediaId).Order().ToArray(), ciphertext);
|
||||
using var signing = SigningPrivateKey(privateKeys);
|
||||
var result = Prefix + JWT.Encode(JsonSerializer.Serialize(envelope), signing, JwsAlgorithm.ES256);
|
||||
if (result.Length > MaxEnvelopeLength) throw new CryptographicException("E2EE envelope is too large.");
|
||||
return result;
|
||||
}
|
||||
finally { foreach (var key in keys) key.Dispose(); }
|
||||
}
|
||||
|
||||
// Reading the unverified payload is used only to select its verification key.
|
||||
// No caller may trust the returned fields until Verify has completed.
|
||||
public static EncryptedMessage Inspect(string value)
|
||||
{
|
||||
if (!IsEncrypted(value) || value.Length > MaxEnvelopeLength)
|
||||
throw new CryptographicException("An E2EE envelope is required.");
|
||||
var parts = value[Prefix.Length..].Split('.');
|
||||
if (parts.Length != 3) throw new CryptographicException("Invalid signed E2EE envelope.");
|
||||
var envelope = JsonSerializer.Deserialize<EncryptedMessage>(Base64Url.Decode(parts[1]), Json)
|
||||
?? throw new CryptographicException("Invalid E2EE envelope.");
|
||||
if (envelope.Version != 1 || envelope.Sender is null || envelope.MessageId == Guid.Empty ||
|
||||
envelope.ConversationId == Guid.Empty || envelope.RecipientType is < 0 or > 1 ||
|
||||
envelope.Recipients is null || envelope.Recipients.Length is 0 or > MaxDevices ||
|
||||
envelope.MediaIds is null || envelope.MediaIds.Length > 100 ||
|
||||
string.IsNullOrWhiteSpace(envelope.Ciphertext))
|
||||
throw new CryptographicException("Invalid E2EE envelope fields.");
|
||||
return envelope;
|
||||
}
|
||||
|
||||
public static EncryptedMessage Verify(string value)
|
||||
{
|
||||
var envelope = Inspect(value);
|
||||
ValidatePublicKey(envelope.Sender);
|
||||
using var signing = SigningPublicKey(envelope.Sender);
|
||||
JWT.Decode(value[Prefix.Length..], signing, JwsAlgorithm.ES256);
|
||||
// Reject algorithm negotiation, compression, and unprotected shared headers.
|
||||
using var jwe = JsonDocument.Parse(envelope.Ciphertext);
|
||||
var root = jwe.RootElement;
|
||||
if (root.TryGetProperty("unprotected", out _) || root.TryGetProperty("aad", out _))
|
||||
throw new CryptographicException("Unsupported JWE headers.");
|
||||
using var header = JsonDocument.Parse(Base64Url.Decode(root.GetProperty("protected").GetString()));
|
||||
if (header.RootElement.GetProperty("enc").GetString() != "A256GCM" ||
|
||||
header.RootElement.TryGetProperty("zip", out _))
|
||||
throw new CryptographicException("Unsupported content encryption.");
|
||||
var recipients = root.TryGetProperty("recipients", out var many)
|
||||
? many.EnumerateArray().ToArray() : new[] { root };
|
||||
if (recipients.Length != envelope.Recipients.Length ||
|
||||
recipients.Any(r => r.GetProperty("header").GetProperty("alg").GetString() != "RSA-OAEP-256") ||
|
||||
!recipients.Select(r => r.GetProperty("header").GetProperty("kid").GetString())
|
||||
.Order(StringComparer.Ordinal).SequenceEqual(envelope.Recipients.Order(StringComparer.Ordinal)) ||
|
||||
envelope.Recipients.Distinct(StringComparer.Ordinal).Count() != envelope.Recipients.Length)
|
||||
throw new CryptographicException("Invalid E2EE recipient manifest.");
|
||||
return envelope;
|
||||
}
|
||||
|
||||
public static MessagePlaintext Decrypt(string value, DevicePrivateKeys 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))
|
||||
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()));
|
||||
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
|
||||
// OS-specific error while trying another recipient's RSA-OAEP encrypted key.
|
||||
var selected = System.Text.Json.Nodes.JsonNode.Parse(envelope.Ciphertext)!;
|
||||
if (selected["recipients"] is System.Text.Json.Nodes.JsonArray recipients)
|
||||
{
|
||||
var recipient = recipients.Single(r => r!["header"]!["kid"]!.GetValue<string>() == fingerprint)!;
|
||||
selected["recipients"] = new System.Text.Json.Nodes.JsonArray(recipient.DeepClone());
|
||||
}
|
||||
var decrypted = JWE.Decrypt(selected.ToJsonString(), rsa,
|
||||
JweAlgorithm.RSA_OAEP_256, JweEncryption.A256GCM);
|
||||
var plaintext = JsonSerializer.Deserialize<MessagePlaintext>(decrypted.Plaintext, Json)
|
||||
?? throw new CryptographicException("Invalid encrypted content.");
|
||||
if (plaintext.Text is null || plaintext.Text.Length > 20_000 || plaintext.Attachments is null ||
|
||||
!plaintext.Attachments.Select(a => a.MediaId).Order().SequenceEqual(envelope.MediaIds.Order()))
|
||||
throw new CryptographicException("Invalid encrypted attachment manifest.");
|
||||
return plaintext;
|
||||
}
|
||||
|
||||
public static (byte[] Data, string Key) EncryptAttachment(byte[] plaintext)
|
||||
{
|
||||
if (plaintext.Length > 19_000_000) throw new CryptographicException("Attachment is too large.");
|
||||
var key = RandomNumberGenerator.GetBytes(32);
|
||||
try
|
||||
{
|
||||
var data = new byte[12 + plaintext.Length + 16];
|
||||
RandomNumberGenerator.Fill(data.AsSpan(0, 12));
|
||||
using var aes = new AesGcm(key, 16);
|
||||
aes.Encrypt(data.AsSpan(0, 12), plaintext, data.AsSpan(12, plaintext.Length), data.AsSpan(12 + plaintext.Length, 16),
|
||||
"govor-attachment-v1"u8);
|
||||
return (data, Convert.ToBase64String(key));
|
||||
}
|
||||
finally { CryptographicOperations.ZeroMemory(key); }
|
||||
}
|
||||
|
||||
public static byte[] DecryptAttachment(byte[] ciphertext, string encodedKey)
|
||||
{
|
||||
if (ciphertext.Length is < 28 or > 19_000_028) throw new CryptographicException("Invalid attachment size.");
|
||||
var key = Convert.FromBase64String(encodedKey);
|
||||
try
|
||||
{
|
||||
if (key.Length != 32) throw new CryptographicException("Invalid attachment key.");
|
||||
var plaintext = new byte[ciphertext.Length - 28];
|
||||
using var aes = new AesGcm(key, 16);
|
||||
aes.Decrypt(ciphertext.AsSpan(0, 12), ciphertext.AsSpan(12, plaintext.Length),
|
||||
ciphertext.AsSpan(12 + plaintext.Length, 16), plaintext, "govor-attachment-v1"u8);
|
||||
return plaintext;
|
||||
}
|
||||
finally { CryptographicOperations.ZeroMemory(key); }
|
||||
}
|
||||
|
||||
private static byte[] KeyBinding(string encryption) => Encoding.UTF8.GetBytes("govor-key-binding-v1\n" + encryption);
|
||||
private static ECDsa SigningPrivateKey(DevicePrivateKeys keys)
|
||||
{
|
||||
var bytes = Convert.FromBase64String(keys.IdentityKey);
|
||||
var key = ECDsa.Create();
|
||||
try { key.ImportPkcs8PrivateKey(bytes, out _); return key; }
|
||||
catch { key.Dispose(); throw; }
|
||||
finally { CryptographicOperations.ZeroMemory(bytes); }
|
||||
}
|
||||
private static RSA EncryptionPrivateKey(DevicePrivateKeys keys)
|
||||
{
|
||||
var bytes = Convert.FromBase64String(keys.EncryptionKey);
|
||||
var key = RSA.Create();
|
||||
try { key.ImportPkcs8PrivateKey(bytes, out _); return key; }
|
||||
catch { key.Dispose(); throw; }
|
||||
finally { CryptographicOperations.ZeroMemory(bytes); }
|
||||
}
|
||||
private static ECDsa SigningPublicKey(DeviceKey device)
|
||||
{
|
||||
var key = ECDsa.Create();
|
||||
try
|
||||
{
|
||||
var bytes = Convert.FromBase64String(device.IdentityKey);
|
||||
key.ImportSubjectPublicKeyInfo(bytes, out var read);
|
||||
if (read != bytes.Length) throw new CryptographicException("Trailing public key data.");
|
||||
return key;
|
||||
}
|
||||
catch { key.Dispose(); throw; }
|
||||
}
|
||||
private static RSA EncryptionPublicKey(DeviceKey device)
|
||||
{
|
||||
var key = RSA.Create();
|
||||
try
|
||||
{
|
||||
var bytes = Convert.FromBase64String(device.EncryptionKey);
|
||||
key.ImportSubjectPublicKeyInfo(bytes, out var read);
|
||||
if (read != bytes.Length) throw new CryptographicException("Trailing public key data.");
|
||||
return key;
|
||||
}
|
||||
catch { key.Dispose(); throw; }
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,121 @@
|
||||
using System.Security.Cryptography;
|
||||
using Govor.Application.Groups;
|
||||
using Govor.Application.Messages;
|
||||
using Govor.Domain;
|
||||
using Govor.Domain.Models.Messages;
|
||||
using Govor.Domain.Models.Users.Crypto;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
|
||||
namespace Govor.Application.E2ee;
|
||||
|
||||
public sealed class E2eeService(GovorDbContext context)
|
||||
{
|
||||
public async Task<bool> IsRequiredAsync(Guid conversation, RecipientType type) =>
|
||||
type == RecipientType.User || await context.ChatGroups.AnyAsync(g => g.Id == conversation && g.IsPrivate);
|
||||
|
||||
public async Task<ConversationKeys> GetConversationKeysAsync(Guid user, Guid conversation, RecipientType type)
|
||||
{
|
||||
if (!await context.HasChatAccessAsync(user, conversation, type))
|
||||
throw new UnauthorizedAccessException("You are not a member of this conversation.");
|
||||
Guid[] members;
|
||||
if (type == RecipientType.User)
|
||||
{
|
||||
var chat = await context.PrivateChats.AsNoTracking().SingleAsync(c => c.Id == conversation);
|
||||
members = new[] { chat.UserAId, chat.UserBId }.Distinct().Order().ToArray();
|
||||
}
|
||||
else if (type == RecipientType.Group)
|
||||
members = await context.GroupMemberships.AsNoTracking()
|
||||
.Where(m => m.GroupId == conversation && !m.IsBanned).Select(m => m.UserId)
|
||||
.Distinct().OrderBy(id => id).ToArrayAsync();
|
||||
else throw new ArgumentException("Invalid conversation type.");
|
||||
|
||||
// Unexpired sessions are needed for authentication; encryption keys must also
|
||||
// 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)
|
||||
.Take(E2eeProtocol.MaxDevices + 1).ToListAsync();
|
||||
var devices = sessions.Select(s => ToDeviceKey(s)).ToArray();
|
||||
if (devices.Length > E2eeProtocol.MaxDevices)
|
||||
throw new InvalidOperationException("Too many E2EE devices in this conversation.");
|
||||
foreach (var key in devices) E2eeProtocol.ValidatePublicKey(key);
|
||||
if (members.Any(m => !devices.Any(k => k.UserId == m)))
|
||||
throw new InvalidOperationException("Every participant must register E2EE keys before sending messages.");
|
||||
return new(conversation, (int)type, members, devices);
|
||||
}
|
||||
|
||||
public async Task RegisterAsync(Guid user, Guid sessionId, DeviceKey key)
|
||||
{
|
||||
if (key.UserId != user || key.SessionId != sessionId)
|
||||
throw new UnauthorizedAccessException("E2EE key must belong to the current session.");
|
||||
E2eeProtocol.ValidatePublicKey(key);
|
||||
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)
|
||||
?? throw new UnauthorizedAccessException("Session is revoked or expired.");
|
||||
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.");
|
||||
return;
|
||||
}
|
||||
var cryptoId = Guid.NewGuid();
|
||||
var crypto = new UserCryptoSession
|
||||
{
|
||||
Id = cryptoId, UserSessionId = sessionId,
|
||||
PublicIdentityKey = Convert.FromBase64String(key.IdentityKey),
|
||||
SignedPreKey = new SignedPreKey
|
||||
{
|
||||
Id = Guid.NewGuid(), UserCryptoSessionId = cryptoId,
|
||||
PublicSignedPreKey = Convert.FromBase64String(key.EncryptionKey),
|
||||
SignedPreKeySignature = Convert.FromBase64String(key.Signature)
|
||||
},
|
||||
OneTimePreKeys = new List<OneTimePreKey>()
|
||||
};
|
||||
context.UserCryptoSessions.Add(crypto);
|
||||
session.CryptoSession = crypto;
|
||||
await context.SaveChangesAsync();
|
||||
}
|
||||
|
||||
public async Task<EncryptedMessage?> ValidateAsync(string content, Guid sender, Guid conversation,
|
||||
RecipientType type, Guid? replyTo, Guid[] media, Guid? editedMessage = null)
|
||||
{
|
||||
if (!E2eeProtocol.IsEncrypted(content))
|
||||
{
|
||||
if (await IsRequiredAsync(conversation, type))
|
||||
throw new ArgumentException("E2EE is required. Update the client and verify participant keys.");
|
||||
return null;
|
||||
}
|
||||
EncryptedMessage envelope;
|
||||
try { envelope = E2eeProtocol.Verify(content); }
|
||||
catch (Exception ex) when (ex is CryptographicException or FormatException or System.Text.Json.JsonException or
|
||||
Jose.JoseException or KeyNotFoundException or InvalidOperationException)
|
||||
{ throw new ArgumentException("Invalid E2EE envelope."); }
|
||||
if (envelope.Sender.UserId != sender || envelope.ConversationId != conversation ||
|
||||
envelope.RecipientType != (int)type || envelope.ReplyToMessageId != replyTo ||
|
||||
envelope.IsEdit != editedMessage.HasValue ||
|
||||
(editedMessage.HasValue && envelope.MessageId != editedMessage) ||
|
||||
!envelope.MediaIds.Order().SequenceEqual(media.Order()) ||
|
||||
Math.Abs((double)envelope.CreatedAt - DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()) > 300_000)
|
||||
throw new ArgumentException("E2EE routing, attachment or time context does not match.");
|
||||
|
||||
var signingSession = await context.UserSessions.AsNoTracking().Include(s => s.CryptoSession)
|
||||
.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)
|
||||
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.");
|
||||
return envelope;
|
||||
}
|
||||
|
||||
private static DeviceKey ToDeviceKey(UserCryptoSession session, Guid? user = null) =>
|
||||
new(user ?? session.UserSession.UserId, session.UserSessionId,
|
||||
Convert.ToBase64String(session.PublicIdentityKey),
|
||||
Convert.ToBase64String(session.SignedPreKey.PublicSignedPreKey),
|
||||
Convert.ToBase64String(session.SignedPreKey.SignedPreKeySignature));
|
||||
}
|
||||
@@ -1,4 +1,4 @@
|
||||
<Project Sdk="Microsoft.NET.Sdk">
|
||||
<Project Sdk="Microsoft.NET.Sdk">
|
||||
|
||||
<PropertyGroup>
|
||||
<TargetFramework>net10.0</TargetFramework>
|
||||
@@ -7,6 +7,7 @@
|
||||
</PropertyGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<PackageReference Include="jose-jwt" Version="5.3.0" />
|
||||
<PackageReference Include="BCrypt.Net-Next" Version="4.2.0" />
|
||||
<PackageReference Include="FirebaseAdmin" Version="3.6.0" />
|
||||
<PackageReference Include="Microsoft.EntityFrameworkCore" Version="10.0.10" />
|
||||
|
||||
@@ -5,6 +5,7 @@ using Govor.Domain.Models.Messages;
|
||||
using Govor.Application.Groups;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using Microsoft.Extensions.Options;
|
||||
using Govor.Application.E2ee;
|
||||
|
||||
namespace Govor.Application.Messages;
|
||||
|
||||
@@ -107,10 +108,22 @@ public class MessageEditingService : IMessageEditingService
|
||||
MediaAttachments = message.MediaAttachments?.ToList() ?? []
|
||||
};
|
||||
|
||||
if (editParams.NewContent is null || editParams.NewContent.Length > 50_000 ||
|
||||
if (editParams.NewContent is null || editParams.NewContent.Length > E2eeProtocol.MaxEnvelopeLength ||
|
||||
(string.IsNullOrWhiteSpace(editParams.NewContent) && message.MediaAttachments.Count == 0))
|
||||
return new EditMessageResult(false, new ArgumentException("Invalid message content."), null);
|
||||
|
||||
try
|
||||
{
|
||||
var envelope = await new E2eeService(_dbContext).ValidateAsync(editParams.NewContent,
|
||||
editParams.EditorId, message.RecipientId, message.RecipientType, message.ReplyToMessageId,
|
||||
message.MediaAttachments.Select(a => a.MediaFileId).ToArray(), message.Id);
|
||||
if (E2eeProtocol.IsEncrypted(message.EncryptedContent) &&
|
||||
(envelope is null || envelope.CreatedAt <= E2eeProtocol.Inspect(message.EncryptedContent).CreatedAt))
|
||||
throw new ArgumentException("An encrypted message cannot be downgraded or replayed.");
|
||||
}
|
||||
catch (Exception ex) when (ex is ArgumentException or UnauthorizedAccessException or InvalidOperationException)
|
||||
{ return new EditMessageResult(false, ex, null); }
|
||||
|
||||
message.EncryptedContent = editParams.NewContent;
|
||||
message.IsEdited = true;
|
||||
message.EditedAt = editParams.EditedAt;
|
||||
|
||||
@@ -5,6 +5,7 @@ using Govor.Domain.Models.Messages;
|
||||
using Govor.Domain.Models;
|
||||
using Govor.Application.Groups;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using Govor.Application.E2ee;
|
||||
|
||||
namespace Govor.Application.Messages;
|
||||
|
||||
@@ -21,7 +22,10 @@ public class MessageSendingService : IMessageSendingService
|
||||
|
||||
public async Task<SendMessageResult> SendMessageAsync(SendMessage sendParams)
|
||||
{
|
||||
var operationId = Guid.NewGuid();
|
||||
Guid operationId;
|
||||
try { operationId = E2eeProtocol.IsEncrypted(sendParams.EncryptContent)
|
||||
? E2eeProtocol.Inspect(sendParams.EncryptContent).MessageId : Guid.NewGuid(); }
|
||||
catch { return new SendMessageResult(false, new ArgumentException("Invalid E2EE envelope."), default); }
|
||||
if (sendParams.RecipientType != RecipientType.Group)
|
||||
return await SendCoreAsync(sendParams, operationId);
|
||||
return await _dbContext.Database.CreateExecutionStrategy().ExecuteAsync(async () =>
|
||||
@@ -32,9 +36,6 @@ public class MessageSendingService : IMessageSendingService
|
||||
// Same group lock as moderation: bans/demotion cannot race a channel post.
|
||||
await _dbContext.ChatGroups.Where(g => g.Id == sendParams.RecipientId)
|
||||
.ExecuteUpdateAsync(s => s.SetProperty(g => g.Name, g => g.Name));
|
||||
var completed = await _dbContext.Messages.AsNoTracking().Include(m => m.MediaAttachments)
|
||||
.FirstOrDefaultAsync(m => m.Id == operationId);
|
||||
if (completed is not null) return new SendMessageResult(true, null, completed);
|
||||
var result = await SendCoreAsync(sendParams, operationId);
|
||||
if (result.IsSuccess) await transaction.CommitAsync();
|
||||
return result;
|
||||
@@ -47,7 +48,7 @@ public class MessageSendingService : IMessageSendingService
|
||||
{
|
||||
var media = sendParams.Media?.ToArray() ?? [];
|
||||
if ((string.IsNullOrWhiteSpace(sendParams.EncryptContent) && media.Length == 0) ||
|
||||
(sendParams.EncryptContent?.Length ?? 0) > 50_000 || media.Length > 100)
|
||||
(sendParams.EncryptContent?.Length ?? 0) > E2eeProtocol.MaxEnvelopeLength || media.Length > 100)
|
||||
return new SendMessageResult(false, new ArgumentException("Invalid message content or attachment count."), default);
|
||||
|
||||
var validationResult = sendParams.RecipientType switch
|
||||
@@ -63,17 +64,37 @@ public class MessageSendingService : IMessageSendingService
|
||||
return new SendMessageResult(false, new UnauthorizedAccessException(validationResult.Error), default);
|
||||
}
|
||||
|
||||
var completed = await _dbContext.Messages.AsNoTracking().Include(m => m.MediaAttachments)
|
||||
.ThenInclude(m => m.MediaFile).FirstOrDefaultAsync(m => m.Id == operationId);
|
||||
if (completed is not null)
|
||||
return completed.SenderId == sendParams.FromUserId && completed.EncryptedContent == sendParams.EncryptContent
|
||||
? new SendMessageResult(true, null, completed)
|
||||
: new SendMessageResult(false, new ArgumentException("Message ID already exists."), default);
|
||||
|
||||
var mediaIds = media.Select(m => m.MediaId).Distinct().ToArray();
|
||||
var files = await _dbContext.MediaFiles.Where(m => mediaIds.Contains(m.Id) &&
|
||||
m.UploaderId == sendParams.FromUserId && m.OwnerType == MediaOwnerType.Message).ToListAsync();
|
||||
if (files.Count != mediaIds.Length)
|
||||
return new SendMessageResult(false, new UnauthorizedAccessException("Invalid media ownership."), default);
|
||||
|
||||
if (E2eeProtocol.IsEncrypted(sendParams.EncryptContent) &&
|
||||
(files.Any(f => f.MineType != E2eeProtocol.EncryptedMimeType) || media.Any(m => !string.IsNullOrEmpty(m.EncryptedKey))))
|
||||
return new SendMessageResult(false, new ArgumentException("E2EE attachments must be encrypted; keys belong inside the encrypted message."), default);
|
||||
|
||||
if (sendParams.ReplyToMessageId.HasValue && !await _dbContext.Messages.AnyAsync(m =>
|
||||
m.Id == sendParams.ReplyToMessageId && m.RecipientId == sendParams.RecipientId &&
|
||||
m.RecipientType == sendParams.RecipientType))
|
||||
return new SendMessageResult(false, new ArgumentException("Reply must belong to the same chat."), default);
|
||||
|
||||
try
|
||||
{
|
||||
await new E2eeService(_dbContext).ValidateAsync(sendParams.EncryptContent, sendParams.FromUserId,
|
||||
sendParams.RecipientId, sendParams.RecipientType, sendParams.ReplyToMessageId,
|
||||
media.Select(m => m.MediaId).ToArray());
|
||||
}
|
||||
catch (Exception ex) when (ex is ArgumentException or UnauthorizedAccessException or InvalidOperationException)
|
||||
{ return new SendMessageResult(false, ex, default); }
|
||||
|
||||
var messageId = operationId;
|
||||
var message = new Message
|
||||
{
|
||||
|
||||
@@ -8,8 +8,8 @@ public record MessageRequest
|
||||
public Guid RecipientId { get; init; }
|
||||
public RecipientType RecipientType { get; init; }
|
||||
[Required]
|
||||
[MaxLength(100_000, ErrorMessage = "EncryptedContent cannot exceed 100,000 characters.")]
|
||||
[MaxLength(1_000_000, ErrorMessage = "EncryptedContent cannot exceed 1,000,000 characters.")]
|
||||
public string EncryptedContent { get; init; } = string.Empty;
|
||||
public Guid? ReplyToMessageId { get; set; }
|
||||
public List<MediaReference> MediaAttachments { get; set; } = new();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -5,9 +5,10 @@ namespace Govor.Contracts.Responses.SignalR;
|
||||
public class MessageEditResponse
|
||||
{
|
||||
public Guid MessageId { get; set; }
|
||||
public Guid? ReplyToMessageId { get; set; }
|
||||
public Guid EditorId { get; set; }
|
||||
public Guid RecipientId { get; init; }
|
||||
public RecipientType RecipientType{get; init; }
|
||||
public string NewEncryptedContent { get; set; } = string.Empty;
|
||||
public DateTime EditedAt { get; set; }
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,235 @@
|
||||
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 Govor.Security;
|
||||
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 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 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));
|
||||
Assert.ThrowsAsync<UnauthorizedAccessException>(() => _e2ee.ValidateAsync(ciphertext,
|
||||
_db.Alice, _db.ChatId, RecipientType.User, null, []));
|
||||
}
|
||||
|
||||
[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);
|
||||
}
|
||||
}
|
||||
@@ -39,7 +39,7 @@ public class PushReliabilityTests
|
||||
public async Task SavedMessageHasDurablePushAndFailureRetriesAfterBackoff()
|
||||
{
|
||||
var sender = new MessageSendingService(_db.Context, NullLogger<MessageSendingService>.Instance);
|
||||
var sent = await sender.SendMessageAsync(new SendMessage("hello", null, _db.ChatId,
|
||||
var sent = await sender.SendMessageAsync(new SendMessage(await EncryptedHelloAsync(), null, _db.ChatId,
|
||||
Govor.Domain.Models.Messages.RecipientType.User, _db.Alice, _now, []));
|
||||
Assert.That(sent.IsSuccess, Is.True);
|
||||
Assert.That(await _db.Context.ChatPushNotifications.CountAsync(), Is.EqualTo(1));
|
||||
@@ -60,6 +60,26 @@ public class PushReliabilityTests
|
||||
Assert.That(await _db.Context.ChatPushNotifications.CountAsync(), Is.Zero);
|
||||
}
|
||||
|
||||
private async Task<string> EncryptedHelloAsync()
|
||||
{
|
||||
var directory = new Govor.Application.E2ee.E2eeService(_db.Context);
|
||||
var devices = new List<Govor.Security.DeviceKey>();
|
||||
var privateKeys = Govor.Security.E2eeProtocol.GenerateKeys();
|
||||
foreach (var user in new[] { _db.Alice, _db.Bob })
|
||||
{
|
||||
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 = Govor.Security.E2eeProtocol.PublicKey(user == _db.Alice ? privateKeys :
|
||||
Govor.Security.E2eeProtocol.GenerateKeys(), user, session.Id);
|
||||
await directory.RegisterAsync(user, session.Id, key);
|
||||
devices.Add(key);
|
||||
}
|
||||
return Govor.Security.E2eeProtocol.Encrypt(new("hello", []), privateKeys, devices[0],
|
||||
await directory.GetConversationKeysAsync(_db.Alice, _db.ChatId, Govor.Domain.Models.Messages.RecipientType.User), Guid.NewGuid());
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task ReassignedDeviceTokenCannotNotifyThePreviousAccount()
|
||||
{
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -20,3 +20,5 @@ This is my school project that I'm working on in my free time to level up my bac
|
||||
- Frontend (separate project for now): .NET MAUI (cross-platform desktop/mobile client)
|
||||
|
||||
dock: https://nas-3.gitbook.io/govor-api
|
||||
|
||||
Deployment: [Timeweb VPS + GitHub Actions](docs/vps-deployment.md) · [Timeweb App Platform](docs/timeweb-deployment.md).
|
||||
|
||||
@@ -0,0 +1,3 @@
|
||||
{$GOVOR_DOMAIN} {
|
||||
reverse_proxy api:8080
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
name: govor
|
||||
|
||||
services:
|
||||
api:
|
||||
image: ${GOVOR_IMAGE:?Set GOVOR_IMAGE to the published image digest}
|
||||
restart: unless-stopped
|
||||
env_file:
|
||||
- /opt/govor/shared/runtime.env
|
||||
environment:
|
||||
ASPNETCORE_ENVIRONMENT: Production
|
||||
ASPNETCORE_HTTP_PORTS: "8080"
|
||||
volumes:
|
||||
- type: bind
|
||||
source: /opt/govor/data/logs
|
||||
target: /app/logs
|
||||
bind:
|
||||
create_host_path: false
|
||||
- type: bind
|
||||
source: /opt/govor/data/uploads
|
||||
target: /app/uploads
|
||||
bind:
|
||||
create_host_path: false
|
||||
healthcheck:
|
||||
test: ["CMD", "curl", "--fail", "--silent", "--show-error", "--max-time", "5", "http://127.0.0.1:8080/server/ready"]
|
||||
interval: 10s
|
||||
timeout: 6s
|
||||
start_period: 20s
|
||||
retries: 12
|
||||
logging:
|
||||
driver: json-file
|
||||
options:
|
||||
max-size: "10m"
|
||||
max-file: "3"
|
||||
|
||||
proxy:
|
||||
image: caddy:2
|
||||
restart: unless-stopped
|
||||
environment:
|
||||
GOVOR_DOMAIN: ${GOVOR_DOMAIN:?Set GOVOR_DOMAIN in shared/deploy.env}
|
||||
ports:
|
||||
- "80:80"
|
||||
- "443:443"
|
||||
volumes:
|
||||
- ./Caddyfile:/etc/caddy/Caddyfile:ro
|
||||
- caddy_data:/data
|
||||
- caddy_config:/config
|
||||
depends_on:
|
||||
api:
|
||||
condition: service_healthy
|
||||
logging:
|
||||
driver: json-file
|
||||
options:
|
||||
max-size: "10m"
|
||||
max-file: "3"
|
||||
|
||||
volumes:
|
||||
caddy_data:
|
||||
caddy_config:
|
||||
@@ -0,0 +1 @@
|
||||
GOVOR_DOMAIN=api.example.com
|
||||
@@ -0,0 +1,37 @@
|
||||
#!/usr/bin/env bash
|
||||
set -Eeuo pipefail
|
||||
umask 077
|
||||
|
||||
release_dir="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
|
||||
image="${1:?Usage: bash deploy.sh ghcr.io/owner/repo@sha256:digest}"
|
||||
[[ "$image" =~ ^ghcr\.io/[a-z0-9._/-]+@sha256:[a-f0-9]{64}$ ]] || {
|
||||
echo "Expected an immutable GHCR image digest" >&2
|
||||
exit 1
|
||||
}
|
||||
|
||||
# The lock also protects against simultaneous manual and Actions deployments.
|
||||
exec 9>/opt/govor/deploy.lock
|
||||
flock -w 600 9
|
||||
test -s /opt/govor/shared/runtime.env
|
||||
test -s /opt/govor/shared/deploy.env
|
||||
test -d /opt/govor/data/logs
|
||||
test -d /opt/govor/data/uploads
|
||||
printf 'GOVOR_IMAGE=%s\n' "$image" > "$release_dir/image.env"
|
||||
|
||||
compose=(docker compose --project-name govor
|
||||
--env-file /opt/govor/shared/deploy.env
|
||||
--env-file "$release_dir/image.env"
|
||||
-f "$release_dir/compose.yaml")
|
||||
|
||||
# Validate silently: rendered config contains runtime secrets.
|
||||
"${compose[@]}" config --quiet
|
||||
"${compose[@]}" pull
|
||||
# A migration failure leaves the existing API container running.
|
||||
"${compose[@]}" run --rm --no-deps api --migrate-only
|
||||
"${compose[@]}" up -d --wait --wait-timeout 180
|
||||
# Check readiness again, independently of container startup order.
|
||||
"${compose[@]}" exec -T api curl --fail --silent --show-error --max-time 5 http://127.0.0.1:8080/server/ready
|
||||
|
||||
# Keep successful release configuration for a manual rollback.
|
||||
ln -sfn "$release_dir" /opt/govor/current
|
||||
echo "Deployment ready: $image"
|
||||
+133
@@ -0,0 +1,133 @@
|
||||
# E2EE v1
|
||||
|
||||
Новые личные сообщения и сообщения приватных групп/каналов требуют E2EE.
|
||||
Сервер проверяет подпись и права доступа, сохраняет и пересылает зашифрованный
|
||||
конверт. Он не получает приватные ключи устройств или ключи файлов.
|
||||
Новый мобильный клиент шифрует сообщения всех чатов, включая публичные группы;
|
||||
сервер сохраняет совместимость с открытыми сообщениями публичных групп.
|
||||
|
||||
## Протокол
|
||||
|
||||
Используется `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.
|
||||
|
||||
Поле `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` должны оставаться идентичными.
|
||||
Изменение формата требует новой версии протокола и совместимых клиентов.
|
||||
|
||||
## Устройства и доверие
|
||||
|
||||
Клиент генерирует отдельную пару ключей шифрования/подписи для каждой сессии.
|
||||
Приватные ключи хранятся только в MAUI SecureStorage, раздельно для сервера,
|
||||
аккаунта и сессии. Ключи предыдущих сессий остаются локально для чтения истории.
|
||||
Ошибка записи или регистрации останавливает отправку; отката к открытому тексту нет.
|
||||
|
||||
Каждый новый отпечаток нужно сверить лично или по независимому доверенному
|
||||
каналу. Приложение показывает свой отпечаток и отпечаток другого устройства.
|
||||
Простое нажатие подтверждения без сверки не защищает от подстановки устройства
|
||||
скомпрометированным сервером. Дополнительно подтверждается состав получателей
|
||||
каждого чата при первом использовании и изменении списка устройств/участников.
|
||||
Эти подтверждения хранятся локально, а не на сервере.
|
||||
|
||||
Это не система прозрачности ключей и не подписанный участниками протокол
|
||||
управления составом групп. Сервер остаётся источником списка участников и
|
||||
статуса сессий. Если он скрывает изменения/отзыв устройств, это невозможно
|
||||
независимо обнаружить без дополнительного протокола. Не следует заявлять
|
||||
защиту уровня Signal/MLS или защиту от любых действий злонамеренного сервера.
|
||||
До публичного релиза требуется независимый аудит протокола и интеграции.
|
||||
|
||||
## Серверные API
|
||||
|
||||
- `PUT /api/e2ee/device`: публичный `DeviceKey` текущего пользователя/сессии.
|
||||
Повторная регистрация тех же ключей допустима; смена ключей внутри сессии
|
||||
запрещена. Истёкшая или отозванная сессия не может регистрировать ключи.
|
||||
- `GET /api/e2ee/conversations/{type}/{conversationId}/keys`: список участников
|
||||
и зарегистрированных устройств; `type=0` — личный чат, `type=1` — группа.
|
||||
Требуется доступ к чату. Возвращаются только публичные данные.
|
||||
- SignalR `Send`/`Edit` и HTTP загрузки истории сохраняют существующие поля DTO.
|
||||
`MessageEditResponse` дополнительно возвращает `ReplyToMessageId` для проверки
|
||||
подписанного контекста редактирования.
|
||||
|
||||
Для офлайн-доставки устройства с истёкшей, но не отозванной сессией остаются
|
||||
получателями. Отозванные сессии исключаются. При изменении набора устройств
|
||||
необходимо заново получить ключи, подтвердить состав и перешифровать сообщение.
|
||||
В группах это проверяется под существующей блокировкой модерации, чтобы бан
|
||||
не мог гоняться с сохранением сообщения. Каждый отправляемый конверт получает
|
||||
новый случайный ключ содержимого. Исключённый участник сохраняет доступ к уже
|
||||
полученным сообщениям, но его ключ больше не включается в новые конверты.
|
||||
|
||||
ID сообщения генерируется клиентом и подписывается. Повторная отправка того же
|
||||
конверта не создаёт второй записи/задания push. Редактирование проверяет ID,
|
||||
автора, чат, ответ, вложения и время версии. Клиент хранит принятые версии,
|
||||
отклоняет откат к старой версии и проверяет подпись перед показом текста.
|
||||
|
||||
## Вложения
|
||||
|
||||
Клиент шифрует файл AES-256-GCM с новым случайным 32-байтовым ключом и 12-байтовым
|
||||
nonce. Формат: `nonce || ciphertext || tag(16)`; AAD — `govor-attachment-v1`.
|
||||
Сервер получает случайное имя `.bin`, тип `application/vnd.govor.encrypted` и
|
||||
байты шифротекста. Исходное имя, MIME-тип и ключ передаются только внутри
|
||||
зашифрованного сообщения. Поле `EncryptedKey` загрузки должно быть пустым.
|
||||
Незашифрованные загрузки типа Message отклоняются; аватары остаются открытыми.
|
||||
|
||||
Получатель сначала проверяет и расшифровывает сообщение, сохраняет секреты
|
||||
вложений локально, затем загружает и проверяет файл. Предельный размер исходного
|
||||
файла — 19 MB, текста — 20 000 символов, устройств — 500, конверта — 1 000 000
|
||||
символов. Ограничения предотвращают неограниченный рост RSA-конверта.
|
||||
|
||||
## Обновление и ограничения
|
||||
|
||||
1. Собрать и согласованно обновить сервер и клиенты всех участников. Старые
|
||||
клиенты не смогут отправлять сообщения в защищаемые чаты. Автоматического
|
||||
временного перехода на открытый текст нет.
|
||||
2. Пользователям нужно войти в новый клиент для регистрации устройств. Пока
|
||||
хотя бы у одного участника нет ключа, новый клиент блокирует отправку.
|
||||
3. Сверить отпечатки и состав получателей. Проверить личный чат, приватную
|
||||
группу/канал, редактирование, вложения, новое устройство и исключение участника
|
||||
на реальных устройствах перед развёртыванием.
|
||||
|
||||
Новая миграция БД не требуется: используются существующие таблицы CryptoSession
|
||||
и SignedPreKey, в которых хранятся только публичные данные. Старые заготовки
|
||||
Signal prekeys не превращаются автоматически в совместимые ключи JOSE; если
|
||||
они уже были привязаны к сессии, нужна новая сессия.
|
||||
|
||||
Уже сохранённая открытая история и старые файлы не становятся секретными задним
|
||||
числом. Они не удаляются; клиент помечает открытую историю `[Без E2EE]`.
|
||||
При невозможности расшифровки показывается статус без шифротекста и вложений;
|
||||
неуспешный результат не сохраняется вместо исходной записи локального кэша.
|
||||
|
||||
Новый физический аппарат не получает прошлые ключи автоматически. После удаления
|
||||
SecureStorage или потери устройства зашифрованная история без другого устройства
|
||||
с нужными ключами недоступна. Серверного восстановления/экспорта ключей нет.
|
||||
Локальный кэш сообщений пока хранит уже расшифрованный текст, как и раньше.
|
||||
|
||||
В v1 нет forward secrecy/post-compromise security и Double Ratchet/MLS:
|
||||
компрометация приватного ключа устройства позволяет расшифровать сохранённые
|
||||
сообщения, адресованные этому ключу. Отзыв сессии исключает её из будущих
|
||||
получателей; украденные ключи и уже прочитанные сообщения отозвать невозможно.
|
||||
Метаданные, участники, размеры и время сообщений видны серверу. Скомпрометированное
|
||||
устройство участника и копирование текста самим участником за пределами модели
|
||||
защиты. HTTPS по-прежнему требуется для авторизации и защиты транспорта.
|
||||
|
||||
## Проверка
|
||||
|
||||
```powershell
|
||||
dotnet test 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
|
||||
```
|
||||
|
||||
Тесты проверяют совместимость шифрования/расшифровки, подписи и контекст,
|
||||
доступ посторонних, отзыв устройств, смену состава группы, версии сообщений,
|
||||
секреты вложений, отказ сверки ключей и отказ записи приватного ключа.
|
||||
@@ -0,0 +1,172 @@
|
||||
# Деплой на VPS Timeweb через GitHub Actions
|
||||
|
||||
После включения: push в `master` → существующие тесты SQLite/PostgreSQL → сборка
|
||||
Dockerfile → публикация в GitHub Container Registry (GHCR) → SSH → миграции →
|
||||
обновление контейнеров → проверка `/server/ready`. PR выполняет только тесты.
|
||||
Доступен и ручной запуск workflow `.NET` для `master`.
|
||||
|
||||
Базовая конфигурация рассчитана на один VPS Linux x86_64 и внешнюю PostgreSQL.
|
||||
Обновление допускает короткий перерыв. База не переносится автоматически.
|
||||
|
||||
## Постоянные данные
|
||||
|
||||
```text
|
||||
/opt/govor/
|
||||
shared/runtime.env # секреты API, создаются вручную
|
||||
shared/deploy.env # домен
|
||||
data/logs/ # /app/logs в контейнере
|
||||
data/uploads/ # /app/uploads в контейнере
|
||||
releases/<commit-run>/ # Compose, Caddyfile, deploy.sh, image.env
|
||||
current -> releases/... # последний успешный релиз
|
||||
```
|
||||
|
||||
`logs` и `uploads` подключены через bind mounts с фиксированными абсолютными путями.
|
||||
GitHub Actions копирует только конфигурацию нового релиза и заменяет контейнеры.
|
||||
Данные находятся вне репозитория и каталога релиза. Скрипт не выполняет очистку,
|
||||
`git clean`, `rsync --delete`, `docker compose down -v` или удаление Docker volumes.
|
||||
Если папок данных нет, деплой завершится ошибкой вместо создания пустого хранилища.
|
||||
Приложение по-прежнему может удалять файлы по пользовательским запросам.
|
||||
|
||||
Сертификаты Caddy хранятся в именованных Docker volumes проекта `govor`.
|
||||
Ротация Docker stdout ограничена; файловые логи API сохраняются и требуют контроля
|
||||
свободного места. Настройте отдельные резервные копии БД и `/opt/govor/data` вне VPS:
|
||||
постоянный диск сам по себе не является резервной копией.
|
||||
|
||||
## 1. Подготовить сервер один раз
|
||||
|
||||
Установите Docker Engine и Compose plugin по официальной инструкции Docker для
|
||||
выбранной ОС. Нужны Bash, `flock` (util-linux) и OpenSSH. Compose должен поддерживать
|
||||
несколько `--env-file` и `up --wait` (например, актуальный Compose v2).
|
||||
|
||||
Создайте пользователя `deploy` с SSH-доступом по отдельному ключу и доступом к
|
||||
Docker. Членство в группе `docker` фактически даёт административные права на VPS.
|
||||
На сервере, от администратора:
|
||||
|
||||
```bash
|
||||
sudo usermod -aG docker deploy
|
||||
sudo install -d -o deploy -g deploy -m 750 /opt/govor
|
||||
sudo install -d -o deploy -g deploy -m 700 /opt/govor/shared
|
||||
sudo install -d -o deploy -g deploy -m 750 /opt/govor/releases /opt/govor/data
|
||||
sudo install -d -o deploy -g deploy -m 750 /opt/govor/data/logs /opt/govor/data/uploads
|
||||
```
|
||||
|
||||
Переподключитесь по SSH после изменения групп. Добавьте публичный ключ Actions в
|
||||
`~deploy/.ssh/authorized_keys`. Приватный ключ останется в GitHub Secrets.
|
||||
|
||||
Создайте `/opt/govor/shared/runtime.env` по корневому `.env.example` с реальными
|
||||
значениями текущего приложения. Сохраните существующие JWT/refresh-секреты при
|
||||
переносе, если не требуется отзывать сессии. Формат — Docker env file; значения
|
||||
со знаком `$` заключайте в одинарные кавычки, чтобы Compose не интерполировал их.
|
||||
|
||||
Создайте `/opt/govor/shared/deploy.env` по `deploy/deploy.env.example`:
|
||||
|
||||
```dotenv
|
||||
GOVOR_DOMAIN=api.example.com
|
||||
```
|
||||
|
||||
```bash
|
||||
chmod 600 /opt/govor/shared/runtime.env /opt/govor/shared/deploy.env
|
||||
docker compose version
|
||||
docker info >/dev/null
|
||||
```
|
||||
|
||||
Настройте DNS домена на IP VPS, входящие TCP 80/443 на Caddy и SSH для деплоя.
|
||||
API 8080 и PostgreSQL не публикуются этим Compose в интернет. Разрешите новому VPS
|
||||
подключение к внешней БД. Сертификат PostgreSQL из `Govor.API/certs` уже включён
|
||||
в Dockerfile через publish проекта.
|
||||
|
||||
Для приватного GHCR-образа войдите в реестр **под пользователем deploy** один раз:
|
||||
|
||||
```bash
|
||||
read -rsp 'GHCR token (read:packages): ' ghcr_token; echo
|
||||
printf '%s' "$ghcr_token" | docker login ghcr.io -u YOUR_GITHUB_LOGIN --password-stdin
|
||||
unset ghcr_token
|
||||
```
|
||||
|
||||
Используйте токен с доступом к пакету и `read:packages` (при необходимости разрешите
|
||||
SSO организации). Токен сервера нужен для скачивания приватного образа; Actions
|
||||
публикует образ своим временным `GITHUB_TOKEN`. Публичный пакет не требует входа
|
||||
на VPS. Не помещайте токен в runtime.env или Git.
|
||||
|
||||
## 2. Перенести существующие файлы
|
||||
|
||||
До переключения клиентов сохраните копию БД и существующих `uploads`/`logs`.
|
||||
Остановите запись в старый API на время финального копирования, чтобы файлы и БД
|
||||
оставались согласованными. Скопируйте **содержимое** прежней папки uploads в
|
||||
`/opt/govor/data/uploads`, сохраняя все вложенные пути, и аналогично logs в
|
||||
`/opt/govor/data/logs`. Не создавайте лишний уровень `uploads/uploads`.
|
||||
Если БД остаётся прежней, её повторный импорт не нужен.
|
||||
|
||||
Сначала проверьте новую установку, затем переключите домен и отключите старый API.
|
||||
Если адрес API меняется, обновите настройки мобильного клиента. Для проверки до
|
||||
смены DNS можно использовать `curl --resolve` с новым IP после настройки TLS.
|
||||
|
||||
## 3. Настроить GitHub
|
||||
|
||||
В Settings → Environments создайте `production`. Ограничьте deployment branches
|
||||
веткой `master`. Для автоматического деплоя без ручного подтверждения не включайте
|
||||
required reviewers. Добавьте environment secrets:
|
||||
|
||||
| Secret | Значение |
|
||||
| --- | --- |
|
||||
| `VPS_HOST` | IP или домен SSH сервера |
|
||||
| `VPS_USER` | `deploy` |
|
||||
| `VPS_SSH_KEY` | Полный приватный SSH-ключ без passphrase, включая BEGIN/END |
|
||||
| `VPS_KNOWN_HOSTS` | Проверенная запись host key сервера в формате known_hosts |
|
||||
|
||||
Получить запись можно через `ssh-keyscan -p 22 SERVER`, но перед сохранением
|
||||
обязательно сверить fingerprint с ключом через консоль Timeweb:
|
||||
`ssh-keygen -lf /etc/ssh/ssh_host_ed25519_key.pub`.
|
||||
Для нестандартного порта known_hosts использует `[host]:port`.
|
||||
|
||||
В Repository → Settings → Secrets and variables → Actions → Variables:
|
||||
|
||||
| Variable | Значение |
|
||||
| --- | --- |
|
||||
| `VPS_DEPLOY_ENABLED` | `true`, только после подготовки сервера и переноса данных |
|
||||
| `VPS_SSH_PORT` | Необязательно; по умолчанию `22` |
|
||||
|
||||
Workflow публикует `ghcr.io/<owner>/<repo>:<commit>`; запускается точный digest
|
||||
`@sha256:...`. Actions получает `packages: write` только в задаче публикации.
|
||||
Если пакет уже существует, предоставьте репозиторию Actions-доступ к нему в
|
||||
настройках пакета. Пока `VPS_DEPLOY_ENABLED` не включён, работают только тесты.
|
||||
|
||||
## 4. Обновления и диагностика
|
||||
|
||||
Сделайте push в `master` или запустите `.NET` → Run workflow → `master`.
|
||||
Не удаляйте резервную копию БД перед потенциально разрушающими миграциями.
|
||||
Скрипт сначала скачивает образ, затем запускает `--migrate-only`. При ошибке
|
||||
миграции контейнер текущего API не заменяется; сама миграция уже могла изменить БД.
|
||||
При ошибке запуска job падает; автоматического отката схемы или контейнера нет.
|
||||
Ссылка `current` обновляется только после успешной проверки готовности.
|
||||
Деплои сериализуются GitHub concurrency и серверной блокировкой `flock`.
|
||||
|
||||
Посмотреть контейнеры и логи на VPS:
|
||||
|
||||
```bash
|
||||
docker compose --project-name govor \
|
||||
--env-file /opt/govor/shared/deploy.env \
|
||||
--env-file /opt/govor/current/image.env \
|
||||
-f /opt/govor/current/compose.yaml ps
|
||||
docker compose --project-name govor \
|
||||
--env-file /opt/govor/shared/deploy.env \
|
||||
--env-file /opt/govor/current/image.env \
|
||||
-f /opt/govor/current/compose.yaml logs --tail=100 api proxy
|
||||
```
|
||||
|
||||
При первом неудачном деплое вместо `current` используйте путь релиза из Actions.
|
||||
Проверьте HTTPS `/server/ready`, вход, старые вложения, отправку нового файла и
|
||||
SignalR. Чтобы проверить сохранность, запишите контрольные суммы нескольких
|
||||
существующих файлов в uploads, выполните повторный деплой и сравните их.
|
||||
|
||||
Для возврата к прежнему образу выберите совместимый со схемой БД успешный релиз
|
||||
из `releases`, возьмите digest из его `image.env` и выполните
|
||||
`bash /opt/govor/releases/<release>/deploy.sh ghcr.io/<owner>/<repo>@sha256:<digest>`.
|
||||
Старый код не отменяет миграции; несовместимая схема требует отдельного плана
|
||||
восстановления БД. Старые образы и каталоги релизов автоматически не очищаются.
|
||||
|
||||
Официальные инструкции:
|
||||
- https://docs.docker.com/engine/install/ubuntu/
|
||||
- https://docs.docker.com/engine/storage/bind-mounts/
|
||||
- https://docs.github.com/en/actions/tutorials/publish-packages/publish-docker-images
|
||||
- https://caddyserver.com/docs/quick-starts/reverse-proxy
|
||||
Reference in New Issue
Block a user