Vereenvoudig

Veel grafieken bestaan grotendeels uit herhaling. Twee gebeurtenissen delen veertig IP's, en elk IP kost een knooppunt, a label en twee randen, hoewel het erom gaat "deze twee evenementen delen veertig IP's". Een hub heeft tientallen bladeren die nergens anders met elkaar verbonden zijn. Vereenvoudigen vouwt knooppunten die dezelfde rol spelen in één groep, op hun plaats getekend:

const options = {
    render: {
        nodeTypeAccessor: (node) => node.getData().type,
    },
    UI: {
        simplify: {
            rules: [{ kind: 'neighbours', minSize: 5 }],
        },
    },
}

Groepen zijn een weergave, geen gegevens

graph.getNodes(), getEdges(), de tabel, exports en de geschiedenis van ongedaan maken zien de echte knooppunten. Elke keer dat de grafiek verandert, wordt hieruit een groep opnieuw berekend, en er wordt niets over opgeslagen.

Zie het draaien op de Vereenvoudig de grafiek kaart.

Regels

UI.simplify.rules is een geordende lijst. Elke regel geeft sommige knooppunten een sleutel, en knooppunten die een sleutel delen sleutel één groep worden, zolang er maar minstens minSize van zijn.

• Regels lopen in volgorde, en iedereen ziet de groepen die de regels erboven hebben gemaakt als gewoon knooppunten. Een groep kan dus opnieuw gegroepeerd worden door een latere regel.
• Regels worden uitgevoerd na de knooppuntfilters, zodat een groep alleen vasthoudt wat hen doorgeeft: verberg er drie veertig IP's en de groep geeft 37 aan. Randlagen veranderen groepen niet; slechts één uitschakelen verbergt lijnen.
• Een knooppunt met een bijgevoegde notitie en een uitgevouwen cluster zijn nooit gegroepeerd. Een gesloten cluster groepen zoals elk ander knooppunt.
• Een gedeclareerde regel is ingeschakeld tenzij er enabled: false staat.

Zonder UI.simplify biedt de modus full de ingebouwde regels uitgeschakeld in de Simplify-rail modus; de andere modi draaien niets. UI.simplify.enabled: false verwijdert de functie.

De burenregel

{ kind: 'neighbours', minSize: 5, typeOf: (node) => node.getData().type }

Het vouwt knooppunten van één type die linken naar exact dezelfde knooppunten, op dezelfde manier rond: dezelfde knooppunten die naar hen wijzen en dezelfde knooppunten waarnaar zij wijzen. De bladeren van een hub zijn de eenvoudigste geval. Omdat evenementen A en B drie TTP's delen en elk twee eigen TTP's hebben, krijg je drie groepen: de gedeelde drie tussen A en B, en twee aan elke kant.

• Het type is de eigen typeOf van de regel, anders UI.simplify.typeOf, anders render.nodeTypeAccessor. Knooppunten zonder typegroep onderling.
• Een knooppunt dat aan niets is gekoppeld, wordt nooit gegroepeerd: een groep heeft iets nodig om aan vast te houden.
• Een knooppunt dat een link krijgt, verlaat zijn groep en gaat naar het knooppunt dat overeenkomt met zijn nieuwe buren. Als Als er minder dan minSize overblijft, valt de groep uiteen.
• Een groep behoudt zijn identiteit terwijl hij de meeste leden behoudt, dus een nieuw knooppunt landt bij de dezelfde buren worden lid van de bestaande groep zonder deze te verplaatsen.

De kettingregel

{ kind: 'chains', minSize: 5, typeOf: (node) => node.getData().type }

Het vouwt kettingen die aan één knooppunt hangen. Een evenement met dertig bestanden, elk met een eigen hash, is dertig ketens file > sha256: de bestanden delen geen buren, omdat elk zijn eigen hash koppelt, dus de burenregel laat hen met rust. De kettingregel vouwt ze in één groep bestanden gekoppeld aan één groep hashes, en tekent de dertig links ertussen als één lijn.

• De staart van een knooppunt is een knooppunt waarvan de enige link afkomstig is, stroomafwaarts gevolgd terwijl elk knooppunt alleen stapschakels langs de keten. Een knooppunt dat is verbonden met twee andere, een tak of een cyclus, beëindigt het knooppunt ketting daar.
• Knooppunten die ketens met dezelfde vorm leiden worden samengevouwen als ze dezelfde andere delen koppelingen en typen. Vijf geïsoleerde paren domain → ip geven één groep van vijf domeinen die aan één domein zijn gekoppeld groep van vijf IP's.
• Elk niveau van de ketens vouwt ook: onder de groep van hun hoofden, of onder een hoofd van hun eigen als er geen match is.
• Links tellen alleen downstream: een knooppunt waarvan de enige link naar een ander verwijst, is niet dat van dat knooppunt staart.
• Geplaatst na de buurregel, vouwt het wat die regel overhield. Een groep die de burenregel heeft gemaakt kan een staart zijn.

Weinig schakels en de kern

{ kind: 'degree', minDegree: 2 }
{ kind: 'kcore', k: 2 }

Deze regels halen knooppunten uit het canvas op basis van hoe goed ze met elkaar verbonden zijn, en vouwen ze in de knooppunten waaraan ze hangen, zodat de telling op het canvas blijft:

• Weinig links (degree) vouwt knooppunten met minder dan minDegree links: bij 2 vertrekt een hub één groep op de hub worden.
• Buiten de kern (kcore) verwijdert knooppunten met minder dan k koppelingen en doet het vervolgens opnieuw met wat er nog over is, totdat elk knooppunt k links heeft tussen de andere. Bij 2 vouwt het hele bomen hangen aan de grafiek, niet alleen hun bladeren.

Gevouwen knooppunten die dezelfde knooppunten raken die blijven staan, delen een groep, ongeacht hun type, en een groep kan een enkel knooppunt bevatten: er staat "nog 1" op zijn anker. Gevouwen knooppunten met elkaar verbonden ga in dezelfde groep, zodat een pad dat aan een naaf hangt, meevouwt met de bladeren van de naaf. Een run van gevouwen knooppunten die niets raken dat nog overeind staat, vormen een groep op zichzelf, en elk knooppunt is daarmee verbonden niets deelt één groep. Beide instellingen gaan van 1 tot 10, en links tellen hoe dan ook.

Na de buurregel is een groep één knooppunt van deze regels: de verbindingen zijn de lijnen. Een groep alleen aan zijn anker hangend blijft zoals het is.

Gemeenschappen

{ kind: 'communities', level: 4 }

Voor grafieken die te groot zijn voor de bovenstaande regels, vouwt Communities hele buurten op: knooppunten meer nauw met elkaar verbonden zijn dan met de rest van de grafiek één groep worden, ongeacht hun groep typen. Ze worden gevonden met het Leidse algoritme, elke keer hetzelfde voor dezelfde grafiek.

• level gaat van 1, fijn, veel kleine gemeenschappen, tot 7, grof, een handvol grote degenen. In de Vereenvoudigingsmodus is het een schuifregelaar, die wordt toegepast wanneer u loslaat.
• De communities worden gevonden in een werker, buiten de pagina, en pas weer als de grafiek vormveranderingen. Ondertussen staat er op de kaart Groeperen… en blijven de vorige groepen. Waar nee worker kan starten, een Content Security Policy die bijvoorbeeld blob-workers blokkeert, dezelfde code loopt op de pagina; useWorker: false vraagt ​​daar om.
• Een gemeenschap van één knooppunt blijft een knooppunt, en geannoteerde knooppunten blijven buiten beschouwing, zoals bij elke regel.
• In tegenstelling tot de andere ingebouwde regels bevindt Community's zich alleen in de vereenvoudigingsmodus wanneer ze worden gedeclareerd.

Draaiende landingen

{ kind: 'landings', minSize: 2 }

Opnemen in een groep, in de voettekst van het draaipunt, plaatst u de geselecteerde rijen gevouwen: één groep per type, hangend aan het knooppunt waarop u draaide. Veertig IP's arriveren als "40 × ip" in plaats van veertig punten.

• Een groep bevat wat die inname toegevoegd heeft. Een knooppunt dat al op het canvas stond, blijft staan waar het was.
• Een lid blijft waar het later ook naar linkt, in tegenstelling tot de burenregel. Trek het eruit, verwijder het of maak de inname ongedaan om deze eruit te halen. Ongedaan maken ontbindt de groep en opnieuw brengt deze terug.
• Een type met minder knooppunten dan minSize (standaard 2) landt als gewone knooppunten.
• De regel wordt als eerste uitgevoerd, dus de regels erna beschouwen elke landing als één knooppunt. Dat is niet nodig declareer het: de eerste gegroepeerde landing voegt het toe bovenaan de Vereenvoudigingsmodus, ingeschakeld. Geef het aan om het ergens anders te plaatsen of verander de kleinste groep.
• Welke landingen gegroepeerd zijn, duurt de sessie, net als open groepen.
• De landing namen van een landingsgroep waar deze vandaan kwam: { runId, pivotId, pivotLabel }, met het label uit de definitie van het draaipunt. Een chip kan 12 × ip · Event elements lezen zonder de run-ID te parseren.

Om elk draairesultaat gegroepeerd te krijgen, stelt u pivotIngestGrouped in. Met één klik uitgevoerd en autoIngest draaipunten, die Review nooit openen, en dan ook gegroepeerd landen:

new Pivotick(el, data, { pivotIngestGrouped: true })

De voettekst van de recensie volgt de optie:

pivotIngestGrouped	Geselecteerde opname en Alles opnemen	Tweede knop
uit (standaard)	land los	Opnemen in een groep
op	grond gegroepeerd	Los innemen

Als UI.simplify is uitgeschakeld, doet de optie niets en is er geen tweede knop.

Om voor één opname van de code te kiezen, geeft u group door:

await graph.pivots.ingest('correlations', 'triage', { group: true })

Aangepaste regels

Een eigen regel is een partition(view) die een sleutel per knooppunt retourneert:

{
    kind: 'custom',
    id: 'bySensor',
    label: 'By sensor',                      // its name in the Simplify mode
    description: 'Sightings reported by the same sensor.',
    minSize: 2,                              // the default for a custom rule
    partition: (view) => new Map(view.nodes
        .filter((node) => view.typeOf(node) === 'sighting')
        .map((node) => [node.id, node.getData().sensor])),
}

view is de grafiek zoals deze regel deze ziet:

Lid	Wat het is
nodes	De knooppunten die deze regel kan groeperen: wat de filters doorstaat, met de groepen van eerdere regels in plaats van hun leden. Geannoteerde knooppunten, uitgetrokken knooppunten en uitgebreide clusters worden weggelaten.
inNeighbours(node) / outNeighbours(node)	De getekende knooppunten met een lijn naar of van deze.
typeOf(node)	Het type waarop de regel wordt gegroepeerd op: UI.simplify.typeOf, anders render.nodeTypeAccessor.
groupOf(node)	De groep achter een knooppunt, als het er een is, is er een eerdere regel gemaakt.

Een knooppunt dat buiten de kaart wordt gelaten, blijft zichzelf en id's die niet in view.nodes staan, worden genegeerd. EEN regel die gooit is uitgeschakeld, de kaart in de Simplify-modus zegt dat, en de andere regels nog steeds rennen.

De vereenvoudigingsmodus

De knop Vereenvoudigen op de rail opent één kaart per regel, in volgorde van uitvoering: een wissel, de instelling en wat de regel vouwde. De instelling is een − / + stepper voor de kleinste groep, de minste links of de kernsterkte, en een schuifregelaar voor het Community-niveau. Regels verklaard door de app heeft een app-tag. In de samenvatting bovenaan staat hoeveel knooppunten er op het canvas staan van hoeveel er door de filters gaan, en de spoorknop telt de groepen terwijl elke regel vervalt.

Werken met een groep

Een groep wordt als knooppunt getekend en treedt waar dat ondubbelzinnig is op voor haar leden.

• Open met een dubbelklik, Enter, de zijbalk of het contextmenu. De leden komen terug als gewone knooppunten, binnen een wassing in de kleur van de groep, en een lichte trekkracht houdt ze vast samen. Sleep de chip erboven om ze allemaal te verplaatsen; de × vouwt ze terug. Zijn tooltip noemt de regel die de groep heeft gemaakt. Leden komen terug waar ze zaten; degenen zonder gratis een eigen plek verspreid over de groep, en live-fysica krijgt een zacht duwtje in de rug, zoals voor a cluster. simulation.fitViewOnExpandCollapse past bij de weergave van open en dicht. Een groep met meer leden dan UI.simplify.openConfirmAbove (100) vraagt eerst.
• Selecteer om de leden ervan in de zijbalk te zien, in een sorteerbare lijst. Uittrekken houdt een lid uit de groep totdat het wordt teruggezet, vanuit het contextmenu: op het canvas while de groep open is, of vanuit de rij in het datadock, ongeacht of de groep open is of niet. Via een selectie wordt elk geselecteerd lid eruit gehaald.
• Bekijk in tabel, in de zijbalk of het contextmenu, geeft een overzicht van de leden in het gegevensdock, waar de kolomfilters ze verder beperken. De chip boven de tafel geeft elk knooppunt opnieuw weer.
• Leden selecteren, Pivot en Verwijderen hebben invloed op de leden. Draaien en verwijderen gaan door de gebruikelijke haken, dus onBeforeDelete ziet de echte knooppunten. Verbergen, verwijderen en draaien op a selectie waarbij groepen ook op hun leden inwerken.
• Het selecteren van een groep verlicht de knooppunten waarmee het is gekoppeld, terwijl het selecteren van een knooppunt de buren. Bewerken en verbinden worden niet aangeboden op een groep: deze heeft geen eigen gegevens.

Open groepen en uitgetrokken knooppunten duren de sessie en zijn geen ongedaan gemaakte stappen. Om te herstellen hen, bel graph.simplify.open() en pullOut().

Met de hand gemaakte groepen

Selecteer twee of meer knooppunten en vervolgens Groeperen in de bulkbalk van de zijbalk of Groepeer geselecteerde knooppunten in het contextmenu van een geselecteerd knooppunt. Typ een titel, of laat de titel behouden ("3 × ip, 2 × domein"), en de selectie vouwt zich onder die titel in één groep.

• Een handgemaakte groep wint. De regel ervan, Met de hand, loopt vóór elke andere, dus een gekozen knooppunt verlaat elke regelgroep. Een geselecteerde groep geeft zijn leden op, en een knooppunt wordt in een seconde opgepikt handgemaakte groep verlaat de eerste. Geannoteerde knooppunten en open clusters blijven buiten, en de prompt zegt hoeveel.
• Het behoudt zijn leden waar ze ook naar linken. Een die wordt verwijderd of uitgefilterd, is dat niet getekend; een groep die nog één lid heeft, wordt helemaal niet getrokken en komt terug met zijn leden.
• Gebruik Hernoemen en Degroepeer vanuit het zijbalkpaneel of het contextmenu. Een lege titel labelt het opnieuw op type. Met Degroeperen van de bulkbalk wordt elke handgemaakte groep verwijderd selectie houdt stand of zit erin.
• Groeperen, Naam wijzigen en Groep opheffen zijn stappen voor ongedaan maken, in tegenstelling tot openen of verwijderen.
• Het is weergavestatus: niet geëxporteerd en opnieuw geladen. Om het te behouden, slaat u getManualGroups() op en geef het terug aan setManualGroups(). Groepen zijn direct daarna hersteld, geopend of verwijderd new Graph() maken deel uit van de openingsindeling: een gesloten groep wordt als één punt geplaatst, een open iemands leden worden bij elkaar gehouden.

const id = graph.simplify.groupNodes(['ip-1', 'ip-2', 'dom-7'], 'Suspicious infra')
graph.simplify.renameGroup(id, 'Cleared infra')
graph.simplify.ungroup(id)

Zoeken

Zoeken doorzoekt elk knooppunt, inclusief de gevouwen knooppunten.

• Een match binnen een groep zegt dit in de resultaatrij: in 12 × ip.
• Als u deze optie kiest, wordt de groep geopend en wordt het knooppunt geselecteerd, zoals Leden selecteren dat zou doen. Een groep met meer leden dan openConfirmAbove blijft gesloten en wordt in plaats daarvan geselecteerd.
• Alles weergeven op het canvas, de laatste rij met resultaten of Shift+Enter, sluit het zoek en steek elke wedstrijd aan; al het andere vervaagt. Er wordt ook een groep aangestoken die lucifers vasthoudt, en een boog in de themakleur over de ring toont hun aandeel. De tooltip telt ze: 2 van 12 komen overeen met "198.51". Esc, een klik op een leeg canvas of de volgende zoekopdracht beëindigt het.

Als u over een legenda-item beweegt, worden groepen op dezelfde manier gemarkeerd: een groep met knooppunten van dat item wordt verlicht, met hun aandeel op de ring, dus een groep die typen mengt, leest niet als allemaal één.

Een app met een eigen zoekopdracht kan op dezelfde manier zijn overeenkomsten markeren met graph.simplify.setMatches(nodes, query), en wis ze met setMatches([]).

De blik

Een groep is een ring rond een schijf in de kleur van het type, met de telling op de schijf zodra die er is ruimte ervoor en een label eronder. Het groeit met zijn aantal, tot een bepaalde limiet. Een groep die typen mengt krijgt een neutrale schijf en een ring, opgesplitst per type.

Het label is standaard 12 × ip. typeLabel benoemt uw typen:

UI: {
    simplify: {
        typeLabel: (type, count) => `${count} ${count === 1 ? type : `${type}s`}`,
    },
}

render.groupStyle(group) retourneert een NodeStyle gelaagd over de standaard, dus tiers, html, shape en badges werken op een groep als op een knooppunt. render.groupOutline(group) stelt in wat de chip over een open groep zegt:

render: {
    groupStyle: (group) => group.rule === 'bySensor' ? { color: '#6b7280' } : undefined,
    groupOutline: (group) => `${group.members.length} from ${group.rule}`,
}

groupStyle ontvangt ook base, de stijl die de bibliotheek zou tekenen. Wat je terugstuurt, komt in de plaats zijn sleutels, dus een host die een niveau toevoegt, spreidt base.tiers om de telling op de schijf te houden:

render: {
    groupStyle: (group, base) => ({
        tiers: [...(base.tiers ?? []), { width: 140, height: 44, style: { html: () => chip(group) } }],
    }),
}

Elk ontvangt een GroupInfo:

Veld	Wat het is
id	Stabiel terwijl de groep de meeste leden behoudt.
rule	'neighbours', 'chains', 'degree', 'kcore', 'communities', 'landings', 'manual', of id van een aangepaste regel.
members	De echte knooppunten waar het voor staat.
typeCounts	Hoeveel leden van elk type; '' is geen type.
anchors	De getekende knooppunten waarnaar het linkt, inclusief groepen.
open	Of de leden weer op het canvas staan.
level	Het communityniveau waarop het is gevonden.
title	Een handgemaakte groepstitel.
landing	De run en pivot van een landingsgroep: { runId, pivotId, pivotLabel }.

De tooltip van een groep geeft de regel een naam, geeft aan waar deze naar linkt en, voor een gemengde groep, de bijbehorende regel leden per soort. tooltip.renderGroupExtra(group, ctx) voegt uw eigen regels toe, zoals renderNodeExtra geldt voor een knooppunt. Een groep slaat tooltip.render en renderNodeExtra over, wat wel het geval is zijn geschreven voor de gegevens van een knooppunt.

Typen en kleuren van de gastheer

Groepen tellen hun delen met render.nodeTypeAccessor en kleuren ze in met die van elk lid stijl kleur. Twee UI.simplify opties veranderen dat voor elke regel en groep, zonder ontroerende stijlen, de legenda of filters:

• typeOf(node) is het type waarop elke regel wordt gegroepeerd en elke groep telt zijn onderdelen op basis van: de label, de aandelen van een gemengde ring, de titel van een handgemaakte groep. De eigen typeOf van een regel wint nog steeds voor die regel.
• colorOf(node) is de kleur waar een knooppunt voor staat in een groep: de schijf en ring, de open wash, de chips van de tooltip. Het retourneren van undefined valt terug op de stijlkleur van het knooppunt. EEN de eigen groupStyle van de groep heeft nog steeds het laatste woord op de gesloten tekening.

Een host die stijlt op element, groepeert op subtype en zelf zijn knooppunten tekent:

const options = {
    render: {
        nodeTypeAccessor: (node) => node.getData().element,
        nodeStyleMap: { attribute: { shape: 'none', html: drawAttribute } },
    },
    UI: {
        simplify: {
            typeOf: (node) => `${node.getData().element}:${node.getData().subtype}`,
            colorOf: (node) => palette[node.getData().subtype],
        },
    },
}

In de tafel

Het datadock geeft een overzicht van de echte knooppunten. Een gevouwen knooppunt luidt grouped in de kolom Zichtbaarheid, en een kolom Groep noemt de groep terwijl die er is. Een rand waarvan de lijn naar a wordt getrokken groep leest ook grouped.

Tijdens runtime

graph.simplify bevat de regels en de groepen:

Methode	Wat het doet
setRules(rules) / getRules()	Vervang de regels; lees ieders staat en wat het vouwde.
setRuleEnabled(id, on) / setRuleSetting(id, n)	Wat de schakelaar en stepper van de Simplify-modus doen. setRuleMinSize(id, n) stelt slechts een kleinste groep in.
getGroups() / groupOf(node)	Elke groep, en in de eerste groep werd een knooppunt gevouwen. Een groep waarvan de regel later opnieuw is opgevouwen, wordt ook vermeld, naast de groep die deze vasthoudt, en beide vermelden hun leden; summary().groups telt de gesloten groepen die het canvas tekent.
open(group) / close(group)	Zet de groepsleden op het canvas, of vouw ze terug.
pullOut(node) / putBack(node) / isPulledOut(node)	Houd een knooppunt uit een groep of laat het terug.
groupNodes(nodes, title?) / renameGroup(group, title) / ungroup(groups) / isManual(group)	groepen handmatig maken, hernoemen of verwijderen; elk is een ongedaan gemaakte stap.
getManualGroups() / setManualGroups(list)	Bewaar de handgemaakte groepen en herstel ze.
groupLanding(runId) / ungroupLanding(runId) / isLandingGrouped(runId)	Vouw wat een draairun toevoegt in landingsgroepen, of trek het weer los.
summary()	Hoeveel knooppunten worden getekend, passeren de filters en worden gevouwen.
setMatches(nodes, query) / matchesIn(group)	Markeer de overeenkomsten van een zoekopdracht op de groepen die ze vasthouden; lees hoeveel een groep er heeft.
onChange(listener)	Geroepen na de groeperingswijzigingen; retourneert zijn afmelding.