Migrieren von Splunk-Erkennungsregeln zu Microsoft Sentinel

Artikel
03/11/2024

In diesem Artikel erfahren Sie, wie Sie Ihre Splunk-Erkennungsregeln identifizieren, vergleichen und zu den in Microsoft Sentinel integrierten Regeln migrieren können.

Um Ihre Splunk Observability-Bereitstellung zu migrieren, lesen Sie die Anleitung für die Migration von Splunk zu Azure Monitor Protokollen.

Identifizieren und Migrieren von Regeln

Von Microsoft Sentinel werden aus maschinellem Lernen gewonnene Analysen dazu verwendet, hochwertige und praktisch verwertbare Incidents zu erstellen; einige Ihrer vorhandenen Erkennungen sind in Microsoft Sentinel möglicherweise redundant. Migrieren Sie daher nicht einfach unbedacht alle Erkennungs- und Analyseregeln. Überdenken Sie diese Aspekte, während Sie Ihre vorhandenen Erkennungsregeln identifizieren.

Achten Sie darauf, dass Sie Anwendungsfälle auswählen, die die Regelmigration unter Berücksichtigung von Geschäftspriorität und Effizienz rechtfertigen.
Stellen Sie sicher, dass Sie die Microsoft Sentinel-Regeltypen verstehen.
Stellen Sie sicher, dass Sie die Regelterminologie verstehen.
Überprüfen Sie alle Regeln, durch die in den letzten 6 bis 12 Monaten keine Warnungen ausgelöst wurden, und bestimmen Sie, ob sie weiterhin relevant sind.
Beseitigen Sie Bedrohungen oder Warnungen mit niedrigem Schweregrad, die Sie routinemäßig ignorieren.
Verwenden Sie vorhandene Funktionen, und überprüfen Sie, ob die integrierten Analyseregeln von Microsoft Sentinel für Ihre aktuellen Anwendungsfälle geeignet sind. Da Microsoft Sentinel aus maschinellem Lernen gewonnene Analysen dazu verwendet, hochwertige und praktisch verwertbare Vorfälle zu erzeugen, ist es wahrscheinlich, dass einige Ihrer bestehenden Erkennungen nicht mehr benötigt werden.
Vergewissern Sie sich, dass die Datenquellen verbunden sind, und überprüfen Sie die Datenverbindungsmethoden. Gehen Sie erneut die Konversationen zur Datensammlung durch, um die Datentiefe und -breite für die zu erkennenden Anwendungsfälle sicherzustellen.
Testen Sie die Funktionen der SIEM-Migrationsumgebung, um festzustellen, ob die automatisierte Übersetzung geeignet ist.
Erkunden Sie Communityressourcen wie den SOC Prime Threat Detection Marketplace, um zu überprüfen, ob Ihre Regeln verfügbar sind.
Überlegen Sie, ob möglicherweise ein Onlineabfragekonverter wie Uncoder.io für Ihre Regeln in Frage kommt.
Wenn Regeln nicht verfügbar sind oder nicht konvertiert werden können, müssen sie mithilfe einer KQL-Abfrage manuell erstellt werden. Überprüfen Sie die Regelzuordnung, um neue Abfragen zu erstellen.

Erfahren Sie mehr über bewährte Methoden zum Migrieren von Erkennungsregeln.

Migrieren von Analyseregeln zu Microsoft Sentinel:

Stellen Sie sicher, dass für jede Regel, die Sie migrieren möchten, ein Testsystem vorhanden ist.
1. Konzipieren Sie einen Überprüfungsprozess für die migrierten Regeln, einschließlich vollständiger Testszenarios und Skripts.
2. Stellen Sie sicher, dass Ihr Team über nützliche Ressourcen verfügt, damit die migrierten Regeln getestet werden können.
3. Vergewissern Sie sich, dass alle erforderlichen Datenquellen verbunden sind, und überprüfen Sie die Datenverbindungsmethoden.
Überprüfen Sie, ob die Erkennungen als integrierte Vorlagen in Microsoft Sentinel verfügbar sind:
- Verwenden Sie die SIEM-Migrationsumgebung, um Übersetzung und Migration zu automatisieren.
  
  Weitere Informationen finden Sie unter Verwenden der SIEM-Migrationsumgebung.
- Wenn die integrierten Regeln ausreichend sind, verwenden Sie integrierte Regelvorlagen, um Regeln für Ihren eigenen Arbeitsbereich zu erstellen.
  
  Öffnen Sie in Microsoft Azure Sentinel die Registerkarte Konfiguration > Analytics > Regelvorlagen, um die jeweils relevante Analyseregel zu erstellen und zu aktualisieren.
  
  Weitere Informationen finden Sie unter Standardmäßig verfügbare Erkennung von Bedrohungen.
- Wenn Sie über Erkennungen verfügen, die nicht durch die integrierten Regeln von Microsoft Sentinel abgedeckt sind, versuchen Sie mit einem Onlineabfragekonverter wie Uncoder.io oder SPL2KQL, Ihre Abfragen in KQL zu konvertieren.
  
  Identifizieren Sie die Auslöserbedingung und die Regelaktion, und erstellen und überprüfen Sie dann die KQL-Abfrage.
- Wenn weder die integrierten Regeln noch ein Onlineregelkonverter ausreichend sind, müssen Sie die Regel manuell erstellen. Führen Sie in solchen Fällen die folgenden Schritte aus, um mit der Erstellung der Regel zu beginnen:
  1. Identifizieren Sie die Datenquellen, die Sie in der Regel verwenden möchten. Sie sollten eine Zuordnungstabelle zwischen Datenquellen und Datentabellen in Microsoft Sentinel erstellen, um die Tabellen zu identifizieren, die Sie abfragen möchten.
  2. Identifizieren Sie alle Attribute, Felder oder Entitäten in den Daten, die Sie in den Regeln verwenden möchten.
  3. Identifizieren Sie die Regelkriterien und die Logik. In dieser Phase sollten Sie Regelvorlagen als Beispiele zum Erstellen der KQL-Abfragen verwenden.
    
    Berücksichtigen Sie Filter, Korrelationsregeln, aktive Listen, Verweissätze, Watchlists, Erkennungsanomalien, Aggregationen usw. Sie können die von der Legacy-SIEM-Lösung bereitgestellten Verweise verwenden, um nachzuvollziehen, wie Sie die Abfragesyntax am besten zuordnen können.
  4. Identifizieren Sie die Auslöserbedingung und die Regelaktion, und erstellen und überprüfen Sie dann die KQL-Abfrage. Wenn Sie die Abfrage überprüfen, sollten Sie die Anleitungsressourcen für die KQL-Optimierung in Betracht ziehen.
Testen Sie die Regel mit jedem der relevanten Anwendungsfälle. Wenn keine erwarteten Ergebnisse bereitgestellt werden, sollten Sie die KQL-Abfrage überprüfen und erneut testen.
Wenn Sie mit dem Ergebnis zufrieden sind, können Sie die Regel als migriert betrachten. Erstellen Sie bei Bedarf ein Playbook für die Regelaktion. Weitere Informationen finden Sie unter Automatisieren der Bedrohungsabwehr mit Playbooks in Microsoft Sentinel.

Weitere Informationen zu Analyseregeln:

Erstellen benutzerdefinierter Analyseregeln zum Erkennen von Bedrohungen. Verwenden Sie Warnungsgruppen, um Warnungsmüdigkeit 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 Beweismaterials definieren können, das während einer Untersuchung nachverfolgt werden soll. Die Entitätszuordnung ermöglicht es SOC-Analysten zudem, ein intuitives [Untersuchungsdiagramm](investigate-cases.md#use-the-investigation-graph-to-deep-dive) zu nutzen, mit dem sie Zeit und Aufwand reduzieren können.
Untersuchen Sie Incidents mit UEBA-Daten als Beispiel für die Verwendung von Beweisen, um Ereignisse, Warnungen und alle Lesezeichen, die einem bestimmten Incident zugeordnet sind, im Bereich der Incidentvorschau anzuzeigen.
Kusto Query Language (KQL), mit der Sie schreibgeschützte Anforderungen an die Log Analytics-Datenbank senden können, um Daten zu verarbeiten und Ergebnisse zurückzugeben. KQL wird auch für andere Microsoft-Dienste verwendet, z. B. Microsoft Defender für Endpunkt und Application Insights.

Vergleichen der Regelterminologie

Diese Tabelle hilft Ihnen, das Konzept einer Regel in Microsoft Sentinel im Vergleich zu Splunk zu klären.

	Splunk	Microsoft Sentinel
Regeltyp	• Geplant • Echtzeit	• Geplante Abfrage • Fusion • Microsoft Security • Machine Learning-(ML-)Verhaltensanalysen
Kriterien	Definieren in SPL	Definieren in KQL
Auslöserbedingung	• Anzahl von Ergebnissen • Anzahl von Hosts • Anzahl von Quellen • Benutzerdefiniert	Schwellenwert: Die Anzahl der Abfrageergebnisse
Aktion	• Hinzufügen zu ausgelösten Warnungen • Protokollieren von Ereignissen • Ausgeben von Ergebnissen zum Nachschlagen • Und mehr	• Warnungen und Vorfälle erstellen • Integration in Logic Apps herstellen

Zuordnen und Vergleichen von Regelbeispielen

Verwenden Sie diese Beispiele, um Regeln von Splunk zu Microsoft Sentinel in verschiedenen Szenarien 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 bestimmten Kriterium entsprechen.	• distinct • summarize	`… \| summarize by Computer, EventID`
`eval`	Berechnet einen Ausdruck. Erfahren Sie mehr über allgemeine eval-Befehle.	extend	`T \| extend duration = endTime - startTime`
`fields`	Entfernt Felder aus Suchergebnissen.	• project • project-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.	• externaldata • lookup	KQL-Beispiel
`rename`	Benennt ein Feld um. Verwenden Sie Platzhalter, um mehrere Felder anzugeben.	project-rename	`T \| project-rename new_column_name = column_name`
`rex`	Gibt Gruppennamen mit regulären Ausdrücken an, um Felder zu extrahieren.	matches regex	`… \| where field matches regex "^addr.*"`
`search`	Filtert Ergebnisse in Ergebnisse, die dem Suchausdruck entsprechen.	search	`search "X"`
`sort`	Sortiert die Suchergebnisse nach den angegebenen Feldern.	sort	`T \| sort by strlen(country) asc, price desc`
`stats`	Stellt Statistiken bereit, optional nach Feldern gruppiert. Erfahren Sie mehr über allgemeine stats-Befehle.	summarize	KQL-Beispiel
`mstats`	Ähnlich wie „stats“, wird anstelle von Ereignissen auf Metriken verwendet.	summarize	KQL-Beispiel
`table`	Gibt an, welche Felder im Ergebnissatz beibehalten werden sollen, und speichert Daten im Tabellenformat.	project	`T \| project columnA, columnB`
`top/rare`	Zeigt die am häufigsten verwendeten 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 Sammelstatistiken aus Feldern in Ihren Ereignissen und speichert diese Statistiken in einem neuen Feld. SPL-Beispiel	Beispiele: • join • make_list • mv-expand	KQL-Beispiel
`streamstats`	Sucht nach der kumulativen Summe eines Felds. SPL-Beispiel: `... \| streamstats sum(bytes) as bytes _ total \\| timechart`	row_cumsum	`...\\| serialize cs=row_cumsum(bytes)`
`anomalydetection`	Sucht 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.	where	`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

In diesem Beispiel wird die join-Anweisung veranschaulicht:

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

In diesem Beispiel wird die make_list-Anweisung veranschaulicht:

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 der `X`- und `Y`-Argumente, bei denen die `X`-Argumente boolesche Ausdrücke sind. Wenn deren Wert `TRUE` ist, 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 mit doppelt genauer Gleitkommaarithmetik 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)`	Wird `X` als `TRUE` ausgewertet, ist das Ergebnis das zweite Argument `Y`. Wird `X` als `FALSE` ausgewertet, wird das Ergebnis als das dritte Argument `Z` ausgewertet.	`if(error==200,` `"OK", "Error")`	iif()	KQL-Beispiel
`isbool(X)`	Gibt `TRUE` zurück, wenn `X` ein boolescher Wert ist.	`isbool(field)`	• iif() • gettype	`iif(gettype(X) =="bool","TRUE","FALSE")`
`isint(X)`	Gibt `TRUE` zurück, wenn `X` eine ganze Zahl ist.	`isint(field)`	• iif() • gettype	KQL-Beispiel
`isnull(X)`	Gibt `TRUE` zurück, wenn `X` NULL ist.	`isnull(field)`	isnull()	`isnull(field)`
`isstr(X)`	Gibt `TRUE` zurück, wenn `X` eine Zeichenfolge ist.	`isstr(field)`	• iif() • 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 `TRUE` zurück, wenn `X` dem SQLite-Muster in `Y` entspricht.	`like(field, "addr%")`	• has • contains • startswith • matches 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 klein geschriebenen Wert von `X` zurück.	`lower(username)`	tolower	`tolower(username)`
`ltrim(X,Y)`	Gibt `X` mit den Zeichen im Parameter `Y` zurück, die von der linken Seite gekürzt wurden. Die Standardausgabe von `Y` sind Leer- und Tabulatorzeichen.	`ltrim(" ZZZabcZZ ", " Z")`	trim_start()	`trim_start(“ ZZZabcZZ”,” ZZZ”)`
`match(X,Y)`	Wird zurückgegeben, wenn X dem RegEx-Muster Y entspricht.	`match(field, "^\d{1,3}.\d$")`	matches regex	`… \| where field matches regex @"^\d{1,3}.\d$")`
`max(X,…)`	Gibt den größten Wert 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 kleinsten Wert in einer Spalte zurück.	`min(delay, mydelay)`	• min_of() • min() • arg_min	KQL-Beispiel
`mvcount(X)`	Gibt die Zahl (Summe) von `X`-Werten zurück.	`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) `Y` bis `Z` (optional) zurück.	`mvindex( multifield, 2)`	array_slice	`array_slice(arr, 1, 2)`
`mvjoin(X,Y)`	Bei einem mehrwertigen Feld `X` und einem Zeichenfolgen-Trennzeichen `Y`werden die einzelnen Werte von `X` mit `Y` miteinander 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 `NULL` zurück.	`null()`	null	`null`
`nullif(X,Y)`	Enthält zwei Argumente, `X` und `Y`, und gibt `X` zurück, wenn die Argumente unterschiedlich sind. Andernfalls wird `NULL`zurückgegeben.	`nullif(fieldA, fieldB)`	iif	`iif(fieldA==fieldB, null, fieldA)`
`random()`	Gibt eine Pseudo-Zufallszahl zwischen `0` und `2147483647` zurück.	`random()`	rand()	`rand()`
`relative_ time(X,Y)`	Bei einer Epochenzeit `X` und einer relativen Zeitangabe `Y` wird der Epochenzeitwert von `Y`, der auf `X` angewendet wird, zurückgegeben.	`relative_time(now(),"-1d@d")`	unix time	KQL-Beispiel
`replace(X,Y,Z)`	Gibt eine Zeichenfolge zurück, die durch Substituieren einer Zeichenfolge `Z` für jedes Vorkommen regulärer Ausdruckszeichenfolgen `Y` in einer Zeichenfolge `X` gebildet wird.	Gibt das Datum zurück, bei dem die Zahlen für Monat und Tag vertauscht sind. Beispielsweise lautet für die Eingabe `4/30/2015` die Ausgabe `30/4/2009`: `replace(date, "^(\d{1,2})/ (\d{1,2})/", "\2/\1/")`	replace()	KQL-Beispiel
`round(X,Y)`	Gibt `X` zurück, gerundet auf die durch `Y` festgelegte Zahl der Dezimalstellen. Es wird standardmäßig 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 gekürzt werden. Wenn `Y` nicht angegeben ist, werden Leer- und Tabulatorzeichen gekürzt.	`rtrim(" ZZZZabcZZ ", " Z")`	trim_end()	`trim_end(@"[ Z]+",A)`
`searchmatch(X)`	Gibt `TRUE` zurück, wenn das Ereignis mit der Suchzeichenfolge `X` übereinstimmt.	`searchmatch("foo AND bar")`	iif()	`iif(field has "X","Yes","No")`
`split(X,"Y")`	Gibt `X` als mehrwertiges Feld zurück, geteilt durch das Trennzeichen `Y`.	`split(address, ";")`	split()	`split(address, ";")`
`sqrt(X)`	Gibt die Quadratwurzel von `X` zurück.	`sqrt(9)`	sqrt()	`sqrt(9)`
`strftime(X,Y)`	Gibt den Epochenzeitwert `X` im durch `Y` festgelegten Format zurück.	`strftime(_time, "%H:%M")`	format_datetime()	`format_datetime(time,'HH:mm')`
`strptime(X,Y)`	Gibt eine Zeit zurück, die durch eine Zeichenfolge `X` dargestellt wird, deren Wert aus dem Format `Y` geparst 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` (optionale) Zeichen zurück.	`substr("string", 1, 3)`	substring()	`substring("string", 0, 3)`
`time()`	Gibt die Wanduhrzeit mit Mikrosekundengenauigkeit 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 zu konvertierenden Zahl definiert.	`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 URL `X` decodiert 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 X als Zeichenfolge zurück.

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

tostring(X,Y) SPL-Beispiel

Die Rückgabe des Beispiels lautet wie folgt:

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")

Allgemeine stats-Befehle KQL-Beispiel

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 eindeutigen Werte des Felds `X` zurück.	dcount()	`…\\| summarize countries=dcount(country) by continent`
`earliest(X)`	Gibt den chronologisch frühesten Wert von `X` zurück.	arg_min()	`… \\| summarize arg_min(TimeGenerated, *) by X`
`latest(X)`	Gibt den chronologisch spätesten Wert von `X` zurück.	arg_max()	`… \\| summarize arg_max(TimeGenerated, *) by X`
`max(X)`	Gibt den maximalen Wert des Felds `X` zurück. Wenn die Werte von `X` nicht numerisch sind, wird der Maximalwert über alphabetische Sortierung ermittelt.	max()	`…\\| summarize max(X)`
`median(X)`	Gibt den mittleren Wert des Felds `X` zurück.	percentile()	`…\\| summarize percentile(X, 50)`
`min(X)`	Gibt den minimalen Wert des Felds `X` zurück. Wenn die Werte von `X` nicht numerisch sind, wird der Minimalwert über alphabetische Sortierung ermittelt.	min()	`…\\| summarize min(X)`
`mode(X)`	Gibt den am häufigsten vorkommenden Wert des Felds `X` zurück.	top-hitters()	`…\\| top-hitters 1 of Y by X`
`perc(Y)`	Gibt den Prozentwert `X` des Felds `Y` zurück. `perc5(total)` gibt beispielsweise den fünften Prozentwert eines Felds `total` zurück.	percentile()	`…\\| summarize percentile(Y, 5)`
`range(X)`	Gibt den Unterschied zwischen den maximalen und minimalen Werten des Felds `X` zurück.	range()	`range(1, 3)`
`stdev(X)`	Gibt die Standardabweichung einer Stichprobe des Felds `X` zurück.	stdev	`stdev()`
`stdevp(X)`	Gibt die Standardabweichung der Population 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 Quadratsumme der Werte des Felds `X` zurück.
`values(X)`	Gibt die Liste aller eindeutigen Werte des Felds `X` als Eintrag mit mehreren Werten zurück. Die Reihenfolge der Werte ist alphabetisch.	make_set()	`…\\| summarize r = make_set(X)`
`var(X)`	Gibt die Stichprobenabweichung des Felds `X` zurück.	variance	`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

Teilen über