Egy felhasználóból sok bérlő
a bérlő-határ rétegről rétegre, az adattól az ügynök futtatásáig
the tenant boundary layer by layer, from the data to running the agents
Röviden, előismeret nélkül. Egy többbérlős rendszerben több ügyfél használja ugyanazt a rendszert, és egyik sem láthatja a másik adatát. Ez az adatbázison túl a titkokra, az eszközökre, az ütemezésre és az ügynökök futására is igaz. Megmutatom, hol tart ez a rendszeremben, és hol nem.
An English version of this article follows below. Jump to the English version.
Egy bérlő-azonosító oszlop felvétele öt perc. Azt bizonyítani, hogy sehol nem szivárog át semmi, hónapok.
Az első részben a rendszerem mérlegét tettem le: tíz vállalati elvárás, mellettük az állapotom. A mérleg első sora a bérlők elkülönítése volt, és ott ez állt: részben. Ez a rész arról szól, mit jelent ez a „részben”, pontosan hol van kész, és hol nincs.
1. Mi a bérlő, és miért nem egy oszlop
Bérlőnek egy ügyfelet hívok: egy céget vagy egy csapatot, amely a rendszer közös példányában dolgozik, a saját adataival, a saját felhasználóival és a saját ügynökeivel. A követelmény az, hogy ő a másikét ne lássa, és a másik se az övét.
A legegyszerűbb kép egy társasház. Minden lakásnak külön kulcsa van, a lakók nem járnak egymás konyhájában. A pince, a lépcsőház és a vízóra-szekrény viszont közös. Ha többbérlős rendszert tervezek, a kérdés mindig ugyanaz: mi a lakás, és mi a pince? Az adat lakás. Az ügynök, amely az adatot olvassa és a nevemben dolgozik, már nem ennyire egyértelmű.
Az adatbázisban a bérlőt egy bérlő-azonosító oszlop jelöli minden sorban: ez mondja meg, kié a sor. Felvenni egy ilyen oszlopot gyors. A nehéz rész utána jön: minden lekérdezésben, minden menetben, minden háttérfeladatban ott kell lennie a feltételnek, hogy „csak az én bérlőm sorai”. Ha egyetlen helyen kimarad, ott szivárog.
2. Hol húzódik a határ
A bérlő-határ nem egy hely, hanem egy vonal, amely a rendszer minden rétegén átmegy. Hat réteget különböztetek meg: az adatot, a titkokat (jelszavak, kulcsok), az eszközöket, amelyeket az ügynök hív, az üzeneteket, az ütemezett feladatokat és az ügynökök futtatását. A vonal akkor ér valamit, ha mind a hatnál megvan. Ha egy helyen megszakad, a többi rész csak látszatbiztonság.
3. Az adatok: ami kész, és ami szándékosan közös
Az adatbázis alaptábláinak nagyjából 57 százalékán van bérlő-azonosító (kb. 45 a 79-ből). Módszer: az alkalmazás saját indulási útját futtattam üres, az adatbázis összes korábbi módosításából (migrációjából) felépített adatbázison, ahol összesen 111 tábla jön létre; ebből a keresési segédtáblákat nem számoltam, így maradt 79 alaptábla. Mérve: 2026. október 15.
Az első reakcióm erre az volt, hogy ez kevés. Aztán végignéztem, miért hiányzik a többiről. A maradék 34 tábla fele szándékosan globális: példányszintű beállítás, nyilvántartás, üzemi állapot. Nagyjából harmaduk egy szülő-tábla gyereke, amelyik már hordozza a bérlő-azonosítót, így a határt a szülőn át kapja. A többi néhány tábla ügynökhöz vagy csatornához kötött, vagy régi és kivezetés alatt áll. A beosztás a saját kódolvasásom, a két szám (45 és 34) gépi mérés.
A „szándékosan” szót meg kell indokolni, ezért építettem egy védőtesztet. Minden bérlő-azonosítós táblát be kell sorolni négy kategória egyikébe: egyszerű törlés, ügynökhöz kötött, kézi kezelés, vagy szándékos kivétel. Ha valaki egy későbbi módosítással új táblát vesz fel, és nem dönt róla, a teszt piros marad; ugyanígy piros lesz, ha egy beosztás már nem létező táblára hivatkozik. A teszt ma zöld. Egy fontos korlátja van: a bérlő törlésének lefedettségét őrzi, azt nem, hogy minden lekérdezés szűr-e. Ez utóbbit más tesztek próbálják lefedni.
A naplók, az audit és a telemetria táblái utólag, adatbázis-módosításokkal kaptak bérlő-azonosítót, összesen tizenkét tábla. A régi, módosítás előtti sorokat a módosítás kitöltötte annak alapján, melyik ügynök melyik bérlőt szolgálta. Ahol egy ügynököt több bérlő is szolgált, a régi sorokról utólag nem lehetett megmondani, kihez tartoznak, ezért azok külön jelölést kaptak (több bérlős). Üresen azok a sorok maradtak, amelyeknél a bérlő az írás pillanatában nem volt megállapítható. Az üres tehát nem azt jelenti, hogy az alapértelmezett bérlő, hanem azt, hogy nem tudjuk.
4. Nem csak az adat: ütemezés, eszközök, üzenetek
Az ütemezésnél és az ügynökök által használható eszközöknél is bérlőhöz kötöttem a műveletet. Egy ütemezett feladat csak a saját bérlőjének csevegéseibe küldhet eredményt. A feladat bérlője és ügynöke párban érvényes: ha a páros megszűnik, a feladat nem fut le, hanem egyszer riaszt, a futás pedig „kihagyva, bérlő-eltérés” jelöléssel rögzül. Egy ügynök egy kérés alatt csak az adott bérlő képességeit éri el, ezt egy kapu tartatja be, amely hiba esetén tilt, nem enged. A bejövő üzenetcsatorna szintén bérlőhöz van kötve, a továbbított üzenet pedig örökli a feladó bérlőjét.
Ezek apró szabályok, de külön-külön mindegyik egy-egy ajtó, amelyet nyitva lehet felejteni. Mindegyikre van teszt, és a mai állapotban a kapu minden ügynöknél aktív, a beállításában nulla hibával. Élő futtatással az ütemezés kihagyását nem próbáltam, az csak kódból és tesztből ismert.
5. Az ügynök futtatása: a közös pince
Itt a határ más természetű, és ezt nem szabad elkenni. Az ügynökök egy gépen, egyetlen operációs rendszer-felhasználó alatt futnak, közös munkamenetekben. A bérlők közötti elválasztásuk alkalmazás- és profil-szintű: ügynökönként külön beállítási profil, egy elérhetőségi mátrix, amely megmondja, melyik bérlő melyik ügynököt látja, és a tiltó kapuk. Az operációs rendszer szintjén nincs elválasztás: nincs külön konténer, nincs külön felhasználó.
Ma azt tudom garantálni, hogy a rendszer saját szabályai szerint működő ügynökök nem érik el egymás bérlőjét. Azt nem tudom garantálni, hogy egy rosszindulatú, a szabályokat megkerülni próbáló ügynök ne tudná. Ehhez operációs rendszer szintű elválasztás kellene, és az nincs.
6. Hogyan bizonyítom, és mi szivárgott
Bizonyítékot kétféleképpen gyűjtök. Az egyik a tesztek: a bérlő-elkülönítést célzó tesztfájlokban közel hétszáz teszteset van (az első mérés idején, október elején ez még kb. 460 volt). Ez nem garancia, a tesztek csak azt mutatják, amire gondoltam. A másik a hibakeresés: amikor szivárgást találok, abból tanulok.
Egy már javított esetet elmesélek, útvonal és részletek nélkül. Volt egy export, amely minden ügynököt letölthetővé tett volna, a bérlőtől függetlenül. Véletlenül bukkantam rá. A lényege tanulságos: nem egy hiányzó oszlop volt a hiba, hanem egy új funkció, amelynek írásakor senki nem gondolt a bérlő-határra. Az export ma csak rendszergazdának érhető el, és a nem rendszergazda felhasználó csak a saját bérlője ügynökeit látja; ami nincs kifejezetten engedélyezve, annak a neve és azonosítója sem jelenik meg. Azóta egy másik javított eset is akadt: a feladatkezelő táblában egy másik bérlő felhasználója azonosító alapján elérhetett és listázhatott kártyákat. Ma egy idegen bérlő kártyája úgy válaszol, mintha nem létezne, és bérlős tesztek védik. Hogy kihasználta-e valaki, azt nem lehet megállapítani.
A keresésnél külön figyelek, különösen a hasonlóság alapú (vektoros) és a szöveges keresésnél, mert ott a legtipikusabb a szivárgás: a találatok rangsorolása átláthat a bérlő-határon, ha a szűrés a rangsorolás után jön, nem előtte. Nálam a bérlő-feltétel mindkét keresés lekérdezésében benne van. Ezt ma az alkalmazás kódja kényszeríti ki, nem az adatbázis.
7. A bérlő törlése mint a határ próbája
Ha egy bérlő elmegy, az adatait ki kell törölni, és ez az általános adatvédelmi rendelet (GDPR) szerinti törléshez is kapcsolódik. A törlés a határ legjobb tesztje, mert csak az törölhető, amiről tudom, kié. Korábban tíz bérlő-azonosítós tábla kimaradt a törlésből. Ma mind a 45 bérlő-azonosítós táblára van kimondott döntés, és ezt a fent leírt védőteszt tartja karban.
A törlés három módon megy. Tizennyolc táblánál elég a bérlő sorait törölni (köztük a telemetria, a napló, a költség- és használati nyilvántartás). Három ügynökönként dönt: ha egy ügynököt csak a törölt bérlő szolgált, annak sorai mennek; a több bérlőt szolgáló ügynök sorai megmaradnak. Huszonegy kézi kezelést kér, mert gyerek-táblák, keresési szinkron vagy fájlműveletek tartoznak hozzá (jóváhagyások, üzenetek, feladatok, memória, ütemezések, skillek, titkok, munkadokumentumok).
Három tábla szándékosan megmarad: az API-hozzáférés visszavont nyoma (csak ellenőrző lenyomattal, a hozzáférés története miatt), valamint az ügynök-audit és a hook-audit napló. Ezek a governance-nyomvonal. Hordozzák a bérlő-azonosítót, hogy a bérlő auditora lássa a sajátját, de a bérlő törlését túlélik. Ez tervezési döntés, nem hiány. Az audit-napló azt rögzíti, ki mit csinált kinek a nevében, és ha a bérlő törlésével az is eltűnne, éppen ott veszne el a nyom, ahol szükség lenne rá. Úgy gondolom, ez olyan, mint a visszavont kulcs sírköve: a kulcs nem működik, de az adat róla megmarad.
Egy pontosítás a telemetriára és a naplóra: ezek a bérlővel együtt törlődnek, kivéve azokat a sorokat, amelyek több bérlőt szolgáló ügynökhöz tartoznak és nem választhatók szét, vagy amelyeknél a bérlő nem volt megállapítható. Ezek egyetlen bérlőhöz sem tartoznak, ezért maradnak.
8. Számokban
Itt is csak azt mérem, ami ellenőrizhető, és mindegyik mellé odaírom a módszert és a korlátját.
Nagyjából 57 százalék. Mit mér: az alaptáblák közül hánynak van bérlő-azonosítója. Mit nem mér: azt, hogy minden szükséges tábla benne van-e, mert a maradék nagy része szándékosan közös vagy szülő-táblán át kötött. Módszer: migrációkból épített üres adatbázis, a keresési segédtáblák nélkül. Mérve: 2026. október 15.
Mit mér: a bérlő-határra írt teszteseteket (kb. 590 a rendszer fő nyelvén, kb. 100 a kapukat és hookokat tesztelő szkripteknél). Mit nem mér: a lefedettséget, vagyis azt, hogy mi marad le. Módszer: a „tenant” (bérlő) nevű tesztfájlok tesztesetsorainak száma. Mérve: 2026. október 15.
Mit mér: hogy minden bérlő-azonosítós táblára van-e kimondott törlési döntés (18 egyszerű, 3 ügynökönkénti, 21 kézi, 3 szándékos kivétel). Mit nem mér: hogy a törlés hibátlanul lefut éles adaton, és hogy minden lekérdezés szűr. Mérve: 2026. október 15.
9. Mit nem old meg ez
Mit nem old meg ez. Az ügynökök futtatásának nincs operációs rendszer szintű elválasztása: egy gép, egy felhasználó, közös munkamenetek. Az ügynökök futtatásánál a kontextust, amely megmondja, melyik bérlő nevében történik a művelet, az ügynök oldala állítja be, a szerver ezt nem ellenőrzi újra, ezért ellenséges ügynök elleni védelemként nem szabad rá hivatkozni. A böngészőből vagy az API-n át hívó felhasználónál a szerver a bejelentkezésből veszi a bérlőt, azt a hívó nem állíthatja. A bérlő törlése szándékosan nem törli az audit-nyomvonalat. A mérleg pillanatfelvétel, nem tanúsítvány, és független átvilágítás még nem történt.
10. Ami következik
Az adatok bérlő-határa eddig a kód fegyelmén múlt: egy elfelejtett feltétel szivárgás volt. Az adatbázis-átállással ezt maga az adatbázis is kikényszeríti (sor-szintű védelem), így a határ az adatoknál két egymást kiegészítő védvonalon áll: az alkalmazás szűrésén és az adatbázison. Az ügynökök futtatására ez nem terjed ki, arra az 5. pont érvényes.
A bérlő tehát ott van, de még nem tudja, mit szabad. Ez a következő rész.
Ha úgy látod, hol szivároghatna adat egy ilyen rendszerben, írd meg nekem. Jelöld, melyik rétegre gondolsz, és ne tegyél közzé kihasználható részletet: emailben vagy LinkedInen privátban keress meg (info@jonasgergo.hu, LinkedIn).
English version
In brief, for readers with no background. In a multi-tenant system, several customers use the same system, and none of them may see another's data. That applies beyond the database: to secrets, tools, scheduled jobs and the way agents run. I will show where my system stands on this, and where it does not.
Adding a tenant-identifier column takes five minutes. Proving that nothing leaks anywhere takes months.
In the first part I put down the scorecard of my system: ten company requirements, with my status next to each. The first row of the scorecard was the separation of tenants, and it said: partly. This part is about what that "partly" means, exactly where it is done, and where it is not.
1. What a tenant is, and why it is not one column
I call a customer a tenant: a company or a team that works in a shared instance of the system, with its own data, its own users and its own agents. The requirement is that it does not see anyone else's, and nobody else sees its own.
The simplest picture is an apartment building. Every apartment has its own key, and residents do not walk into each other's kitchens. The basement, the stairwell and the meter cupboard are shared. When I design a multi-tenant system, the question is always the same: what is the apartment, and what is the basement? Data is an apartment. The agent that reads the data and works on my behalf is less clear-cut.
In the database, the tenant is marked by a tenant-identifier column in every row: it says whose the row is. Adding such a column is quick. The hard part comes afterwards: in every query, every run, every background job, the condition "only my tenant's rows" has to be there. If it is missing in a single place, that place leaks.
2. Where the boundary runs
The tenant boundary is not a place but a line that passes through every layer of the system. I distinguish six layers: the data, the secrets (passwords, keys), the tools the agent calls, the messages, the scheduled jobs, and the running of the agents. The line is worth something only if it holds at all six. If it breaks in one place, the rest is only apparent security.
3. The data: what is done, and what is shared on purpose
Roughly 57 percent of the base tables of the database carry a tenant identifier (about 45 of 79). Method: I ran the application's own start-up path on an empty database built from the migrations, where 111 tables in total are created; I left out the search helper tables, which leaves 79 base tables. Measured: 15 October 2026.
My first reaction was that this is too few. Then I went through why the rest lack it. Half of the remaining 34 tables are global on purpose: instance-level settings, registries, operating state. About a third are children of a parent table that already carries the tenant identifier, so they receive the boundary through the parent. The few others are tied to an agent or a channel, or are old and being phased out. The classification is my own reading of the code; the two numbers (45 and 34) are machine measurements.
The word "on purpose" has to be justified, which is why I built a guard test. Every table with a tenant identifier has to be placed in one of four categories: plain deletion, agent-bound, manual handling, or deliberate exception. If someone adds a new table in a later change and does not decide about it, the test stays red; it also goes red if a classification refers to a table that no longer exists. Today the test is green. It has one important limit: it guards the coverage of tenant deletion, not whether every query filters. Other tests try to cover that.
The log, audit and telemetry tables received a tenant identifier later, through database changes, twelve tables in all. The changes filled in the old rows, from before the change, based on which agent served which tenant. Where an agent served several tenants, it could not be determined afterwards whom the old rows belong to, so those rows received a separate marker (multi-tenant). Rows that stayed empty are those where the tenant could not be determined at the moment of writing. Empty therefore does not mean the default tenant; it means we do not know.
4. Beyond data: scheduling, tools, messages
In scheduling and in the tools agents can call, I also bound the operation to a tenant. A scheduled job can only send its result to the chats of its own tenant. The tenant and the agent of a job are valid as a pair: if the pair ceases to exist, the job does not run but raises an alert once, and the run is recorded as "skipped, tenant mismatch". During a request, an agent can reach only the capabilities of that tenant; a gate enforces this, and on error it denies instead of allowing. The incoming message channel is also bound to a tenant, and a forwarded message inherits the tenant of its sender.
These are small rules, but each one on its own is a door that can be left open. Each has a test, and in the current state the gate is active for every agent, with zero errors in its configuration. I did not try skipping a schedule in a live run; that is known only from code and tests.
5. Running agents: the shared basement
Here the boundary is of a different nature, and this must not be glossed over. The agents run on one machine, under a single operating-system user, in shared sessions. Their separation between tenants is at the application and profile level: a separate settings profile per agent, an availability matrix that says which tenant sees which agent, and the denying gates. At the level of the operating system there is no separation: no separate container, no separate user.
Today I can guarantee that agents working by the system's own rules do not reach each other's tenant. I cannot guarantee that a malicious agent trying to get around the rules could not. That would need separation at the operating-system level, and there is none.
6. How I prove it, and what leaked
I collect evidence in two ways. One is tests: the test files aimed at tenant separation contain close to seven hundred test cases (at the first measurement in early October there were about 460). This is not a guarantee; the tests show only what I thought of. The other is troubleshooting: when I find a leak, I learn from it.
I will recount one case that has already been fixed, without a route or details. There was an export that would have made every agent downloadable, regardless of tenant. I came across it by accident. The cause is the instructive part: the fault was not a missing column but a new feature whose author did not think about the tenant boundary. The export is now allowed for an administrator only, and a non-administrator user sees only the agents of their own tenant; what is not explicitly allowed does not even show its name or identifier. Since then there has been another fixed case: in the task-management table, a user of another tenant could reach and list cards by identifier. Today a card of a foreign tenant answers as if it did not exist, and tenant-aware tests protect it. Whether anyone exploited it cannot be established.
I pay particular attention to search, especially similarity-based (vector) and text search, because that is where leaks are most typical: the ranking of the hits can see across the tenant boundary if the filter is applied after the ranking, not before it. In my system the tenant condition is in the queries of both searches. Today it is the application code that enforces this, not the database.
7. Deleting a tenant as a test of the boundary
When a tenant leaves, its data has to be deleted, and this also relates to erasure under the General Data Protection Regulation (GDPR). Deletion is the best test of the boundary, because I can delete only what I know the owner of. Earlier, ten tables with a tenant identifier were left out of deletion. Today there is an explicit decision for all 45 tables with a tenant identifier, and the guard test described above maintains it.
Deletion works in three ways. For eighteen tables it is enough to delete the tenant's rows (among them telemetry, logs, and cost and usage records). Three decide per agent: if an agent served only the deleted tenant, its rows go; the rows of an agent serving several tenants stay. Twenty-one need manual handling, because child tables, search synchronisation or file operations belong to them (approvals, messages, tasks, memory, schedules, skills, secrets, working documents).
Three tables stay on purpose: the revoked trace of an API access (with a verification hash only, for the sake of the access history), and the agent audit and hook audit logs. These are the governance trail. They carry the tenant identifier so that the tenant's auditor can see their own, but they survive the deletion of the tenant. This is a design decision, not a gap. The audit log records who did what on whose behalf, and if it vanished with the tenant, the trail would be lost exactly where it is needed. I think of it as the tombstone of a revoked key: the key no longer works, but the record of it remains.
One clarification on telemetry and logs: they are deleted together with the tenant, except rows that belong to an agent serving several tenants and cannot be separated, or where the tenant could not be determined. These belong to no single tenant, which is why they stay.
8. In numbers
Here too I measure only what can be checked, and next to each figure I give the method and its limit.
Roughly 57 percent. What it measures: how many of the base tables carry a tenant identifier. What it does not measure: whether every necessary table is included, because most of the rest are shared on purpose or tied through a parent table. Method: an empty database built from the migrations, without the search helper tables. Measured: 15 October 2026.
What it measures: the test cases written for the tenant boundary (about 590 in the main language of the system, about 100 in the scripts that test gates and hooks). What it does not measure: coverage, that is, what is left out. Method: the number of test-case lines in the test files named "tenant". Measured: 15 October 2026.
What it measures: whether every table with a tenant identifier has an explicit deletion decision (18 plain, 3 per agent, 21 manual, 3 deliberate exceptions). What it does not measure: that deletion runs flawlessly on live data, or that every query filters. Measured: 15 October 2026.
9. What this does not solve
What this does not solve. Running the agents has no operating-system-level separation: one machine, one user, shared sessions. When agents run, the context that says on whose behalf an operation runs is set on the agent's side and the server does not check it again, so it must not be relied on as protection against a hostile agent. For a user calling from the browser or through the API, the server takes the tenant from the login, and the caller cannot set it. Deleting a tenant deliberately does not delete the audit trail. The scorecard is a snapshot, not a certificate, and no independent audit has taken place.
10. What comes next
Until now, the tenant boundary of the data depended on the discipline of the code: a forgotten condition was a leak. With the database migration, the database itself will also enforce it (row-level security), so for data the boundary stands on two complementary lines of defence: the application's filtering and the database. This does not extend to running the agents; section 5 applies to that.
The tenant is therefore there, but does not yet know what it is allowed to do. That is the next part.
If you see where data could leak in a system like this, tell me. Say which layer you mean, and do not publish an exploitable detail: contact me privately by email or on LinkedIn (info@jonasgergo.hu, LinkedIn).