CyberKit

SentinelOne Cheat Sheet

SentinelOne Deep Visibility and PowerQuery syntax. Every field name traces to a published source.

SentinelOne's full documentation sits behind a customer login. Everything here comes from SentinelOne's own public engineering and threat research posts that ship complete queries, and each section links to its source.

Before you read the table

  • The field list is not the schema. The console's autocomplete is the authority on the rest.
  • Only event.type values that appear in a published query are named. The full list is not public.

61 rows.

SentinelOne cheat sheet
SyntaxMeaning
filter | command | commandA PowerQuery starts with a plain Deep Visibility filter expression (no leading pipe) and then chains commands with the pipe character. Everything before the first pipe selects events; everything after it transforms them.
dataSource.name = 'SentinelOne'Scopes a query to SentinelOne agent telemetry rather than any other source feeding the Data Lake. Every SentinelOne-published hunting query opens with it.
filter → group → let → columns → filterThe shape SentinelOne's own published queries follow: select events, aggregate them, compute derived fields from the aggregates, choose the output columns, then filter on what you just computed. A second `filter` after the aggregation is how you threshold a summary.
| filter <condition>Discards records that do not match a condition. Placed after a `group` or `columns` stage, it filters on the fields that stage produced rather than on raw event fields.
| limit NCaps the number of records displayed or processed by subsequent commands. Worth setting explicitly on a wide hunt so an aggregation downstream stays bounded.
| sort -fieldDetermines the order records are displayed in. A leading `-` sorts descending.
| transposeRemoves columns from a table and creates a new column from their values: for turning a wide summary into a narrow one.
=Equality against a literal. String literals are single-quoted (double quotes appear in SentinelOne's own queries too).
and / orLogical conjunction and disjunction. Parenthesise groups when you mix them: SentinelOne's own published queries do.
!( ... )Negates a whole parenthesised expression: the way to exclude a known-good hash set from an otherwise broad file hunt.
containsSubstring match. The most-used operator in SentinelOne's published hunting queries, because command lines and paths are rarely exact-matchable.
contains:anycaseCase-insensitive substring match. Accepts a parenthesised list, in which case any element matching is enough.
contains (a, b, c)Substring match against several candidates at once: one clause instead of a chain of ORs.
in ( ... )Exact membership against a list of literals. This is the shape SentinelOne publishes IOC hash sweeps in.
in:anycase ( ... )Case-insensitive membership test: the right operator for Windows process names, whose casing is not consistent in telemetry.
matches "regex"Regular-expression match against a field. Used inside a filter, and equally inside a ternary to bucket values.
> < >= <=Numeric comparison. Works on raw event fields and on values you computed in an earlier `group` or `let` stage.
&&The C-style logical AND, used inside a `filter` expression alongside comparisons.
event.typeThe event class. SentinelOne's published queries use 'Process Creation' and 'IP Connect'; the console's autocomplete lists the rest, and this sheet does not guess at values that have not been published.
event.timeThe event timestamp. Bucket it with `timebucket()` in a `let` before grouping, to turn a raw event stream into a timeline.
event.network.directionDirection of a network event. 'OUTGOING' is the value SentinelOne uses in its own egress-hunting example.
endpoint.nameThe agent hostname. The natural `by` key for almost every summary, and the field you pivot on once a hunt returns a hit.
endpoint.osThe endpoint operating system: 'windows' in SentinelOne's published Windows-specific hunts.
dataSource.nameWhich product fed the record into the Data Lake. Pin it to SentinelOne when you want agent telemetry rather than an ingested third-party log.
task.nameScheduled-task name. A persistence-hunting field: SentinelOne uses it alongside process and file predicates in the same query.
src.process.nameThe SOURCE (acting/parent-side) process image name. In SentinelOne telemetry `src.*` is the process that did something and `tgt.*` is what it did it to: getting the two the wrong way round is the most common mistake in an S1 query.
src.process.cmdlineCommand line of the source process. The highest-signal field on the platform for anything script- or LOLBin-shaped.
src.process.parent.nameThe grandparent in the chain: the process that spawned the source process. This is what turns a single event into a lineage.
src.process.parent.cmdlineCommand line of that grandparent process. Aggregate it with `array_agg_distinct()` to see every way a parent was invoked.
src.process.parent.publisherSigning publisher of the parent process image: the quick signed/unsigned sanity check on a suspicious chain.
src.process.userThe user context the source process ran as. Pair it with the process name to separate service activity from a real interactive user.
src.process.storyline.idThe Storyline identifier: SentinelOne's correlation key that ties every related process, file, thread and network event together. Copy it out of a hit and query on it to get the whole incident in one shot.
tgt.process.nameThe TARGET process image name: on a Process Creation event, the process that was created.
tgt.process.cmdlineCommand line of the target process. The field to aggregate when you want every distinct way a binary was invoked across the estate.
tgt.process.displayNameThe binary's file description string: "Lists the current running tasks" for tasklist.exe. Catches a renamed LOLBin that a name-based filter would miss.
tgt.process.publisherSigning publisher of the target process image.
tgt.file.pathFull path of the file the event acted on. Remember to cover both path separators when a hunt spans Windows and Unix endpoints.
tgt.file.sha1SHA-1 of the target file. The field SentinelOne publishes its own IOC sweeps against, using `in ( ... )`.
tgt.file.sizeSize of the target file in bytes. A size floor is a cheap way to cut a broad filename hunt down to plausible payloads.
src.ip.address / dst.ip.addressSource and destination IP of a network event. Group by the destination to map where a host has been reaching out to.
src.port.number / dst.port.numberSource and destination port. A specific port pair is often the cheapest first filter for an agent or C2 you already know the shape of.
| group name = func() by fieldAggregates records, grouping by one or more fields and computing statistics for each group. Comma-separate several aggregates, and several `by` keys.
count()Counts records in the group.
count(<condition>)Conditional count: counts only the records satisfying a predicate, so you can put a total and a subset side by side in one pass.
estimate_distinct(field)Approximate distinct count over the group. The cardinality signal you threshold on when hunting for spray or enumeration behavior.
sum() / min() / max()The standard numeric aggregates over a group. SentinelOne documents `percentile()` alongside them; no published example of its argument form was available, so none is invented here.
array_agg_distinct(field)Collapses every DISTINCT value in the group into one array cell. This is what turns "1,400 process events on this host" into one readable row listing what actually ran.
timebucket(field, "interval")Rounds a timestamp down to an interval. Assign it back over `event.time` in a `let`, then group by it, and you have a per-interval timeline.
array_to_string(array, sep)Renders an aggregated array back into a single readable string with a separator. The step that makes an `array_agg_distinct()` column legible in an exported report.
by field = <expression>The `by` key can be a computed expression, including a constant. A static key (`by key = 1`) collapses everything into one group: the trick SentinelOne publishes for computing a percentage-of-total.
| columns a, b, cChooses which columns appear in the output table, in the order given.
| columns name = <expression>Defines a new column inline while selecting, including a ternary, which is how you bucket a numeric value into a label.
| let name = <expression>Defines one or more new fields on the table. Later stages (`columns`, `filter`, `sort`) can then refer to them by name.
+ - * / %Arithmetic operators, plus negation. Available anywhere an expression is: in `let`, in `columns`, and inside a `filter`.
(cond) ? a : bTernary conditional. Chain them for multi-way classification: SentinelOne's own example nests one inside the false branch of another.
format("%s %s", a, b)printf-style string formatting: the way to build one composite field out of several columns before grouping on it.
| parse "regex" from fieldExtracts new columns inline using a regular expression with named captures, reading from the named field. The captured names become fields the next stage can group on.
| join a = (...), b = (...) on keyRuns two or more named subqueries and merges them side by side on a shared key, keeping only records that match. Each subquery is a full query in its own right, pipes included.
alias.fieldAfter a join, reference a column from a specific side by its subquery alias. This is how you compute an elapsed time between two event types.
| union (...), (...)Runs two or more subqueries and stacks their results as ROWS rather than columns: the way to append a synthetic "all hosts" total row underneath a per-host breakdown.
join ... by key = "1"Joining on a statically-assigned constant key pairs every row against a single aggregate row: the documented SentinelOne pattern for percentage-of-total and rate calculations.

Related

All references