Privacy-first password manager with built-in email aliasing. Fully encrypted and self-hostable.
//-----------------------------------------------------------------------
// <copyright file="TestController.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>
//-----------------------------------------------------------------------
/*
* Note: this file is used for E2E testing purposes only. It contains test endpoints that are used by
* E2E tests (browser extension Playwright tests, mobile app UI tests) to manipulate server state.
*
* These endpoints are only available in DEBUG builds.
*/
namespace AliasVault.Api.Controllers.V2.Tests;
using AliasServerDb;
using AliasVault.Api.Controllers.Abstracts;
using AliasVault.Api.Controllers.Tests;
using AliasVault.Api.Helpers;
using AliasVault.Api.Services;
using AliasVault.Shared.Models.Enums;
using AliasVault.Shared.Server.Services;
using Asp.Versioning;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Caching.Memory;
#if DEBUG
/// <summary>
/// Test controller that contains test endpoints for E2E testing purposes.
/// All endpoints are hidden from Swagger and only work in Development environment.
/// </summary>
/// <param name="userManager">UserManager instance.</param>
/// <param name="environment">IWebHostEnvironment instance.</param>
/// <param name="dbContextFactory">DbContext factory instance.</param>
/// <param name="serverSettingsService">ServerSettingsService instance.</param>
/// <param name="registrationInviteService">RegistrationInviteService instance.</param>
/// <param name="capabilityService">CapabilityService instance.</param>
/// <param name="cache">IMemoryCache instance.</param>
[ApiVersion("2")]
public class TestController(
UserManager<AliasVaultUser> userManager,
IWebHostEnvironment environment,
IAliasServerDbContextFactory dbContextFactory,
ServerSettingsService serverSettingsService,
RegistrationInviteService registrationInviteService,
CapabilityService capabilityService,
IMemoryCache cache) : AuthenticatedRequestController(userManager)
{
/// <summary>
/// Authenticated test request. Used to verify authentication is working.
/// </summary>
/// <returns>Static OK.</returns>
[HttpGet("")]
public IActionResult TestCall()
{
if (!environment.IsDevelopment())
{
return NotFound();
}
return Ok();
}
/// <summary>
/// Test request that throws an exception. Used for testing error handling.
/// </summary>
/// <returns>Never returns - always throws.</returns>
[AllowAnonymous]
[HttpGet("Error")]
public IActionResult TestCallError()
{
if (!environment.IsDevelopment())
{
return NotFound();
}
// Throw an exception here to test error handling.
throw new ArgumentException("Test error");
}
/// <summary>
/// Delete the newest vault revisions for the current user.
/// Used for testing RPO (Recovery Point Objective) recovery scenarios.
/// </summary>
/// <param name="count">Number of newest revisions to delete.</param>
/// <returns>OK with the number of deleted revisions, or NotFound in production.</returns>
[HttpDelete("vault-revisions/{count:int}")]
public async Task<IActionResult> DeleteVaultRevisions(int count)
{
if (!environment.IsDevelopment())
{
return NotFound();
}
if (count <= 0)
{
return BadRequest("Count must be greater than 0");
}
var user = await GetCurrentUserAsync();
if (user == null)
{
return Unauthorized();
}
await using var context = await dbContextFactory.CreateDbContextAsync();
var deletedRevisions = await PopNewestRevisionsAsync(context, user.Id, count);
if (deletedRevisions.Count == 0)
{
return Ok(new { deleted = 0, message = "No revisions found to delete" });
}
return Ok(new
{
deleted = deletedRevisions.Count,
deletedRevisions,
message = $"Deleted {deletedRevisions.Count} vault revision(s)",
});
}
/// <summary>
/// Get vault revision information for the current user.
/// Used for E2E tests to verify vault state.
/// </summary>
/// <returns>Vault revision information.</returns>
[HttpGet("vault-revisions")]
public async Task<IActionResult> GetVaultRevisions()
{
if (!environment.IsDevelopment())
{
return NotFound();
}
var user = await GetCurrentUserAsync();
if (user == null)
{
return Unauthorized();
}
await using var context = await dbContextFactory.CreateDbContextAsync();
return Ok(await BuildRevisionInfoAsync(context, user.Id));
}
/// <summary>
/// Block the current user's account.
/// Used for testing forced logout scenarios.
/// After calling this, any subsequent API calls to /status will return 401.
/// </summary>
/// <returns>OK with the blocked status.</returns>
[HttpPost("block-user")]
public async Task<IActionResult> BlockUser()
{
if (!environment.IsDevelopment())
{
return NotFound();
}
var user = await GetCurrentUserAsync();
if (user == null)
{
return Unauthorized();
}
await using var context = await dbContextFactory.CreateDbContextAsync();
// Find the user in the new context and block them
var dbUser = await context.AliasVaultUsers.FindAsync(user.Id);
if (dbUser == null)
{
return NotFound("User not found");
}
dbUser.Blocked = true;
await context.SaveChangesAsync();
return Ok(new
{
blocked = true,
message = $"User {user.UserName} has been blocked",
});
}
/// <summary>
/// Unblock the current user's account.
/// Used for testing - allows re-enabling the account after forced logout test.
/// Note: This uses the JWT token which is still valid even for blocked users,
/// so the user can unblock themselves for testing purposes.
/// </summary>
/// <returns>OK with the blocked status.</returns>
[HttpPost("unblock-user")]
public async Task<IActionResult> UnblockUser()
{
if (!environment.IsDevelopment())
{
return NotFound();
}
var user = await GetCurrentUserAsync();
if (user == null)
{
return Unauthorized();
}
await using var context = await dbContextFactory.CreateDbContextAsync();
// Find the user in the new context and unblock them
var dbUser = await context.AliasVaultUsers.FindAsync(user.Id);
if (dbUser == null)
{
return NotFound("User not found");
}
dbUser.Blocked = false;
await context.SaveChangesAsync();
return Ok(new
{
blocked = false,
message = $"User {user.UserName} has been unblocked",
});
}
/// <summary>
/// Get vault revision information for a user by username.
/// Anonymous endpoint for E2E tests that cannot access auth tokens.
/// Only available in DEBUG builds.
/// </summary>
/// <param name="username">The username to look up.</param>
/// <returns>Vault revision information.</returns>
[AllowAnonymous]
[HttpGet("vault-revisions/by-username/{username}")]
public async Task<IActionResult> GetVaultRevisionsByUsername(string username)
{
if (!environment.IsDevelopment())
{
return NotFound();
}
await using var context = await dbContextFactory.CreateDbContextAsync();
var user = await context.AliasVaultUsers
.FirstOrDefaultAsync(u => u.NormalizedUserName == username.ToUpperInvariant());
if (user == null)
{
return NotFound($"User '{username}' not found");
}
return Ok(await BuildRevisionInfoAsync(context, user.Id));
}
/// <summary>
/// Delete the newest vault revisions for a user by username.
/// Anonymous endpoint for E2E tests that cannot access auth tokens.
/// Only available in DEBUG builds.
/// </summary>
/// <param name="username">The username to look up.</param>
/// <param name="count">Number of newest revisions to delete.</param>
/// <returns>OK with the number of deleted revisions.</returns>
[AllowAnonymous]
[HttpDelete("vault-revisions/by-username/{username}/{count:int}")]
public async Task<IActionResult> DeleteVaultRevisionsByUsername(string username, int count)
{
if (!environment.IsDevelopment())
{
return NotFound();
}
if (count <= 0)
{
return BadRequest("Count must be greater than 0");
}
await using var context = await dbContextFactory.CreateDbContextAsync();
var user = await context.AliasVaultUsers
.FirstOrDefaultAsync(u => u.NormalizedUserName == username.ToUpperInvariant());
if (user == null)
{
return NotFound($"User '{username}' not found");
}
var deletedRevisions = await PopNewestRevisionsAsync(context, user.Id, count);
if (deletedRevisions.Count == 0)
{
return Ok(new { deleted = 0, message = "No revisions found to delete" });
}
return Ok(new
{
deleted = deletedRevisions.Count,
deletedRevisions,
message = $"Deleted {deletedRevisions.Count} vault revision(s)",
});
}
/// <summary>
/// Block a user's account by username.
/// Anonymous endpoint for E2E tests that cannot access auth tokens.
/// Only available in DEBUG builds.
/// </summary>
/// <param name="username">The username to block.</param>
/// <returns>OK with the blocked status.</returns>
[AllowAnonymous]
[HttpPost("block-user/by-username/{username}")]
public async Task<IActionResult> BlockUserByUsername(string username)
{
if (!environment.IsDevelopment())
{
return NotFound();
}
await using var context = await dbContextFactory.CreateDbContextAsync();
var user = await context.AliasVaultUsers
.FirstOrDefaultAsync(u => u.NormalizedUserName == username.ToUpperInvariant());
if (user == null)
{
return NotFound($"User '{username}' not found");
}
user.Blocked = true;
await context.SaveChangesAsync();
return Ok(new
{
blocked = true,
message = $"User {user.UserName} has been blocked",
});
}
/// <summary>
/// Unblock a user's account by username.
/// Anonymous endpoint for E2E tests that cannot access auth tokens.
/// Only available in DEBUG builds.
/// </summary>
/// <param name="username">The username to unblock.</param>
/// <returns>OK with the blocked status.</returns>
[AllowAnonymous]
[HttpPost("unblock-user/by-username/{username}")]
public async Task<IActionResult> UnblockUserByUsername(string username)
{
if (!environment.IsDevelopment())
{
return NotFound();
}
await using var context = await dbContextFactory.CreateDbContextAsync();
var user = await context.AliasVaultUsers
.FirstOrDefaultAsync(u => u.NormalizedUserName == username.ToUpperInvariant());
if (user == null)
{
return NotFound($"User '{username}' not found");
}
user.Blocked = false;
await context.SaveChangesAsync();
return Ok(new
{
blocked = false,
message = $"User {user.UserName} has been unblocked",
});
}
/// <summary>
/// Turn an account into one that predates the unlock-method model and holds a legacy (sqlite-blob) vault: the v2 key
/// material is removed so login falls back to the salt and verifier on the vault row, and the personal vault is
/// overwritten with the given one.
/// Only available in DEBUG builds.
/// </summary>
/// <param name="username">The username of the account.</param>
/// <param name="request">The legacy vault and the login material it was written with.</param>
/// <returns>OK with the manifest id of the overwritten vault.</returns>
[AllowAnonymous]
[HttpPost("legacy-vault/by-username/{username}")]
public async Task<IActionResult> RestoreLegacyVaultByUsername(string username, [FromBody] RestoreLegacyVaultRequest request)
{
if (!environment.IsDevelopment())
{
return NotFound();
}
await using var context = await dbContextFactory.CreateDbContextAsync();
var user = await context.AliasVaultUsers.FirstOrDefaultAsync(u => u.NormalizedUserName == username.ToUpperInvariant());
if (user == null)
{
return NotFound($"User '{username}' not found");
}
await context.AliasVaultUsers.Where(u => u.Id != user.Id && u.SrpIdentity == request.SrpIdentity).ExecuteUpdateAsync(u => u.SetProperty(x => x.SrpIdentity, (string?)null));
user.SrpIdentity = request.SrpIdentity;
context.UserUnlockMethods.RemoveRange(context.UserUnlockMethods.Where(x => x.UserId == user.Id));
context.UserGrantKeys.RemoveRange(context.UserGrantKeys.Where(x => x.UserId == user.Id));
context.UserSigningKeys.RemoveRange(context.UserSigningKeys.Where(x => x.UserId == user.Id));
context.VaultManifestAccessKeys.RemoveRange(context.VaultManifestAccessKeys.Where(x => x.UserId == user.Id));
var manifest = await context.VaultManifests.FirstOrDefaultAsync(x => x.OwnerGroupId == user.PersonalGroupId);
if (manifest == null)
{
return NotFound($"User '{username}' has no personal vault");
}
// A legacy account holds nothing of the manifest storage format, so drop what an earlier write left behind.
context.VaultDataBuckets.RemoveRange(context.VaultDataBuckets.Where(x => x.ManifestId == manifest.ManifestId));
context.VaultDataBucketsHistory.RemoveRange(context.VaultDataBucketsHistory.Where(x => x.ManifestId == manifest.ManifestId));
context.VaultBlobReferences.RemoveRange(context.VaultBlobReferences.Where(x => x.ManifestId == manifest.ManifestId));
context.VaultBlobObjects.RemoveRange(context.VaultBlobObjects.Where(x => x.ManifestId == manifest.ManifestId));
context.VaultManifestDeliveryKeys.RemoveRange(context.VaultManifestDeliveryKeys.Where(x => x.VaultManifestId == manifest.ManifestId));
var now = DateTime.UtcNow;
manifest.CopyPayloadFrom(new VaultManifestsHistory
{
ManifestId = manifest.ManifestId,
StorageFormat = VaultManifestBase.LegacyStorageFormat,
Version = request.Version,
RevisionNumber = request.RevisionNumber,
CreatedAt = now,
UpdatedAt = now,
EncryptionType = request.EncryptionType,
EncryptionSettings = request.EncryptionSettings,
VaultBlob = request.VaultBlob,
Salt = request.Salt,
Verifier = request.Verifier,
});
await context.SaveChangesAsync();
LegacyVaultHelper.ForgetMigrationState(cache, user.Id);
return Ok(new
{
manifestId = manifest.ManifestId,
});
}
/// <summary>
/// Set a server setting by key/value. Used by E2E tests to tune runtime limits
/// (e.g. disabling the per-IP registration rate limit by setting it to 0).
/// Anonymous endpoint for E2E tests that cannot access auth tokens.
/// Only available in DEBUG builds.
/// </summary>
/// <param name="request">The setting to update.</param>
/// <returns>OK with the updated key and value.</returns>
[AllowAnonymous]
[HttpPost("server-settings")]
public async Task<IActionResult> SetServerSetting([FromBody] SetServerSettingRequest request)
{
if (!environment.IsDevelopment())
{
return NotFound();
}
if (string.IsNullOrWhiteSpace(request.Key))
{
return BadRequest("Key is required");
}
await serverSettingsService.SetSettingAsync(request.Key, request.Value);
return Ok(new
{
key = request.Key,
value = request.Value,
});
}
/// <summary>
/// Create a registration invite and return its code, as the admin panel would.
/// Only available in DEBUG builds.
/// </summary>
/// <param name="maxUses">Number of accounts that may register with the invite.</param>
/// <returns>OK with the invite code.</returns>
[AllowAnonymous]
[HttpPost("registration-invites")]
public async Task<IActionResult> CreateRegistrationInvite([FromQuery] int maxUses = 1)
{
if (!environment.IsDevelopment())
{
return NotFound();
}
var code = await registrationInviteService.CreateAsync("E2E test", maxUses, null, "e2e");
return Ok(new { code });
}
/// <summary>
/// Set a capability for one account with a per-account rule, and drop the rule cache so it applies right away.
/// Only available in DEBUG builds.
/// </summary>
/// <param name="username">The username of the account.</param>
/// <param name="request">The capability key and value.</param>
/// <returns>OK with the key and value.</returns>
[AllowAnonymous]
[HttpPost("capabilities/by-username/{username}")]
public async Task<IActionResult> SetCapabilityByUsername(string username, [FromBody] SetCapabilityRequest request)
{
if (!environment.IsDevelopment())
{
return NotFound();
}
await using var context = await dbContextFactory.CreateDbContextAsync();
var user = await context.AliasVaultUsers.FirstOrDefaultAsync(u => u.NormalizedUserName == username.ToUpperInvariant());
if (user == null)
{
return NotFound($"User '{username}' not found");
}
var now = DateTime.UtcNow;
context.CapabilityRules.Add(new CapabilityRule
{
Id = Guid.NewGuid(),
CapabilityKey = request.Key,
UserId = user.Id,
Value = request.Value,
Notes = "E2E test",
CreatedBy = "e2e",
CreatedAt = now,
UpdatedAt = now,
});
await context.SaveChangesAsync();
capabilityService.ClearCache();
return Ok(new { key = request.Key, value = request.Value });
}
/// <summary>
/// Drop the cached capability rules, so rules changed in the database apply on the next request.
/// Only available in DEBUG builds.
/// </summary>
/// <returns>OK.</returns>
[AllowAnonymous]
[HttpPost("capabilities/reset-cache")]
public IActionResult ResetCapabilityCache()
{
if (!environment.IsDevelopment())
{
return NotFound();
}
capabilityService.ClearCache();
return Ok();
}
/// <summary>
/// Get a server setting by key.
/// Anonymous endpoint for E2E tests that cannot access auth tokens.
/// Only available in DEBUG builds.
/// </summary>
/// <param name="key">The setting key to read.</param>
/// <returns>OK with the current key and value (value may be null if unset).</returns>
[AllowAnonymous]
[HttpGet("server-settings/{key}")]
public async Task<IActionResult> GetServerSetting(string key)
{
if (!environment.IsDevelopment())
{
return NotFound();
}
var value = await serverSettingsService.GetSettingAsync(key);
return Ok(new
{
key,
value,
});
}
/// <summary>
/// The account's key generations, primary public keys and session count, so a test can check what a key rotation changed.
/// Only available in DEBUG builds.
/// </summary>
/// <param name="username">The username of the account.</param>
/// <returns>OK with the key state.</returns>
[AllowAnonymous]
[HttpGet("key-state/by-username/{username}")]
public async Task<IActionResult> GetKeyStateByUsername(string username)
{
if (!environment.IsDevelopment())
{
return NotFound();
}
await using var context = await dbContextFactory.CreateDbContextAsync();
var user = await context.AliasVaultUsers.FirstOrDefaultAsync(u => u.NormalizedUserName == username.ToUpperInvariant());
if (user == null)
{
return NotFound($"User '{username}' not found");
}
var personalManifestId = await GroupHelper.GetPersonalManifestIdAsync(context, user.PersonalGroupId);
var manifest = personalManifestId == null ? null : await context.VaultManifests.Where(m => m.ManifestId == personalManifestId.Value).Select(m => new { m.KeyVersion, m.RevisionNumber }).FirstOrDefaultAsync();
var credentials = await AuthHelper.GetUserLatestVaultEncryptionSettingsAsync(context, user);
return Ok(new
{
accountKeyVersion = await context.UserUnlockMethods.Where(x => x.UserId == user.Id && x.Type == UnlockMethodType.Password).Select(x => (int?)x.AccountKeyVersion).FirstOrDefaultAsync(),
srpSalt = credentials.Salt,
manifestKeyVersion = manifest?.KeyVersion,
manifestRevision = manifest?.RevisionNumber,
personalVekVersions = await context.VaultManifestAccessKeys.Where(k => k.UserId == user.Id && k.Type == ManifestKeyType.AccountKey && k.VaultManifestId == personalManifestId).OrderBy(k => k.KeyVersion).Select(k => k.KeyVersion).ToListAsync(),
accountPublicKey = await context.UserGrantKeys.Where(k => k.UserId == user.Id && k.IsPrimary).Select(k => k.PublicKey).FirstOrDefaultAsync(),
signingPublicKey = await context.UserSigningKeys.Where(k => k.UserId == user.Id && k.IsPrimary).Select(k => k.PublicKey).FirstOrDefaultAsync(),
deliveryPublicKey = await context.VaultManifestDeliveryKeys.Where(k => k.VaultManifestId == personalManifestId && k.IsPrimary).Select(k => k.PublicKey).FirstOrDefaultAsync(),
activeSessions = await context.AliasVaultUserRefreshTokens.CountAsync(t => t.UserId == user.Id),
});
}
/// <summary>
/// Builds the revision info payload for a user: the current revision of the personal manifest plus all history
/// revisions, newest first.
/// </summary>
private static async Task<object> BuildRevisionInfoAsync(AliasServerDbContext context, string userId)
{
var current = await context.VaultManifests
.Where(v => context.AliasVaultUsers.Any(u => u.Id == userId && u.PersonalGroupId == v.OwnerGroupId))
.Select(v => new { v.RevisionNumber, v.CreatedAt, v.UpdatedAt })
.FirstOrDefaultAsync();
var history = await context.VaultManifestsHistory
.Where(v => context.VaultManifests.Any(m => m.ManifestId == v.ManifestId && context.AliasVaultUsers.Any(u => u.Id == userId && u.PersonalGroupId == m.OwnerGroupId)))
.OrderByDescending(v => v.RevisionNumber)
.Select(v => new { v.RevisionNumber, v.CreatedAt, v.UpdatedAt })
.ToListAsync();
var revisions = history.ToList();
if (current != null)
{
revisions.Insert(0, current);
}
revisions = revisions.OrderByDescending(v => v.RevisionNumber).ToList();
return new
{
count = revisions.Count,
currentRevision = current?.RevisionNumber ?? 0,
revisions,
};
}
/// <summary>
/// Deletes the newest <paramref name="count"/> revisions of the user's personal manifest by rolling the current row
/// back to the newest history revision each time (the inverse of the archive-then-update upload flow). When no
/// history remains, the manifest row itself is deleted. Returns the revision numbers that were discarded.
/// </summary>
private static async Task<List<long>> PopNewestRevisionsAsync(AliasServerDbContext context, string userId, int count)
{
var deletedRevisions = new List<long>();
var current = await context.VaultManifests.FirstOrDefaultAsync(v => context.AliasVaultUsers.Any(u => u.Id == userId && u.PersonalGroupId == v.OwnerGroupId));
for (var i = 0; i < count && current != null; i++)
{
deletedRevisions.Add(current.RevisionNumber);
// Drop the blob references of the revision being discarded.
await context.VaultBlobReferences.Where(r => r.ManifestId == current.ManifestId && r.RevisionNumber == current.RevisionNumber).ExecuteDeleteAsync();
var newestHistory = await context.VaultManifestsHistory
.Where(h => h.ManifestId == current.ManifestId)
.OrderByDescending(h => h.RevisionNumber)
.FirstOrDefaultAsync();
if (newestHistory == null)
{
context.VaultManifests.Remove(current);
current = null;
}
else
{
current.CopyPayloadFrom(newestHistory);
context.VaultManifestsHistory.Remove(newestHistory);
}
await context.SaveChangesAsync();
}
return deletedRevisions;
}
}
#endif