C# / .NET Kompendium PLEN
.NET / C# / Bezpieczeństwo

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 (jak FixedTenantProvider przy zasiewie danych).
  • Find/FindAsync nie nadaje się do pewnej izolacji, używaj FirstOrDefaultAsync z 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 tid tokenu. 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ą TenantId wymuszaną 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 TenantId moż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.
Postaw mi kawę