In this section

0.11 Threat Intelligence Foundations

Module 0

Introduction

Threat intelligence arrives as prose: vendor reports, sharing-group notes, forum posts, write-ups of incidents at other organizations. Before it can protect anything, the useful parts have to be pulled out, judged and put into a form tools can act on.

Module 11 builds that pipeline with a model doing the extraction, and its central risk is a model that produces an indicator the report never contained, which then reaches a blocklist. This lesson lays the foundation with code that has no model in it: what an indicator is, what it is worth, how reports hide and mangle them, and the standard format they are shared in.

An assistant writes an extractor and a STIX packager for one campaign note, and the first draft fails the check in an instructive way. The lesson follows the failure to its cause, fixes it, measures one shortcut, and ends with what the extractor cannot see at all: the paragraph that describes how the attackers work.

Procedure: indicators out of a reportThe report textRefang: hxxp to http,[.] to a dotFind IPv4, domains, URLs,SHA-256 of 64 hexPrivate: 10/8, 172.16/12and 192.168/16 only.Private, or anallowlisted domain?yesLeave it outnoLower case; sort;remove duplicatesOne STIX indicator pervalue, with its patternBundle; parse itwith stix2stepdecisionnotestops or failsbranch ends

A report defangs its indicators and mentions things that are not indicators; extraction refangs, filters, then emits one STIX 2.1 indicator per value.

1

A Report as It Arrives

Defanged, mixed and partly broken

Here is the campaign note the lab supplies.

Visual Studio Codereport.txt - sec410-lab
report.txt
lab › data › foundations › report.txt
1TLP:GREEN23Campaign note 2026-11-12: invoice-themed loader against finance teams45Summary. Since 4 November we have seen emails with an invoice attachment that drops a loader. The6loader fetches a second stage from hxxps://cdn-invoice-portal[.]com/assets/update.bin and beacons7to 198.51.100.23 over HTTPS every 60 seconds. A fallback beacon uses invoice-portal-cdn[.]net.89The lure links to a fake sign-in page at hxxp://login-micros0ft[.]com/owa that imitates10microsoft.com; do not block microsoft.com itself. Victims' internal hosts in the 10.20.0.0/16 range,11for example 10.20.4.17, made the first connections.1213File hashes (SHA-256):14  loader     0debc51a59c409dcbfaf7dc9472bf345fefd190b54c533684ad0b2204ae931ce15  stage two  9ce220a8d9203f4106fb1009d5a4b480336842fd297fd7d882a2084e20bf98b716  (a third sample, 9ce220a8d9203f4106fb1009d5a4b480336842fd297fd7d882a2084e20bf98b, was truncated in our tooling and could not be recovered)1718Infrastructure also seen: 203.0.113.45, which hosted the fake sign-in page until 9 November.1920The operators' technique matters more than this infrastructure, which will change: an Office21document starts PowerShell with an encoded command, the PowerShell fetches the second stage, and22the second stage persists as a scheduled task named UpdateCheck.
mainPlain TextUTF-8Ln 1, Col 1
A campaign note as it arrives: defanged, mixed with things that are not indicators, one value broken.

The note is labeled TLP:GREEN. The Traffic Light Protocol, maintained by FIRST and in its version 2.0 since August 2022, tells recipients how far they may share information: TLP:GREEN may be shared within the community but not through publicly accessible channels. The label applies to everything extracted from the note, which matters the moment indicators leave it.

The other labels set the boundary tighter or looser. TLP:RED is for the named recipients only, with no further disclosure. TLP:AMBER may be shared within the recipient's organization and its clients on a need-to-know basis, and TLP:AMBER+STRICT within the organization only.

TLP:CLEAR has no limit at all. A pipeline that extracts indicators from many sources has to carry each source's label with every value it produces, because a blocklist built from mixed sources is only as shareable as its most restricted entry.

The indicators are defanged: hxxps for https and [.] for a dot, so that nobody who reads the note clicks a live link and no tool turns it into one. A brand is named that must not be blocked, because the fake sign-in page imitates it.

The victim's own internal addresses appear, because they made the first connections. And one hash is broken, 63 characters instead of 64, because the reporter's tooling truncated it. A good extractor finds every real indicator and none of these.

Defanging is a courtesy to readers and a hazard for tools. It stops a mail client turning an attacker's address into a link and stops an analyst clicking it by accident, and it means the indicators in a report are, as written, not indicators at all.

Any pipeline that consumes reports has to undo the defanging before searching, and has to redo it whenever it displays values to people, so that the tool never turns a report into a page of live links.

Values that look like indicators and must not be treated as them are common in real reports. Victims' addresses appear because they show the timeline. Sinkholes, addresses that researchers have taken over to observe infected machines, appear because infected machines connect to them.

Shared cloud and content delivery addresses appear because attackers rent from the same providers as everyone else. A report that says do not block something is unusually helpful; most leave the reader to work it out.

2

What an Indicator Is Worth

The Pyramid of Pain

David Bianco's Pyramid of Pain, published in 2013 and extended in 2014, orders indicators by the cost to an attacker when defenders act on them. At the bottom are hash values, which change when a single byte of a file changes. Then IP addresses, replaced as easily as renting another server, and domain names, which take a little more effort.

Above them are network and host artifacts, the traces an operation leaves, then the tools the attackers use, and at the top their tactics, techniques and procedures: how they operate.

The note's own last paragraph makes the same point in its own words: the technique matters more than the infrastructure, which will change. Here is the note's content sorted that way.

Visual Studio Codepyramid.md - sec410-lab
pyramid.md
pyramid.md
1# The note's contents, by what acting on them costs the attacker23| level                      | from the note                           | to change it    |4|----------------------------|-----------------------------------------|-----------------|5| hash values                | loader and stage two SHA-256            | rebuild a file  |6| IP addresses               | 198.51.100.23, 203.0.113.45             | rent a server   |7| domain names               | cdn-invoice-portal.com and two others   | register one    |8| network and host artifacts | a 60-second beacon; task UpdateCheck    | change the code |9| tools                      | the invoice loader                      | write a new one |10| TTPs                       | Office starts encoded PowerShell        | change methods  |
mainMarkdownUTF-8Ln 1, Col 1
The same note, read for value rather than for extraction.

Everything this lesson's extractor finds sits on the bottom three levels. Those indicators are still worth blocking, for as long as they last, and they are the easiest to extract, share and act on automatically. They also go stale. A domain the attackers abandon is re-registered by someone else; an address is reassigned to a new tenant of the same provider.

Indicators need an expiry, which STIX expresses with a valid-until time, and a blocklist that keeps every indicator forever slowly fills with values that now belong to someone innocent. The technique paragraph describes the top of the pyramid, and no pattern-matching extractor will find anything in it, which is section 8's subject and much of Module 11's.

The top of the pyramid is where the hunting of Module 1 lives. An Office application starting encoded PowerShell is the behavior hunt H1 looked for, and a detection written for it fires whatever domain, address or file hash the next campaign uses.

Intelligence that names a technique is the input to a hunt or a detection rule; intelligence that names a domain is the input to a blocklist. Both are worth having, and they go to different places in a security team.

STIX 2.1, the OASIS standard for sharing threat intelligence, reflects the same distinction. It separates domain objects, such as an indicator, a malware family or an attack pattern, from cyber-observable objects, which in the standard's words record facts about what happened on a network or host without capturing the who, when or why.

An indicator wraps a pattern that detects something, and a relationship of type indicates links it to the malware or campaign it detects.

3

The Contract

Extract exactly, package correctly

The exercise file states what the extractor and packager must do.

Visual Studio Codeintel.py - sec410-lab
intel.py
lab › foundations › intel.py
⋯ 8 lines folded910    extract(text, allow=ALLOW) -> {'ipv4': [...], 'domain': [...], 'url': [...], 'sha256': [...]}11        Refang first (hxxp to http, hxxps to https, [.] to .). Then find IPv4 addresses, domains, http and https URLs,12        and SHA-256 hashes (exactly 64 hex characters, not part of a longer run). Leave out private addresses13        (10/8, 172.16/12, 192.168/16) and any domain in allow. A domain inside a URL also counts as a domain. Each list is14        sorted with no duplicates; values are lower case.⋯ 19 lines folded
mainPythonUTF-8Ln 1, Col 1
The contract: extract exactly the indicators, and package them as STIX.

The contract is written for this exercise and is narrower than a production extractor needs to be, which keeps the exercise to two functions and the check exact.

The contract makes each trap explicit: refang first, leave out the three private ranges, leave out allowed domains, accept only complete hashes, and count a URL's host as a domain too. The packager's patterns follow the STIX patterning language, one per indicator type.

Run the check against the file as shipped.

$ python3 -m lab check f11
f11  0.11 Threat Intelligence Foundations: lab/foundations/intel.py
FAIL  the functions are written
      lesson 0.11: write extract
FAIL

Once extraction exists, the check compares each kind of indicator against a list prepared by hand from the report, and reports what was missed and what was extra, separately.

It then builds a bundle, confirms one indicator per value with the right patterns, and, if the stix2 library is installed, asks it to parse the bundle, so the output is checked by an implementation of the standard rather than by the check's own idea of it.

4

Session: The Brief

Both errors are defects

The brief points at the contract and the report, and says where the output goes.

SEC410 lab, lesson 0.112026-11-18
intel.pyPYreport.txtTXT

Write extract() and bundle() in intel.py to the contract in its docstring, standard library only. Whatever this returns goes onto a blocklist, so a false indicator blocks something legitimate and a missed one lets an attacker through: treat both as defects. Don't special-case anything in this particular report.

intel.pyCode · PY · 73 linesDownload
Reply to Claude…Opus 5.5
Recorded unedited in assistant-records/m00/0.11-brief.md

Saying that the output feeds a blocklist sets the stakes in both directions. A missed indicator lets the attacker's infrastructure through; a false one blocks something legitimate, and a blocklist that blocks a widely used service gets switched off.

The last sentence forbids special-casing the report, which keeps the extractor general: an assistant that saw microsoft.com in the report might hard-code an exception for it, which would pass the check and fail on the next report.

The brief deliberately asks the assistant for code, not for the indicators themselves. An assistant asked to read the report and list its indicators would usually do it well, and sometimes would not: it might normalize a lookalike domain to the brand it imitates, or produce a plausible address that is not in the text.

Code written by an assistant can be checked once and then trusted to do the same thing every time; extraction by a model has to be checked every time, which is the problem Module 11 takes on.

Attaching the report to the session is itself a small act of trust. A report is text written by someone else, and like lesson 0.3's documents it could contain instructions addressed to whatever reads it. Threat reports in particular quote attacker material, phishing text, command lines, ransom notes, verbatim.

When an assistant reads a report to help write code, read its draft for anything the report could have asked for; when a model extracts from reports in Module 11, its output is checked against the text for the same reason.

5

The First Draft

And where it failed

The reply was the file. Here is the code below the docstring.

Visual Studio Codeintel.py - sec410-lab
intel.py
lab › foundations › intel.py
24import ipaddress25import re26import uuid2728ALLOW = {'microsoft.com'}2930URL = re.compile(r'https?://[^\s<>"\')\]]+', re.I)31IPV4 = re.compile(r'(?<![\d.])(?:\d{1,3}\.){3}\d{1,3}(?![\d.])')32DOMAIN = re.compile(r'(?<![\w/@.-])((?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z]{2,})(?![\w.-]*[\w-])', re.I)33SHA256 = re.compile(r'(?<![0-9a-f])[0-9a-f]{64}(?![0-9a-f])', re.I)343536def _refang(text):37    return re.sub(r'hxxp', 'http', text, flags=re.I).replace('[.]', '.')383940def _public_ip(value):41    try:42        ip = ipaddress.IPv4Address(value)43    except ValueError:44        return False45    return not ip.is_private and not ip.is_loopback and not ip.is_unspecified464748def extract(text, allow=ALLOW):49    text = _refang(text)50    urls = {u.rstrip('.,;:').lower() for u in URL.findall(text)}51    hosts = {re.match(r'https?://([^/:?#]+)', u).group(1) for u in urls}52    ips = {v for v in IPV4.findall(text) if _public_ip(v)} | {h for h in hosts if _public_ip(h)}53    without_urls = URL.sub(' ', text)54    domains = {d.lower() for d in DOMAIN.findall(without_urls)}55    domains |= {h for h in hosts if not IPV4.fullmatch(h)}56    domains = {d for d in domains if d not in allow and not IPV4.fullmatch(d)}57    urls = {u for u in urls if re.match(r'https?://([^/:?#]+)', u).group(1) not in allow}58    hashes = {h.lower() for h in SHA256.findall(text)}59    return {'ipv4': sorted(ips), 'domain': sorted(domains), 'url': sorted(urls), 'sha256': sorted(hashes)}606162PATTERN = {'ipv4': "[ipv4-addr:value = '{}']", 'domain': "[domain-name:value = '{}']", 'url': "[url:value = '{}']",63           'sha256': "[file:hashes.'SHA-256' = '{}']"}646566def bundle(iocs, now):67    objects = []68    for kind, values in iocs.items():69        for value in values:70            objects.append({'type': 'indicator', 'spec_version': '2.1', 'id': f'indicator--{uuid.uuid4()}',71                            'created': now, 'modified': now, 'valid_from': now, 'pattern_type': 'stix',72                            'pattern': PATTERN[kind].format(value.replace("'", "\\'"))})73    return {'type': 'bundle', 'id': f'bundle--{uuid.uuid4()}', 'objects': objects}
mainPythonUTF-8Ln 1, Col 1
The first draft: refang, find each kind, filter, package.

The draft refangs the text, finds URLs, takes their hosts, finds IPv4 addresses and filters them through a helper, removes URLs from the text before searching for bare domains so that file names inside URL paths are not mistaken for domains, and finds hashes of exactly 64 hex characters.

The domain pattern carries most of the judgment. It refuses a match that follows a slash, an at sign or a dot, so a file name in a path and the domain part of an email address are not taken as domains, and it requires the match to end cleanly.

That is why update.bin, which sits in the URL path, is not reported. Patterns like this are where extractors accumulate special cases over time, and each one should come with a test that shows why it is there.

Run the check against it.

$ cp records/intel-0.11.py lab/foundations/intel.py
$ python3 -m lab check f11 | head -n 3
f11  0.11 Threat Intelligence Foundations: lab/foundations/intel.py
FAIL  ipv4: every indicator, nothing else
      0 of 2 found; missed: ['198.51.100.23', '203.0.113.45']

Both public addresses in the report were dropped, while the domains, URLs and hashes were all right, so the failure is confined to one decision in one helper. The helper decides what is private with Python's ipaddress module, and the module's idea of private is broader than the contract's.

$ python3 ipcheck.py
198.51.100.23   is_private True   is_global False
203.0.113.45    is_private True   is_global False
10.20.4.17      is_private True   is_global False
8.8.8.8         is_private False  is_global True

Python counts 198.51.100.0/24 and 203.0.113.0/24 as private, alongside the internal 10.20.4.17 the draft was right to drop; only the ordinary public address in the last line is reported as global. Those ranges are reserved for documentation, which is why the lab uses them for attacker infrastructure, and the module treats them as not globally reachable.

The contract named three ranges; the draft used a library property that sounded the same and meant something else. In a real pipeline the same pattern of mistake appears whenever a library's definition is assumed to match the specification: the code looks correct, the name of the property sounds right, and only a test with a known answer shows the gap.

The general lesson is about what a test with a known answer is for. The draft was reasonable code that a reviewer could easily approve: the property name says private, and the intent was to exclude private addresses. Reading the code would not have found the problem.

Running it against a report whose correct output was written down beforehand found it in one line. That is why every exercise in this module ships with a check, and why Module 11's extraction pipeline is measured against reports whose indicators are known before the model ever sees them.

6

The Fix

The contract's ranges, exactly

The follow-up brief states the failure and the rule.

SEC410 lab, lesson 0.112026-11-18
intel.pyPY

The check fails on IPv4: both addresses in the report were dropped. ipaddress counts more than the three private ranges as private. Use exactly the ranges the contract names, 10/8, 172.16/12 and 192.168/16, and nothing else.

intel.pyCode · PY · 76 linesDownload
Reply to Claude…Opus 5.5
Recorded unedited in assistant-records/m00/0.11-fix-brief.md

The reply was the file again; here is the change against the first draft.

Visual Studio Codeintel.py (Working Tree) - sec410-lab
intel.py (Working Tree)
Source Control › Changes › lab/foundations/intel.py
39  40+ PRIVATE = [ipaddress.IPv4Network(n) for n in ('10.0.0.0/8', '172.16.0.0/12', '192.168.0.0/16')]41+ 42+ 43  def _public_ip(value):⋯47          return False-     return not ip.is_private and not ip.is_loopback and not ip.is_unspecified48+     return not any(ip in net for net in PRIVATE)49  
main*1 file changed
The fix: the three private ranges the contract names, and no others.

The follow-up brief states what failed, why, and the rule to apply, rather than asking for the code to be fixed. An assistant told only that a check failed will often find a fix that passes it, and the fix may be another library property that happens to work for these two addresses.

Naming the rule, the three ranges and nothing else, makes the intended fix the only one that fits. The fix replaces the library property with the three networks the contract names and nothing else. Run the check again with the fixed file in the lab's foundations folder.

$ cp records/intel-fix.py lab/foundations/intel.py
$ python3 -m lab check f11
f11  0.11 Threat Intelligence Foundations: lab/foundations/intel.py
ok    ipv4: every indicator, nothing else
      2 of 2 found
ok    domain: every indicator, nothing else
      3 of 3 found
ok    url: every indicator, nothing else
      2 of 2 found
ok    sha256: every indicator, nothing else
      2 of 2 found
ok    lists are sorted and unique
ok    one STIX indicator per value, with the right patterns
      9 objects for 9 values
ok    the stix2 library parses the bundle
      stix2 3.0.2
PASS

Every indicator is found and nothing else is reported. The bundle has one indicator per value, and the stix2 library, version 3.0.2, parses it without complaint. Here is what the extractor produced and the first indicator in the bundle.

$ cp records/intel-fix.py lab/foundations/intel.py
$ python3 ioc.py
ipv4    198.51.100.23
ipv4    203.0.113.45
domain  cdn-invoice-portal.com
domain  invoice-portal-cdn.net
domain  login-micros0ft.com
url     http://login-micros0ft.com/owa
url     https://cdn-invoice-portal.com/assets/update.bin
sha256  0debc51a59c409dcbfaf7dc9472bf345fefd190b54c533684ad0b2204ae931ce
sha256  9ce220a8d9203f4106fb1009d5a4b480336842fd297fd7d882a2084e20bf98b7
9 indicators in bundle--66ba5572...
{
 "type": "indicator",
 "spec_version": "2.1",
 "id": "indicator--90031c49-4a...",
 "created": "2026-11-18T10:00:00.000Z",
 "modified": "2026-11-18T10:00:00.000Z",
 "valid_from": "2026-11-18T10:00:00.000Z",
 "pattern_type": "stix",
 "pattern": "[ipv4-addr:value = '198.51.100.23']"
}

Two public addresses, three domains, two URLs and two hashes, nine values in all, each found once although several appear in the report more than once. The lookalike domain is reported exactly as the attackers registered it, with a zero in place of the letter o, which is the detail a careless normalization would erase.

The brand that must not be blocked is absent, and so are the internal address and the truncated hash. Each indicator carries a STIX pattern, a type, and the time from which it is valid.

The hash rule rejected the truncated value because it is 63 characters, not 64, and the pattern refuses a 64-character match inside a longer hexadecimal run. A truncated hash is worse than no hash: blocking it blocks nothing, and searching for it finds nothing, so a pipeline that accepted it would report coverage it did not have.

Reports also carry MD5 and SHA-1 values, which the contract leaves out; a real extractor handles them, labels each with its algorithm, and never treats one length as another.

7

Searching Text as It Arrives, Measured

Without refanging

The shortcut skips refanging and searches the report as it was written.

Visual Studio Codeintel.py (Working Tree) - sec410-lab
intel.py (Working Tree)
Source Control › Changes › lab/foundations/intel.py
51  def extract(text, allow=ALLOW):-     text = _refang(text)52      urls = {u.rstrip('.,;:').lower() for u in URL.findall(text)}
main*1 file changed
The shortcut: search the text as it arrives.

Run the check and read the extraction results.

$ cp records/intel-norefang.py lab/foundations/intel.py
$ python3 -m lab check f11 | sed -n "2,9p"
ok    ipv4: every indicator, nothing else
      2 of 2 found
FAIL  domain: every indicator, nothing else
      0 of 3 found; missed: ['cdn-invoice-portal.com',
      'invoice-portal-cdn.net', 'login-micros0ft.com']
FAIL  url: every indicator, nothing else
      0 of 2 found; missed: ['http://login-micros0ft.com/owa',
      'https://cdn-invoice-portal.com/assets/update.bin']

The check runs the same report through the shortcut and compares with the same known answers. Every domain and URL is missed, because hxxps is not a URL scheme and a bracketed dot does not join a domain.

The addresses and hashes, which are never defanged, are still found, so a pipeline running this code would report a partial success that looks reasonable and quietly drops the indicators most worth blocking. Defanging conventions also vary between sources, with hxxp, h**p, [.] and (.) all in use, so a real refanger handles every convention its sources use and is tested against each.

What happens downstream decides how much these errors cost. An indicator that reaches a blocklist is acted on automatically, often by firewalls, proxies and mail gateways at once. A false domain blocks a service people use. A false address can block a shared hosting provider and everything else hosted with it.

A missed domain is invisible until the attack it would have stopped succeeds. Extraction quality is measured on both errors for that reason, and a pipeline's output is reviewed most carefully at the point where it leaves for a blocking control.

8

What Extraction Cannot See

From indicators to Module 11

The session record keeps the failed first draft, the fix, the measurement, and three gaps.

Visual Studio Code0.11-session.md - sec410-lab
0.11-session.md
records › 0.11-session.md
1# Session 0.11: indicators into STIX23Assistant: Claude Opus 5.5 (claude-opus-5-5), the SEC410 build session, 2026-11-1845## First draft6- Refang, then one pattern per kind; URLs removed before the7  domain search, hosts taken from URLs as domains.8- Failed: both public addresses dropped. ipaddress.is_private9  counts the documentation ranges as private too.1011## After the fix12- The contract's three ranges, exactly. check f11: PASS.13- stix2 3.0.2 parses the bundle.1415## Measured16- Without refanging: domains and URLs missed entirely.1718## For Module 1119- The bundle carries no TLP marking: the report was TLP:GREEN.20- No confidence, no source, no relationship to the campaign.21- The technique paragraph produced nothing at all.
mainMarkdownUTF-8Ln 5, Col 1

The first gap is handling. The note was TLP:GREEN and the bundle says nothing about it, so a consumer has no way to know the indicators may not be published; STIX provides marking definitions for TLP, and the practice's stretch goal adds one.

The second is judgment: the indicators carry no confidence, which STIX expresses as a number from 0 to 100, no source and no link to the campaign they came from. The third is the paragraph about technique, the most valuable part of the note, which produced nothing because it has no pattern to match.

Confidence deserves care when it is added. STIX defines it as a number from 0 to 100 and gives mappings to other scales for display, but the number means only what the producer meant by it.

A pipeline should say how it sets confidence, from the source's track record, from whether the value was seen elsewhere, from how the value was extracted, so that a consumer can decide what to act on automatically and what to send to an analyst.

Module 11 puts a model on that paragraph to map it to techniques, adds confidence and source to every indicator, and checks every value the model extracts against the text, because a model can produce a plausible indicator that was never in the report, and a blocklist cannot tell the difference.

Intelligence also flows back. A sharing community runs on members contributing what they see, and STIX is designed for that: indicators, sightings that record where an indicator was actually observed, and relationships that say what campaign or malware a finding belongs to, exchanged over TAXII, its companion protocol for transport.

An extractor that only consumes is half a pipeline. Module 11's output is shaped so it can be shared back, with its markings, confidence and sources intact.

Do

Practice

Indicators into STIX
the lab

Brief your assistant with the contract and the stakes, check the draft and fix what fails, then place each indicator on the pyramid and reproduce the refang shortcut.

Visual Studio Code0.11.md - sec410-lab
0.11.md
practice › 0.11.md
1# Practice 0.11: indicators into STIX23## Done when4- [ ] lab/foundations/intel.py meets its docstring's contract5- [ ] python -m lab check f11 prints PASS6- [ ] ioc.py run; each indicator placed on the pyramid7- [ ] the refang shortcut reproduced; what it missed recorded8- [ ] records/0.11-<assistant>.md: brief, draft, runs, review910## Constraints11- Nothing in report.txt is special-cased in the code.12- Output keeps the report's TLP: TLP:GREEN stays out of public13  channels.1415## Stretch16- Add the TLP:GREEN marking definition to the bundle and refer17  to it from every indicator; check stix2 still parses it.
mainMarkdownUTF-8Ln 3, Col 1

An indicator is a value worth detecting, and the Pyramid of Pain ranks them by what acting on them costs an attacker, with techniques at the top. Reports defang indicators and mix them with things that must not be blocked, so an extractor refangs, filters and accepts only complete values.

The first draft dropped both attacker addresses because a library's definition of private differed from the contract's; the fix used the contract's ranges exactly. Skipping refanging missed every domain and URL. STIX packages the result, and TLP governs where it may go.