SecurityDatabases.NETAI

Het Lovable-lek en Row-Level Security: autorisatie in lagen voor je .NET-API

24.664 Lovable-sites stuurden databaserecords zonder login. Wat dat zegt over Row-Level Security, en hoe je in .NET met policies, EF Core-filters, Postgres RLS en tests autorisatie in lagen bouwt.

JB
Jean-Pierre Broeders
Freelance .NET Developer · 16 november 2026 · 13 min lezen
Het Lovable-lek en Row-Level Security: autorisatie in lagen voor je .NET-API

Paspoortnummers. Meer dan 200.000 chatberichten. Facturen, contracten, fotoalbums. Allemaal op te vragen door een webpagina te openen, zonder in te loggen. Dat is de kern van het onderzoek dat Crissy Field samen met Handelsblatt deed naar apps die met Lovable zijn gebouwd, en het stond dit weekend met bijna 1.000 punten bovenaan Hacker News.

De reflex is om dit af te doen als een probleem van vibe coders. Mensen zonder technische achtergrond klikken een app in elkaar, de AI vergeet iets, pech. Ik denk dat dat te makkelijk is. Wat hier misging, gaat ook mis in teams met senior developers. Het gaat over de vraag waar je autorisatie laat wonen, en of iemand ooit test dat die autorisatie werkt.

Wat Crissy Field precies vond

De onderzoekers bekeken 159.041 Lovable-projecten uit Common Crawl-data, verzameld tussen december 2025 en september 2026. Ze richtten zich op de 34.545 projecten met een Supabase-koppeling, omdat die integratie volgens hen relatief makkelijk te analyseren is en vermoedelijk de meest gebruikte database onder Lovable-projecten.

Het hoofdgetal: 24.664 websites stuurden direct bij het laden databaserecords mee uit Supabase, zonder login of andere interactie. Bij 7.403 van die sites (30 procent) zaten in 10.560 tabellen e-mailadressen. Onder de gevonden data noemen ze ruim 80.000 profielen met naam, e-mail, geboortedatum en geslacht, meer dan 200.000 chatberichten en ruim 1.000 records met identiteitsgegevens zoals paspoortnummers.

De onderzoekers zijn zelf voorzichtig. Die 30 procent is volgens hen geen bevestigd lekpercentage, want niet elke tabel met e-mailadressen bevat gevoelige data. Het rapport noemt ook geen exacte technische oorzaak per site. Het zegt wel dat database-integraties bij Lovable terugkerende patronen volgen, zodat een aanvaller makkelijk op zoek kan naar dezelfde fout bij duizenden apps tegelijk.

De oorzaak kwam in de HN-discussie van Lovable zelf. Igor, die zich voorstelt als Head of Security bij Lovable, schrijft daar dat de root cause "insufficient Row-Level Security" was. Hij wijst op hun scanner die elke app voor publicatie controleert en zegt dat veel van de projecten met oudere modellen zijn gebouwd.

Waarom dit geen vibe-coderprobleem is

Supabase werkt zoals Firebase: de browser praat rechtstreeks met de database via een API, en wat iemand mag zien bepaal je met Postgres RLS-policies. Klopt de policy niet, of staat RLS uit op een tabel, dan ligt de tabel open. Er zit geen backend tussen die het nog kan opvangen.

Wat me in de draad opviel, is hoeveel ervaren mensen zeggen dat ze hier zelf ook last van hebben. Een reactie die bleef hangen: "I've seen staff+ level developers get bit by this." Een ander wijst erop hoe makkelijk het misgaat als je tabellen niet via het dashboard aanmaakt, maar met een ORM of direct in SQL.

Dat laatste is precies hoe het in .NET-projecten gaat. Een nieuwe EF Core-migratie maakt een tabel invoice_attachments aan. Niemand denkt aan tenant-isolatie, want de controller filtert toch op TenantId. Tot iemand een tweede endpoint schrijft dat dat filter vergeet. Of een agent dat doet, wat in 2026 net zo waarschijnlijk is.

Het gemeenschappelijke probleem: autorisatie zit op één plek, en niemand heeft ooit bewezen dat die plek werkt.

Mijn positie: RLS is een vangnet

Een reactie in de draad vat mijn mening goed samen. RLS als "one layer of defense in depth, or an underlying safety net for when your backend code forgets to filter properly". Bij Supabase is RLS vaak de enige laag. In een .NET-backend hoeft dat niet en moet je het ook niet willen.

Ik bouw multi-tenant API's daarom met drie lagen en een vierde die de andere drie controleert:

  1. Autorisatie in de API zelf, per resource, met ASP.NET Core-policies.
  2. Een EF Core global query filter op tenant, zodat een vergeten Where niet meteen data van een ander oplevert.
  3. Postgres Row-Level Security als laatste muur, voor raw SQL, rapportagequeries en alles wat langs EF Core gaat.
  4. Tests die elke laag apart aanvallen, plus een check in CI die faalt als een tabel zonder RLS de database in komt.

Hieronder de code. Ik ga uit van Npgsql met EFCore.NamingConventions, zodat kolommen in snake_case staan.

Laag 1: resource-based authorization

Een [Authorize]-attribuut controleert of iemand is ingelogd. Het controleert niet of factuur 8f3c... van die persoon is. Daarvoor heb je resource-based authorization nodig.

using System.Security.Claims;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Authorization.Infrastructure;

public static class Operations
{
    public static readonly OperationAuthorizationRequirement Read = new() { Name = nameof(Read) };
    public static readonly OperationAuthorizationRequirement Update = new() { Name = nameof(Update) };
}

public sealed class SameTenantHandler
    : AuthorizationHandler<OperationAuthorizationRequirement, Invoice>
{
    protected override Task HandleRequirementAsync(
        AuthorizationHandlerContext context,
        OperationAuthorizationRequirement requirement,
        Invoice resource)
    {
        var claim = context.User.FindFirstValue("tenant_id");

        if (Guid.TryParse(claim, out var tenantId) && resource.TenantId == tenantId)
        {
            context.Succeed(requirement);
        }

        return Task.CompletedTask;
    }
}

In de endpoint haal je de resource op en vraag je daarna expliciet toestemming:

builder.Services.AddSingleton<IAuthorizationHandler, SameTenantHandler>();

app.MapGet("/invoices/{id:guid}", async (
        Guid id,
        AppDbContext db,
        IAuthorizationService authz,
        ClaimsPrincipal user,
        CancellationToken ct) =>
    {
        var invoice = await db.Invoices.FirstOrDefaultAsync(i => i.Id == id, ct);
        if (invoice is null) return Results.NotFound();

        var result = await authz.AuthorizeAsync(user, invoice, Operations.Read);
        return result.Succeeded ? Results.Ok(invoice) : Results.NotFound();
    })
    .RequireAuthorization();

Bij een mislukte check geef ik bewust een 404 en geen 403. Een 403 vertelt een aanvaller dat het id bestaat. Bij opeenvolgende of voorspelbare id's is dat al genoeg om te gaan enumereren.

Laag 2: een global query filter op tenant

Laag 1 werkt alleen als elke developer hem aanroept. Dat gaat een keer mis. Een global query filter zorgt dat elke LINQ-query op Invoices automatisch op tenant filtert.

public interface ITenantContext
{
    Guid? TenantId { get; }
}

public sealed class HttpTenantContext(IHttpContextAccessor accessor) : ITenantContext
{
    public Guid? TenantId =>
        Guid.TryParse(accessor.HttpContext?.User.FindFirst("tenant_id")?.Value, out var id)
            ? id
            : null;
}

public sealed class AppDbContext(
    DbContextOptions<AppDbContext> options,
    ITenantContext tenant) : DbContext(options)
{
    public DbSet<Invoice> Invoices => Set<Invoice>();

    // Een property op de context, zodat EF Core de waarde per instantie opnieuw leest.
    private Guid? CurrentTenantId => tenant.TenantId;

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Invoice>()
            .HasQueryFilter(i => i.TenantId == CurrentTenantId);
    }
}

Let op het gedrag zonder tenant. Is CurrentTenantId null, dan matcht het filter niets en krijg je nul rijen terug. Dat wil je: fail closed.

Er zijn twee gaten. IgnoreQueryFilters() zet het filter uit, dus zoek daar in code reviews actief op. En FromSql of Dapper-queries op dezelfde connectie gaan er gewoon langs. Daarvoor is laag 3.

Laag 3: Postgres Row-Level Security

RLS werkt in de database zelf, onafhankelijk van welke client de query stuurt. De tenant geef je door via een sessievariabele. Eerst de migratie:

public partial class EnableRlsOnInvoices : Migration
{
    protected override void Up(MigrationBuilder migrationBuilder)
    {
        migrationBuilder.Sql("""
            ALTER TABLE invoices ENABLE ROW LEVEL SECURITY;
            ALTER TABLE invoices FORCE ROW LEVEL SECURITY;

            CREATE POLICY tenant_isolation ON invoices
                USING (tenant_id = NULLIF(current_setting('app.tenant_id', true), '')::uuid)
                WITH CHECK (tenant_id = NULLIF(current_setting('app.tenant_id', true), '')::uuid);
            """);
    }

    protected override void Down(MigrationBuilder migrationBuilder)
    {
        migrationBuilder.Sql("""
            DROP POLICY IF EXISTS tenant_isolation ON invoices;
            ALTER TABLE invoices NO FORCE ROW LEVEL SECURITY;
            ALTER TABLE invoices DISABLE ROW LEVEL SECURITY;
            """);
    }
}

Drie details die ik vaak fout zie gaan.

FORCE ROW LEVEL SECURITY is nodig omdat de eigenaar van een tabel RLS anders standaard omzeilt. Draait je app met dezelfde rol als je migraties, dan doet de policy zonder FORCE niets.

De NULLIF(..., '') vangt een lege sessievariabele op. Zonder die check geeft ''::uuid een fout. Met de check wordt het NULL, en tenant_id = NULL is nooit waar. Weer nul rijen.

WITH CHECK voorkomt dat iemand een rij schrijft met de tenant_id van een ander. USING alleen beschermt lezen, updaten en verwijderen, niet het invoegen van nieuwe rijen.

Daarnaast geef je de app een eigen rol zonder speciale rechten:

CREATE ROLE app_user LOGIN PASSWORD 'uit-je-secret-store' NOSUPERUSER NOBYPASSRLS;
GRANT USAGE ON SCHEMA public TO app_user;
GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public TO app_user;

Dan de sessievariabele. Die zet ik met een interceptor elke keer dat EF Core een connectie opent:

using System.Data.Common;
using Microsoft.EntityFrameworkCore.Diagnostics;

public sealed class TenantConnectionInterceptor(ITenantContext tenant) : DbConnectionInterceptor
{
    private const string Sql = "SELECT set_config('app.tenant_id', @tenant, false)";

    public override void ConnectionOpened(DbConnection connection, ConnectionEndEventData eventData)
    {
        using var cmd = CreateCommand(connection);
        cmd.ExecuteNonQuery();
    }

    public override async Task ConnectionOpenedAsync(
        DbConnection connection,
        ConnectionEndEventData eventData,
        CancellationToken cancellationToken = default)
    {
        await using var cmd = CreateCommand(connection);
        await cmd.ExecuteNonQueryAsync(cancellationToken);
    }

    private DbCommand CreateCommand(DbConnection connection)
    {
        var cmd = connection.CreateCommand();
        cmd.CommandText = Sql;

        var p = cmd.CreateParameter();
        p.ParameterName = "tenant";
        p.Value = tenant.TenantId?.ToString() ?? string.Empty;
        cmd.Parameters.Add(p);

        return cmd;
    }
}

En de registratie:

builder.Services.AddHttpContextAccessor();
builder.Services.AddScoped<ITenantContext, HttpTenantContext>();
builder.Services.AddScoped<TenantConnectionInterceptor>();

builder.Services.AddDbContext<AppDbContext>((sp, options) =>
    options
        .UseNpgsql(builder.Configuration.GetConnectionString("App"))
        .UseSnakeCaseNamingConvention()
        .AddInterceptors(sp.GetRequiredService<TenantConnectionInterceptor>()));

De interceptor is scoped, omdat hij de tenant van het huidige request nodig heeft. Daarom gebruik ik hier AddDbContext en geen AddDbContextPool: bij pooling worden de options eenmalig gebouwd en zou je een interceptor van één request delen met alle andere.

Over connection pooling in Npgsql zelf: de interceptor zet de variabele bij elke open opnieuw, ook als er geen tenant is (dan een lege string). Een connectie uit de pool kan dus nooit de tenant van een vorig request meenemen. Gebruik je PgBouncer in transaction mode, dan werkt dit niet. Dan moet je set_config(..., true) binnen een expliciete transactie aanroepen, zodat de waarde transactie-lokaal is.

Laag 4: bewijs het met tests

Hier ging het bij Lovable volgens mij echt mis. Een policy die niemand test, is een aanname. De HN-draad staat vol mensen die zeggen dat RLS lastig te debuggen is. Klopt. Daarom laat ik de computer het controleren.

Twee soorten tests. De eerste valt de database rechtstreeks aan, als app_user, zonder EF Core ertussen. Ik gebruik Testcontainers met een echte Postgres; de fixture die migraties draait en twee tenants met data vult laat ik hier weg.

public sealed class RlsTests(PostgresFixture fx) : IClassFixture<PostgresFixture>
{
    [Fact]
    public async Task App_user_without_tenant_sees_no_rows()
    {
        await using var conn = new NpgsqlConnection(fx.AppUserConnectionString);
        await conn.OpenAsync();

        await using var cmd = new NpgsqlCommand("SELECT count(*) FROM invoices", conn);
        var count = (long)(await cmd.ExecuteScalarAsync())!;

        Assert.Equal(0, count);
    }

    [Fact]
    public async Task Tenant_a_cannot_read_rows_of_tenant_b()
    {
        await using var conn = new NpgsqlConnection(fx.AppUserConnectionString);
        await conn.OpenAsync();

        await using (var set = new NpgsqlCommand(
            "SELECT set_config('app.tenant_id', @t, false)", conn))
        {
            set.Parameters.AddWithValue("t", fx.TenantA.ToString());
            await set.ExecuteNonQueryAsync();
        }

        await using var cmd = new NpgsqlCommand(
            "SELECT count(*) FROM invoices WHERE tenant_id = @b", conn);
        cmd.Parameters.AddWithValue("b", fx.TenantB);

        Assert.Equal(0L, (long)(await cmd.ExecuteScalarAsync())!);
    }
}

De tweede soort test is degene die het Lovable-scenario echt afvangt: een nieuwe tabel zonder RLS. Deze query zoekt in de systeemcatalogus naar tabellen waar RLS uit staat of niet geforceerd is, en naar policies die alles doorlaten:

[Fact]
public async Task Every_table_has_forced_rls_and_no_permissive_true_policy()
{
    await using var conn = new NpgsqlConnection(fx.OwnerConnectionString);
    await conn.OpenAsync();

    const string sql = """
        SELECT c.relname
        FROM pg_class c
        JOIN pg_namespace n ON n.oid = c.relnamespace
        WHERE n.nspname = 'public'
          AND c.relkind = 'r'
          AND c.relname <> '__EFMigrationsHistory'
          AND (NOT c.relrowsecurity OR NOT c.relforcerowsecurity)
        UNION
        SELECT tablename
        FROM pg_policies
        WHERE schemaname = 'public'
          AND (qual = 'true' OR with_check = 'true');
        """;

    var offenders = new List<string>();
    await using var cmd = new NpgsqlCommand(sql, conn);
    await using var reader = await cmd.ExecuteReaderAsync();
    while (await reader.ReadAsync())
    {
        offenders.Add(reader.GetString(0));
    }

    Assert.Empty(offenders);
}

Heb je tabellen die echt publiek mogen zijn, zoals een lijst met landen, zet die dan in een expliciete allowlist in de test. Dan moet iemand in een pull request uitleggen waarom een tabel open staat. Die discussie wil je hebben voor de release, niet erna.

Wat dit betekent als een AI je code schrijft

Lovable zegt dat ze hun modellen trainen om beter te worden in RLS. Dat geloof ik. Maar ik reken er niet op, net zo min als ik erop reken dat een nieuwe collega het meteen goed doet.

In mijn eigen projecten staat in het AGENTS.md-bestand een regel: elke migratie die een tabel aanmaakt, bevat RLS, een policy en een uitbreiding van de tenant-tests. De catalogustest hierboven maakt die regel afdwingbaar. Vergeet de agent het, dan faalt de build. Daar hoef ik niet voor op te letten in een review van 600 regels.

Dat is ook mijn kritiek op het "we scannen voor publicatie"-antwoord. Een scanner die waarschuwt, kun je negeren. Igor vraagt gebruikers in de draad zelf om waarschuwingen niet te negeren, en geeft toe dat RLS achteraf toevoegen aan een complexe app lastig is en dingen laat breken. Een test die de build tegenhoudt, kun je niet negeren.

De prijs van RLS

RLS is niet gratis. Postgres voegt de policy-expressie aan elke query toe. Met een index op tenant_id merk je daar bij normale OLTP-queries weinig van, maar houd de expressie simpel. Een policy die per rij een subquery op een memberships-tabel doet, voel je wel.

Achtergrondjobs worden lastiger. Een nachtelijke job die over alle tenants heen rapporteert, ziet nul rijen. Je kunt die job per tenant laten lopen, of een aparte rol met BYPASSRLS maken die alleen die job gebruikt. Kies het tweede alleen als je die rol net zo strak bewaakt als je admin-credentials.

En debuggen is vervelender. Een query die "niets" teruggeeft, kan een bug zijn of een policy die precies doet wat hij moet doen. Log daarom bij elke request de tenant die je in de sessie zet. Dan zie je het verschil binnen een minuut.

Ik vind die kosten het waard voor elke app met data van meerdere klanten. Voor een interne tool met één tenant zou ik laag 2 en 4 bouwen en RLS overslaan.

Veelgestelde vragen over Row-Level Security in .NET

Is een EF Core global query filter niet genoeg voor tenant-isolatie? Voor de meeste LINQ-queries wel, maar IgnoreQueryFilters(), FromSql, Dapper en losse rapportagescripts gaan er langs. RLS werkt op databaseniveau, dus ook voor alles wat niet via je DbContext loopt.

Werkt deze aanpak met PgBouncer? In session mode wel. In transaction mode deelt PgBouncer een serverconnectie tussen clients per transactie, waardoor een sessievariabele kan blijven hangen. Gebruik dan set_config('app.tenant_id', ..., true) binnen een expliciete transactie, zodat de waarde na de commit verdwijnt.

Kan ik RLS ook gebruiken met SQL Server? Ja, SQL Server heeft Row-Level Security met security policies en predicate functions, en SESSION_CONTEXT vervult de rol van de Postgres-sessievariabele. De syntax verschilt, maar het idee van een filterpredicaat plus een block-predicaat voor schrijfacties is hetzelfde.

Moet een geweigerde aanvraag een 403 of een 404 teruggeven? Voor resources van een andere tenant geef ik een 404, omdat een 403 bevestigt dat het id bestaat. Een 403 bewaar ik voor gevallen waarin de gebruiker de resource wel mag zien maar de actie niet mag uitvoeren, zoals een factuur die al definitief is.

Hoe weet ik of mijn bestaande database tabellen zonder RLS heeft? Draai de catalogusquery uit dit artikel tegen een kopie van productie. Die toont elke tabel in het public-schema waar RLS uit staat of niet geforceerd is, plus elke policy met USING (true).

Verder lezen


Conclusie: Het Lovable-lek laat zien wat er gebeurt als autorisatie op één plek woont en niemand test of die plek werkt. Zet in je .NET-API resource-based checks, een query filter en Postgres RLS achter elkaar, en laat een test in CI falen zodra er een tabel zonder policy bij komt.

Bronnen: Crissy Field: Lovable-onderzoek · Hacker News-discussie · PostgreSQL-documentatie: Row Security Policies.

Hulp nodig bij een vergelijkbaar vraagstuk?
Neem contact op