Multi-tenancy i bezpieczeństwo WebAPI: czym jest tenant
Słowo tenant (po polsku „najemca”) ma w kontekście bezpieczeństwa API dwa powiązane znaczenia. Wspólny wniosek: tenant to granica izolacji i zaufania, której API musi pilnować na każdym kroku. Podstawy uwierzytelniania i autoryzacji są w temacie Zabezpieczanie WebAPI.
1. Tenant w aplikacji wielodostępnej (multi-tenancy)
W modelu SaaS jedna instancja aplikacji i API obsługuje wielu niezależnych klientów (firm, organizacji), a każdy z nich jest osobnym tenantem. Użytkownicy firmy A nie mogą w żaden sposób zobaczyć, zmienić ani nawet wykryć danych firmy B.
Przykład: system faktur, w którym klientami są firmy Acme i Globex. Obie korzystają z api.faktury.pl, ale każda widzi wyłącznie swoje faktury, użytkowników i ustawienia.
Główne zagrożenie to przeciek danych między tenantami (cross-tenant data leak). To szczególny przypadek BOLA/IDOR: nie chodzi o cudzy rekord w obrębie firmy, tylko o rekord innej firmy. W SaaS taki błąd bywa katastrofalny, bo dotyczy wielu klientów jednocześnie.
2. Tenant w Microsoft Entra ID (dawniej Azure AD)
Tutaj tenant to katalog tożsamości organizacji: jej użytkownicy, grupy i aplikacje. Ma identyfikator (tenant id, GUID) i pojawia się:
- w adresie dostawcy tożsamości:
https://login.microsoftonline.com/{tenantId}/v2.0, - w tokenie JWT jako claim
tid, a wystawca (iss) zawiera ten sam identyfikator.
Aplikację (API) rejestruje się w Entra jako:
- single-tenant - dostępna tylko dla użytkowników jednej organizacji (typowe aplikacje wewnętrzne),
- multi-tenant - dostępna dla użytkowników wielu organizacji (typowe SaaS).
W aplikacjach multi-tenant tokeny przychodzą z różnych tenantów, więc nie wolno walidować wystawcy „na ślepo”. Przy endpointach common i organizations wystawca się zmienia, dlatego trzeba własnym IssuerValidator dopuścić tylko tenanty, które są Twoimi klientami (allow-list). W przeciwnym razie ktokolwiek z dowolnej firmy korzystającej z Entra mógłby się zalogować do Twojego API.
3. Jak API ustala, który to tenant (tenant resolution)
| Źródło | Przykład | Uwagi |
|---|---|---|
| Claim w tokenie | tid lub własny tenant_id |
najbezpieczniejsze, bo podpisane przez dostawcę tożsamości |
| Subdomena | acme.faktury.pl |
wygodne, ale musi być zgodne z tenantem z tokenu |
| Nagłówek | X-Tenant-Id: acme |
nie ufaj bez sprawdzenia, klient może go podmienić |
| Ścieżka | /tenants/acme/orders |
jak wyżej: sprawdź, czy użytkownik należy do tego tenanta |
Złota zasada: tenant bierz z zaufanego źródła (podpisany token), a wszystko, co przysłał klient, traktuj jako dane do zweryfikowania. Jeśli nagłówek lub subdomena wskazuje inny tenant niż token, odrzuć żądanie (403).
4. Modele izolacji danych
| Model | Opis | Izolacja | Koszt i skala |
|---|---|---|---|
| Baza na tenanta | każdy tenant ma własną bazę | najsilniejsza | najdroższe, trudniejsze migracje |
| Schemat na tenanta | jedna baza, osobne schematy | silna | średnie |
Wspólna baza i kolumna TenantId |
wszystkie dane w tych samych tabelach | najsłabsza, wymaga dyscypliny w kodzie | najtańsze, najlepsza skalowalność |
Przy modelu z kolumną TenantId jedno zapomniane Where(o => o.TenantId == ...) oznacza wyciek danych. Dlatego filtr wymusza się centralnie, a nie ręcznie w każdym zapytaniu.
5. Implementacja w .NET: tenant z tokenu i globalny filtr EF Core
Najważniejsze elementy to: dostawca tenanta czytający claim z podpisanego tokenu, globalny filtr zapytań (HasQueryFilter) oraz SaveChanges, który sam ustawia TenantId nowych rekordów. Efekt: GET /api/orders/3 dla zamówienia innej firmy zwraca 404, bo filtr w ogóle go nie „widzi”.
using System.Security.Claims;
using Microsoft.EntityFrameworkCore;
// Where the current tenant comes from.
public interface ITenantProvider
{
string TenantId { get; }
}
// Production implementation: the tenant comes from the SIGNED token ("tid" claim),
// never from a header or body supplied by the client.
public class ClaimsTenantProvider(IHttpContextAccessor accessor) : ITenantProvider
{
public string TenantId =>
accessor.HttpContext?.User.FindFirstValue("tid")
?? throw new UnauthorizedAccessException("No tenant claim in the token");
}
// Used for seeding data and for background work that has no HTTP request.
public class FixedTenantProvider(string tenantId) : ITenantProvider
{
public string TenantId => tenantId;
}
public interface ITenantEntity
{
string TenantId { get; set; }
}
public class Order : ITenantEntity
{
public int Id { get; set; }
public string TenantId { get; set; } = string.Empty;
public string Item { get; set; } = string.Empty;
}
public class AppDbContext : DbContext
{
private readonly ITenantProvider _tenant;
public AppDbContext(DbContextOptions<AppDbContext> options, ITenantProvider tenant) : base(options)
=> _tenant = tenant;
public DbSet<Order> Orders => Set<Order>();
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
// Global query filter: EVERY query on Orders is limited to the current tenant,
// so a forgotten Where(...) cannot leak data between tenants.
modelBuilder.Entity<Order>().HasQueryFilter(o => o.TenantId == _tenant.TenantId);
}
public override int SaveChanges(bool acceptAllChangesOnSuccess)
{
ApplyTenant();
return base.SaveChanges(acceptAllChangesOnSuccess);
}
public override Task<int> SaveChangesAsync(bool acceptAllChangesOnSuccess, CancellationToken cancellationToken = default)
{
ApplyTenant();
return base.SaveChangesAsync(acceptAllChangesOnSuccess, cancellationToken);
}
private void ApplyTenant()
{
foreach (var entry in ChangeTracker.Entries<ITenantEntity>())
{
if (entry.State == EntityState.Added)
entry.Entity.TenantId = _tenant.TenantId; // the client cannot choose the tenant
else if (entry.State == EntityState.Modified)
entry.Property(nameof(ITenantEntity.TenantId)).IsModified = false; // a row cannot be moved to another tenant
}
}
}
Podłączenie w API (uwaga na nagłówek X-Tenant-Id, który może tylko potwierdzić tenanta z tokenu):
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Text;
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.EntityFrameworkCore;
using Microsoft.IdentityModel.Tokens;
var builder = WebApplication.CreateBuilder(args);
// DEMO ONLY: in production tokens come from an identity provider (e.g. Entra ID with its "tid" claim)
// and the key is not stored in code.
const string Issuer = "https://demo.local";
const string Audience = "orders-api";
var signingKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("demo-key-change-me-at-least-32-bytes-long!!"));
builder.Services
.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddJwtBearer(o =>
{
o.MapInboundClaims = false; // keep claim names as in the token ("sub", "tid")
o.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuer = true, ValidIssuer = Issuer,
ValidateAudience = true, ValidAudience = Audience,
ValidateLifetime = true,
ValidateIssuerSigningKey = true, IssuerSigningKey = signingKey,
ValidAlgorithms = new[] { SecurityAlgorithms.HmacSha256 }
};
});
builder.Services.AddAuthorization();
builder.Services.AddHttpContextAccessor();
builder.Services.AddScoped<ITenantProvider, ClaimsTenantProvider>();
builder.Services.AddDbContext<AppDbContext>(o => o.UseInMemoryDatabase("tenants-demo"));
var app = builder.Build();
// Seed: each tenant gets its own orders (a context with a FIXED tenant, no HTTP request here).
using (var scope = app.Services.CreateScope())
{
var options = scope.ServiceProvider.GetRequiredService<DbContextOptions<AppDbContext>>();
var seed = new Dictionary<string, string[]>
{
["acme"] = new[] { "Laptop", "Mouse" },
["globex"] = new[] { "Keyboard" }
};
foreach (var (tenant, items) in seed)
{
using var db = new AppDbContext(options, new FixedTenantProvider(tenant));
db.Orders.AddRange(items.Select(i => new Order { Item = i }));
db.SaveChanges(); // TenantId is filled in by the context
}
}
app.UseAuthentication();
// A tenant sent by the client (header) may only CONFIRM the tenant from the token, never override it.
app.Use(async (ctx, next) =>
{
if (ctx.User.Identity?.IsAuthenticated == true
&& ctx.Request.Headers.TryGetValue("X-Tenant-Id", out var header)
&& header != ctx.User.FindFirstValue("tid"))
{
ctx.Response.StatusCode = StatusCodes.Status403Forbidden;
return;
}
await next();
});
app.UseAuthorization();
// demo users: user -> (password, tenant)
var users = new Dictionary<string, (string Password, string Tenant)>
{
["alice"] = ("alice123", "acme"),
["carol"] = ("carol123", "acme"),
["bob"] = ("bob123", "globex")
};
app.MapPost("/login", (LoginRequest request) =>
{
if (!users.TryGetValue(request.Username, out var u) || u.Password != request.Password)
return Results.Unauthorized();
var claims = new[]
{
new Claim("sub", request.Username),
new Claim("tid", u.Tenant) // the tenant is part of the SIGNED token
};
var token = new JwtSecurityToken(Issuer, Audience, claims,
expires: DateTime.UtcNow.AddMinutes(10),
signingCredentials: new SigningCredentials(signingKey, SecurityAlgorithms.HmacSha256));
return Results.Ok(new { access_token = new JwtSecurityTokenHandler().WriteToken(token), tenant = u.Tenant });
});
// No Where(TenantId) here on purpose: the global query filter does it.
app.MapGet("/api/orders", async (AppDbContext db) => await db.Orders.ToListAsync())
.RequireAuthorization();
// Another tenant's order simply does not exist for the caller -> 404 (not even a hint that it exists).
// Note: FirstOrDefaultAsync applies the query filter (do not rely on Find for this).
app.MapGet("/api/orders/{id:int}", async (int id, AppDbContext db) =>
{
var order = await db.Orders.FirstOrDefaultAsync(o => o.Id == id);
return order is null ? Results.NotFound() : Results.Ok(order);
}).RequireAuthorization();
// The client sends only the item; TenantId is assigned by the server.
app.MapPost("/api/orders", async (NewOrder input, AppDbContext db) =>
{
var order = new Order { Item = input.Item };
db.Orders.Add(order);
await db.SaveChangesAsync();
return Results.Created($"/api/orders/{order.Id}", order);
}).RequireAuthorization();
// ANTI-PATTERN, on purpose: IgnoreQueryFilters bypasses the tenant filter and leaks all tenants' data.
// Such a call must never be reachable by ordinary users - review every use of IgnoreQueryFilters.
app.MapGet("/api/debug/leak", async (AppDbContext db) => await db.Orders.IgnoreQueryFilters().ToListAsync())
.RequireAuthorization();
app.Run();
record LoginRequest(string Username, string Password);
record NewOrder(string Item);
Projekt (TenantIsolationDemo.csproj, pakiety JwtBearer i EF Core InMemory):
<Project Sdk="Microsoft.NET.Sdk.Web">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<Nullable>enable</Nullable>
<ImplicitUsings>enable</ImplicitUsings>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="8.0.10" />
<PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="8.0.10" />
</ItemGroup>
</Project>
Jak to wypróbować
dotnet run, potem plik requests.http (VS Code z REST Client, Rider, Visual Studio) lub curl. Użytkownicy: alice i carol (tenant acme), bob (tenant globex). Hasła mają postać nazwa123.
| Żądanie | Wynik |
|---|---|
alice: GET /api/orders |
tylko zamówienia tenanta acme (Laptop, Mouse) |
alice: GET /api/orders/3 (zamówienie tenanta globex) |
404 |
alice z nagłówkiem X-Tenant-Id: globex |
403 |
bob: POST /api/orders |
zamówienie z tenantem globex, niewidoczne dla alice |
alice: GET /api/debug/leak |
wyciek zamówień wszystkich tenantów (celowy antywzorzec) |
Pułapki tego podejścia
IgnoreQueryFilters()i surowy SQL (FromSqlRaw) omijają filtr, więc trzeba je kontrolować w code review.- Zadania w tle i konsumenci kolejek nie mają
HttpContext, więc tenant musi trafić do nich w komunikacie i zostać jawnie ustawiony (jakFixedTenantProviderprzy zasiewie danych). Find/FindAsyncnie nadaje się do pewnej izolacji, używajFirstOrDefaultAsyncz filtrem.- Globalne tabele (słowniki wspólne dla wszystkich) nie powinny mieć filtra.
- Migracje i raporty administracyjne wymagają świadomego, audytowanego obejścia filtra.
6. Co jeszcze oznacza tenant dla bezpieczeństwa
- Autoryzacja ma dwa poziomy: najpierw „czy ten użytkownik należy do tego tenanta”, potem „co wolno mu w tym tenancie”. Role i polityki działają wewnątrz tenanta. Administrator tenanta to nie to samo co administrator platformy.
- Cache musi uwzględniać tenant w kluczu (
orders:{tenantId}:{id}), inaczej tenant A dostanie z cache odpowiedź tenanta B. - Rate limiting i limity zasobów per tenant, żeby jeden klient nie zajął całej platformy (problem „hałaśliwego sąsiada”, zobacz Rate limiting).
- Klucze i szyfrowanie per tenant (osobne klucze w Key Vault) w wymagających branżach, co ogranicza skutki wycieku jednego klucza.
- Logi i audyt z identyfikatorem tenanta, żeby dało się zbadać incydent u konkretnego klienta.
- Testy izolacji: zautomatyzowane testy, w których tenant A próbuje odczytać i zmienić dane tenanta B i musi dostać 403 lub 404.
- Sekrety i integracje klienta (np. własne klucze API tenanta) trzymaj osobno dla każdego tenanta.
Odpowiedź na rozmowie w skrócie
Tenant to klient (organizacja) korzystający z jednej współdzielonej instancji aplikacji SaaS, a w Entra ID katalog tożsamości organizacji, którego identyfikator jest w claimie
tidtokenu. W kontekście bezpieczeństwa najważniejsza jest izolacja tenantów: tenant ustalam z podpisanego tokenu, nie z nagłówka od klienta, a dostęp do danych wymuszam centralnie (np. globalny filtr EF Core), żeby nie doszło do przecieku danych między klientami. Przy aplikacji multi-tenant walidacja wystawcy musi przepuszczać tylko dozwolone tenanty.
Pytania rekrutacyjne
- Co to tenant? Klient (organizacja) korzystający ze wspólnej instancji aplikacji, a w Entra ID katalog tożsamości organizacji (claim
tid). - Jak zapewnić izolację danych w multi-tenancy? Baza lub schemat na tenanta albo wspólna baza z kolumną
TenantIdwymuszaną centralnie (globalny filtr zapytań EF Core). - Skąd brać tenanta w żądaniu? Z podpisanego tokenu, a nagłówek lub subdomenę tylko porównywać z nim, nigdy nie ufać im samodzielnie.
- Czym grozi multi-tenant app w Entra bez walidacji wystawcy? Zalogować się mogłaby dowolna organizacja, więc trzeba dopuścić tylko znanych klientów (allow-list tenantów).
- Jak zwykły filtr
TenantIdmoże zawieść?IgnoreQueryFilters, surowy SQL,Find, zadania w tle bez kontekstu HTTP oraz cache bez tenanta w kluczu. - Czym różni się BOLA/IDOR od wycieku między tenantami? To ta sama klasa błędu, ale przy multi-tenancy dotyczy danych innej firmy, więc skutki są dużo poważniejsze.