Skip to content

Privacy-first password manager with built-in email aliasing. Fully encrypted and self-hostable.

Tweak API accessible manifests query to prevent table scans (#2159)

Leendert de Borstd957cfd0f92a
diff --git a/apps/server/AliasVault.Api/Controllers/V2/StatusController.cs b/apps/server/AliasVault.Api/Controllers/V2/StatusController.cs
index 2e998b928..64952039a 100644
--- a/apps/server/AliasVault.Api/Controllers/V2/StatusController.cs
+++ b/apps/server/AliasVault.Api/Controllers/V2/StatusController.cs
@@ -54,7 +54,8 @@ public class StatusController(IAliasServerDbContextFactory dbContextFactory, Use
// Manifest revisions for every manifest this user can access, built via the shared helper, plus which of them
// is their own: the client needs the id to tell its personal vault from the shared ones it syncs alongside.
- var manifestRevisions = await VaultStatusHelper.GetManifestRevisionsAsync(context, user.Id);
+ var accessScope = await ManifestAccessHelper.ResolveScopeAsync(context, user.Id, user.PersonalGroupId);
+ var manifestRevisions = await VaultStatusHelper.GetManifestRevisionsAsync(context, accessScope);
var personalManifestId = await GroupHelper.GetPersonalManifestIdAsync(context, user.PersonalGroupId);
// Latest revision of every bucket available to the caller.
diff --git a/apps/server/AliasVault.Api/Controllers/V2/VaultController.cs b/apps/server/AliasVault.Api/Controllers/V2/VaultController.cs
index 336e15427..6682fc432 100644
--- a/apps/server/AliasVault.Api/Controllers/V2/VaultController.cs
+++ b/apps/server/AliasVault.Api/Controllers/V2/VaultController.cs
@@ -10,6 +10,7 @@ namespace AliasVault.Api.Controllers.V2;
using AliasServerDb;
using AliasVault.Api.Controllers.Abstracts;
using AliasVault.Api.Helpers;
+using AliasVault.Api.Models;
using AliasVault.Api.Services;
using AliasVault.Api.Vault;
using AliasVault.Api.Vault.RetentionRules;
@@ -88,9 +89,10 @@ public class VaultController(
}
var emailRouting = await BuildEmailRoutingAsync(context, user);
+ var accessScope = await ManifestAccessHelper.ResolveScopeAsync(context, user.Id, user.PersonalGroupId);
// Every manifest the caller can open.
- var latestManifests = await AccessibleManifests(context, user.Id)
+ var latestManifests = await AccessibleManifests(context, accessScope)
.Select(x => new { x.ManifestId, x.ManifestBlob, x.ManifestCiphertextHash, x.RevisionNumber, x.OwnerGroupId, OwnerGroupType = x.OwnerGroup.Type })
.ToListAsync();
@@ -188,7 +190,8 @@ public class VaultController(
}
// The caller can fetch a manifest owned by a group they own, or one granted to them (a shared manifest).
- var latest = await AccessibleManifests(context, user.Id).FirstOrDefaultAsync(x => x.ManifestId == manifestId);
+ var accessScope = await ManifestAccessHelper.ResolveScopeAsync(context, user.Id, user.PersonalGroupId);
+ var latest = await AccessibleManifests(context, accessScope).FirstOrDefaultAsync(x => x.ManifestId == manifestId);
if (latest == null)
{
@@ -285,10 +288,12 @@ public class VaultController(
bucketBlobs[(bucket.ManifestId, bucket.Category)] = bucketBlob;
}
+ var accessScope = await ManifestAccessHelper.ResolveScopeAsync(context, user.Id, user.PersonalGroupId);
+
var resolved = new List<(ManifestWrite Write, VaultManifest Row)>();
foreach (var mw in model.Manifests)
{
- var row = await ManifestAccessHelper.AccessibleManifests(context, user.Id).FirstOrDefaultAsync(x => x.ManifestId == mw.ManifestId);
+ var row = await ManifestAccessHelper.AccessibleManifests(context, accessScope).FirstOrDefaultAsync(x => x.ManifestId == mw.ManifestId);
if (row == null)
{
return NotFound(ApiErrorCodeHelper.CreateValidationErrorResponse(ApiErrorCode.SHARED_MANIFEST_NOT_FOUND, 404));
@@ -304,7 +309,7 @@ public class VaultController(
continue;
}
- if (!await ManifestAccessHelper.AccessibleManifests(context, user.Id).AnyAsync(x => x.ManifestId == bucketManifestId))
+ if (!await ManifestAccessHelper.AccessibleManifests(context, accessScope).AnyAsync(x => x.ManifestId == bucketManifestId))
{
return NotFound(ApiErrorCodeHelper.CreateValidationErrorResponse(ApiErrorCode.SHARED_MANIFEST_NOT_FOUND, 404));
}
@@ -561,7 +566,7 @@ public class VaultController(
{
// Only update email claims when the client sends a non-empty routing object. If null has been sent by client, we
// do not update the email claims (so to not delete any claims if they have been forgotten by the client).
- await UpdateEmailClaimsAsync(context, user, model.EmailRouting);
+ await UpdateEmailClaimsAsync(context, user, accessScope, model.EmailRouting);
}
await context.SaveChangesAsync();
@@ -677,7 +682,8 @@ public class VaultController(
var missing = wanted.Except(rows.Select(r => r.Hash), StringComparer.Ordinal).ToList();
if (missing.Count > 0)
{
- var accessibleManifests = await AccessibleManifests(context, user.Id)
+ var accessScope = await ManifestAccessHelper.ResolveScopeAsync(context, user.Id, user.PersonalGroupId);
+ var accessibleManifests = await AccessibleManifests(context, accessScope)
.Where(m => m.OwnerGroup.Type == GroupType.Shared)
.Select(m => new { m.ManifestId, m.RevisionNumber })
.ToListAsync();
@@ -760,11 +766,11 @@ public class VaultController(
/// Same access rule as <see cref="ManifestAccessHelper.AccessibleManifests"/>; only the format differs.
/// </summary>
/// <param name="context">Database context.</param>
- /// <param name="userId">The calling user.</param>
+ /// <param name="scope">The caller's manifest access scope.</param>
/// <returns>Query over the accessible manifest-v1 manifests.</returns>
- private static IQueryable<VaultManifest> AccessibleManifests(AliasServerDbContext context, string userId)
+ private static IQueryable<VaultManifest> AccessibleManifests(AliasServerDbContext context, ManifestAccessScope scope)
{
- return ManifestAccessHelper.AccessibleManifests(context, userId).Where(m => m.StorageFormat == ManifestFormat);
+ return ManifestAccessHelper.AccessibleManifests(context, scope).Where(m => m.StorageFormat == ManifestFormat);
}
/// <summary>
@@ -991,8 +997,9 @@ public class VaultController(
/// </summary>
/// <param name="context">Database context.</param>
/// <param name="user">The calling user.</param>
+ /// <param name="scope">The caller's manifest access scope.</param>
/// <param name="routing">The pushed routing data: one entry per (address, manifest) pair, plus the manifests it speaks for.</param>
- private async Task UpdateEmailClaimsAsync(AliasServerDbContext context, AliasVaultUser user, EmailRoutingPush routing)
+ private async Task UpdateEmailClaimsAsync(AliasServerDbContext context, AliasVaultUser user, ManifestAccessScope scope, EmailRoutingPush routing)
{
// Get all unique emails with calculated state (active wins from paused in case there are multiple).
var pushedPairs = routing.EmailAddressList
@@ -1000,7 +1007,7 @@ public class VaultController(
.Select(g => new { g.Key.Address, g.Key.ManifestId, State = g.All(x => x.Paused) ? EmailClaimLinkState.Paused : EmailClaimLinkState.Active })
.ToList();
- var accessibleManifests = (await ManifestAccessHelper.AccessibleManifests(context, user.Id).Select(m => m.ManifestId).ToListAsync()).ToHashSet();
+ var accessibleManifests = (await ManifestAccessHelper.AccessibleManifests(context, scope).Select(m => m.ManifestId).ToListAsync()).ToHashSet();
var ownedManifests = (await context.VaultManifests
.Where(m => context.GroupMembers.Any(gm => gm.GroupId == m.OwnerGroupId && gm.UserId == user.Id && gm.Role == GroupRole.Owner))
.Select(m => m.ManifestId)
@@ -1048,12 +1055,14 @@ public class VaultController(
// Per address: the manifests that carry it, each with the state the push puts that link in.
var desiredByAddress = assertedPairs.GroupBy(p => p.Address).ToDictionary(g => g.Key, g => g.ToDictionary(p => p.ManifestId, p => p.State));
- // Get the claims this push may update: every claim linked to a manifest inside the caller's update scope.
- var userOwnedEmailClaims = await context.EmailClaims
+ // Get the claims this push may update.
+ var scopedEmailClaims = await context.EmailClaims
.Include(c => c.Links)
- .Where(c => c.Links.Any(l => updateScope.Contains(l.VaultManifestId) && l.State != EmailClaimLinkState.Removed)
- || (c.Links.All(l => l.State == EmailClaimLinkState.Removed) && c.Links.Any(l => updateScope.Contains(l.VaultManifestId))))
+ .Where(c => c.Links.Any(l => updateScope.Contains(l.VaultManifestId)))
.ToListAsync();
+ var userOwnedEmailClaims = scopedEmailClaims
+ .Where(c => c.Links.Any(l => updateScope.Contains(l.VaultManifestId) && l.State != EmailClaimLinkState.Removed) || c.Links.All(l => l.State == EmailClaimLinkState.Removed))
+ .ToList();
var processed = new HashSet<string>();
var supportedDomains = config.PrivateEmailDomains;
diff --git a/apps/server/AliasVault.Api/Helpers/GrantHelper.cs b/apps/server/AliasVault.Api/Helpers/GrantHelper.cs
index e205f3acb..3d3e82dc0 100644
--- a/apps/server/AliasVault.Api/Helpers/GrantHelper.cs
+++ b/apps/server/AliasVault.Api/Helpers/GrantHelper.cs
@@ -8,6 +8,7 @@
namespace AliasVault.Api.Helpers;
using AliasServerDb;
+using AliasVault.Api.Models;
using AliasVault.Shared.Models.Enums;
using Microsoft.EntityFrameworkCore;
diff --git a/apps/server/AliasVault.Api/Helpers/GroupHelper.cs b/apps/server/AliasVault.Api/Helpers/GroupHelper.cs
index fdb1c5932..aef560398 100644
--- a/apps/server/AliasVault.Api/Helpers/GroupHelper.cs
+++ b/apps/server/AliasVault.Api/Helpers/GroupHelper.cs
@@ -157,6 +157,7 @@ public static class GroupHelper
return await context.VaultManifests
.Where(m => ids.Contains(m.ManifestId))
+ .Select(m => new { m.ManifestId, m.OwnerGroupId })
.ToDictionaryAsync(m => m.ManifestId, m => m.OwnerGroupId);
}
}
diff --git a/apps/server/AliasVault.Api/Helpers/ManifestAccessHelper.cs b/apps/server/AliasVault.Api/Helpers/ManifestAccessHelper.cs
index 27bb0ddc0..4a147da76 100644
--- a/apps/server/AliasVault.Api/Helpers/ManifestAccessHelper.cs
+++ b/apps/server/AliasVault.Api/Helpers/ManifestAccessHelper.cs
@@ -8,7 +8,9 @@
namespace AliasVault.Api.Helpers;
using AliasServerDb;
+using AliasVault.Api.Models;
using AliasVault.Shared.Models.Enums;
+using Microsoft.EntityFrameworkCore;
/// <summary>
/// Helper for resolving which vault manifests a user can access.
@@ -16,15 +18,35 @@ using AliasVault.Shared.Models.Enums;
public static class ManifestAccessHelper
{
/// <summary>
- /// Every manifest the user can access: their own personal manifest, plus every shared manifest they hold a grant on.
+ /// Resolves the caller's access scope.
/// </summary>
/// <param name="context">Database context.</param>
/// <param name="userId">The calling user.</param>
+ /// <param name="personalGroupId">The caller's personal group, when already loaded. Looked up when null.</param>
+ /// <returns>The caller's access scope.</returns>
+ public static async Task<ManifestAccessScope> ResolveScopeAsync(AliasServerDbContext context, string userId, Guid? personalGroupId = null)
+ {
+ var groupId = personalGroupId ?? await context.AliasVaultUsers.Where(u => u.Id == userId).Select(u => u.PersonalGroupId).FirstOrDefaultAsync();
+ var grantedManifestIds = await context.VaultManifestAccessKeys
+ .Where(k => k.UserId == userId && k.Type == ManifestKeyType.GrantKey)
+ .Select(k => k.VaultManifestId)
+ .Distinct()
+ .ToListAsync();
+
+ return new ManifestAccessScope(groupId, grantedManifestIds);
+ }
+
+ /// <summary>
+ /// Every manifest the user can access: their own personal manifest, plus every shared manifest they hold a grant on.
+ /// </summary>
+ /// <param name="context">Database context.</param>
+ /// <param name="scope">The caller's access scope, from <see cref="ResolveScopeAsync"/>.</param>
/// <returns>Query over the manifests the user can access, in any storage format.</returns>
- public static IQueryable<VaultManifest> AccessibleManifests(AliasServerDbContext context, string userId)
+ public static IQueryable<VaultManifest> AccessibleManifests(AliasServerDbContext context, ManifestAccessScope scope)
{
- return context.VaultManifests
- .Where(m => context.AliasVaultUsers.Any(u => u.Id == userId && u.PersonalGroupId == m.OwnerGroupId)
- || context.VaultManifestAccessKeys.Any(k => k.UserId == userId && k.Type == ManifestKeyType.GrantKey && k.VaultManifestId == m.ManifestId));
+ var personalGroupId = scope.PersonalGroupId;
+ var grantedManifestIds = scope.GrantedManifestIds;
+
+ return context.VaultManifests.Where(m => m.OwnerGroupId == personalGroupId || grantedManifestIds.Contains(m.ManifestId));
}
}
diff --git a/apps/server/AliasVault.Api/Helpers/VaultStatusHelper.cs b/apps/server/AliasVault.Api/Helpers/VaultStatusHelper.cs
index 52d8cf290..a9ac6eb8c 100644
--- a/apps/server/AliasVault.Api/Helpers/VaultStatusHelper.cs
+++ b/apps/server/AliasVault.Api/Helpers/VaultStatusHelper.cs
@@ -8,6 +8,7 @@
namespace AliasVault.Api.Helpers;
using AliasServerDb;
+using AliasVault.Api.Models;
using AliasVault.Shared.Models.WebApi.V2.Vault;
using Microsoft.EntityFrameworkCore;
@@ -20,11 +21,11 @@ public static class VaultStatusHelper
/// The full manifest-revision list a status endpoint reports: every manifest the user can access.
/// </summary>
/// <param name="context">Database context.</param>
- /// <param name="userId">The id of the user to build manifest revisions for.</param>
+ /// <param name="scope">The caller's manifest access scope.</param>
/// <returns>The accessible manifest revision list.</returns>
- public static async Task<List<ManifestRevision>> GetManifestRevisionsAsync(AliasServerDbContext context, string userId)
+ public static async Task<List<ManifestRevision>> GetManifestRevisionsAsync(AliasServerDbContext context, ManifestAccessScope scope)
{
- return await ManifestAccessHelper.AccessibleManifests(context, userId)
+ return await ManifestAccessHelper.AccessibleManifests(context, scope)
.Select(x => new ManifestRevision { ManifestId = x.ManifestId, Revision = x.RevisionNumber })
.ToListAsync();
}
diff --git a/apps/server/AliasVault.Api/Models/ManifestAccessScope.cs b/apps/server/AliasVault.Api/Models/ManifestAccessScope.cs
new file mode 100644
index 000000000..0c899b8bd
--- /dev/null
+++ b/apps/server/AliasVault.Api/Models/ManifestAccessScope.cs
@@ -0,0 +1,15 @@
+//-----------------------------------------------------------------------
+// <copyright file="ManifestAccessScope.cs" company="aliasvault">
+// Copyright (c) aliasvault. All rights reserved.
+// Licensed under the AGPLv3 license. See LICENSE.md file in the project root for full license information.
+// </copyright>
+//-----------------------------------------------------------------------
+
+namespace AliasVault.Api.Models;
+
+/// <summary>
+/// The two arms of the manifest access rule resolved to constants.
+/// </summary>
+/// <param name="PersonalGroupId">The caller's personal group.</param>
+/// <param name="GrantedManifestIds">The manifests the caller holds a grant key on.</param>
+public readonly record struct ManifestAccessScope(Guid PersonalGroupId, List<Guid> GrantedManifestIds);
diff --git a/apps/server/AliasVault.Api/Helpers/MemberPublicKey.cs b/apps/server/AliasVault.Api/Models/MemberPublicKey.cs
similarity index 95%
rename from apps/server/AliasVault.Api/Helpers/MemberPublicKey.cs
rename to apps/server/AliasVault.Api/Models/MemberPublicKey.cs
index c650cd8ef..00f37817e 100644
--- a/apps/server/AliasVault.Api/Helpers/MemberPublicKey.cs
+++ b/apps/server/AliasVault.Api/Models/MemberPublicKey.cs
@@ -5,7 +5,7 @@
// </copyright>
//-----------------------------------------------------------------------
-namespace AliasVault.Api.Helpers;
+namespace AliasVault.Api.Models;
/// <summary>
/// The public key a shared manifest's key is sealed for when it is handed to somebody.