DAEDALUS

Link analysis & OSINT
platform

[ OSINT ]

Investigate relationships across open sources. Trace every connection to its evidence. Keep case data on infrastructure you control.

Transforms
46
Entity types
20
No API key
41
Machines
05
DEMO · Example OSINT workflow, from a first lead to a mapped case.

01Why DAEDALUS?

Because DAEDALUS turns open-source signals into traceable investigations.

Every finding stays connected to its source, transform and path through the case, so analysts can verify how they got there and keep case data on infrastructure they control.

01

Start with a lead

Begin with a domain, alias, email, address or another recognized entity. A single indicator becomes the first node in a case.

02

Connect through sources

Transforms expand the case, and each result is linked to the input and transform that produced it.

03

Keep the evidence trail

Provenance stays attached to the graph, so analysts can inspect the route behind a conclusion and return to its source.

02See DAEDALUS in action

From a single lead to the report, in six moves.

FIG. 02 Seed 01 / 06
Graph canvas Transform menu on a domain Ariadne’s thread showing two paths between an alias and a person Structural analysis panel with centrality and communities Investigation timeline

03Capabilities

A complete workbench for the intelligence analyst.

It speaks the vocabulary analysts already know —entities, transforms and machines— and adds what only a graph can do.

Link analysis

Graph canvas with organic and hierarchical layouts, area selection, neighbourhood isolation, search, and table, map and timeline views.

46 transforms

Nine families of public-source queries: DNS, infrastructure, web, identity, social, search engines, location, blockchain and threat intelligence.

Machines

Sequences that walk several stages on their own: domain, IP, identity and website footprints, or the Labyrinth, an automatic expansion one to four levels deep.

Ariadne’s thread

The k shortest paths between two entities, hop by hop with the evidence behind every link, or the smallest subgraph connecting a whole selection.

Structural analysis

Betweenness, PageRank, community detection and choke points computed locally to find the centre of the labyrinth and its forced passages.

Identity resolution

Suggests same-type entities that share neighbours without being linked: aliases, emails or accounts that might belong to the same person.

Time and space

An automatic timeline of every dated event and a map of every coordinate, including EXIF and GPS metadata extracted from photographs.

API and plugins

Everything the interface does goes through a JSON API, with live progress over Server-Sent Events. A new transform is a small Python class: drop it into the plugins folder and it appears in the menu.

04Coverage

46 transforms. Nine families.
41 without an API key.

Public sources that work from minute one. Keys for Shodan, VirusTotal, Have I Been Pwned and other services are optional and extend coverage when you need them.

Alias sweep

More than 75 sites (400+ with the optional Sherlock list), with every hit verified and detailed profiles on ten platforms.

Optional keys

Shodan · VirusTotal · Hunter.io · Have I Been Pwned · AbuseIPDB · urlscan.io · GitHub · Serper · Brave

20 entity types, recognised as you type

Paste a value into the quick-add bar and DAEDALUS detects its type, normalises it and merges duplicates automatically.

05Analytics engine

The questions only a graph can answer.

Classic graph-theory algorithms, implemented without external dependencies and run on your own server.

Function Question Algorithm
Ariadne’s thread How are A and B connected? Yen’s k loopless shortest paths over BFS
Connect selection What ties all these entities together? Union of shortest paths between every pair · up to 25
Betweenness Who controls the flow? Brandes, normalised 0–1 · sampled on large graphs
PageRank What matters most? Power iteration, damping 0.85
Communities Which groups exist? Louvain modularity optimisation, deterministic
Choke points Which passages are unavoidable? Tarjan’s articulation points and bridges
Same identity? Are they the same person? Shared neighbours and Jaccard similarity

06Deployment

Your infrastructure. Your data. Your control.

A single Python process with SQLite storage. No build step, no external database and no third-party services beyond the OSINT sources you choose to query.

Architecture

Interface Build-free single-page app · Cytoscape.js · Leaflet
API FastAPI · authentication · import and export
Engine Async jobs · 10 transforms in parallel · SSRF protection
Analytics graphalgo.py · zero dependencies
Storage SQLite (WAL) · settings.json · plugins/
  • Your machine Python 3.11+ · one start script for Linux, macOS and Windows
  • Docker Docker Compose with a persistent volume and an unprivileged user
  • Railway Deploys straight from the repository; refuses to start without a password
  • Your own server A VPS behind Caddy or Nginx with HTTPS
bash
$ git clone https://github.com/BreaGG/DAEDALUS.git
$ cd DAEDALUS && ./start.sh
→ http://127.0.0.1:8787

07Security

Hardened to be exposed safely.

A tool that queries untrusted sources has to treat every response as hostile. DAEDALUS does so by default.

S-01

Controlled access

Authentication on every route, delayed responses to wrong passwords and listening on 127.0.0.1 only by default. On Railway the app refuses to start without a password.

S-02

SSRF protection

Transforms that fetch URLs resolve the host first and reject private, loopback, link-local, reserved and multicast addresses, re-checking every redirect.

S-03

Hostile content isolated

Every value coming from a source is escaped before rendering, only http(s) URLs become links, and remote images load on demand with no referrer.

S-04

Hardened headers

Responses carry X-Content-Type-Options: nosniff and Referrer-Policy: no-referrer; external links use noopener noreferrer nofollow.

S-05

Data in your custody

Investigations, settings and API keys live in a data folder you control, with no synchronisation to third-party services.

S-06

Verifiable quality

Open source, tests with all HTTP traffic mocked, static analysis with ruff and continuous integration on Python 3.11, 3.12 and 3.13.

08Use cases

For teams that need defensible answers.

01

Threat intelligence

Pivot across hostile infrastructure: domains, subdomains, certificates, IPs, exposed ports, known CVEs and reputation.

02

Investigative journalism

Rebuild networks of people, companies and accounts with the source of every connection and its timeline.

03

Due diligence

Check the digital footprint of counterparties, suppliers and executives before closing a deal.

04

Fraud and crypto assets

Follow balances, activity and counterparties of Bitcoin and Ethereum wallets and connect them to identities.

05

Exposure audits

Measure what your organisation reveals in the open: leaked emails, forgotten subdomains, trackers and exposed services.

06

Training and exercises

Train analysts with reproducible cases and exportable investigations that can be reviewed and compared.

09Extensibility

Open by design. Automatable end to end.

Write your own transforms in Python or drive whole investigations from scripts through the HTTP API.

plugins/email_hashes.pyPlugin
from daedalus.transforms import L, Transform, register


@register
class EmailHashes(Transform):
    name = "plugin_email_hashes"
    title = L("To MD5 / SHA-256 hashes", "A hashes MD5 / SHA-256")
    inputs = ("email",)

    async def run(self, ctx):
        import hashlib
        email = ctx.value.lower().encode()
        ctx.add("hash", hashlib.md5(email).hexdigest(), label="MD5")
        ctx.add("hash", hashlib.sha256(email).hexdigest(), label="SHA-256")
automate.shHTTP API
API=http://127.0.0.1:8787/api
J='content-type: application/json'
CASE=$(curl -s -X POST $API/cases -H "$J" \
  -d '{"name":"automated"}' | jq .id)
ID=$(curl -s -X POST $API/cases/$CASE/entities -H "$J" \
  -d '{"value":"example.com"}' | jq -r .entity.id)
JOB=$(curl -s -X POST $API/cases/$CASE/machine -H "$J" \
  -d "{\"entity_ids\":[\"$ID\"],\"machine\":\"domain_footprint\"}" \
  | jq -r .job_id)

# live progress (Server-Sent Events), then export
curl -sN $API/jobs/$JOB/events
curl -s "$API/cases/$CASE/export?format=graphml" -o case.graphml

10Roadmap

The labyrinth keeps growing.

Version 0.1 laid the foundations. The next steps focus on making investigations more reliable, more reproducible and more useful beyond the graph itself.

· Plans, not promises. The roadmap evolves with the people who use and support DAEDALUS.

Help decide what ships next.

DAEDALUS is an independent, open-source project. Every coffee buys development time for the next phase, and every issue helps set the order.

11Access

Request access to the evaluation instance.

The hosted DAEDALUS demo is protected. Tell us who you are and what you need it for, and we will send you credentials once the request is approved.

  1. 01
    Request

    Fill in the form with your professional details and your use case.

  2. 02
    Review

    Every request is reviewed by hand to ensure legitimate use.

  3. 03
    Access

    You receive the credentials for the demo instance by email.

Access request REF —