SC-200 domain - 22% of the exam

Perform Threat Hunting

Perform Threat Hunting is 22% of the SC-200 exam. These are the objectives it covers, each with practice questions, with every answer explained.

The domain in numbers

60
Practice questions
4
Objectives
30
Medium
30
Hard

Where people go wrong

  • Reading the wrong threat analytics tab

    The wrong answers hand a question to the neighbouring tab: Exposure and mitigations or the Analyst report for the list of affected devices, Impacted assets for devices still exposed, and Impacted assets or the Analyst report for a link to opened cases. Each tab answers one question. Impacted assets lists devices and identities already affected, Exposure and mitigations shows devices still exposed, Related incidents links to incidents already raised, and the Analyst report is the narrative write-up.

    See it in a sample question
  • Treating DeviceEvents as the catch-all table

    DeviceEvents appears as a wrong option because it holds assorted events such as ASR rule hits and protection toggles. The correct table is a dedicated one: DeviceProcessEvents for process creation with parent command lines, DeviceFileEvents for file creation, modification and rename with the hash, DeviceNetworkEvents for each connection with remote IP, port and URL, and AlertEvidence for the entities tied to an alert.

    See it in a sample question
  • Picking the wrong join flavour

    The wrong options attach a real join kind to the wrong requirement. leftanti keeps only left rows with no match on the right, which finds unpatched hosts. leftouter keeps every left row and fills right columns with nulls, which suits attaching a threat label while keeping clean sign-ins. inner returns only matching pairs with columns from both sides. leftsemi keeps matching left rows with left columns only, so right-side metadata is lost.

    See it in a sample question
  • Swapping MSTICPy components

    Each wrong option is a genuine MSTICPy component used for a different job. QueryProvider connects to the workspace and runs KQL, returning a pandas DataFrame. TILookup submits indicators to external threat intelligence providers for verdicts and severity. A GeoLite lookup resolves IP addresses to country and city. init_notebook prepares the whole environment in one call, while MpConfigEdit only edits the configuration file.

    See it in a sample question
  • Confusing summary rules with KQL jobs

    Both features run KQL and write to a table, so each is offered for the other's job. A summary rule aggregates a verbose table on a schedule into a separate summarised table, which suits recurring counts and can feed a scheduled analytics rule. A KQL job runs a query as a batch over data lake tier data and writes the results to a new table. A search job targets analytics-tier workspace tables instead.

    See it in a sample question

Objectives in this domain

What to study

The official documents this domain's practice questions cite most.

Sample questions from this domain

Free samplePerform Threat Huntingmedium

A security operations team wants ongoing assurance that their estate is protected against an emerging supply-chain attack documented in a Microsoft Defender XDR threat analytics report. Rather than the list of already affected machines, they need to see which devices are misconfigured or unpatched in ways that leave them exposed to the report's techniques. Which part of the threat analytics report answers this exposure question?

  • AThe Exposure and mitigations section, because it reports the status of recommended configurations and shows which devices remain exposed because the mitigations are not yet applied. Correct
  • BThe Impacted assets section, because it inventories the devices and identities the threat has already reached, which is the same data set that reveals which machines remain exposed to the techniques.
  • CThe Related incidents section, because each incident bundles the alerts for the campaign, so reviewing them shows which devices are exposed to the techniques described in the report.
  • DThe Analyst report tab, because its detailed description of attacker behaviour lets the team infer which devices in the estate are misconfigured and therefore exposed to the threat.
Use the exposure and mitigations view of a threat analytics report to find devices still exposed because recommended configurations are missing. Threat analytics distinguishes assets already impacted from assets still exposed. The exposure and mitigations section measures the estate against the configurations recommended for that threat and highlights devices where the mitigations are not in place. This proactive coverage gap is separate from the impacted assets list and is what drives hardening before a device is compromised.

Why A is correct: The exposure and mitigations view tracks the recommended security configurations for the threat and flags the devices that are still exposed because those mitigations are missing, which is exactly the proactive hardening signal the team needs.

Why B is wrong: Impacted assets lists devices and identities already affected by the threat, which is valuable but is a different question from configuration exposure; a machine can be exposed yet not yet impacted, so this does not answer the gap.

Why C is wrong: Related incidents groups alerts that have already fired into incidents, which reflects detected activity rather than latent configuration weakness, so it cannot tell the team which unaffected devices are still exposed.

Why D is wrong: The Analyst report tab supplies generic narrative on the campaign and is identical for every tenant; it offers no tenant-specific configuration assessment, so it cannot identify the exposed devices.

Free samplePerform Threat Huntinghard

During an Advanced Hunting investigation in Microsoft Defender XDR, you must reconstruct a suspected malware execution chain on a single workstation by listing every process that was launched, together with its full command line and its initiating parent process, so that you can trace the lineage from the original loader. Which table should the Kusto Query Language (KQL) query target to obtain the parent and child process command lines directly?

// Goal: child process, its command line, and its parent process command line
<Table>
| where DeviceName == "FIN-WKS-014"
| project Timestamp, FileName, ProcessCommandLine, InitiatingProcessFileName, InitiatingProcessCommandLine
  • ADeviceProcessEvents, because it records one row per process creation with the child FileName and ProcessCommandLine alongside the InitiatingProcess fields for the parent, giving the full lineage on the device. Correct
  • BDeviceEvents, because it is the general endpoint event table and therefore records every action a device takes, including each process that is created along with its parent and child command lines.
  • CDeviceImageLoadEvents, because the loader and every subsequently launched binary must be mapped into memory, so the image load records reveal the parent and child process command lines for the chain.
  • DDeviceFileEvents, because the loader writes the child executables to disk before running them, so the file create and modify records carry the process command lines for each stage of the chain.
Use DeviceProcessEvents in Advanced Hunting for process creation telemetry, as it carries both the child and initiating-parent command lines. DeviceProcessEvents is the schema table dedicated to process creation in Microsoft Defender for Endpoint telemetry. Each row pairs the spawned process FileName and ProcessCommandLine with the InitiatingProcessFileName and InitiatingProcessCommandLine of its parent, which lets an analyst pivot up and down the chain from a single table rather than joining across general event tables.

Why A is correct: DeviceProcessEvents is purpose-built for process creation telemetry, exposing the spawned process command line and the InitiatingProcess parent fields in the same row, which is exactly what is needed to walk a malware execution chain on one host.

Why B is wrong: DeviceEvents is a catch-all table for miscellaneous security and audit events such as protection toggles and ASR triggers; it does not provide a dedicated row per process creation with both the child and initiating-parent command lines, so the lineage reconstruction would be incomplete.

Why C is wrong: DeviceImageLoadEvents tracks DLL and module loads into a process, not process creation, so it lacks a per-spawn child command line and is the wrong surface for reconstructing parent-to-child execution lineage.

Why D is wrong: DeviceFileEvents captures file create, modify, rename, and delete activity, which is useful for tracking dropped payloads, but it does not record process command lines or parent-child execution, so it cannot reconstruct the run chain on its own.

Free samplePerform Threat Huntinghard

You have two result sets in an Advanced Hunting query: a left set listing every device that ran a suspicious PowerShell command, and a right set listing devices that already have the relevant security update installed. You want to return only the devices from the left set that have NO matching row in the right set, so you can target unpatched hosts. Which join flavour completes the query correctly?

DeviceProcessEvents
| where ProcessCommandLine has "DownloadString"
| distinct DeviceId
| join kind=<Kind> (
    DeviceTvmSoftwareVulnerabilities
    | where CveId == "CVE-2024-0001"
    | distinct DeviceId
) on DeviceId
  • Akind=leftsemi, which returns only the rows from the left set whose DeviceId has no matching row on the right, yielding the suspicious devices that are missing the relevant update.
  • Bkind=inner, which returns only the rows from the left set whose DeviceId has no matching row on the right, yielding the suspicious devices that are missing the relevant update.
  • Ckind=leftouter, which returns only the rows from the left set whose DeviceId has no matching row on the right, yielding the suspicious devices that are missing the relevant update.
  • Dkind=leftanti, which returns only the rows from the left set whose DeviceId has no matching row on the right, yielding the suspicious devices that are missing the relevant update. Correct
Select join kind=leftanti to return left-side rows that have no match on the right, isolating an absence such as unpatched devices. In Kusto Query Language, leftanti is the anti-join that returns only the left-hand rows with no matching key on the right and projects just the left columns. This is the correct construct for finding records present in one set but absent from another, such as devices that executed a suspicious command yet are missing from a patched or known set, whereas leftsemi keeps matches and leftouter and inner both include matched rows.

Why A is wrong: A leftsemi join also emits only left-side columns, but it keeps the rows that DO have a match on the right, so it returns the opposite population and would list devices that are present in the right set rather than absent from it.

Why B is wrong: An inner join returns only rows that match on both sides and merges columns from each, so it produces the intersection rather than the unmatched left rows, which is the inverse of the unpatched-host requirement.

Why C is wrong: A leftouter join keeps every left row and fills right columns with nulls when there is no match, so it returns matched and unmatched rows together and would require an extra null filter to approximate, making it not the direct answer.

Why D is correct: A leftanti join keeps left-side rows that fail to match any right-side row and emits only the left columns, which precisely isolates the devices that ran the command yet do not appear in the patched or vulnerable set as intended.

Free samplePerform Threat Huntinghard

A hunter has pulled several thousand rows of failed sign-in events into a notebook as a pandas DataFrame and now wants to enrich the distinct source IP addresses by checking each one against multiple configured external threat intelligence providers in a single call, returning verdicts and severity for any known-malicious indicators. Which MSTICPy capability is purpose-built for this enrichment step?

  • AThe QueryProvider connect method against Microsoft Sentinel, which authenticates to the workspace and submits a KQL lookup so the source IP addresses are checked against the configured external threat intelligence providers in one call.
  • BThe MpConfigEdit settings editor, which reads the provider keys from msticpyconfig.yaml and submits the source IP addresses to the configured external threat intelligence providers, returning their verdicts and severity for known-malicious indicators.
  • CThe MSTICPy entity graph visualisation, which plots the source IP addresses as nodes and queries the configured external threat intelligence providers for each node, labelling any known-malicious indicators with their verdicts and severity.
  • DThe TILookup provider with lookup_iocs over the DataFrame, which submits the distinct source IP addresses to the multiple configured external threat intelligence providers at once and returns the verdicts and severity for any matches. Correct
Use the MSTICPy TILookup provider, such as lookup_iocs, to enrich a set of indicators against multiple configured external threat intelligence providers at once. MSTICPy provides TILookup as a unified front end to many external threat intelligence services. Its lookup_iocs method takes a list or DataFrame column of indicators, fans the request out to every configured provider, and returns a combined result with each provider verdict and severity, so a hunter can score thousands of observables in bulk. QueryProvider only queries workspace data, MpConfigEdit only edits configuration, and the entity graph only visualises, so none of them perform the external TI lookups.

Why A is wrong: QueryProvider connects to the Sentinel workspace and runs KQL over ingested data, which is how the rows were retrieved, but it does not call external threat intelligence provider APIs, so it cannot return third-party verdicts for the IP addresses.

Why B is wrong: MpConfigEdit only edits the configuration file that stores provider API keys and workspace details, so it prepares MSTICPy for use but performs no lookups and returns no threat intelligence verdicts itself.

Why C is wrong: The entity graph visualises relationships between observables for investigation, which aids interpretation, but it is a display component that does not itself call external threat intelligence providers or return their verdicts and severity.

Why D is correct: TILookup is the MSTICPy threat intelligence interface that queries one or many configured external providers for a list of indicators, and lookup_iocs accepts a DataFrame of observables and returns the per-provider verdicts and severity, which is exactly the bulk enrichment needed.

Free samplePerform Threat Huntingmedium

A Microsoft Sentinel workspace ingests a very high-volume DNS log into a table on the Auxiliary (basic) table plan to keep storage cheap. Hunters frequently need an hourly count of queries per domain, and the SOC also wants a scheduled analytics rule to alert when any domain exceeds a threshold. A scheduled analytics rule cannot be based on the Auxiliary-plan table directly. With the least administrative effort, how should the team make the aggregated counts both cheaply queryable and usable by a scheduled analytics rule?

  • ACreate a summary rule that aggregates the DNS table into a separate summarised table on the Analytics plan on a schedule, then point the scheduled analytics rule at that summarised table. Correct
  • BRun a one-time KQL job in the data lake that reads the DNS table and writes the per-domain counts into a results table for the hunters to query.
  • CChange the DNS table from the Auxiliary (basic) plan to the Analytics plan so a scheduled analytics rule can query the raw records and aggregate them at run time.
  • DBuild a saved hunting query that performs the aggregation and rely on the Hunting blade results count so analysts can watch the per-domain totals climb over time.
Summary rules aggregate high-volume or Auxiliary-plan logs into a compact Analytics-plan table on a schedule, making the results cheaply queryable and usable by scheduled analytics rules. Auxiliary (basic) plan tables cannot back a scheduled analytics rule, and querying their raw volume is costly. A summary rule runs the aggregation on a schedule and lands the compact results in an Analytics-plan table, which a scheduled analytics rule can then query, satisfying both the cost and the alerting requirement.

Why A is correct: A summary rule pre-computes the hourly per-domain counts into a compact Analytics-plan table on a schedule, which is cheap to query and is a valid source for a scheduled analytics rule.

Why B is wrong: A data lake KQL job runs as a single ad hoc batch, so it produces a one-off result set rather than a continuously refreshed table that a scheduled analytics rule can alert on.

Why C is wrong: Moving the table to the Analytics plan would let a rule query it, but it raises ingestion cost on a very high-volume table, which defeats the requirement to keep storage cheap.

Why D is wrong: A saved hunting query runs only when invoked and writes nothing to a table, so it cannot feed a scheduled analytics rule or store the counts for cheap repeated querying.

Other domains in this exam

See also the SC-200 cert hub, the study guide, and the cheat sheet.

Examworthy is not affiliated with or endorsed by Microsoft. Original, blueprint-aligned practice material only.