Migrieren von Splunk-Erkennungsregeln zu Microsoft Sentinel

Splunk-Erkennungsregeln sind SIEM-Komponenten (Security Information and Event Management), die mit Analyseregeln in Microsoft Sentinel verglichen werden. In diesem Artikel werden die Konzepte zum Identifizieren, Vergleichen und Migrieren zu Microsoft Sentinel beschrieben. Die beste Möglichkeit besteht darin, mit der SIEM-Migrationserfahrung zu beginnen, die OOTB-Analyseregeln (Out-of-the-Box) identifiziert, in die automatisch übersetzt werden sollen.

Wenn Sie Ihre Splunk Observability-Bereitstellung migrieren möchten, erfahren Sie mehr darüber, wie Sie von Splunk zu Azure Monitor-Protokollen migrieren.

Überwachungsregeln

Microsoft Sentinel verwendet Machine Learning-Analysen, um hochgenaue und umsetzbare Incidents zu erstellen. Einige Ihrer vorhandenen Splunk-Erkennungen sind möglicherweise in Microsoft Sentinel redundant, daher sollten Sie sie nicht alle blind migrieren. Überprüfen Sie diese Überlegungen, wenn Sie Ihre vorhandenen Erkennungsregeln identifizieren.

Stellen Sie sicher, dass Sie Anwendungsfälle auswählen, die die Regelmigration unter Berücksichtigung der Geschäftlichen Priorität und Effizienz rechtfertigen.
Vergewissern Sie sich, dass Sie Microsoft Sentinel Regeltypen verstehen.
Überprüfen Sie, ob Sie die Regelterminologie verstehen.
Überprüfen Sie veraltete Regeln, die in den letzten 6 bis 12 Monaten keine Warnungen enthalten, und ermitteln Sie, ob sie weiterhin relevant sind.
Beseitigen Sie Bedrohungen oder Warnungen auf niedriger Ebene, die Sie routinemäßig ignorieren.
Bestätigen Sie verbundene Datenquellen, und überprüfen Sie Ihre Datenverbindungsmethoden. Microsoft Sentinel Analytics erfordern, dass der Datentyp im Log Analytics-Arbeitsbereich vorhanden ist, bevor eine Regel aktiviert wird. Rufen Sie die Konversationen zur Datensammlung erneut auf, um die Datentiefe und -breite in den Anwendungsfällen sicherzustellen, die Sie erkennen möchten. Verwenden Sie dann die SIEM-Migrationsumgebung , um sicherzustellen, dass die Datenquellen ordnungsgemäß zugeordnet sind.

Migrieren von Regeln

Nachdem Sie die zu migrierenden Splunk-Erkennungen ermittelt haben, überprüfen Sie die folgenden Überlegungen für den Migrationsprozess:

Vergleichen Sie die vorhandenen Funktionen der OOTB-Analyseregeln von Microsoft Sentinel mit Ihren aktuellen Anwendungsfällen. Verwenden Sie die SIEM-Migrationsumgebung , um zu sehen, welche Splunk-Erkennungen automatisch in OOTB-Vorlagen konvertiert werden.
Übersetzen Sie Erkennungen, die nicht an OOTB-Analyseregeln ausgerichtet sind. Die beste Möglichkeit, Splunk-Erkennungen automatisch zu übersetzen, ist die SIEM-Migrationserfahrung.
Entdecken Sie weitere Algorithmen für Ihre Anwendungsfälle, indem Sie Communityressourcen wie den SOC Prime Threat Detection Marketplace erkunden.
Manuelles Übersetzen von Erkennungen, wenn integrierte Regeln nicht verfügbar sind oder nicht automatisch übersetzt werden. Erstellen Sie die neuen KQL-Abfragen, und überprüfen Sie die Regelzuordnung.

Weitere Informationen finden Sie unter Bewährte Methoden für die Migration von Erkennungsregeln.

Schritte zur Regelmigration

Vergewissern Sie sich, dass für jede Zu migrierende Regel ein Testsystem vorhanden ist.
1. Bereiten Sie einen Validierungsprozess für Ihre migrierten Regeln vor, einschließlich vollständiger Testszenarien und Skripts.
2. Stellen Sie sicher, dass Ihr Team über nützliche Ressourcen zum Testen Der migrierten Regeln verfügt.
3. Vergewissern Sie sich, dass die erforderlichen Datenquellen verbunden sind, und überprüfen Sie Ihre Datenverbindungsmethoden.
Überprüfen Sie, ob Ihre Erkennungen als OOTB-Vorlagen in Microsoft Sentinel verfügbar sind:
- Verwenden Sie die SIEM-Migrationsumgebung , um die Übersetzung und Installation der OOTB-Vorlagen zu automatisieren.
  
  Weitere Informationen finden Sie unter Verwenden der SIEM-Migrationsumgebung.
- Wenn Sie Anwendungsfälle haben, die in den Erkennungen nicht widerspiegelt sind, erstellen Sie Regeln für Ihren eigenen Arbeitsbereich mit OOTB-Regelvorlagen.
  
  Wechseln Sie Microsoft Sentinel zum Inhaltshub.
  
  Filterinhaltstyp für Analytics-Regelvorlagen.
  
  Suchen und installieren/aktualisieren Sie jede entsprechende Content Hub-Lösung oder eigenständige Analyseregelvorlage.
  
  Weitere Informationen finden Sie unter Sofort einsatzbereite Erkennung von Bedrohungen.
- Wenn Sie über Erkennungen verfügen, die nicht von den OOTB-Regeln Microsoft Sentinel abgedeckt werden, probieren Sie zunächst die SIEM-Migrationsumgebung für die automatische Übersetzung aus.
- Wenn weder die OOTB-Regeln noch die SIEM-Migration die Erkennung vollständig übersetzen, erstellen Sie die Regel manuell. Führen Sie in solchen Fällen die folgenden Schritte aus, um Ihre Regel zu erstellen:
  1. Identifizieren Sie die Datenquellen, die Sie in Ihrer Regel verwenden möchten. Identifizieren Sie die Microsoft Sentinel Tabellen, die Sie abfragen möchten, indem Sie eine Zuordnungstabelle zwischen Datenquellen und Datentabellen erstellen.
  2. Identifizieren Sie alle Attribute, Felder oder Entitäten in Ihren Daten, die Sie in Ihren Regeln verwenden möchten.
  3. Identifizieren Sie Ihre Regelkriterien und -logik. Erwägen Sie in dieser Phase die Suche nach Regelvorlagen als Beispiele für die Erstellung Ihrer KQL-Abfragen.
    
    Berücksichtigen Sie Filter, Korrelationsregeln, aktive Listen, Verweissätze, Watchlists, Erkennungsanomalien, Aggregationen usw. Sie können Verweise verwenden, die von Ihrem Legacy-SIEM bereitgestellt werden, um zu verstehen , wie Sie Ihre Abfragesyntax am besten zuordnen.
  4. Identifizieren Sie die Triggerbedingung und die Regelaktion, erstellen und überprüfen Sie dann Ihre KQL-Abfrage. Berücksichtigen Sie beim Überprüfen Ihrer Abfrage die Ressourcen des KQL-Optimierungsleitfadens.
Testen Sie die Regel mit jedem Ihrer relevanten Anwendungsfälle. Wenn es keine erwarteten Ergebnisse liefert, überprüfen und bearbeiten Sie die KQL, und testen Sie sie erneut.
Wenn Sie zufrieden sind, sollten Sie die Migrierte Regel in Betracht ziehen. Erstellen Sie nach Bedarf ein Playbook für Ihre Regelaktion. Weitere Informationen finden Sie unter Automatisieren der Reaktion auf Bedrohungen mit Playbooks in Microsoft Sentinel.

Weitere Informationen zu Analyseregeln:

Erstellen Sie benutzerdefinierte Analyseregeln, um Bedrohungen zu erkennen. Verwenden Sie die Warnungsgruppierung , um die Ermüdung von Warnungen zu reduzieren, indem Sie Warnungen gruppieren, die innerhalb eines bestimmten Zeitraums auftreten.
Ordnen Sie Datenfelder Entitäten in Microsoft Sentinel zu, damit SOC-Techniker Entitäten als Teil des Nachweises definieren können, der während einer Untersuchung nachverfolgt werden soll. Die Entitätszuordnung ermöglicht es SOC-Analysten auch, einen intuitiven [Untersuchungsgraphen] (investigation-cases.md#use-the-investigation-graph-to-deep-dive) zu nutzen, der dazu beitragen kann, Zeit und Aufwand zu reduzieren.
Untersuchen Sie Vorfälle mit UEBA-Daten als Beispiel für die Verwendung von Beweisen, um Ereignisse, Warnungen und lesezeichen, die einem bestimmten Incident zugeordnet sind, im Vorschaubereich des Incidents anzuzeigen.
Kusto-Abfragesprache (KQL), mit dem Sie schreibgeschützte Anforderungen an Ihre Log Analytics-Datenbank senden können, um Daten zu verarbeiten und Ergebnisse zurückzugeben. KQL wird auch für andere Microsoft-Dienste wie Microsoft Defender for Endpoint und Application Insights verwendet.

Vergleichen der Regelterminologie

Diese Tabelle hilft Ihnen, das Konzept einer Regel, die auf Kusto-Abfragesprache (KQL) in Microsoft Sentinel im Vergleich zu einer Splunk-Erkennung basierend auf der Suchverarbeitungssprache (Search Processing Language, SPL) basiert, zu verdeutlichen.

	Splunk	Microsoft Sentinel
Regeltyp	•Geplant • Echtzeit	• Geplante Abfrage •Fusion • Microsoft-Sicherheit • Machine Learning (ML) Behavior Analytics
Kriterium	Definieren in SPL	Definieren in KQL
Triggerbedingung	• Anzahl der Ergebnisse • Anzahl der Hosts • Anzahl der Quellen •Benutzerdefinierte	Schwellenwert: Anzahl der Abfrageergebnisse
Aktion	• Zu ausgelösten Warnungen hinzufügen • Protokollereignis • Ausgabeergebnisse zum Nachschlagen • Und mehr	• Erstellen einer Warnung oder eines Incidents • Integration in Logic Apps

Zuordnen und Vergleichen von Regelbeispielen

Verwenden Sie diese Beispiele, um Regeln von Splunk in verschiedenen Szenarien zu Microsoft Sentinel zu vergleichen und zuzuordnen.

Allgemeine Suchbefehle

SPL-Befehl	Beschreibung	KQL-Operator	KQL-Beispiel
`chart/ timechart`	Gibt Ergebnisse in einer tabellarischen Ausgabe für Zeitreihendiagramme zurück.	render-Operator	`… \| render timechart`
`dedup`	Entfernt nachfolgende Ergebnisse, die einem angegebenen Kriterium entsprechen.	• eindeutig • zusammenfassen	`… \| summarize by Computer, EventID`
`eval`	Berechnet einen Ausdruck. Erfahren Sie mehr über allgemeine `eval` Befehle.	Erweitern	`T \| extend duration = endTime - startTime`
`fields`	Entfernt Felder aus Suchergebnissen.	• Projekt • projekt-away	`T \| project cost=price*quantity, price`
`head/tail`	Gibt die ersten oder letzten N Ergebnisse zurück.	top	`T \| top 5 by Name desc nulls last`
`lookup`	Fügt Feldwerte aus einer externen Quelle hinzu.	• externe Daten • Nachschlagen	KQL-Beispiel
`rename`	Benennt ein Feld um. Verwenden Sie Wildcards, um mehrere Felder anzugeben.	Projekt umbenennen	`T \| project-rename new_column_name = column_name`
`rex`	Gibt Gruppennamen an, die reguläre Ausdrücke zum Extrahieren von Feldern verwenden.	entspricht regex	`… \| where field matches regex "^addr.*"`
`search`	Filtert Ergebnisse nach Ergebnissen, die dem Suchausdruck entsprechen.	Suche	`search "X"`
`sort`	Sortiert die Suchergebnisse nach den angegebenen Feldern.	sort	`T \| sort by strlen(country) asc, price desc`
`stats`	Stellt Statistiken bereit, die optional nach Feldern gruppiert sind. Erfahren Sie mehr über allgemeine Statistikbefehle.	Zusammenfassen	KQL-Beispiel
`mstats`	Ähnlich wie Statistiken, die für Metriken anstelle von Ereignissen verwendet werden.	Zusammenfassen	KQL-Beispiel
`table`	Gibt an, welche Felder im Resultset beibehalten werden sollen, und behält Daten im tabellarischen Format bei.	Projekt	`T \| project columnA, columnB`
`top/rare`	Zeigt die am häufigsten oder am wenigsten gebräuchlichen Werte eines Felds an.	top	`T \| top 5 by Name desc nulls last`
`transaction`	Gruppiert Suchergebnisse in Transaktionen. SPL-Beispiel	Beispiel: row_window_session	KQL-Beispiel
`eventstats`	Generiert Zusammenfassungsstatistiken aus Feldern in Ihren Ereignissen und speichert diese Statistiken in einem neuen Feld. SPL-Beispiel	Beispiele: • Beitreten • make_list • mv-expand	KQL-Beispiel
`streamstats`	Suchen Sie die kumulierte Summe eines Felds. SPL-Beispiel: `... \| streamstats sum(bytes) as bytes _ total \\| timechart`	row_cumsum	`...\\| serialize cs=row_cumsum(bytes)`
`anomalydetection`	Suchen Sie Anomalien im angegebenen Feld. SPL-Beispiel	series_decompose_anomalies()	KQL-Beispiel
`where`	Filtert Suchergebnisse mithilfe von `eval` Ausdrücken. Wird verwendet, um zwei verschiedene Felder zu vergleichen.	Wo	`T \| where fruit=="apple"`

`lookup` Befehl: KQL-Beispiel

Users 
| where UserID in ((externaldata (UserID:string) [
@"https://storageaccount.blob.core.windows.net/storagecontainer/users.txt" 
h@"?...SAS..." // Secret token to access the blob 
])) | ...

`stats` Befehl: KQL-Beispiel

Sales 
| summarize NumTransactions=count(), 
Total=sum(UnitPrice * NumUnits) by Fruit, 
StartOfMonth=startofmonth(SellDateTime)

`mstats` Befehl: KQL-Beispiel

T | summarize count() by price_range=bin(price, 10.0)

`transaction` Befehl: SPL-Beispiel

sourcetype=MyLogTable type=Event
| transaction ActivityId startswith="Start" endswith="Stop"
| Rename timestamp as StartTime
| Table City, ActivityId, StartTime, Duration

`transaction` Befehl: KQL-Beispiel

let Events = MyLogTable | where type=="Event";
Events
| where Name == "Start"
| project Name, City, ActivityId, StartTime=timestamp
| join (Events
| where Name == "Stop"
| project StopTime=timestamp, ActivityId)
on ActivityId
| project City, ActivityId, StartTime, 
Duration = StopTime – StartTime

Verwenden Sie row_window_session() , um Sitzungsstartwerte für eine Spalte in einem serialisierten Zeilensatz zu berechnen.

...| extend SessionStarted = row_window_session(
Timestamp, 1h, 5m, ID != prev(ID))

`eventstats` Befehl: SPL-Beispiel

… | bin span=1m _time
|stats count AS count_i by _time, category
| eventstats sum(count_i) as count_total by _time

`eventstats` Befehl: KQL-Beispiel

Hier sehen Sie ein Beispiel mit der join -Anweisung:

let binSize = 1h;
let detail = SecurityEvent 
| summarize detail_count = count() by EventID,
tbin = bin(TimeGenerated, binSize);
let summary = SecurityEvent
| summarize sum_count = count() by 
tbin = bin(TimeGenerated, binSize);
detail 
| join kind=leftouter (summary) on tbin 
| project-away tbin1

Hier sehen Sie ein Beispiel mit der make_list -Anweisung:

let binSize = 1m;
SecurityEvent
| where TimeGenerated >= ago(24h)
| summarize TotalEvents = count() by EventID, 
groupBin =bin(TimeGenerated, binSize)
|summarize make_list(EventID), make_list(TotalEvents), 
sum(TotalEvents) by groupBin
| mvexpand list_EventID, list_TotalEvents

`anomalydetection` Befehl: SPL-Beispiel

sourcetype=nasdaq earliest=-10y
| anomalydetection Close _ Price

`anomalydetection` Befehl: KQL-Beispiel

let LookBackPeriod= 7d;
let disableAccountLogon=SignIn
| where ResultType == "50057"
| where ResultDescription has "account is disabled";
disableAccountLogon
| make-series Trend=count() default=0 on TimeGenerated 
in range(startofday(ago(LookBackPeriod)), now(), 1d)
| extend (RSquare,Slope,Variance,RVariance,Interception,
LineFit)=series_fit_line(Trend)
| extend (anomalies,score) = 
series_decompose_anomalies(Trend)

Allgemeine `eval` Befehle

SPL-Befehl	Beschreibung	SPL-Beispiel	KQL-Befehl	KQL-Beispiel
`abs(X)`	Gibt den absoluten Wert von X zurück.	`abs(number)`	`abs()`	`abs(X)`
`case(X,"Y",…)`	Verwendet Paare von `X` - und `Y` -Argumenten, wobei die `X` Argumente boolesche Ausdrücke sind. Bei der Auswertung auf `TRUE`geben die Argumente das entsprechende `Y` Argument zurück.	SPL-Beispiel	`case`	KQL-Beispiel
`ceil(X)`	Obergrenze einer Zahl X.	`ceil(1.9)`	`ceiling()`	`ceiling(1.9)`
`cidrmatch("X",Y)`	Identifiziert IP-Adressen, die zu einem bestimmten Subnetz gehören.	`cidrmatch` `("123.132.32.0/25",ip)`	• `ipv4_is_match()` • ipv6_is_match()	`ipv4_is_match('192.168.1.1', '192.168.1.255')` `== false`
`coalesce(X,…)`	Gibt den ersten Wert zurück, der nicht NULL ist.	`coalesce(null(), "Returned val", null())`	`coalesce()`	`coalesce(tolong("not a number"),` `tolong("42"), 33) == 42`
`cos(X)`	Berechnet den Kosinus von X.	`n=cos(0)`	cos()	`cos(X)`
`exact(X)`	Wertet einen Ausdruck X mithilfe einer Gleitkommaarithmetik mit doppelter Genauigkeit aus.	`exact(3.14*num)`	`todecimal()`	`todecimal(3.14*2)`
`exp(X)`	Gibt eX zurück.	`exp(3)`	exp()	`exp(3)`
`if(X,Y,Z)`	Wenn `X` als `TRUE`ausgewertet wird, ist das Ergebnis das zweite Argument `Y`. Wenn `X` als `FALSE`ausgewertet wird, ergibt das Ergebnis das dritte Argument `Z`.	`if(error==200,` `"OK", "Error")`	`iff()`	KQL-Beispiel
`isbool(X)`	Gibt zurück `TRUE` , wenn `X` boolescher Wert ist.	`isbool(field)`	• `iff()` • `gettype`	`iff(gettype(X) =="bool","TRUE","FALSE")`
`isint(X)`	Gibt zurück `TRUE` , wenn `X` eine ganze Zahl ist.	`isint(field)`	• `iff()` • `gettype`	KQL-Beispiel
`isnull(X)`	Gibt zurück `TRUE` , wenn `X` NULL ist.	`isnull(field)`	`isnull()`	`isnull(field)`
`isstr(X)`	Gibt zurück `TRUE` , wenn `X` eine Zeichenfolge ist.	`isstr(field)`	• `iff()` • `gettype`	KQL-Beispiel
`len(X)`	Diese Funktion gibt die Zeichenlänge einer Zeichenfolge `X`zurück.	`len(field)`	`strlen()`	`strlen(field)`
`like(X,"y")`	Gibt nur dann zurück `TRUE` , wenn `X` dem SQLite-Muster in `Y`ähnelt.	`like(field, "addr%")`	• `has` • `contains` • `startswith` • entspricht regex	KQL-Beispiel
`log(X,Y)`	Gibt das Protokoll des ersten Arguments `X` mit dem zweiten Argument `Y` als Basis zurück. Der Standardwert von `Y` ist `10`.	`log(number,2)`	• `log` • `log2` • `log10`	`log(X)` `log2(X)` `log10(X)`
`lower(X)`	Gibt den Kleinbuchstabenwert von zurück `X`.	`lower(username)`	tolower	`tolower(username)`
`ltrim(X,Y)`	Gibt zurück `X` , wobei die Zeichen im Parameter `Y` von der linken Seite gekürzt wurden. Die Standardausgabe von `Y` sind Leerzeichen und Registerkarten.	`ltrim(" ZZZabcZZ ", " Z")`	`trim_start()`	`trim_start(“ ZZZabcZZ”,” ZZZ”)`
`match(X,Y)`	Gibt zurück, wenn X mit dem RegEx-Muster Y übereinstimmt.	`match(field, "^\d{1,3}.\d$")`	`matches regex`	`… \| where field matches regex @"^\d{1,3}.\d$")`
`max(X,…)`	Gibt den Maximalwert in einer Spalte zurück.	`max(delay, mydelay)`	• `max()` • `arg_max()`	`… \| summarize max(field)`
`md5(X)`	Gibt den MD5-Hash eines Zeichenfolgenwerts `X`zurück.	`md5(field)`	`hash_md5`	`hash_md5("X")`
`min(X,…)`	Gibt den Mindestwert in einer Spalte zurück.	`min(delay, mydelay)`	• `min_of()` • min() • arg_min	KQL-Beispiel
`mvcount(X)`	Gibt die Anzahl (Gesamt) der Werte zurück `X` .	`mvcount(multifield)`	`dcount`	`…\| summarize dcount(X) by Y`
`mvfilter(X)`	Filtert ein mehrwertiges Feld basierend auf dem booleschen `X` Ausdruck.	`mvfilter(match(email, "net$"))`	`mv-apply`	KQL-Beispiel
`mvindex(X,Y,Z)`	Gibt eine Teilmenge des mehrwertigen `X` Arguments von einer Startposition (nullbasiert) bis (optional) `Y` zurück `Z` .	`mvindex( multifield, 2)`	`array_slice`	`array_slice(arr, 1, 2)`
`mvjoin(X,Y)`	Bei einem mehrwertigen Feld `X` und einem Zeichenfolgentrennzeichen `Y`werden die einzelnen Werte von `X` mit `Y`verknüpft.	`mvjoin(address, ";")`	`strcat_array`	KQL-Beispiel
`now()`	Gibt die aktuelle Zeit zurück, die in Unix-Zeit dargestellt wird.	`now()`	`now()`	`now()` `now(-2d)`
`null()`	Akzeptiert keine Argumente und gibt zurück `NULL`.	`null()`	null	`null`
`nullif(X,Y)`	Enthält zwei Argumente, `X` und `Y`, und gibt zurück `X` , wenn die Argumente unterschiedlich sind. Andernfalls wird zurückgegeben `NULL`.	`nullif(fieldA, fieldB)`	`iff`	`iff(fieldA==fieldB, null, fieldA)`
`random()`	Gibt eine Pseudo-Zufallszahl zwischen `0` bis zurück `2147483647`.	`random()`	`rand()`	`rand()`
`relative_ time(X,Y)`	Bei einer Epochenzeit `X` und einem relativen Zeitbezeichner `Y`gibt den Epochenzeitwert von zurück, der `Y` auf `X`angewendet wird.	`relative_time(now(),"-1d@d")`	UNIX-Zeit	KQL-Beispiel
`replace(X,Y,Z)`	Gibt eine Zeichenfolge zurück, die durch ersetzende Zeichenfolge `Z` für jedes Vorkommen der Zeichenfolge `Y` für reguläre Ausdrücke in der Zeichenfolge `X`gebildet wird.	Gibt datum mit gewechselten Monats- und Tageszahlen zurück. Für die `4/30/2015` Eingabe lautet `30/4/2009`die Ausgabe beispielsweise : `replace(date, "^(\d{1,2})/ (\d{1,2})/", "\2/\1/")`	`replace()`	KQL-Beispiel
`round(X,Y)`	Gibt `X` gerundet auf die Anzahl von Dezimalstellen zurück, die durch angegeben werden `Y`. Standardmäßig wird auf eine ganze Zahl gerundet.	`round(3.5)`	`round`	`round(3.5)`
`rtrim(X,Y)`	Gibt `X` mit den Zeichen von `Y` zurück, die von der rechten Seite abgeschnitten wurden. Wenn `Y` nicht angegeben ist, werden Leerzeichen und Registerkarten gekürzt.	`rtrim(" ZZZZabcZZ ", " Z")`	`trim_end()`	`trim_end(@"[ Z]+",A)`
`searchmatch(X)`	Gibt zurück `TRUE` , wenn das Ereignis mit der Suchzeichenfolge `X`übereinstimmt.	`searchmatch("foo AND bar")`	iff()	`iff(field has "X","Yes","No")`
`split(X,"Y")`	Gibt `X` als mehrwertiges Feld zurück, das durch Trennzeichen `Y`geteilt wird.	`split(address, ";")`	`split()`	`split(address, ";")`
`sqrt(X)`	Gibt die Quadratwurzel von zurück `X`.	`sqrt(9)`	`sqrt()`	`sqrt(9)`
`strftime(X,Y)`	Gibt den Epochenzeitwert `X` zurück, der mit dem von `Y`angegebenen Format gerendert wird.	`strftime(_time, "%H:%M")`	`format_datetime()`	`format_datetime(time,'HH:mm')`
`strptime(X,Y)`	Bei einer Zeit, die durch eine Zeichenfolge `X`dargestellt wird, gibt den Wert zurück, der aus dem Format `Y`analysiert wird.	`strptime(timeStr, "%H:%M")`	format_datetime()	KQL-Beispiel
`substr(X,Y,Z)`	Gibt ein Teilzeichenfolgenfeld `X` von der Startposition (einsbasiert) `Y` für `Z` (optional) Zeichen zurück.	`substr("string", 1, 3)`	`substring()`	`substring("string", 0, 3)`
`time()`	Gibt die Wanduhrzeit mit Mikrosekundenauflösung zurück.	`time()`	`format_datetime()`	KQL-Beispiel
`tonumber(X,Y)`	Konvertiert die Eingabezeichenfolge `X` in eine Zahl, wobei `Y` (optional, Standardwert ist `10`) die Basis der Zahl definiert, in die konvertiert werden soll.	`tonumber("0A4",16)`	`toint()`	`toint("123")`
`tostring(X,Y)`	Beschreibung	SPL-Beispiel	`tostring()`	`tostring(123)`
`typeof(X)`	Gibt eine Zeichenfolgendarstellung des Feldtyps zurück.	`typeof(12)`	`gettype()`	`gettype(12)`
`urldecode(X)`	Gibt die decodierte URL `X` zurück.	SPL-Beispiel	`url_decode`	KQL-Beispiel

`case(X,"Y",…)` SPL-Beispiel

case(error == 404, "Not found",
error == 500,"Internal Server Error",
error == 200, "OK")

`case(X,"Y",…)` KQL-Beispiel

T
| extend Message = case(error == 404, "Not found", 
error == 500,"Internal Server Error", "OK")

`if(X,Y,Z)` KQL-Beispiel

iif(floor(Timestamp, 1d)==floor(now(), 1d), 
"today", "anotherday")

`isint(X)` KQL-Beispiel

iif(gettype(X) =="long","TRUE","FALSE")

`isstr(X)` KQL-Beispiel

iif(gettype(X) =="string","TRUE","FALSE")

`like(X,"y")` Beispiel

… | where field has "addr"

… | where field contains "addr"

… | where field startswith "addr"

… | where field matches regex "^addr.*"

`min(X,…)` KQL-Beispiel

min_of (expr_1, expr_2 ...)

…|summarize min(expr)

…| summarize arg_min(Price,*) by Product

`mvfilter(X)` KQL-Beispiel

T | mv-apply Metric to typeof(real) on 
(
 top 2 by Metric desc
)

`mvjoin(X,Y)` KQL-Beispiel

strcat_array(dynamic([1, 2, 3]), "->")

`relative time(X,Y)` KQL-Beispiel

let toUnixTime = (dt:datetime)
{
(dt - datetime(1970-01-01))/1s 
};

`replace(X,Y,Z)` KQL-Beispiel

replace( @'^(\d{1,2})/(\d{1,2})/', @'\2/\1/',date)

`strptime(X,Y)` KQL-Beispiel

format_datetime(datetime('2017-08-16 11:25:10'),
'HH:mm')

`time()` KQL-Beispiel

format_datetime(datetime(2015-12-14 02:03:04),
'h:m:s')

`tostring(X,Y)`

Gibt einen Feldwert von X als Zeichenfolge zurück.

Wenn der Wert von X eine Zahl ist, X wird in einen Zeichenfolgenwert neu formatiert.
Wenn X ein boolescher Wert ist, X wird in TRUE oder FALSEneu formatiert.
Wenn X eine Zahl ist, ist das zweite Argument Y optional und kann entweder hex sein (konvertiert X in ein Hexadezimal), commas (Formate X mit Kommas und zwei Dezimalstellen) oder duration (konvertiert X von einem Zeitformat in Sekunden in ein lesbares Zeitformat: HH:MM:SS).

`tostring(X,Y)` SPL-Beispiel

In diesem Beispiel wird Folgendes zurückgegeben:

foo=615 and foo2=00:10:15:

… | eval foo=615 | eval foo2 = tostring(
foo, "duration")

`urldecode(X)` SPL-Beispiel

urldecode("http%3A%2F%2Fwww.splunk.com%2Fdownload%3Fr%3Dheader")

KQL-Beispiel für allgemeine `stats` Befehle

SPL-Befehl	Beschreibung	KQL-Befehl	KQL-Beispiel
`avg(X)`	Gibt den Mittelwert der Werte des Felds `X`zurück.	avg()	`avg(X)`
`count(X)`	Gibt die Anzahl der Vorkommen des Felds `X`zurück. Um einen bestimmten Feldwert anzugeben, der übereinstimmen soll, formatieren Sie `X` als `eval(field="value")`.	count()	`summarize count()`
`dc(X)`	Gibt die Anzahl der unterschiedlichen Werte des Felds `X`zurück.	dcount()	`…\\| summarize countries=dcount(country) by continent`
`earliest(X)`	Gibt den chronologisch frühesten sichtbaren Wert von zurück `X`.	arg_min()	`… \\| summarize arg_min(TimeGenerated, *) by X`
`latest(X)`	Gibt den chronologisch letzten angezeigten Wert von zurück `X`.	arg_max()	`… \\| summarize arg_max(TimeGenerated, *) by X`
`max(X)`	Gibt den Maximalwert des Felds `X`zurück. Wenn die Werte von `X` nicht numerisch sind, wird der Maximalwert in alphabetischer Reihenfolge gefunden.	max()	`…\\| summarize max(X)`
`median(X)`	Gibt den mittleren Wert des Felds `X`zurück.	percentile()	`…\\| summarize percentile(X, 50)`
`min(X)`	Gibt den Mindestwert des Felds `X`zurück. Wenn die Werte von `X` nicht numerisch sind, wird der Mindestwert in alphabetischer Reihenfolge gefunden.	min()	`…\\| summarize min(X)`
`mode(X)`	Gibt den häufigsten Wert des Felds `X`zurück.	top-hitters()	`…\\| top-hitters 1 of Y by X`
`perc(Y)`	Gibt den Perzentilwert `X` des Felds `Y`zurück. Gibt beispielsweise `perc5(total)` den fünften Perzentilwert eines Felds `total`zurück.	percentile()	`…\\| summarize percentile(Y, 5)`
`range(X)`	Gibt die Differenz zwischen dem Maximal- und minimalen Wert des Felds `X`zurück.	range()	`range(1, 3)`
`stdev(X)`	Gibt die Standardabweichung des Beispiels des Felds `X`zurück.	Stdev	`stdev()`
`stdevp(X)`	Gibt die Standardabweichung der Auffüllung des Felds `X`zurück.	stdevp()	`stdevp()`
`sum(X)`	Gibt die Summe der Werte des Felds `X`zurück.	sum()	`sum(X)`
`sumsq(X)`	Gibt die Summe der Quadrate der Werte des Felds `X`zurück.
`values(X)`	Gibt die Liste aller unterschiedlichen Werte des Felds `X` als mehrwertigen Eintrag zurück. Die Reihenfolge der Werte ist alphabetisch.	make_set()	`…\\| summarize r = make_set(X)`
`var(X)`	Gibt die Stichprobenvarianz des Felds `X`zurück.	Varianz	`variance(X)`

Nächste Schritte

In diesem Artikel haben Sie erfahren, wie Sie Ihre Migrationsregeln von Splunk zu Microsoft Sentinel zuordnen.

Migrieren Ihrer SOAR-Automatisierung

Feedback

War diese Seite hilfreich?

Last updated on 2026-04-23

Migrieren von Splunk-Erkennungsregeln zu Microsoft Sentinel

Überwachungsregeln

Migrieren von Regeln

Schritte zur Regelmigration

Vergleichen der Regelterminologie

Zuordnen und Vergleichen von Regelbeispielen

Allgemeine Suchbefehle

lookup Befehl: KQL-Beispiel

stats Befehl: KQL-Beispiel

mstats Befehl: KQL-Beispiel

transaction Befehl: SPL-Beispiel

transaction Befehl: KQL-Beispiel

eventstats Befehl: SPL-Beispiel

eventstats Befehl: KQL-Beispiel

anomalydetection Befehl: SPL-Beispiel

anomalydetection Befehl: KQL-Beispiel

Allgemeine eval Befehle

case(X,"Y",…) SPL-Beispiel

case(X,"Y",…) KQL-Beispiel

if(X,Y,Z) KQL-Beispiel

isint(X) KQL-Beispiel

isstr(X) KQL-Beispiel

like(X,"y") Beispiel

min(X,…) KQL-Beispiel

mvfilter(X) KQL-Beispiel

mvjoin(X,Y) KQL-Beispiel

relative time(X,Y) KQL-Beispiel

replace(X,Y,Z) KQL-Beispiel

strptime(X,Y) KQL-Beispiel

time() KQL-Beispiel

tostring(X,Y)

tostring(X,Y) SPL-Beispiel

urldecode(X) SPL-Beispiel

KQL-Beispiel für allgemeine stats Befehle