skip to content

Your EDR vendor flags unfamiliar console API use; how do you separate your SOC's commands from an intruder's?

level: seniorimportance: nice to knowfreq 31%

answer

  1. export the trail before analysing it
  2. sort by principal, then session
  3. every action should tie to a case
  4. unreconciled is a lead, not a verdict
  5. submitted is not executed

basics

~20 s

Reconcile the console's own per-command history against your case records and roster: every legitimate action should tie to an open case and a rostered operator. Then sort by principal, session and source address, and treat anything unreconciled as a lead to test, not a conclusion.

solid answer

~50 s

Start with the platform's administrative audit trail, and export it immediately — in a vendor-hosted console it is the only copy and its retention is not yours. Build a timeline of principals: operator authentications, role grants, API-client creation, and the per-command response history, each with session and source address. Then reconcile: our commands should map to an open case, a rostered analyst and a plausible source address, and the SOC's own case notes should reference them. What remains — an API client created outside change control, a session from an unfamiliar address, commands with no case behind them — is a candidate for the intruder's activity, and each one is a hypothesis you test rather than a verdict. Pair the console history with endpoint telemetry to see what actually executed and whether it succeeded, since a submitted command is not a completed one. Expect an ambiguous middle, and say what would resolve it.

code

text · 5 lines
text
time=2026-03-04T09:12:41Z principal=a.okafor@corp principal_type=user session=S-8841 src=203.0.113.20 action=rtr.session.start target=WKS-2291 case=IR-4471
time=2026-03-04T09:13:02Z principal=a.okafor@corp session=S-8841 action=rtr.get_file target=WKS-2291 args="C:\\Users\\public\\svc.dat" result=ok case=IR-4471
...
time=2026-03-01T02:44:10Z principal=a.okafor@corp session=S-8102 src=198.51.100.77 action=apiclient.create client=ci-backup-sync roles=[responder.execute] result=ok case=-
time=2026-03-04T09:47:55Z principal=ci-backup-sync principal_type=api_client src=198.51.100.77 action=rtr.run_script target=<host_group:ALL> result=ok case=-

go deeper

for a junior

Know that the security console keeps its own record of who ran which response command, and that it is separate from the alerts and from what the endpoint agent logs locally.

for a middle

Explain the reconciliation: console command history against case records, roster and source addresses, and why endpoint telemetry is needed to confirm a command actually ran.

for a senior

Show the operating judgment — export before analysis, hypotheses rather than verdicts, eviction of API clients and tokens as a separate list, and an explicit statement of what remains ambiguous.

for a principal

Be ready to say what you would change so this reconstruction is possible next time, and what you accept you cannot prove given a vendor-hosted platform you do not control.

## The situation The discovery route here is worth naming, because it is common and it changes your starting position: the platform vendor's own abuse team noticed anomalous console API use and told you. Nothing fired internally, so you begin with no case, no alert, and a period of unknown length in which someone with response privilege may have been acting on your estate — using the same verbs your analysts use, producing the same host-side artefacts. Your job as the examiner is to produce a defensible split of console activity into *ours* and *not ours*, and to be honest about the part that cannot be split. ## Preserve before you analyse In a fully vendor-hosted console the administrative audit trail has no copy inside your estate, its retention window is set by the vendor, and console administrator rights can create and delete objects within the platform. So the first action is an export of the full window — operator authentications, role and permission grants, API-client lifecycle events, and per-command response history — into storage you control, along with a note of who exported it, when, and by what method. That note is what lets the reconstruction be defended later; without it your evidence is a spreadsheet of uncertain provenance. ## Build the principal timeline Sort every entry by the principal that submitted it, then within a principal by session. You are looking at four object types: - **Authentications** — which operators logged in, from what addresses, with what authentication method, and whether any session outlived its usual pattern. - **Grants** — role changes, especially any principal that gained an execute-everywhere role during the window. - **API clients** — creation, the role attached, and which principal created them. This is the persistence to look for: a new client with the same execute role survives a password reset and is easy to overlook because it looks like an integration. - **Commands** — the per-command history: verb, arguments, target, outcome. ## Reconcile against your own records This is the step that does the actual separating, and it only works if you set it up beforehand. For each command ask three things: **is there a case it belongs to**, **was the named operator on shift and would they have been working that case**, and **is the source address consistent with how that operator connects**. Legitimate response work usually reconciles on all three, and the SOC's own case notes should mention the collection or containment at roughly the right time. What fails to reconcile is your candidate set. Typical shapes: - Commands submitted by an API client that no integration owner claims. - A named operator's session from an address they have never used, at an hour they were not rostered. - Verbs your team does not use — mass collection across hundreds of hosts, exclusion changes, sensor removal. - Commands with no case and no note. Call these hypotheses. A rostered analyst working an urgent case from a hotel network fails two of the three tests and is entirely innocent; the reconciliation narrows the field, it does not decide. ## Corroborate on the host Console history records what was **submitted by an authenticated principal**. It does not prove the command ran, that it ran to completion, or what it produced. So pair each candidate command with the endpoint's own process telemetry for that host and time: the effects appear as children of the agent process, and there you can see the actual command line, exit behaviour, and any files written or connections made. Two useful outcomes come out of this pairing — you learn what the intruder achieved rather than what they tried, and you sometimes find agent-child activity with **no** matching console entry, which points at a different execution path and changes the scope of the investigation. ## Eviction is a separate list Separating past activity is not removing present access, and the two get conflated under pressure. Removing an operator's password does not revoke an active console session, an issued bearer token, or an API client created during the window. Eviction here means enumerating and revoking the platform's own objects — sessions, tokens, API clients, role grants made in the window — and checking the identity provider for scopes granted to the platform's service principal, because an integration authorised to read mail or directory data is access that outlives the console credential entirely. ## What you say about the ambiguous middle Some commands will reconcile weakly: the right operator, the right period, no case reference because the team does not use one consistently. Say so, plainly, and say what would have resolved it — a case identifier on every command, individual federated operator identities, an exported trail. An examiner who presents a clean binary split they cannot support is far weaker than one who states the confident set, the ambiguous set, and the specific evidence that would move entries between them.

  • In the excerpt, which single entry would you chase first, and why?
    The API-client creation at 02:44 attributed to an operator, from an address that differs from their normal console sessions, with an execute role and no case behind it. It is both the likely persistence mechanism and the object that explains the later fleet-wide command, and it survives a password reset.
  • What stops you concluding the operator created that client themselves?
    Nothing yet — a console entry proves a principal was authenticated, not that the named human acted. You test it: ask the operator, check the roster and their usual source addresses, look for the authentication that opened that session and its method, and see whether any change record or integration owner claims the client.
  • You find agent child processes on a host with no matching console command. What does that mean?
    Either your console export is incomplete for that window, or the execution reached the host by another path entirely — a different management tool, a local process misattributed to the agent, or activity predating the exported range. It widens scope, so resolve it before writing conclusions about what the console did.

saying these in an interview costs you the question

  • Analyses in the console instead of exporting first
  • Treats an unreconciled command as proof of intrusion
  • Assumes a submitted command actually executed
  • Stops at the operator password reset
  • Presents a clean split with no ambiguous set

context