Threat-Intel-Nom-Nom: The open-source TIP that only pings you when the threat is actually new

A self-hosted threat-intel stack that watches websites, RSS, APIs, and .onion sources, extracts IOCs, and uses content-plus-context hashing to cut alert fatigue before it starts.

8 to 10 min read • View on GitHub • More from luemmelsec

A wide editorial scene shows a cluttered analyst desk on the left, buried under duplicate threat alerts, while a clean signal emerges on the right from a conveyor of feeds. A pruning machine in the center is labeled by its two jobs, content hash and context hash, and thin wires run in from RSS, web pages, APIs, and onion sources. It explains that the project is designed to reduce noise before alerts ever reach a human.
Threat-Intel-Nom-Nom is less a dashboard than a filter: it trims repeated signals before they turn into inbox fatigue.
Key Takeaways

Why alert fatigue is the real problem

Threat feeds are noisy by default. Pages change for reasons that have nothing to do with new intelligence, and most tools still forward every change as if it matters. Threat-Intel-Nom-Nom starts with the more useful question: did anything actually new appear?

That matters because analysts do not need more data. They need fewer false positives, fewer duplicate mentions, and a cleaner path from raw source to actionable IOC. This repo aims to cut the noise at ingestion, not after the inbox has already filled up.

The nom nom trick: page hashes are not enough

The heart of the system is a two-step test. First it asks whether the page changed. Then it asks whether the matched context is actually new.

A close-up shows one webpage with a single threat sentence highlighted in ink. The same sentence appears in two versions of the page, while the surrounding chrome changes. One alert bell stays silent over the repeated sentence, and another bell rings only when the sentence itself changes. It explains why context hashing suppresses repeated mentions even when a page has been updated.
A page can change without producing a new alert. The sentence has to change too.

The distinction is subtle but important. A content hash tells the system whether a page changed. A context hash tells it whether the specific mention worth alerting on changed. The first keeps fetch cycles efficient. The second keeps the analyst quiet unless the signal is genuinely new.

That is the project’s best idea. It does not just scrape more web pages. It turns repeated threat chatter into a controlled comparison problem.

How it watches the web without being loud

The collection layer treats each source type on its own terms. RSS feeds, regular websites, APIs, and .onion addresses are not interchangeable, and the repo does not pretend they are. Tor support is first-class, which matters if you want to monitor hidden services without leaking where your request came from.

Source types
  RSS -> parser
  Website -> fetch + clean HTML
  API -> normalize JSON or feed template
  .onion -> Tor proxy -> fetch

Shared pipeline
  normalize -> extract -> hash -> alert

This is where the self-hosted stack earns its keep. FastAPI handles the API layer, Celery runs background work, PostgreSQL stores state, Redis brokers jobs, and Tor sits beside the fetchers. The result is a compact operator tool, not a collection of disconnected scripts.

What gets extracted, and what gets ignored

The repo’s IOC logic is pragmatic. It looks for CVEs, IPs, hashes, and domains, then filters out junk that would otherwise pollute the results. Private IPs do not belong in public threat intel. Neither do obviously fake hashes.

Signal typeWhat it catchesWhat it ignores
CVEKnown vulnerability identifiersAnything that is not a valid CVE pattern
IP addressPublic network endpointsPrivate or internal IP ranges
HashesMD5, SHA-1, SHA-256 style indicatorsAll-zero values and obvious placeholder junk
DomainsSuspicious hostnames and infrastructureMalformed or irrelevant text fragments

That filtering philosophy is the point. Good threat intel extraction is not just about finding matches. It is about refusing to promote junk into a real alert.

Why this feels bigger than a hobby tool

The repo is small, but it is not flimsy. Preconfigured feeds, multiple alert channels, and Docker-based deployment make it usable without a lot of ceremony. For a security team, that matters more than a grand platform story.

The practical payoff is simple: you can stand up a threat monitor that reaches into surface web sources and onion services, extracts useful indicators, and stays quiet when it has already seen the same sentence. That combination is rare in a tool this focused.

What it replaces, and what it doesn’t

ProjectPrimary jobWhere it sits in the workflowHow it differs here
Threat-Intel-Nom-NomCollect, extract, dedupe, alertEarly ingestion and signal filteringNarrower, lighter, and focused on noise control
MISPStore, share, and correlate IoCsBroader intel management layerHeavier platform with collaboration and sharing
OpenCTIModel threat knowledge and relationshipsKnowledge graph and analysis layerBuilt for structured context, not lean collection
TheHiveIncident response and case managementInvestigation and response layerOriented around analyst workflows, not feed scraping
MinemeldAggregate and filter indicatorsProcessing frameworkCloser in spirit, but less centered on mention-level novelty

The cleanest way to say it is this. Threat-Intel-Nom-Nom is not trying to be a full cyber threat-intelligence universe. It is trying to be the part that listens, dedupes, and only bothers you when the news is actually new.

Who built it, and why that matters

This is a one-maintainer project from LuemmelSec, and that shows in the shape of the work. The stack is opinionated, the deployment path is practical, and the feature set points toward immediate utility rather than platform theater. That is often what makes a small security tool worth watching.

A WSJ-style hedcut portrait of LuemmelSec rendered in black ink on white. The face is built from stipple dots and fine hatching, with no background clutter. It introduces the maintainer behind the project and reinforces that this is a focused individual effort rather than a large platform team.