Kommentar
Åtkomst till den här sidan kräver auktorisering. Du kan prova att logga in eller ändra kataloger.
Åtkomst till den här sidan kräver auktorisering. Du kan prova att ändra kataloger.
Important
Lakewatch är i beta. Arbetsyteadministratörer kan styra åtkomsten till den här funktionen från sidan Förhandsversioner . Se Hantera förhandsversioner på arbetsytenivå.
Detektionsregelns logik är den SQL som definierar vad den söker efter. Den här sidan förklarar hur regler fungerar, hur man väljer en metod för vanliga detektionsmönster och hur man avgränsar en regel till rätt datafönster. Anvisningar för hur du skapar en regel finns i Create and manage detection rules.
Hur detektionsregler fungerar
Varje detektionsregel i Lakewatch körs enligt ett schema. När en regel körs kör den din detektions-SQL över ett tidsfönster och genererar en signal för varje matchning. Du skriver hela frågan, inklusive klausulen FROM , så en regel kan slå ihop tabeller, skanna en hel tabell eller beräkna aggregat. Varje regel kör sin SQL på ett SQL warehouse som du tillhandahåller. Se Konfigurera ett identifieringslager.
Du anger schemat för en regel och beräkning när du skapar den. Se Skapa och hantera detekteringsregler.
Val av tillvägagångssätt
Denna tabell kartlägger vanliga detektionsmönster till hur du skapar varje mönster:
| Detektionsmönster | Example | Hur man skapar den |
|---|---|---|
| Signatur eller IOC-matchning | En processhash i en lista över kända skadliga objekt; en anslutning till en flaggad IP | Jämför evenemang mot en lista över kända dåliga värden |
| Atomisk signal | Ett nytt administratörskonto; en granskningslogg rensad; en regel för vidarebefordran av postlåda tillagd | Matcha ihop en enskild händelse som i sig är anmärkningsvärd |
| Tröskel för kort fönster | Mer än 5 misslyckade inloggningar för en användare på 1 minut; en IP-adress med misslyckade inloggningar på 20 konton på 10 minuter | Aggregera och ange tröskelvärde med kort intervall |
| Beteendemässig baslinje eller avvikelse | En användare som använder betydligt fler servrar än deras 30-dagarsnorm | Jämför med en baseline-tabell |
| Sällsynt eller sedd för första gången | En processhash som aldrig setts förut; ett första tillägg till en privilegierad grupp | Jämför med en seen-list-tabell |
| korrelation mellan källor | Inloggning, sedan fildelningsåtkomst, sedan exfiltration, sammanfogade över flera källor | Sammanfoga mellan källor på ett tim- eller kortare schema |
Begränsa regler till ett tidsintervall
När det är möjligt, begränsa en regel till ett relevant tidsintervall istället för att skanna en hel tabell. Använd funktionen IN_TIMERANGE för att uttrycka det fönstret, och låt run ange gränserna:
SELECT *
FROM process_activity
WHERE IN_TIMERANGE(<event_time>)
AND activity_id = 1
AND endswith(lower(process.name), '\\hashcat.exe')
Ersätt <event_time> med TIMESTAMP-kolumnen eller uttrycket för filtrering.
IN_TIMERANGE(<event_time>) returnerar true när en händelse faller inom det effektiva tidsintervallet för den aktuella körningen. Intervallet är halvöppet: en händelse vars tidsstämpel motsvarar fönstrets början inkluderas, men en som motsvarar slutet utesluts. Detta undviker att dela en ändpunkt mellan icke-överlappande fönster. Ett icke-nollvärde extend_lookback gör att på varandra följande fönster avsiktligt överlappar. Signaldeduplicering hanterar upprepade signaler från matchande rader. Du skriver inte start- och sluttiderna i SQL:en själv. Istället tillhandahåller Lakewatch intervallet baserat på hur frågan körs:
- Vid en schemalagd körning börjar basfönstret vid den tidigare schemalagda utlösningstiden och slutar vid den aktuella schemalagda utlösningstiden. Detta tidsfönster påverkas inte av schemaläggningsförseningar. För att ta hänsyn till fördröjning vid import, se Förläng fönstret med
extend_lookback. - På frågesidan för frågor (som du kan använda för att utveckla en regel) väljer du intervallet med datum-/tidväljaren. Eftersom SQL skrivet på frågesidan inte själv innehåller tidsintervallet kan det implementeras som en detektionsregel oförändrad.
Förläng fönstret med extend_lookback
IN_TIMERANGE(<event_time>) filtrerar på händelsetiden, men loggar når ofta tabellen minuter efter att händelsen inträffat. En rad kan landa efter att körningen vars fönster täckte dess händelsetid redan har avslutats, och senare körningar skannar nyare händelsetider och skapar ett täckningsgap.
extend_lookback, en valfri regelinställning, flyttar fönstrets start tidigare så att varje körning skannar om ett intervall av tidigare händelsetid och fångar rader som anlände sedan senaste körning. Den flyttar bara den tidigaste gränsen. Den senaste gränsen stannar vid den aktuella schemalagda körtiden. Sätt den till en varaktighet såsom 30s, 10m, eller 2h. Fönstret som en schemalagd regel skannar är dess schemaintervall plus extend_lookback:
extend_lookback |
Schedule | Tidsintervall inskannat (slutar vid den schemalagda körtiden) |
|---|---|---|
| Inte angiven (standardvärde 15m) | Var 5:e minut | De föregående 20 minuterna |
0s |
Var 5:e minut | De senaste 5 minuterna |
12m |
Var 30:e minut | De föregående 42 minuterna |
5h |
Var 10:e minut | De senaste 5 timmarna och 10 minuterna |
Överlappande körningar kan välja samma rad flera gånger. Ha signaldeduplicering aktiverad. Det automatiska dedupliceringsfönstret tar hänsyn till extend_lookback när SQL använder IN_TIMERANGE, så en längre tillbakablick förlänger det. Om du ställer in ett anpassat dedupliceringsfönster, gör det åtminstone lika långt som det skannade tidsintervallet. Undvik att lägga till föränderliga värden som CURRENT_TIMESTAMP() till SQL-resultatet enbart för bokföring, eftersom ändrade resultatrader inte är dubbletter. Se Signaldeduplicering.
Om du inte anger extend_lookback, tillämpar Lakewatch en standardtid på 15 minuter. De flesta företagskällor levererar inom några minuter, men få garanterar en övre gräns, så standardinställningen absorberar vanliga sena leveranser utan någon justering.
För att sätta extend_lookback i UI:t, ange en duration i Extend lookback, bredvid detekterings-SQL. Använd ordnade dag-, tim-, minut- och sekundvärden, såsom 15m eller 1h30m. Låt den vara tom för att använda standarden på 15 minuter, eller ange 0s för att stänga av tillägget. Inställningen har ingen effekt om inte din SQL använder IN_TIMERANGE.
Välj rätt tidskolumn
En händelsetidskolumn tillsammans med extend_lookback är rätt metod för nästan varje regel. Uppskatta din källas intagningsfördröjning och ställ in extend_lookback så att den täcker den, eller förlita dig på 15-minutersstandarden för källor som levererar snabbt.
Om en källas inmatningslatens är så varierande att ingen enskild extend_lookback täcker den pålitligt, kan du istället avgränsa regeln utifrån inmatningstid. På tabeller producerade av en Lakewatch-datakälla registrerar kolumnen lw_meta.ingestion_time när Lakewatch skrev varje rad efter insamling, så ett fönster över den påverkas inte av leveransförseningar:
WHERE IN_TIMERANGE(lw_meta.ingestion_time)
Ta till detta bara när eventtid plus extend_lookback inte räcker. Varje körning täcker sedan en fast del av insamlingstiden snarare än händelsetiden , så en händelses egen tidsstämpel kan falla utanför körningens nominella fönster, vilket kan snedvrida tidsbundna aggregationer. Försök lösa det med event time först.
Undvik att ankra vid NOW() eller CURRENT_TIMESTAMP()
Ett vanligt mönster skriver fönstret manuellt mot den aktuella systemtiden:
-- Avoid this
WHERE time BETWEEN CURRENT_TIMESTAMP() - INTERVAL 24 HOUR AND CURRENT_TIMESTAMP()
Detta fungerar för en rutinmässig körning, men kan skapa problem:
-
Missad eller dubbelräknad data: Ett fönster som "den sista timmen" är förankrat till när körningen startar, inte den del den var tänkt att täcka. Om ett 3:00-pass fördröjs till 3:12, skannar det 2:12–3:12, lämnar ett gap på 2:00–2:12 och kan överlappa nästa körning.
IN_TIMERANGEFönstret härleds från det schemalagda intervallet, så en fördröjd körning lämnar inget glapp. Överlappning mellan schemalagda körningar kommer frånextend_lookback. Se Förläng fönstret medextend_lookback. -
Ändringar i schemat: Om du ändrar en regel från var 15:e minut till var 30:e minut är en hårdkodad
INTERVAL 15 MINUTESregel fel tills du kommer ihåg att ändra den. MedIN_TIMERANGE, följer fönstret schemat. -
Re-windowing: Att fylla i en missad period, spela upp efter en datafix eller förhandsgranska en ny regel mot äldre data innebär alla att samma regel körs över ett annat tidsfönster. En sökfråga som är låst till
NOW()går inte att göra utan manuella redigeringar. -
Reproducerbarhet: Givet samma gränser,
IN_TIMERANGEskannar samma rader vid varje körning, så resultaten är upprepbara. En fråga kopplad tillNOW()skiftar vid varje körning.
Reservera NOW() och CURRENT_TIMESTAMP() för fall där du behöver referera till den verkliga klocktiden, till exempel för att räkna ut hur gammal en händelse är i förhållande till nuet.
Referera till körningens fönster med TIMERANGE_NOW()
När du behöver ett "nu"-värde som respekterar körningens fönster istället för väggklockan, använd TIMERANGE_NOW(). Den returnerar körningens schemalagda starttid. På söksidan returnerar den slutet av det valda tidsintervallet, så att du kan testa en regels predikat mot historiska data. När inget tidsintervall är inställt returnerar den den faktiska aktuella tiden. Använd det för att handbygga ett fönster som IN_TIMERANGE inte kan uttrycka, till exempel genom att förskjuta fönstret eller skanna två icke-intilliggande perioder i en och samma runda:
| Schedule | Predikat | Result |
|---|---|---|
| Var 10:e minut | time >= TIMERANGE_NOW() - INTERVAL 17 MINUTE AND time < TIMERANGE_NOW() - INTERVAL 7 MINUTE |
Flyttar 10-minutersfönstret 7 minuter tillbaka i tiden |
| Varje dag | (time >= TIMERANGE_NOW() - INTERVAL 1 DAY AND time < TIMERANGE_NOW()) OR (time >= TIMERANGE_NOW() - INTERVAL 8 DAY AND time < TIMERANGE_NOW() - INTERVAL 7 DAY) |
Matchar de 24 timmarna innan det schemalagda fönstret går ut och motsvarande 24-timmarsperiod sju dagar tidigare |
Dessa predikat använder fasta offsetar från TIMERANGE_NOW(). Att ändra schemat ändrar inte deras intervalliteraler.
extend_lookback breddar inte dessa manuellt specificerade fönster, eftersom det endast ändrar den hanterade startgränsen som används av IN_TIMERANGE.
Denna tabell sammanfattar när varje funktion ska användas:
| Goal | Använd |
|---|---|
| Begränsa en regel till dess tidsfönster | IN_TIMERANGE(<event_time>) |
| Referera till "nu" som tar hänsyn till körningens tidsfönster | TIMERANGE_NOW() |