Device-graafanalyse: de puntjes verbinden over sessies heen
Hoe grafendatabases verborgen verbanden tussen apparaten blootleggen en zo detectie van meervoudige accounts en fraudenetwerken op schaal mogelijk maken.
Wanneer één fraudeur tientallen accounts beheert, zien de afzonderlijke accounts er op zichzelf legitiem uit. Elk heeft een uniek e-mailadres, een plausibel IP-adres en realistisch surfgedrag. Traditionele regelgebaseerde detectie beoordeelt elk account afzonderlijk en vindt niets verdachts. De verbanden tussen accounts — de gedeelde apparaten, overlappende sessies, gemeenschappelijke netwerkfingerprints — zijn onzichtbaar voor systemen die accounts één voor één verwerken.
Waarom grafen
Device-graafanalyse verandert het model. In plaats van accounts afzonderlijk te beoordelen, bouwen we een graaf waarin nodes apparaten, accounts, IP-adressen en sessies zijn, en waarin edges waargenomen verbanden voorstellen: "dit apparaat is gebruikt om dit account aan te maken", "dit IP is samen met dit apparaat gezien", "deze twee accounts deelden een sessiecookie". De graaf onthult structuur die platte tabellen niet kunnen tonen.
Een fraudenetwerk dat 50 accounts gebruikt verspreid over 5 apparaten en 3 IP-adressen vormt een kenmerkend cluster in de graaf. De clusterdichtheid — veel verbanden binnen een kleine groep nodes — is een sterk signaal. Legitieme gebruikers delen zelden apparaten met vreemden, en hun account-apparaatverbanden vormen ijle, boomachtige structuren in plaats van dichte clusters.
Architectuur van de grafendatabase
We gebruiken een property-graafmodel met vier nodetypes: Device (geïdentificeerd door visitor ID), Account (jouw user ID), Network (IP-adres + ASN) en Session (afzonderlijke identificatiegebeurtenis). Edges dragen metadata: timestamp, confidence score en event type.
De graaf wordt opgeslagen in een speciaal gebouwde adjacency-index die is geoptimaliseerd voor 2-hop-traversals. Wanneer een nieuwe identificatiegebeurtenis binnenkomt, voegen we de gebeurtenis in als Session-node, verbinden we die met de Device- en Network-nodes, en controleren we of een gekoppeld Account verbanden heeft met andere apparaten. Deze insert-en-query-operatie voltooit in minder dan 5ms voor grafen tot 10 miljoen nodes.
We hebben eerst Neo4j geprobeerd. Het werkte prima in ontwikkeling met 100K nodes. Toen laadden we productiedata — 500M nodes — en Cypher-queries die 2ms duurden begonnen 800ms te duren. David besteedde een week aan het benchmarken van alternatieven voordat we onze eigen adjacency-index bouwden, ondersteund door geshardde RocksDB. Soms verslaat de saaie, op maat gemaakte oplossing de elegante kant-en-klare.
Clusteringalgoritmen
We passen twee clusteringalgoritmen toe op de device-graaf:
Connected components
De eenvoudigste aanpak: vind alle nodes die bereikbaar zijn vanaf een bepaald apparaat. Als Device A verbonden is met Account 1 en Account 2, en Device B ook verbonden is met Account 2, dan zitten Device A en B in dezelfde connected component. Dit identificeert alle accounts die enige transitieve apparaatverbinding delen.
Connected components zijn snel te berekenen, maar kunnen zeer grote clusters opleveren wanneer legitieme gedeelde apparaten (gezinscomputers, bibliotheekterminals) bruggen vormen tussen ongerelateerde accounts. We ondervangen dit met edge weighting — verbindingen via bekende gedeelde omgevingen krijgen een lager gewicht.
Communitydetectie
Voor een genuanceerdere analyse draaien we Louvain-communitydetectie op de gewogen graaf. Dit algoritme verdeelt de graaf in communities waarin de verbindingen binnen een community dicht zijn en die tussen communities ijl. Fraudenetwerken vormen hechte communities, zelfs wanneer ze via gedeelde infrastructuur met de bredere graaf verbonden zijn.
Het Louvain-algoritme draait in O(n log n)-tijd, wat het praktisch maakt voor grafen met miljoenen nodes. We draaien het incrementeel — wanneer nieuwe edges worden toegevoegd, werken we de community-toewijzingen lokaal bij in plaats van de volledige partitie opnieuw te berekenen.
Patroon uit de praktijk: detectie van fraudenetwerken
Een gamingplatform integreerde onze device-graaf-API om georganiseerde fraudenetwerken op te sporen. Al binnen de eerste week onthulde de graaf een cluster van 127 accounts die verbonden waren via 8 apparaten en 4 IP-adressen. De accounts waren over een periode van 3 maanden aangemaakt, elk met een uniek e-mailadres en een realistisch profiel. Regelgebaseerde detectie had er nul gemarkeerd.
De graafstructuur was verraderlijk: 127 accounts die 8 apparaten delen levert gemiddeld 15,8 accounts per apparaat op. Legitieme gebruikers hebben op dit platform gemiddeld 1,2 accounts per apparaat. De clusterdichtheid lag 47x boven de baseline — een ondubbelzinnig fraudesignaal.
Prestaties op schaal
Onze device-graaf in productie verwerkt 2,3 miljard nodes en 8,1 miljard edges. De insertlatentie bedraagt 2,4ms bij p99. Een two-hop-traversal (vind alle accounts die via een pad van lengte 2 met een apparaat verbonden zijn) voltooit in 4,1ms bij p99. Community-detectie-updates verwerken 50.000 nieuwe edges per seconde.
De graaf is gesharded op basis van de hash van de device ID over 12 nodes, waarbij elke shard ongeveer 190 miljoen nodes bevat. Een replicatiefactor van 3 zorgt voor beschikbaarheid. We maken elk uur een snapshot van de graaf voor disaster recovery en draaien dagelijks een volledige herberekening van de communitydetectie als consistentiecheck tegenover de incrementele updates.
Integratie
De device-graaf is toegankelijk via twee interfaces: een realtime query-API voor individuele lookups (is dit apparaat verbonden met andere accounts?) en een batch-export-API voor analyse (geef me alle clusters met meer dan N accounts). De realtime API is ontworpen voor inline fraudebeslissingen — bevraag hem tijdens het aanmaken van een account om te controleren of het apparaat andere accounts heeft gezien. De batch-API voedt de onderzoeksworkflows van je datateam.