ATT&CK guide
Threat hunting in a 72-hour window: how to find what no rule caught
A rule finds what you thought of. Hunting finds what you did not. The difference is a person with a hypothesis and enough history to test it.
For the owner
Most organizations own a large pile of alerts and no way to use them. The alerts cover the attacks somebody anticipated. What they cannot cover is the attack nobody thought of — the one that used a tool in an unusual place, or stole a file that was not obviously worth stealing.
Hunting is how you close that gap, and it is not a tool you buy. It is a person, a hypothesis, and a question that the system's own history can answer. The person is the scarce part. The rest is discipline.
For a business owner, hunting is worth understanding for one reason: it is the only activity that finds the compromises your alerting never mentioned. If your organization has never done any, the honest statement about its security posture is that it knows what it has been told and nothing else. That is not a criticism of the tooling. It is a description of what alerting is.
Two questions tell you whether hunting is happening at all:
- When did someone last look for something they were not looking for? A number, and a recent one. Zero is a normal answer for a small business, and it is worth knowing.
- What did the last hunt find? "Nothing" is a legitimate and valuable answer, and it is very different from "we did not look".
The practical constraint for a small organization is not interest, it is capacity. An hour of hunting a week, done consistently, is worth more than a week of triage that is never finished. The habit is what matters.
For the analyst
What hunting is, precisely
Hunting is hypothesis-driven search over collected telemetry. The structure is always the same:
- A hypothesis. "An account that never signs in interactively has been used to run a scheduled task." It has to be falsifiable. "There might be something weird going on" is not a hypothesis; it is a mood.
- A technique. The hypothesis maps onto ATT&CK, which is what makes the hunt repeatable — the next person can run the same hunt, and the one after them can improve it.
- A query. Over the normalized telemetry.
- A decision. Found, not found, or inconclusive. All three are results. "Inconclusive" is the most common and the most useful, because it tells you what data you are missing.
The technique is the part people skip, and it is the part that makes hunting scale. A hunt that is not written down, with the technique named, is a one-off that nobody else can repeat. ATT&CK gives the vocabulary for it: the hunt is "a credential-access hunt" or "a discovery hunt", and every incident that teaches you something new can be folded back into a named hunt.
What to hunt, and why these
Accounts that do not behave like accounts. The highest-value hunt in most environments, and it needs no exotic telemetry. T1078 is the biggest technique family in the corpus, and the reason is that a valid credential generates no malware signature. What it does generate is a pattern, and patterns are what queries are for.
The hunts that pay:
- Accounts whose sign-in source address never appears elsewhere in the window
- Accounts that authenticate from two countries in one hour
- Service accounts that produce interactive process events
- Accounts whose activity begins at a time that does not match the schedule
Processes that should not exist. T1059 and its sub-techniques cover the interpreters — PowerShell, Python, WMI — that are the delivery mechanism for most intrusions. The hunt is not "find PowerShell"; it is "find PowerShell whose parent is not what this host usually runs".
Credential material being read. T1003 is loud in the sense that the telemetry is specific, which makes it a good first hunt for a new team. Reading /etc/shadow, opening LSASS memory, running a credential dumping tool — these leave a shape.
Movement between machines. T1021 and the remote services family. The hunt is about a host that talks to a peer it has no reason to talk to.
Artifacts that do not belong. T1036 (masquerading) and T1070 (indicator removal) are the quiet ones. A renamed utility, a deleted file, a process whose name mimics a legitimate one.
Discovery itself. T1087 and the enumeration family are the tell of an intruder who has just arrived and is mapping the estate. A burst of account enumeration from a workstation, at an unusual hour, is one of the earliest reliable signals there is.
Why the window is the difficulty
A hunt is a query against history, and the amount of history decides what questions you can ask. This is the part worth understanding even if you never run a query yourself.
72 hours covers the live investigation window: enough to catch an intruder who is still present and still moving, and to reconstruct an incident that was noticed late. 365 days covers the questions that arrive late — the insurance questionnaire, the regulator's question eleven months later, the discovery that the credential was stolen in March.
Both matter, and they fail differently. A short window means you cannot answer "was this account compromised last week?". A long window means you cannot answer "what happened at 14:05 on Tuesday?" without waiting, because the cold lake is columnar storage over partitioned Parquet and a query across an hour of a partition is not the same operation as a query across the last hour.
The practical consequence is that an investigation is easiest while the event is recent and gets harder with every day that passes. That is not a technical accident; it is the argument for collecting everything up front, because the collection decision is the only one you can make before the incident.
Writing a hunt that works
The mechanics are simpler than people expect, because the telemetry is already normalized onto one set of columns.
-- Hunt: an account signing in from an address never seen in the window.
SELECT user_name, src_ip, count(*) AS signins
FROM events_recent
WHERE event_type = 'authentication'
AND severity IN ('high', 'critical')
GROUP BY user_name, src_ip
ORDER BY signins DESC
The columns are the same whatever the source, so the same query shape works against Windows events, Linux audit records and cloud audit trails. That is the practical payoff of normalization: an analyst writes one query, not three per-platform dialects.
Four habits make the difference between a hunt and a query:
Start from the entity, not the technique. "Show me everything account jdoe did" beats "show me executions" every time. The entity is the thread that connects the stages of an intrusion.
Ask for the exception. The interesting rows are the ones that differ from the norm: an account that usually signs in from one address and today used three; a host that usually spawns one parent and today spawned another. Absolute thresholds produce volume; relative ones produce findings.
Write the hunt down. The next analyst needs the query, the technique, the date it ran, and what it found. A hunt that is not written down is a hunch that will not be repeated.
Turn a finding into a rule. The highest-value output of a hunt is a detection. A hunt that finds the behaviour once and leaves it at that has found it once.
Where hunting usually fails
No data. The most common failure by far, and it is a collection problem rather than a hunting problem. A hunt for network telemetry in an environment that only collects endpoint telemetry returns nothing, and returns nothing confidently.
Hunting the wrong layer. Chasing a technique in telemetry that cannot carry it — looking for credential dumping in a firewall log.
Hunting without a decision. A hunt that ends with a list of interesting rows and no next step does not improve anything. Every hunt ends with found, not found, or a documented gap.
Never repeating. A hunt done once is an incident. A hunt done on a schedule is a programme.
The honest summary
Hunting is a small, repeatable, written-down activity that runs against history deep enough to answer the question. Everything else — the framework, the vocabulary, the clever queries — is downstream of having those three things.
Where DetectMonkey fits
DetectMonkey gives a hunting team the thing hunting needs most and that small environments almost never have: history that is queryable while it matters. The last 72 hours of telemetry stay immediately queryable for investigation, and the cold lake keeps 365 days for the questions that arrive late — the insurance questionnaire, the regulator's question eleven months after the fact.
The same normalized columns serve both: user_name, host_id, process_name, parent_process, command_line, src_ip, dst_ip, event_type, severity — the same shape whether the event came from a Windows log, an auditd record or a cloud audit trail, so one query works across all of them instead of three platform dialects.
The platform detects and alerts, and it does not isolate, quarantine, block or remediate anything on your systems — a hunt that finds something hands your team the evidence and the decision. Telemetry is processed and stored on private servers operated by Codein in New Brunswick, Canada, never in a public cloud, and analysts work in English and French.
Early access is 90 days at no charge, for up to 100 seats, founder-led onboarding, and no card required.
See it on your own telemetry
Early access is 90 days at no charge, for up to 100 seats, founder-led onboarding, no card required.