Privacy-first password manager with built-in email aliasing. Fully encrypted and self-hostable.
//-----------------------------------------------------------------------
// <copyright file="Program.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>
//-----------------------------------------------------------------------
using System.Globalization;
using System.Reflection;
using System.Text;
using System.Text.Json;
using AliasServerDb;
using AliasServerDb.Configuration;
using AliasVault.Api;
using AliasVault.Api.Filters;
using AliasVault.Api.Helpers;
using AliasVault.Api.Jwt;
using AliasVault.Api.Services;
using AliasVault.Api.Services.RateLimiting;
using AliasVault.Api.Services.RateLimiting.Helpers;
using AliasVault.Auth;
using AliasVault.Auth.IpAddress;
using AliasVault.Cryptography;
using AliasVault.Logging;
using AliasVault.Shared.Models.Configuration;
using AliasVault.Shared.Models.Enums;
using AliasVault.Shared.Models.WebApi.V2;
using AliasVault.Shared.Server.Services;
using AliasVault.Shared.Server.Utilities;
using Asp.Versioning;
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.AspNetCore.Http.Features;
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using Microsoft.IdentityModel.Tokens;
using Microsoft.OpenApi;
var builder = WebApplication.CreateBuilder(args);
// Force invariant culture to prevent regional date formatting issues
// (e.g., times should be formatted as "09:03:09" instead of alternate region formats like "09.03.09").
CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.InvariantCulture;
builder.Configuration.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true);
builder.Configuration.AddJsonFile($"appsettings.{builder.Environment.EnvironmentName}.json", optional: true, reloadOnChange: true);
#if DEBUG
// E2E tests override config values for their own requests via headers, see TestConfig.
var config = builder.Environment.IsDevelopment() ? new AliasVault.Api.Controllers.V2.Tests.TestConfig(new HttpContextAccessor()) : new Config();
#else
var config = new Config();
#endif
var publicRegistrationEnabled = Environment.GetEnvironmentVariable("PUBLIC_REGISTRATION_ENABLED") ?? "false";
config.PublicRegistrationEnabled = bool.Parse(publicRegistrationEnabled);
var privateEmailDomains = Environment.GetEnvironmentVariable("PRIVATE_EMAIL_DOMAINS")?
.Split(",", StringSplitOptions.RemoveEmptyEntries)
.Select(d => d.Trim().ToLowerInvariant())
.Where(d => !string.IsNullOrWhiteSpace(d));
config.PrivateEmailDomains = privateEmailDomains?.ToList() ?? new List<string>();
var hiddenPrivateEmailDomains = Environment.GetEnvironmentVariable("HIDDEN_PRIVATE_EMAIL_DOMAINS")?
.Split(",", StringSplitOptions.RemoveEmptyEntries)
.Select(d => d.Trim().ToLowerInvariant())
.Where(d => !string.IsNullOrWhiteSpace(d));
config.HiddenPrivateEmailDomains = hiddenPrivateEmailDomains?.ToList() ?? new List<string>();
var ipLoggingEnabled = Environment.GetEnvironmentVariable("IP_LOGGING_ENABLED") ?? "false";
config.IpLoggingEnabled = bool.Parse(ipLoggingEnabled);
// Configure maximum upload size (applies to vault syncs and any other client uploads).
var maxUploadSizeMb = int.TryParse(Environment.GetEnvironmentVariable("MAX_UPLOAD_SIZE_MB"), out var parsedMb) && parsedMb > 0 ? parsedMb : 100;
var maxUploadSizeBytes = (long)maxUploadSizeMb * 1024 * 1024;
builder.WebHost.ConfigureKestrel(options =>
{
options.Limits.MaxRequestBodySize = maxUploadSizeBytes;
});
builder.Services.Configure<FormOptions>(options =>
{
options.MultipartBodyLengthLimit = maxUploadSizeBytes;
});
builder.Services.AddSingleton(config);
builder.Services.AddSingleton<SharedConfig>(sp => sp.GetRequiredService<Config>());
builder.Services.ConfigureLogging(builder.Configuration, Assembly.GetExecutingAssembly().GetName().Name!, "../../logs");
builder.Services.AddAliasVaultDatabaseConfiguration(builder.Configuration);
builder.Services.AddAliasVaultDataProtection("AliasVault.Api");
builder.Services.AddSingleton(TimeProvider.System);
builder.Services.AddScoped<TimeValidationJwtBearerEvents>();
builder.Services.AddScoped<AuthLoggingService>();
builder.Services.AddScoped<ServerSettingsService>();
builder.Services.AddSingleton<KeyedAsyncLock>();
builder.Services.AddScoped<RegistrationRateLimitService>();
builder.Services.AddScoped<RegistrationInviteService>();
builder.Services.AddScoped<IpBlockListService>();
builder.Services.AddScoped<MobileLoginRateLimitService>();
builder.Services.AddSingleton<FaviconRateLimitService>();
builder.Services.AddSingleton<TakenAliasLookupRateLimitService>();
builder.Services.AddSingleton<LoginRateLimitService>();
builder.Services.AddSingleton<AccountFingerprintLookupRateLimitService>();
builder.Services.AddScoped<RateLimitService>();
builder.Services.AddScoped<CapabilityService>();
builder.Services.AddScoped<TokenService>();
builder.Services.AddHttpContextAccessor();
builder.Services.AddRateLimiter(options => RegistrationCheckRateLimit.Configure(options, builder.Environment.IsDevelopment()));
builder.Services.AddLogging(logging =>
{
logging.AddConsole();
logging.SetMinimumLevel(LogLevel.Error);
logging.AddFilter("Microsoft.AspNetCore.Identity.DataProtectorTokenProvider", LogLevel.Error);
logging.AddFilter("Microsoft.AspNetCore.Identity.UserManager", LogLevel.Error);
});
builder.Services.AddIdentityCore<AliasVaultUser>(options =>
{
options.Password.RequireDigit = false;
options.Password.RequireLowercase = false;
options.Password.RequireNonAlphanumeric = false;
options.Password.RequireUppercase = false;
options.Password.RequiredLength = 8;
options.Password.RequiredUniqueChars = 0;
options.SignIn.RequireConfirmedAccount = false;
options.Lockout.MaxFailedAccessAttempts = 10;
options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(30);
options.Tokens.ProviderMap.Add("AliasVault", new TokenProviderDescriptor(typeof(DataProtectorTokenProvider<AliasVaultUser>)));
})
.AddEntityFrameworkStores<AliasServerDbContext>()
.AddDefaultTokenProviders()
.AddTokenProvider<DataProtectorTokenProvider<AliasVaultUser>>("AliasVault");
builder.Services.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(options =>
{
var jwtKey = SecretReader.GetJwtKey();
options.IncludeErrorDetails = builder.Environment.IsDevelopment();
options.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuer = true,
ValidateAudience = true,
ValidateLifetime = true,
RequireExpirationTime = true,
ValidateIssuerSigningKey = true,
ValidIssuer = builder.Configuration["Jwt:Issuer"],
ValidAudience = builder.Configuration["Jwt:Issuer"],
IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(jwtKey)),
ClockSkew = TimeSpan.Zero,
};
// Add custom event handler for validating token expiration time in order
// to be able to mutate current time for testing the token expiration logic in unit tests.
options.EventsType = typeof(TimeValidationJwtBearerEvents);
});
// Configure CORS
builder.Services.AddCors(options =>
{
options.AddPolicy(
"CorsPolicy",
policy => policy.AllowAnyOrigin()
.AllowAnyMethod()
.AllowAnyHeader());
});
builder.Services.AddControllers(options =>
{
options.InputFormatters.Insert(0, new BinaryFrameInputFormatter());
options.Filters.Add<LegacyApiGuardFilter>();
})
.AddJsonOptions(options =>
{
// Ensure consistent date formatting regardless of server locale
options.JsonSerializerOptions.PropertyNamingPolicy = JsonNamingPolicy.CamelCase;
options.JsonSerializerOptions.WriteIndented = false;
})
.ConfigureApiBehaviorOptions(options =>
{
// A V2 request that fails model binding or validation gets the coded error body; V1 keeps the framework default.
var defaultFactory = options.InvalidModelStateResponseFactory;
options.InvalidModelStateResponseFactory = context => ApiError.IsV2Request(context.HttpContext) ? ApiError.Result(ApiErrorCode.INVALID_REQUEST, StatusCodes.Status400BadRequest) : defaultFactory(context);
});
builder.Services.AddMemoryCache();
builder.Services.AddApiVersioning(options =>
{
options.DefaultApiVersion = new ApiVersion(1, 0);
options.AssumeDefaultVersionWhenUnspecified = true;
options.ReportApiVersions = true;
})
.AddMvc()
.AddApiExplorer(options =>
{
options.GroupNameFormat = "'v'VVV";
options.SubstituteApiVersionInUrl = true;
});
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo { Title = "AliasVault API", Version = "v1" });
// Add JWT Authentication
c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
{
In = ParameterLocation.Header,
Description = "Please enter a valid token",
Name = "Authorization",
Type = SecuritySchemeType.Http,
BearerFormat = "JWT",
Scheme = "Bearer",
});
c.AddSecurityRequirement(_ => new OpenApiSecurityRequirement
{
[new OpenApiSecuritySchemeReference("Bearer")] = [],
});
});
var app = builder.Build();
if (app.Environment.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseSwagger();
app.UseSwaggerUI();
}
app.UseCors("CorsPolicy");
// If the ASPNETCORE_PATHBASE environment variable is set, use it as the path base
if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("ASPNETCORE_PATHBASE")))
{
app.UsePathBase(Environment.GetEnvironmentVariable("ASPNETCORE_PATHBASE"));
}
// An unhandled exception on a V2 request still answers with the coded error body.
app.UseWhen(ApiError.IsV2Request, v2 => v2.UseExceptionHandler(errorApp => errorApp.Run(context => context.Response.WriteAsJsonAsync(ErrorResponse.Create(ApiErrorCode.INTERNAL_SERVER_ERROR, StatusCodes.Status500InternalServerError)))));
app.UseAuthentication();
app.UseAuthorization();
app.UseRateLimiter();
app.MapControllers();
using (var scope = app.Services.CreateScope())
{
var container = scope.ServiceProvider;
var migrationLogger = container.GetRequiredService<ILoggerFactory>().CreateLogger("AliasVault.DatabaseMigrations");
await using var db = await container.GetRequiredService<IAliasServerDbContextFactory>().CreateDbContextAsync();
// The API is responsible for database migrations and runtime should not be limited by a command timeout.
db.Database.SetCommandTimeout(0);
await db.MigrateWithLoggingAsync(migrationLogger);
}
await app.RunAsync();
namespace AliasVault.Api
{
/// <summary>
/// Explicit program class definition. This is required in order to start the WebAPI project
/// in-memory from E2ETests project via WebApplicationFactory.
/// </summary>
public partial class Program
{
}
}