Privacy-first password manager with built-in email aliasing. Fully encrypted and self-hostable.
Add rate limit tables
Leendert de Borst78559c7ece5c
diff --git a/apps/server/AliasVault.Api/Program.cs b/apps/server/AliasVault.Api/Program.csindex 7fd290343..9923ca071 100644--- a/apps/server/AliasVault.Api/Program.cs+++ b/apps/server/AliasVault.Api/Program.cs@@ -88,6 +88,7 @@ builder.Services.AddScoped<ServerSettingsService>();builder.Services.AddScoped<RegistrationRateLimitService>();builder.Services.AddScoped<IpBlockListService>();builder.Services.AddSingleton<FaviconRateLimitService>();+builder.Services.AddScoped<RateLimitService>();builder.Services.AddHttpContextAccessor();builder.Services.AddLogging(logging =>diff --git a/apps/server/AliasVault.Api/Services/EffectiveRateLimit.cs b/apps/server/AliasVault.Api/Services/EffectiveRateLimit.csnew file mode 100644index 000000000..57a7a5df2--- /dev/null+++ b/apps/server/AliasVault.Api/Services/EffectiveRateLimit.cs@@ -0,0 +1,16 @@+//-----------------------------------------------------------------------+// <copyright file="EffectiveRateLimit.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.Services;++/// <summary>+/// A resolved limit for a user: <paramref name="MaxCount"/> over a window (<paramref name="WindowSeconds"/> 0 =+/// absolute cap, > 0 = rolling window).+/// </summary>+/// <param name="WindowSeconds">The rolling window length in seconds, or 0 for an absolute cap.</param>+/// <param name="MaxCount">The maximum allowed count for the window.</param>+public sealed record EffectiveRateLimit(int WindowSeconds, int MaxCount);diff --git a/apps/server/AliasVault.Api/Services/RateLimitResolver.cs b/apps/server/AliasVault.Api/Services/RateLimitResolver.csnew file mode 100644index 000000000..061f553b3--- /dev/null+++ b/apps/server/AliasVault.Api/Services/RateLimitResolver.cs@@ -0,0 +1,124 @@+//-----------------------------------------------------------------------+// <copyright file="RateLimitResolver.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.Services;++using AliasServerDb;++/// <summary>+/// Rate limit resolver logic which determines the limits that apply to a given user.+/// </summary>+public static class RateLimitResolver+{+ /// <summary>+ /// Resolves the limits that apply to the given user. For each window the most specific scope wins+ /// (per-user > per-tier > global); a winning MaxCount of 0 means unlimited.+ /// </summary>+ /// <param name="rules">The candidate rules.</param>+ /// <param name="user">The user to resolve limits for.</param>+ /// <param name="limitType">The limit type to resolve.</param>+ /// <param name="now">The current UTC time, used to evaluate effective-from/until windows.</param>+ /// <returns>The limits that must all be satisfied. Empty means no limit applies.</returns>+ public static IReadOnlyList<EffectiveRateLimit> Resolve(IEnumerable<RateLimit> rules, AliasVaultUser user, RateLimitType limitType, DateTime now)+ {+ var tier = ResolveTier(user);++ var applicableRules = rules+ .Where(r => r.Enabled)+ .Where(r => r.LimitType == limitType)+ .Where(r => (r.EffectiveFrom is null || r.EffectiveFrom <= now) && (r.EffectiveUntil is null || r.EffectiveUntil >= now))+ .Where(r => r.AppliesToAccountAgeMaxDays is null || user.CreatedAt > now.AddDays(-r.AppliesToAccountAgeMaxDays.Value));++ var windows = new HashSet<int>();+ var userMax = new Dictionary<int, int>();+ var tierMax = new Dictionary<int, int>();+ var globalMax = new Dictionary<int, int>();++ foreach (var rule in applicableRules)+ {+ if (rule.UserId is not null)+ {+ if (rule.UserId == user.Id)+ {+ Record(windows, userMax, rule.WindowSeconds, rule.MaxCount);+ }+ }+ else if (rule.Tier is not null)+ {+ if (rule.Tier == tier)+ {+ Record(windows, tierMax, rule.WindowSeconds, rule.MaxCount);+ }+ }+ else+ {+ Record(windows, globalMax, rule.WindowSeconds, rule.MaxCount);+ }+ }++ var result = new List<EffectiveRateLimit>();+ foreach (var window in windows)+ {+ int max;+ if (userMax.TryGetValue(window, out var um))+ {+ max = um;+ }+ else if (tierMax.TryGetValue(window, out var tm))+ {+ max = tm;+ }+ else if (globalMax.TryGetValue(window, out var gm))+ {+ max = gm;+ }+ else+ {+ continue;+ }++ // 0 = unlimited, so not enforced.+ if (max > 0)+ {+ result.Add(new EffectiveRateLimit(window, max));+ }+ }++ return result;+ }++ /// <summary>+ /// Resolves the user's tier. Tiers are not implemented yet, so every user is <see cref="AccountTier.Free"/> by default.+ /// </summary>+ /// <param name="user">The user to resolve the tier for.</param>+ /// <returns>The account tier that applies to the user.</returns>+ public static AccountTier ResolveTier(AliasVaultUser user) => AccountTier.Free;++ /// <summary>+ /// Records a candidate MaxCount for a scope+window. A concrete limit wins over unlimited (0), and between+ /// multiple concrete limits the most restrictive (smallest) is kept.+ /// </summary>+ private static void Record(HashSet<int> windows, Dictionary<int, int> map, int window, int max)+ {+ windows.Add(window);++ if (!map.TryGetValue(window, out var existing))+ {+ map[window] = max;+ return;+ }++ if (existing == 0)+ {+ map[window] = max;+ }+ else if (max > 0)+ {+ map[window] = Math.Min(existing, max);+ }+ }+}diff --git a/apps/server/AliasVault.Api/Services/RateLimitService.cs b/apps/server/AliasVault.Api/Services/RateLimitService.csnew file mode 100644index 000000000..4b2af4623--- /dev/null+++ b/apps/server/AliasVault.Api/Services/RateLimitService.cs@@ -0,0 +1,60 @@+//-----------------------------------------------------------------------+// <copyright file="RateLimitService.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.Services;++using AliasServerDb;+using AliasVault.Shared.Providers.Time;+using Microsoft.EntityFrameworkCore;+using Microsoft.Extensions.Caching.Memory;++/// <summary>+/// Resolves the rate-limit rules that apply to a given user. Rules are read from the RateLimits table and cached+/// in memory briefly so the vault-sync hot path does not hit the database on every request.+/// </summary>+/// <param name="dbContextFactory">IDbContextFactory instance.</param>+/// <param name="cache">IMemoryCache instance used to cache the enabled rules.</param>+/// <param name="timeProvider">ITimeProvider instance.</param>+public class RateLimitService(IAliasServerDbContextFactory dbContextFactory, IMemoryCache cache, ITimeProvider timeProvider)+{+ private const int CacheDurationSeconds = 60;++ private const string EnabledRulesCacheKey = "RateLimits_EnabledRules";++ /// <summary>+ /// Resolves the limits that apply to the given user for the given limit type.+ /// </summary>+ /// <param name="user">The user to resolve limits for.</param>+ /// <param name="limitType">The limit type to resolve.</param>+ /// <returns>The limits that must all be satisfied. Empty means no limit applies.</returns>+ public async Task<IReadOnlyList<EffectiveRateLimit>> ResolveAsync(AliasVaultUser user, RateLimitType limitType)+ {+ var rules = await GetEnabledRulesAsync();+ return RateLimitResolver.Resolve(rules, user, limitType, timeProvider.UtcNow);+ }++ /// <summary>+ /// Returns the enabled rules from cache, refreshing at most once every <see cref="CacheDurationSeconds"/>.+ /// </summary>+ /// <returns>The list of enabled rules.</returns>+ private async Task<List<RateLimit>> GetEnabledRulesAsync()+ {+ if (cache.TryGetValue(EnabledRulesCacheKey, out List<RateLimit>? cached) && cached is not null)+ {+ return cached;+ }++ await using var dbContext = await dbContextFactory.CreateDbContextAsync();+ var rules = await dbContext.RateLimits+ .AsNoTracking()+ .Where(x => x.Enabled)+ .ToListAsync();++ cache.Set(EnabledRulesCacheKey, rules, TimeSpan.FromSeconds(CacheDurationSeconds));+ return rules;+ }+}diff --git a/apps/server/Databases/AliasServerDb/AccountTier.cs b/apps/server/Databases/AliasServerDb/AccountTier.csnew file mode 100644index 000000000..7514b773e--- /dev/null+++ b/apps/server/Databases/AliasServerDb/AccountTier.cs@@ -0,0 +1,25 @@+//-----------------------------------------------------------------------+// <copyright file="AccountTier.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 AliasServerDb;++/// <summary>+/// Subscription tier of an account, used to target a <see cref="RateLimit"/> rule at a class of users.+/// Tiers are not implemented yet, acts as placeholder for future implementation.+/// </summary>+public enum AccountTier+{+ /// <summary>+ /// The default tier for all accounts.+ /// </summary>+ Free = 0,++ /// <summary>+ /// Premium (paid) tier. Not yet implemented, acts as placeholder for unit tests.+ /// </summary>+ Premium = 1,+}diff --git a/apps/server/Databases/AliasServerDb/AliasServerDbContext.cs b/apps/server/Databases/AliasServerDb/AliasServerDbContext.csindex 67216e2dc..9c09c508c 100644--- a/apps/server/Databases/AliasServerDb/AliasServerDbContext.cs+++ b/apps/server/Databases/AliasServerDb/AliasServerDbContext.cs@@ -147,6 +147,11 @@ public class AliasServerDbContext : WorkerStatusDbContext, IDataProtectionKeyCon/// </summary>public DbSet<BlockedIpRange> BlockedIpRanges { get; set; }+ /// <summary>+ /// Gets or sets the RateLimits DbSet.+ /// </summary>+ public DbSet<RateLimit> RateLimits { get; set; }+/// <summary>/// Sets up the connection string if it is not already configured./// </summary>@@ -285,5 +290,12 @@ public class AliasServerDbContext : WorkerStatusDbContext, IDataProtectionKeyCon.WithMany().HasForeignKey(m => m.UserId).OnDelete(DeleteBehavior.Cascade);++ // Configure RateLimit - AliasVaultUser relationship+ modelBuilder.Entity<RateLimit>()+ .HasOne(r => r.User)+ .WithMany()+ .HasForeignKey(r => r.UserId)+ .OnDelete(DeleteBehavior.Cascade);}}diff --git a/apps/server/Databases/AliasServerDb/AliasVaultUser.cs b/apps/server/Databases/AliasServerDb/AliasVaultUser.csindex 0767528ee..f98c0fbdb 100644--- a/apps/server/Databases/AliasServerDb/AliasVaultUser.cs+++ b/apps/server/Databases/AliasServerDb/AliasVaultUser.cs@@ -69,13 +69,6 @@ public class AliasVaultUser : IdentityUser/// </summary>public int MaxEmailAgeDays { get; set; } = 0;- /// <summary>- /// Gets or sets the per-user alias creation limit. 0 means no per-user limit (global settings may apply).- /// A value greater than 0 is a explicit per-user cap that always applies to this account and takes priority- /// over any other global limit.- /// </summary>- public int MaxAliases { get; set; } = 0;-/// <summary>/// Gets or sets the date of the user's last activity (login, API call, etc.)./// Updated automatically on successful authentication events.diff --git a/apps/server/Databases/AliasServerDb/Migrations/20260624212335_AddRateLimits.Designer.cs b/apps/server/Databases/AliasServerDb/Migrations/20260624212335_AddRateLimits.Designer.csnew file mode 100644index 000000000..f682c0f14--- /dev/null+++ b/apps/server/Databases/AliasServerDb/Migrations/20260624212335_AddRateLimits.Designer.cs@@ -0,0 +1,1118 @@+// <auto-generated />+using System;+using AliasServerDb;+using Microsoft.EntityFrameworkCore;+using Microsoft.EntityFrameworkCore.Infrastructure;+using Microsoft.EntityFrameworkCore.Migrations;+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;++#nullable disable++namespace AliasServerDb.Migrations+{+ [DbContext(typeof(AliasServerDbContext))]+ [Migration("20260624212335_AddRateLimits")]+ partial class AddRateLimits+ {+ /// <inheritdoc />+ protected override void BuildTargetModel(ModelBuilder modelBuilder)+ {+#pragma warning disable 612, 618+ modelBuilder+ .HasAnnotation("ProductVersion", "10.0.6")+ .HasAnnotation("Proxies:ChangeTracking", false)+ .HasAnnotation("Proxies:CheckEquality", false)+ .HasAnnotation("Proxies:LazyLoading", true)+ .HasAnnotation("Relational:MaxIdentifierLength", 63);++ NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);++ modelBuilder.Entity("AliasServerDb.AdminRole", b =>+ {+ b.Property<string>("Id")+ .HasColumnType("text");++ b.Property<string>("ConcurrencyStamp")+ .HasColumnType("text");++ b.Property<string>("Name")+ .HasColumnType("text");++ b.Property<string>("NormalizedName")+ .HasColumnType("text");++ b.HasKey("Id");++ b.ToTable("AdminRoles");+ });++ modelBuilder.Entity("AliasServerDb.AdminUser", b =>+ {+ b.Property<string>("Id")+ .HasColumnType("text");++ b.Property<int>("AccessFailedCount")+ .HasColumnType("integer");++ b.Property<string>("ConcurrencyStamp")+ .HasColumnType("text");++ b.Property<string>("Email")+ .HasColumnType("text");++ b.Property<bool>("EmailConfirmed")+ .HasColumnType("boolean");++ b.Property<DateTime?>("LastPasswordChanged")+ .HasColumnType("timestamp with time zone");++ b.Property<bool>("LockoutEnabled")+ .HasColumnType("boolean");++ b.Property<DateTimeOffset?>("LockoutEnd")+ .HasColumnType("timestamp with time zone");++ b.Property<string>("NormalizedEmail")+ .HasColumnType("text");++ b.Property<string>("NormalizedUserName")+ .HasColumnType("text");++ b.Property<string>("PasswordHash")+ .HasColumnType("text");++ b.Property<string>("PhoneNumber")+ .HasColumnType("text");++ b.Property<bool>("PhoneNumberConfirmed")+ .HasColumnType("boolean");++ b.Property<string>("SecurityStamp")+ .HasColumnType("text");++ b.Property<bool>("TwoFactorEnabled")+ .HasColumnType("boolean");++ b.Property<string>("UserName")+ .HasColumnType("text");++ b.HasKey("Id");++ b.ToTable("AdminUsers");+ });++ modelBuilder.Entity("AliasServerDb.AliasVaultRole", b =>+ {+ b.Property<string>("Id")+ .HasColumnType("text");++ b.Property<string>("ConcurrencyStamp")+ .HasColumnType("text");++ b.Property<string>("Name")+ .HasColumnType("text");++ b.Property<string>("NormalizedName")+ .HasColumnType("text");++ b.HasKey("Id");++ b.ToTable("AliasVaultRoles");+ });++ modelBuilder.Entity("AliasServerDb.AliasVaultUser", b =>+ {+ b.Property<string>("Id")+ .HasColumnType("text");++ b.Property<int>("AccessFailedCount")+ .HasColumnType("integer");++ b.Property<bool>("Blocked")+ .HasColumnType("boolean");++ b.Property<DateTime?>("BlockedAt")+ .HasColumnType("timestamp with time zone");++ b.Property<string>("ConcurrencyStamp")+ .HasColumnType("text");++ b.Property<DateTime>("CreatedAt")+ .HasColumnType("timestamp with time zone");++ b.Property<string>("Email")+ .HasColumnType("text");++ b.Property<bool>("EmailConfirmed")+ .HasColumnType("boolean");++ b.Property<int>("EmailsReceived")+ .HasColumnType("integer");++ b.Property<DateTime?>("LastActivityDate")+ .HasColumnType("timestamp with time zone");++ b.Property<bool>("LockoutEnabled")+ .HasColumnType("boolean");++ b.Property<DateTimeOffset?>("LockoutEnd")+ .HasColumnType("timestamp with time zone");++ b.Property<int>("MaxEmailAgeDays")+ .HasColumnType("integer");++ b.Property<int>("MaxEmails")+ .HasColumnType("integer");++ b.Property<string>("NormalizedEmail")+ .HasColumnType("text");++ b.Property<string>("NormalizedUserName")+ .HasColumnType("text");++ b.Property<DateTime>("PasswordChangedAt")+ .HasColumnType("timestamp with time zone");++ b.Property<string>("PasswordHash")+ .HasColumnType("text");++ b.Property<string>("PhoneNumber")+ .HasColumnType("text");++ b.Property<bool>("PhoneNumberConfirmed")+ .HasColumnType("boolean");++ b.Property<string>("SecurityStamp")+ .HasColumnType("text");++ b.Property<bool>("ShadowBlocked")+ .HasColumnType("boolean");++ b.Property<DateTime?>("ShadowBlockedAt")+ .HasColumnType("timestamp with time zone");++ b.Property<string>("SrpIdentity")+ .HasMaxLength(255)+ .HasColumnType("character varying(255)");++ b.Property<bool>("TwoFactorEnabled")+ .HasColumnType("boolean");++ b.Property<DateTime>("UpdatedAt")+ .HasColumnType("timestamp with time zone");++ b.Property<string>("UserName")+ .HasColumnType("text");++ b.HasKey("Id");++ b.ToTable("AliasVaultUsers");+ });++ modelBuilder.Entity("AliasServerDb.AliasVaultUserRefreshToken", b =>+ {+ b.Property<Guid>("Id")+ .ValueGeneratedOnAdd()+ .HasColumnType("uuid");++ b.Property<DateTime>("CreatedAt")+ .HasColumnType("timestamp with time zone");++ b.Property<string>("DeviceIdentifier")+ .IsRequired()+ .HasColumnType("text");++ b.Property<DateTime>("ExpireDate")+ .HasMaxLength(255)+ .HasColumnType("timestamp with time zone");++ b.Property<string>("IpAddress")+ .HasMaxLength(45)+ .HasColumnType("character varying(45)");++ b.Property<string>("PreviousTokenValue")+ .HasMaxLength(255)+ .HasColumnType("character varying(255)");++ b.Property<string>("UserId")+ .IsRequired()+ .HasMaxLength(255)+ .HasColumnType("character varying(255)");++ b.Property<string>("Value")+ .IsRequired()+ .HasMaxLength(255)+ .HasColumnType("character varying(255)");++ b.HasKey("Id");++ b.HasIndex("UserId");++ b.ToTable("AliasVaultUserRefreshTokens");+ });++ modelBuilder.Entity("AliasServerDb.AuthLog", b =>+ {+ b.Property<int>("Id")+ .ValueGeneratedOnAdd()+ .HasColumnType("integer");++ NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));++ b.Property<string>("AdditionalInfo")+ .HasMaxLength(255)+ .HasColumnType("character varying(255)");++ b.Property<string>("Browser")+ .HasMaxLength(100)+ .HasColumnType("character varying(100)");++ b.Property<string>("Client")+ .HasMaxLength(100)+ .HasColumnType("character varying(100)");++ b.Property<string>("Country")+ .HasMaxLength(50)+ .HasColumnType("character varying(50)");++ b.Property<string>("DeviceType")+ .HasMaxLength(100)+ .HasColumnType("character varying(100)");++ b.Property<int>("EventType")+ .HasColumnType("integer");++ b.Property<int?>("FailureReason")+ .HasColumnType("integer");++ b.Property<string>("IpAddress")+ .HasMaxLength(50)+ .HasColumnType("character varying(50)");++ b.Property<bool>("IsSuccess")+ .HasColumnType("boolean");++ b.Property<bool>("IsSuspiciousActivity")+ .HasColumnType("boolean");++ b.Property<string>("OperatingSystem")+ .HasMaxLength(100)+ .HasColumnType("character varying(100)");++ b.Property<string>("RequestPath")+ .HasMaxLength(100)+ .HasColumnType("character varying(100)");++ b.Property<DateTime>("Timestamp")+ .HasColumnType("timestamp with time zone");++ b.Property<string>("Username")+ .IsRequired()+ .HasMaxLength(255)+ .HasColumnType("character varying(255)");++ b.HasKey("Id");++ b.HasIndex(new[] { "EventType" }, "IX_EventType");++ b.HasIndex(new[] { "IpAddress" }, "IX_IpAddress");++ b.HasIndex(new[] { "Timestamp" }, "IX_Timestamp");++ b.HasIndex(new[] { "Username", "IsSuccess", "Timestamp" }, "IX_Username_IsSuccess_Timestamp")+ .IsDescending(false, false, true);++ b.HasIndex(new[] { "Username", "Timestamp" }, "IX_Username_Timestamp")+ .IsDescending(false, true);++ b.ToTable("AuthLogs");+ });++ modelBuilder.Entity("AliasServerDb.BlockedIpRange", b =>+ {+ b.Property<int>("Id")+ .ValueGeneratedOnAdd()+ .HasColumnType("integer");++ NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));++ b.Property<bool>("BlockLogin")+ .HasColumnType("boolean");++ b.Property<bool>("BlockRegistration")+ .HasColumnType("boolean");++ b.Property<bool>("BlockShadow")+ .HasColumnType("boolean");++ b.Property<DateTime>("CreatedAt")+ .HasColumnType("timestamp with time zone");++ b.Property<string>("CreatedBy")+ .HasMaxLength(255)+ .HasColumnType("character varying(255)");++ b.Property<bool>("Enabled")+ .HasColumnType("boolean");++ b.Property<string>("IpRange")+ .IsRequired()+ .HasMaxLength(50)+ .HasColumnType("character varying(50)");++ b.Property<string>("Reason")+ .HasMaxLength(500)+ .HasColumnType("character varying(500)");++ b.Property<DateTime>("UpdatedAt")+ .HasColumnType("timestamp with time zone");++ b.HasKey("Id");++ b.HasIndex(new[] { "Enabled" }, "IX_BlockedIpRange_Enabled");++ b.HasIndex(new[] { "IpRange" }, "IX_BlockedIpRange_IpRange")+ .IsUnique();++ b.ToTable("BlockedIpRanges");+ });++ modelBuilder.Entity("AliasServerDb.Email", b =>+ {+ b.Property<int>("Id")+ .ValueGeneratedOnAdd()+ .HasColumnType("integer");++ NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));++ b.Property<DateTime>("Date")+ .HasColumnType("timestamp with time zone");++ b.Property<DateTime>("DateSystem")+ .HasColumnType("timestamp with time zone");++ b.Property<string>("EncryptedSymmetricKey")+ .IsRequired()+ .HasColumnType("text");++ b.Property<string>("From")+ .IsRequired()+ .HasColumnType("text");++ b.Property<string>("FromDomain")+ .IsRequired()+ .HasColumnType("text");++ b.Property<string>("FromLocal")+ .IsRequired()+ .HasColumnType("text");++ b.Property<string>("MessageHtml")+ .HasColumnType("text");++ b.Property<string>("MessagePlain")+ .HasColumnType("text");++ b.Property<string>("MessagePreview")+ .HasColumnType("text");++ b.Property<string>("MessageSource")+ .IsRequired()+ .HasColumnType("text");++ b.Property<bool>("PushNotificationSent")+ .HasColumnType("boolean");++ b.Property<string>("Subject")+ .IsRequired()+ .HasColumnType("text");++ b.Property<string>("To")+ .IsRequired()+ .HasColumnType("text");++ b.Property<string>("ToDomain")+ .IsRequired()+ .HasColumnType("text");++ b.Property<string>("ToLocal")+ .IsRequired()+ .HasColumnType("text");++ b.Property<Guid>("UserEncryptionKeyId")+ .HasMaxLength(255)+ .HasColumnType("uuid");++ b.Property<bool>("Visible")+ .HasColumnType("boolean");++ b.HasKey("Id");++ b.HasIndex("Date");++ b.HasIndex("DateSystem");++ b.HasIndex("PushNotificationSent");++ b.HasIndex("UserEncryptionKeyId");++ b.HasIndex("Visible");++ b.HasIndex("To", "DateSystem");++ b.ToTable("Emails");+ });++ modelBuilder.Entity("AliasServerDb.EmailAttachment", b =>+ {+ b.Property<int>("Id")+ .ValueGeneratedOnAdd()+ .HasColumnType("integer");++ NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));++ b.Property<byte[]>("Bytes")+ .IsRequired()+ .HasColumnType("bytea");++ b.Property<DateTime>("Date")+ .HasColumnType("timestamp with time zone");++ b.Property<int>("EmailId")+ .HasColumnType("integer");++ b.Property<string>("Filename")+ .IsRequired()+ .HasColumnType("text");++ b.Property<int>("Filesize")+ .HasColumnType("integer");++ b.Property<string>("MimeType")+ .IsRequired()+ .HasColumnType("text");++ b.HasKey("Id");++ b.HasIndex("EmailId");++ b.ToTable("EmailAttachments");+ });++ modelBuilder.Entity("AliasServerDb.Log", b =>+ {+ b.Property<int>("Id")+ .ValueGeneratedOnAdd()+ .HasColumnType("integer");++ NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));++ b.Property<string>("Application")+ .IsRequired()+ .HasMaxLength(50)+ .HasColumnType("character varying(50)");++ b.Property<string>("Exception")+ .IsRequired()+ .HasColumnType("text");++ b.Property<string>("Level")+ .IsRequired()+ .HasMaxLength(128)+ .HasColumnType("character varying(128)");++ b.Property<string>("LogEvent")+ .IsRequired()+ .HasColumnType("text")+ .HasColumnName("LogEvent");++ b.Property<string>("Message")+ .IsRequired()+ .HasColumnType("text");++ b.Property<string>("MessageTemplate")+ .IsRequired()+ .HasColumnType("text");++ b.Property<string>("Properties")+ .IsRequired()+ .HasColumnType("text");++ b.Property<string>("SourceContext")+ .IsRequired()+ .HasMaxLength(255)+ .HasColumnType("character varying(255)");++ b.Property<DateTime>("TimeStamp")+ .HasColumnType("timestamp with time zone");++ b.HasKey("Id");++ b.HasIndex("Application");++ b.HasIndex("TimeStamp");++ b.ToTable("Logs", (string)null);+ });++ modelBuilder.Entity("AliasServerDb.MobileLoginRequest", b =>+ {+ b.Property<string>("Id")+ .HasColumnType("text");++ b.Property<DateTime?>("ClearedAt")+ .HasColumnType("timestamp with time zone");++ b.Property<string>("ClientIpAddress")+ .HasColumnType("text");++ b.Property<string>("ClientPublicKey")+ .IsRequired()+ .HasColumnType("text");++ b.Property<DateTime>("CreatedAt")+ .HasColumnType("timestamp with time zone");++ b.Property<string>("EncryptedDecryptionKey")+ .HasColumnType("text");++ b.Property<DateTime?>("FulfilledAt")+ .HasColumnType("timestamp with time zone");++ b.Property<string>("MobileIpAddress")+ .HasColumnType("text");++ b.Property<DateTime?>("RetrievedAt")+ .HasColumnType("timestamp with time zone");++ b.Property<string>("UserId")+ .HasColumnType("text");++ b.HasKey("Id");++ b.HasIndex(new[] { "ClientIpAddress" }, "IX_ClientIpAddress");++ b.HasIndex(new[] { "CreatedAt" }, "IX_CreatedAt");++ b.HasIndex(new[] { "MobileIpAddress" }, "IX_MobileIpAddress");++ b.HasIndex(new[] { "RetrievedAt", "ClearedAt", "FulfilledAt" }, "IX_RetrievedAt_ClearedAt_FulfilledAt");++ b.HasIndex(new[] { "UserId" }, "IX_UserId");++ b.ToTable("MobileLoginRequests");+ });++ modelBuilder.Entity("AliasServerDb.RateLimit", b =>+ {+ b.Property<Guid>("Id")+ .ValueGeneratedOnAdd()+ .HasColumnType("uuid");++ b.Property<int?>("AppliesToAccountAgeMaxDays")+ .HasColumnType("integer");++ b.Property<DateTime>("CreatedAt")+ .HasColumnType("timestamp with time zone");++ b.Property<string>("CreatedBy")+ .HasMaxLength(255)+ .HasColumnType("character varying(255)");++ b.Property<DateTime?>("EffectiveFrom")+ .HasColumnType("timestamp with time zone");++ b.Property<DateTime?>("EffectiveUntil")+ .HasColumnType("timestamp with time zone");++ b.Property<bool>("Enabled")+ .HasColumnType("boolean");++ b.Property<int>("LimitType")+ .HasColumnType("integer");++ b.Property<int>("MaxCount")+ .HasColumnType("integer");++ b.Property<string>("Notes")+ .HasMaxLength(1000)+ .HasColumnType("character varying(1000)");++ b.Property<int?>("Tier")+ .HasColumnType("integer");++ b.Property<DateTime>("UpdatedAt")+ .HasColumnType("timestamp with time zone");++ b.Property<string>("UserId")+ .HasMaxLength(255)+ .HasColumnType("character varying(255)");++ b.Property<int>("WindowSeconds")+ .HasColumnType("integer");++ b.HasKey("Id");++ b.HasIndex("Tier");++ b.HasIndex("UserId");++ b.HasIndex("LimitType", "Enabled");++ b.ToTable("RateLimits");+ });++ modelBuilder.Entity("AliasServerDb.ServerSetting", b =>+ {+ b.Property<string>("Key")+ .HasMaxLength(255)+ .HasColumnType("character varying(255)");++ b.Property<DateTime>("CreatedAt")+ .HasColumnType("timestamp with time zone");++ b.Property<DateTime>("UpdatedAt")+ .HasColumnType("timestamp with time zone");++ b.Property<string>("Value")+ .HasColumnType("text");++ b.HasKey("Key");++ b.ToTable("ServerSettings");+ });++ modelBuilder.Entity("AliasServerDb.TaskRunnerJob", b =>+ {+ b.Property<int>("Id")+ .ValueGeneratedOnAdd()+ .HasColumnType("integer");++ NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));++ b.Property<TimeOnly?>("EndTime")+ .HasColumnType("time without time zone");++ b.Property<string>("ErrorMessage")+ .HasColumnType("text");++ b.Property<bool>("IsOnDemand")+ .HasColumnType("boolean");++ b.Property<string>("Name")+ .IsRequired()+ .HasMaxLength(50)+ .HasColumnType("character varying(50)");++ b.Property<DateTime>("RunDate")+ .HasColumnType("timestamp with time zone");++ b.Property<TimeOnly>("StartTime")+ .HasColumnType("time without time zone");++ b.Property<int>("Status")+ .HasColumnType("integer");++ b.HasKey("Id");++ b.ToTable("TaskRunnerJobs");+ });++ modelBuilder.Entity("AliasServerDb.UserEmailClaim", b =>+ {+ b.Property<Guid>("Id")+ .ValueGeneratedOnAdd()+ .HasColumnType("uuid");++ b.Property<string>("Address")+ .IsRequired()+ .HasMaxLength(255)+ .HasColumnType("character varying(255)");++ b.Property<string>("AddressDomain")+ .IsRequired()+ .HasMaxLength(255)+ .HasColumnType("character varying(255)");++ b.Property<string>("AddressLocal")+ .IsRequired()+ .HasMaxLength(255)+ .HasColumnType("character varying(255)");++ b.Property<DateTime>("CreatedAt")+ .HasColumnType("timestamp with time zone");++ b.Property<bool>("Disabled")+ .HasColumnType("boolean");++ b.Property<DateTime>("UpdatedAt")+ .HasColumnType("timestamp with time zone");++ b.Property<string>("UserId")+ .HasMaxLength(255)+ .HasColumnType("character varying(255)");++ b.HasKey("Id");++ b.HasIndex("Address")+ .IsUnique();++ b.HasIndex("UserId", "CreatedAt");++ b.HasIndex("UserId", "Disabled");++ b.ToTable("UserEmailClaims");+ });++ modelBuilder.Entity("AliasServerDb.UserEncryptionKey", b =>+ {+ b.Property<Guid>("Id")+ .ValueGeneratedOnAdd()+ .HasColumnType("uuid");++ b.Property<DateTime>("CreatedAt")+ .HasColumnType("timestamp with time zone");++ b.Property<bool>("IsPrimary")+ .HasColumnType("boolean");++ b.Property<string>("PublicKey")+ .IsRequired()+ .HasMaxLength(2000)+ .HasColumnType("character varying(2000)");++ b.Property<DateTime>("UpdatedAt")+ .HasColumnType("timestamp with time zone");++ b.Property<string>("UserId")+ .IsRequired()+ .HasMaxLength(255)+ .HasColumnType("character varying(255)");++ b.HasKey("Id");++ b.HasIndex("UserId");++ b.ToTable("UserEncryptionKeys");+ });++ modelBuilder.Entity("AliasServerDb.Vault", b =>+ {+ b.Property<Guid>("Id")+ .ValueGeneratedOnAdd()+ .HasColumnType("uuid");++ b.Property<string>("Client")+ .HasMaxLength(255)+ .HasColumnType("character varying(255)");++ b.Property<DateTime>("CreatedAt")+ .HasColumnType("timestamp with time zone");++ b.Property<int>("CredentialsCount")+ .HasColumnType("integer");++ b.Property<int>("EmailClaimsCount")+ .HasColumnType("integer");++ b.Property<string>("EncryptionSettings")+ .IsRequired()+ .HasColumnType("text");++ b.Property<string>("EncryptionType")+ .IsRequired()+ .HasColumnType("text");++ b.Property<int>("FileSize")+ .HasColumnType("integer");++ b.Property<long>("RevisionNumber")+ .HasColumnType("bigint");++ b.Property<string>("Salt")+ .IsRequired()+ .HasMaxLength(100)+ .HasColumnType("character varying(100)");++ b.Property<DateTime>("UpdatedAt")+ .HasColumnType("timestamp with time zone");++ b.Property<string>("UserId")+ .IsRequired()+ .HasMaxLength(255)+ .HasColumnType("character varying(255)");++ b.Property<string>("VaultBlob")+ .IsRequired()+ .HasColumnType("text");++ b.Property<string>("Verifier")+ .IsRequired()+ .HasMaxLength(1000)+ .HasColumnType("character varying(1000)");++ b.Property<string>("Version")+ .IsRequired()+ .HasMaxLength(255)+ .HasColumnType("character varying(255)");++ b.HasKey("Id");++ b.HasIndex("UserId");++ b.ToTable("Vaults");+ });++ modelBuilder.Entity("AliasVault.WorkerStatus.Database.WorkerServiceStatus", b =>+ {+ b.Property<int>("Id")+ .ValueGeneratedOnAdd()+ .HasColumnType("integer");++ NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));++ b.Property<string>("CurrentStatus")+ .IsRequired()+ .HasMaxLength(50)+ .HasColumnType("character varying(50)");++ b.Property<string>("DesiredStatus")+ .IsRequired()+ .HasMaxLength(50)+ .HasColumnType("character varying(50)");++ b.Property<DateTime>("Heartbeat")+ .HasColumnType("timestamp with time zone");++ b.Property<string>("ServiceName")+ .IsRequired()+ .HasMaxLength(255)+ .HasColumnType("character varying(255)");++ b.HasKey("Id");++ b.ToTable("WorkerServiceStatuses");+ });++ modelBuilder.Entity("Microsoft.AspNetCore.DataProtection.EntityFrameworkCore.DataProtectionKey", b =>+ {+ b.Property<int>("Id")+ .ValueGeneratedOnAdd()+ .HasColumnType("integer");++ NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));++ b.Property<string>("FriendlyName")+ .HasColumnType("text");++ b.Property<string>("Xml")+ .HasColumnType("text");++ b.HasKey("Id");++ b.ToTable("DataProtectionKeys");+ });++ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>+ {+ b.Property<int>("Id")+ .ValueGeneratedOnAdd()+ .HasColumnType("integer");++ NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));++ b.Property<string>("ClaimType")+ .HasColumnType("text");++ b.Property<string>("ClaimValue")+ .HasColumnType("text");++ b.Property<string>("RoleId")+ .HasColumnType("text");++ b.HasKey("Id");++ b.ToTable("RoleClaims", (string)null);+ });++ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>+ {+ b.Property<int>("Id")+ .ValueGeneratedOnAdd()+ .HasColumnType("integer");++ NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));++ b.Property<string>("ClaimType")+ .HasColumnType("text");++ b.Property<string>("ClaimValue")+ .HasColumnType("text");++ b.Property<string>("UserId")+ .HasColumnType("text");++ b.HasKey("Id");++ b.ToTable("UserClaims", (string)null);+ });++ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>+ {+ b.Property<string>("LoginProvider")+ .HasColumnType("text");++ b.Property<string>("ProviderKey")+ .HasColumnType("text");++ b.Property<string>("ProviderDisplayName")+ .HasColumnType("text");++ b.Property<string>("UserId")+ .HasColumnType("text");++ b.HasKey("LoginProvider", "ProviderKey");++ b.ToTable("UserLogins", (string)null);+ });++ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>+ {+ b.Property<string>("UserId")+ .HasColumnType("text");++ b.Property<string>("RoleId")+ .HasColumnType("text");++ b.HasKey("UserId", "RoleId");++ b.ToTable("UserRoles", (string)null);+ });++ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>+ {+ b.Property<string>("UserId")+ .HasColumnType("text");++ b.Property<string>("LoginProvider")+ .HasColumnType("text");++ b.Property<string>("Name")+ .HasColumnType("text");++ b.Property<string>("Value")+ .HasColumnType("text");++ b.HasKey("UserId", "LoginProvider", "Name");++ b.ToTable("UserTokens", (string)null);+ });++ modelBuilder.Entity("AliasServerDb.AliasVaultUserRefreshToken", b =>+ {+ b.HasOne("AliasServerDb.AliasVaultUser", "User")+ .WithMany()+ .HasForeignKey("UserId")+ .OnDelete(DeleteBehavior.Cascade)+ .IsRequired();++ b.Navigation("User");+ });++ modelBuilder.Entity("AliasServerDb.Email", b =>+ {+ b.HasOne("AliasServerDb.UserEncryptionKey", "EncryptionKey")+ .WithMany("Emails")+ .HasForeignKey("UserEncryptionKeyId")+ .OnDelete(DeleteBehavior.Cascade)+ .IsRequired();++ b.Navigation("EncryptionKey");+ });++ modelBuilder.Entity("AliasServerDb.EmailAttachment", b =>+ {+ b.HasOne("AliasServerDb.Email", "Email")+ .WithMany("Attachments")+ .HasForeignKey("EmailId")+ .OnDelete(DeleteBehavior.Cascade)+ .IsRequired();++ b.Navigation("Email");+ });++ modelBuilder.Entity("AliasServerDb.MobileLoginRequest", b =>+ {+ b.HasOne("AliasServerDb.AliasVaultUser", "User")+ .WithMany()+ .HasForeignKey("UserId")+ .OnDelete(DeleteBehavior.Cascade);++ b.Navigation("User");+ });++ modelBuilder.Entity("AliasServerDb.RateLimit", b =>+ {+ b.HasOne("AliasServerDb.AliasVaultUser", "User")+ .WithMany()+ .HasForeignKey("UserId")+ .OnDelete(DeleteBehavior.Cascade);++ b.Navigation("User");+ });++ modelBuilder.Entity("AliasServerDb.UserEmailClaim", b =>+ {+ b.HasOne("AliasServerDb.AliasVaultUser", "User")+ .WithMany("EmailClaims")+ .HasForeignKey("UserId")+ .OnDelete(DeleteBehavior.SetNull);++ b.Navigation("User");+ });++ modelBuilder.Entity("AliasServerDb.UserEncryptionKey", b =>+ {+ b.HasOne("AliasServerDb.AliasVaultUser", "User")+ .WithMany("EncryptionKeys")+ .HasForeignKey("UserId")+ .OnDelete(DeleteBehavior.Cascade)+ .IsRequired();++ b.Navigation("User");+ });++ modelBuilder.Entity("AliasServerDb.Vault", b =>+ {+ b.HasOne("AliasServerDb.AliasVaultUser", "User")+ .WithMany("Vaults")+ .HasForeignKey("UserId")+ .OnDelete(DeleteBehavior.Cascade)+ .IsRequired();++ b.Navigation("User");+ });++ modelBuilder.Entity("AliasServerDb.AliasVaultUser", b =>+ {+ b.Navigation("EmailClaims");++ b.Navigation("EncryptionKeys");++ b.Navigation("Vaults");+ });++ modelBuilder.Entity("AliasServerDb.Email", b =>+ {+ b.Navigation("Attachments");+ });++ modelBuilder.Entity("AliasServerDb.UserEncryptionKey", b =>+ {+ b.Navigation("Emails");+ });+#pragma warning restore 612, 618+ }+ }+}diff --git a/apps/server/Databases/AliasServerDb/Migrations/20260624212335_AddRateLimits.cs b/apps/server/Databases/AliasServerDb/Migrations/20260624212335_AddRateLimits.csnew file mode 100644index 000000000..c2bce8f9f--- /dev/null+++ b/apps/server/Databases/AliasServerDb/Migrations/20260624212335_AddRateLimits.cs@@ -0,0 +1,91 @@+using System;+using Microsoft.EntityFrameworkCore.Migrations;++#nullable disable++namespace AliasServerDb.Migrations+{+ /// <inheritdoc />+ public partial class AddRateLimits : Migration+ {+ /// <inheritdoc />+ protected override void Up(MigrationBuilder migrationBuilder)+ {+ migrationBuilder.DropColumn(+ name: "MaxAliases",+ table: "AliasVaultUsers");++ migrationBuilder.CreateTable(+ name: "RateLimits",+ columns: table => new+ {+ Id = table.Column<Guid>(type: "uuid", nullable: false),+ LimitType = table.Column<int>(type: "integer", nullable: false),+ UserId = table.Column<string>(type: "character varying(255)", maxLength: 255, nullable: true),+ Tier = table.Column<int>(type: "integer", nullable: true),+ WindowSeconds = table.Column<int>(type: "integer", nullable: false),+ MaxCount = table.Column<int>(type: "integer", nullable: false),+ AppliesToAccountAgeMaxDays = table.Column<int>(type: "integer", nullable: true),+ Enabled = table.Column<bool>(type: "boolean", nullable: false),+ Notes = table.Column<string>(type: "character varying(1000)", maxLength: 1000, nullable: true),+ EffectiveFrom = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),+ EffectiveUntil = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),+ CreatedBy = table.Column<string>(type: "character varying(255)", maxLength: 255, nullable: true),+ CreatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),+ UpdatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false)+ },+ constraints: table =>+ {+ table.PrimaryKey("PK_RateLimits", x => x.Id);+ table.ForeignKey(+ name: "FK_RateLimits_AliasVaultUsers_UserId",+ column: x => x.UserId,+ principalTable: "AliasVaultUsers",+ principalColumn: "Id",+ onDelete: ReferentialAction.Cascade);+ });++ migrationBuilder.CreateIndex(+ name: "IX_UserEmailClaims_UserId_CreatedAt",+ table: "UserEmailClaims",+ columns: new[] { "UserId", "CreatedAt" });++ migrationBuilder.CreateIndex(+ name: "IX_RateLimits_LimitType_Enabled",+ table: "RateLimits",+ columns: new[] { "LimitType", "Enabled" });++ migrationBuilder.CreateIndex(+ name: "IX_RateLimits_Tier",+ table: "RateLimits",+ column: "Tier");++ migrationBuilder.CreateIndex(+ name: "IX_RateLimits_UserId",+ table: "RateLimits",+ column: "UserId");++ // Remove obsolete settings that are now handled by this new RateLimits table.+ migrationBuilder.Sql(+ "DELETE FROM \"ServerSettings\" WHERE \"Key\" IN ('MaxAliasesForNewAccounts', 'NewAccountAliasLimitDays');");+ }++ /// <inheritdoc />+ protected override void Down(MigrationBuilder migrationBuilder)+ {+ migrationBuilder.DropTable(+ name: "RateLimits");++ migrationBuilder.DropIndex(+ name: "IX_UserEmailClaims_UserId_CreatedAt",+ table: "UserEmailClaims");++ migrationBuilder.AddColumn<int>(+ name: "MaxAliases",+ table: "AliasVaultUsers",+ type: "integer",+ nullable: false,+ defaultValue: 0);+ }+ }+}diff --git a/apps/server/Databases/AliasServerDb/Migrations/AliasServerDbContextModelSnapshot.cs b/apps/server/Databases/AliasServerDb/Migrations/AliasServerDbContextModelSnapshot.csindex 03bb99641..eca916ffc 100644--- a/apps/server/Databases/AliasServerDb/Migrations/AliasServerDbContextModelSnapshot.cs+++ b/apps/server/Databases/AliasServerDb/Migrations/AliasServerDbContextModelSnapshot.cs@@ -156,9 +156,6 @@ namespace AliasServerDb.Migrationsb.Property<DateTimeOffset?>("LockoutEnd").HasColumnType("timestamp with time zone");- b.Property<int>("MaxAliases")- .HasColumnType("integer");-b.Property<int>("MaxEmailAgeDays").HasColumnType("integer");@@ -604,6 +601,65 @@ namespace AliasServerDb.Migrationsb.ToTable("MobileLoginRequests");});+ modelBuilder.Entity("AliasServerDb.RateLimit", b =>+ {+ b.Property<Guid>("Id")+ .ValueGeneratedOnAdd()+ .HasColumnType("uuid");++ b.Property<int?>("AppliesToAccountAgeMaxDays")+ .HasColumnType("integer");++ b.Property<DateTime>("CreatedAt")+ .HasColumnType("timestamp with time zone");++ b.Property<string>("CreatedBy")+ .HasMaxLength(255)+ .HasColumnType("character varying(255)");++ b.Property<DateTime?>("EffectiveFrom")+ .HasColumnType("timestamp with time zone");++ b.Property<DateTime?>("EffectiveUntil")+ .HasColumnType("timestamp with time zone");++ b.Property<bool>("Enabled")+ .HasColumnType("boolean");++ b.Property<int>("LimitType")+ .HasColumnType("integer");++ b.Property<int>("MaxCount")+ .HasColumnType("integer");++ b.Property<string>("Notes")+ .HasMaxLength(1000)+ .HasColumnType("character varying(1000)");++ b.Property<int?>("Tier")+ .HasColumnType("integer");++ b.Property<DateTime>("UpdatedAt")+ .HasColumnType("timestamp with time zone");++ b.Property<string>("UserId")+ .HasMaxLength(255)+ .HasColumnType("character varying(255)");++ b.Property<int>("WindowSeconds")+ .HasColumnType("integer");++ b.HasKey("Id");++ b.HasIndex("Tier");++ b.HasIndex("UserId");++ b.HasIndex("LimitType", "Enabled");++ b.ToTable("RateLimits");+ });+modelBuilder.Entity("AliasServerDb.ServerSetting", b =>{b.Property<string>("Key")@@ -699,6 +755,8 @@ namespace AliasServerDb.Migrationsb.HasIndex("Address").IsUnique();+ b.HasIndex("UserId", "CreatedAt");+b.HasIndex("UserId", "Disabled");b.ToTable("UserEmailClaims");@@ -991,6 +1049,16 @@ namespace AliasServerDb.Migrationsb.Navigation("User");});+ modelBuilder.Entity("AliasServerDb.RateLimit", b =>+ {+ b.HasOne("AliasServerDb.AliasVaultUser", "User")+ .WithMany()+ .HasForeignKey("UserId")+ .OnDelete(DeleteBehavior.Cascade);++ b.Navigation("User");+ });+modelBuilder.Entity("AliasServerDb.UserEmailClaim", b =>{b.HasOne("AliasServerDb.AliasVaultUser", "User")diff --git a/apps/server/Databases/AliasServerDb/RateLimit.cs b/apps/server/Databases/AliasServerDb/RateLimit.csnew file mode 100644index 000000000..29b455bbc--- /dev/null+++ b/apps/server/Databases/AliasServerDb/RateLimit.cs@@ -0,0 +1,108 @@+//-----------------------------------------------------------------------+// <copyright file="RateLimit.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 AliasServerDb;++using System;+using System.ComponentModel.DataAnnotations;+using System.ComponentModel.DataAnnotations.Schema;+using Microsoft.EntityFrameworkCore;++/// <summary>+/// A rate-limit / quota rule used by the API to throttle different types of usage.+/// - <see cref="UserId"/> set = per-user,+/// - <see cref="Tier"/> set = per-tier,+/// - else global (most specific wins).+/// - <see cref="WindowSeconds"/> 0 = global maximum (all-time). > 0 = max allowed within a rolling window.+/// - <see cref="MaxCount"/> 0 = unlimited.+/// </summary>+[Index(nameof(LimitType), nameof(Enabled))]+[Index(nameof(UserId))]+[Index(nameof(Tier))]+public class RateLimit+{+ /// <summary>+ /// Gets or sets the unique identifier for the rule.+ /// </summary>+ [Key]+ public Guid Id { get; set; }++ /// <summary>+ /// Gets or sets the action this rule governs.+ /// </summary>+ public RateLimitType LimitType { get; set; } = RateLimitType.AliasCreation;++ /// <summary>+ /// Gets or sets the user this rule applies to (per-user override). Null for tier-level and global rules.+ /// </summary>+ [StringLength(255)]+ public string? UserId { get; set; }++ /// <summary>+ /// Gets or sets the navigation property to the user this rule applies to.+ /// </summary>+ [ForeignKey(nameof(UserId))]+ public virtual AliasVaultUser? User { get; set; }++ /// <summary>+ /// Gets or sets the account tier this rule applies to. Null for per-user and global rules.+ /// </summary>+ public AccountTier? Tier { get; set; }++ /// <summary>+ /// Gets or sets the rolling window length in seconds (0 = absolute cap on currently-held aliases).+ /// </summary>+ public int WindowSeconds { get; set; }++ /// <summary>+ /// Gets or sets the maximum allowed count for the window (0 = unlimited).+ /// </summary>+ public int MaxCount { get; set; }++ /// <summary>+ /// Gets or sets the account age (in days) below which the rule applies; null = applies regardless of age.+ /// Used to restrict new accounts more tightly (the limit lifts once the account is older).+ /// </summary>+ public int? AppliesToAccountAgeMaxDays { get; set; }++ /// <summary>+ /// Gets or sets a value indicating whether this rule is enforced. Disabled rules are retained for auditing.+ /// </summary>+ public bool Enabled { get; set; } = true;++ /// <summary>+ /// Gets or sets an optional note describing why the rule exists.+ /// </summary>+ [MaxLength(1000)]+ public string? Notes { get; set; }++ /// <summary>+ /// Gets or sets an optional UTC timestamp before which the rule is not enforced.+ /// </summary>+ public DateTime? EffectiveFrom { get; set; }++ /// <summary>+ /// Gets or sets an optional UTC timestamp after which the rule is no longer enforced.+ /// </summary>+ public DateTime? EffectiveUntil { get; set; }++ /// <summary>+ /// Gets or sets an optional identifier of who created the rule.+ /// </summary>+ [MaxLength(255)]+ public string? CreatedBy { get; set; }++ /// <summary>+ /// Gets or sets the creation date of the rule.+ /// </summary>+ public DateTime CreatedAt { get; set; }++ /// <summary>+ /// Gets or sets the last update date of the rule.+ /// </summary>+ public DateTime UpdatedAt { get; set; }+}diff --git a/apps/server/Databases/AliasServerDb/RateLimitType.cs b/apps/server/Databases/AliasServerDb/RateLimitType.csnew file mode 100644index 000000000..1a8f76773--- /dev/null+++ b/apps/server/Databases/AliasServerDb/RateLimitType.cs@@ -0,0 +1,19 @@+//-----------------------------------------------------------------------+// <copyright file="RateLimitType.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 AliasServerDb;++/// <summary>+/// The action a <see cref="RateLimit"/> rule governs.+/// </summary>+public enum RateLimitType+{+ /// <summary>+ /// Limits the creation of new email aliases.+ /// </summary>+ AliasCreation = 0,+}diff --git a/apps/server/Databases/AliasServerDb/UserEmailClaim.cs b/apps/server/Databases/AliasServerDb/UserEmailClaim.csindex d42e77986..8b4899c38 100644--- a/apps/server/Databases/AliasServerDb/UserEmailClaim.cs+++ b/apps/server/Databases/AliasServerDb/UserEmailClaim.cs@@ -16,6 +16,7 @@ using Microsoft.EntityFrameworkCore;/// </summary>[Index(nameof(Address), IsUnique = true)][Index(nameof(UserId), nameof(Disabled))]+[Index(nameof(UserId), nameof(CreatedAt))]public class UserEmailClaim{/// <summary>diff --git a/apps/server/Shared/AliasVault.Shared.Server/Models/ServerSettingsModel.cs b/apps/server/Shared/AliasVault.Shared.Server/Models/ServerSettingsModel.csindex 07132534c..b7d7afd7f 100644--- a/apps/server/Shared/AliasVault.Shared.Server/Models/ServerSettingsModel.cs+++ b/apps/server/Shared/AliasVault.Shared.Server/Models/ServerSettingsModel.cs@@ -84,17 +84,4 @@ public class ServerSettingsModel/// Set to 0 to disable IP-based registration rate limiting./// </summary>public int MaxRegistrationsPerIpPer24Hours { get; set; } = 5;-- /// <summary>- /// Gets or sets the age (in days) below which an account is considered "new" for alias-creation limiting purposes.- /// Defaults to 0 (disabled). When 0, or when MaxAliasesForNewAccounts is 0, no new-account alias limit is applied.- /// </summary>- public int NewAccountAliasLimitDays { get; set; }-- /// <summary>- /// Gets or sets the maximum number of active aliases a "new" account (younger than NewAccountAliasLimitDays) may- /// have. Defaults to 0 (unlimited). When the limit is reached, additional alias creation is silently skipped- /// during vault sync.- /// </summary>- public int MaxAliasesForNewAccounts { get; set; }}diff --git a/apps/server/Shared/AliasVault.Shared.Server/Services/ServerSettingsService.cs b/apps/server/Shared/AliasVault.Shared.Server/Services/ServerSettingsService.csindex 9bd77d044..af30f1bb8 100644--- a/apps/server/Shared/AliasVault.Shared.Server/Services/ServerSettingsService.cs+++ b/apps/server/Shared/AliasVault.Shared.Server/Services/ServerSettingsService.cs@@ -201,16 +201,6 @@ public class ServerSettingsService(IAliasServerDbContextFactory dbContextFactorymodel.MobileLoginLogRetentionDays = mobileLoginDays;}- if (int.TryParse(settings.GetValueOrDefault("NewAccountAliasLimitDays"), out var newAccountAliasLimitDays))- {- model.NewAccountAliasLimitDays = newAccountAliasLimitDays;- }-- if (int.TryParse(settings.GetValueOrDefault("MaxAliasesForNewAccounts"), out var maxAliasesForNewAccounts))- {- model.MaxAliasesForNewAccounts = maxAliasesForNewAccounts;- }-cache.Set(AllSettingsCacheKey, model, TimeSpan.FromSeconds(AllSettingsCacheDurationSeconds));return model;@@ -236,7 +226,5 @@ public class ServerSettingsService(IAliasServerDbContextFactory dbContextFactoryawait SetSettingAsync("RefreshTokenLifetimeLong", model.RefreshTokenLifetimeLong.ToString());await SetSettingAsync("MaxRegistrationsPerIpPer24Hours", model.MaxRegistrationsPerIpPer24Hours.ToString());await SetSettingAsync("MobileLoginLogRetentionDays", model.MobileLoginLogRetentionDays.ToString());- await SetSettingAsync("NewAccountAliasLimitDays", model.NewAccountAliasLimitDays.ToString());- await SetSettingAsync("MaxAliasesForNewAccounts", model.MaxAliasesForNewAccounts.ToString());}}