Updated Oct 13, 2026

Recon

puredns: resolve and bruteforce subdomains without wildcards

puredns is a fast domain resolver and subdomain bruteforcing tool that uses massdns for bulk DNS lookups and filters out wildcard subdomains and DNS-poisoned entries by validating answers against trusted resolvers.

installgo install github.com/d3mondev/puredns/v2@latest

Go · GPL-3.0 license

Agent

overview

What puredns does

This is the recon tool that wraps massdns — not the puredns.org hosted DNS service. Wildcard DNS makes every random name answer, so a naive brute-force fills with junk. puredns strips wildcard hits and poisoned answers so survivors are names that resolve for real.

Bruteforce mode takes a domain and a wordlist. Resolve mode takes an existing name list and confirms which answer. Use a public --resolvers pool for throughput, --resolvers-trusted to re-check survivors, and --rate-limit when the pool fights back. Raise --wildcard-tests when load-balanced DNS hides the catch-all. Trickest publishes both lists in the trickest/resolvers repo, the source the puredns README points to: resolvers.txt for the public pool and resolvers-trusted.txt for re-validation.

In a Trickest workflow, feed names from subfinder or a wordlist into the puredns node. It writes a file and a folder of clean resolved subdomains for httpx and later stages. Schedule the run to re-resolve the surface so dead names drop and new ones show up.

source github.com/d3mondev/puredns

use cases

Where puredns fits

Brute-force subdomains accurately

Run bruteforce mode with a wordlist against a domain and let wildcard filtering strip the false positives so only real subdomains survive.

Resolve a list of candidate names

Feed subdomains gathered from passive sources into resolve mode to confirm which actually resolve before spending probe time on them.

Validate against trusted resolvers

Use a public resolver pool for throughput and a trusted set for validation so DNS poisoning and load balancing do not corrupt the results.

reference

puredns inputs and flags

16 inputs
NameTypeFlagDescription
modeSTRING·Operating mode: bruteforce or resolve.
domainSTRING·Domain to brute-force (bruteforce mode only).
wordlistFILE·Wordlist for bruteforce mode, or the list of names to resolve.
resolversFILE--resolversFile of public resolvers to query for throughput.
resolvers-trustedFILE--resolvers-trustedFile of trusted resolvers used to validate hits.
rate-limitSTRING--rate-limitQueries-per-second cap for public resolvers (0 = unlimited).
wildcard-testsSTRING--wildcard-testsProbes run to detect DNS load balancing (default 3).
skip-wildcard-filterBOOLEAN--skip-wildcard-filterTurn off wildcard detection and filtering.

Showing key inputs. puredns exposes 16 inputs in total.

Full flag reference (16 inputs)
NameTypeFlagDescription
modeSTRING·Available modes: bruteforce, resolve
quietBOOLEAN--quietquiet mode
domainSTRING·Domain name (available in 'bruteforce' mode only)
domainsFILE--domainstext file containing domains to bruteforce
threadsSTRING--threadsnumber of threads to use while filtering wildcards (default 100)
wordlistFILE·Wordlist used for bruteforcing in 'bruteforce' mode or list of domains in 'resolve' mode
resolversFILE--resolverstext file containing public resolvers
rate-limitSTRING--rate-limitlimit total queries per second for public resolvers (0 = unlimited) (default unlimited)
trusted-onlyBOOLEAN--trusted-onlyuse only trusted resolvers (implies --skip-validation)
skip-sanitizeBOOLEAN--skip-sanitizedo not sanitize the list of domains to test
wildcard-batchSTRING--wildcard-batchnumber of subdomains to test for wildcards in a single batch (0 = unlimited) (default unlimited)
wildcard-testsSTRING--wildcard-testsnumber of tests to perform to detect DNS load balancing (default 3)
skip-validationBOOLEAN--skip-validationdo not validate results with trusted resolvers
resolvers-trustedFILE--resolvers-trustedtext file containing trusted resolvers
rate-limit-trustedSTRING--rate-limit-trustedlimit total queries per second for trusted resolvers (0 = unlimited) (default 500)
skip-wildcard-filterBOOLEAN--skip-wildcard-filterdo not perform wildcard detection and filtering

example

Run puredns

puredns · command
# resolver lists from github.com/trickest/resolvers
curl -sO https://raw.githubusercontent.com/trickest/resolvers/main/resolvers.txt
curl -sO https://raw.githubusercontent.com/trickest/resolvers/main/resolvers-trusted.txt

# brute-force example.com against a wordlist, wildcards filtered out
puredns bruteforce wordlist.txt example.com \
  --resolvers resolvers.txt --resolvers-trusted resolvers-trusted.txt \
  --wildcard-tests 5 --rate-limit 1500
sample output
www.example.com
api.example.com
mail.example.com
dev.example.com
staging.example.com
vpn.example.com
blog.example.com
admin.example.com
cdn.example.com

guidance

Choosing puredns

Reach for puredns when you need high-volume subdomain resolution or bruteforce with wildcards filtered out. It wraps massdns and adds trusted validation so poisoned or catch-all answers do not pollute the list. Pair it with subfinder for discovery, then httpx to see what speaks HTTP.

massdns

Raw high-speed stub resolver. puredns wraps it and adds wildcard detection plus trusted validation.

shuffledns

Another massdns wrapper with a different wildcard algorithm. Peer drop-in when you want speed over puredns's trusted re-check pass.

subfinder

Passive subdomain discovery. Feed its output into puredns resolve mode before probing.

faq

puredns questions

Bruteforce mode takes a wordlist and a domain: `puredns bruteforce wordlist.txt example.com --resolvers resolvers.txt`. It generates names, resolves them, and filters wildcards. On Trickest, set mode to bruteforce and wire the wordlist plus domain with your resolvers.

Trickest maintains them in the trickest/resolvers repo, which the puredns README recommends. resolvers.txt is the validated public pool for --resolvers; resolvers-trusted.txt lists resolvers from organizations like Cloudflare and Google for --resolvers-trusted. Pull fresh copies before a long run, because public resolvers drop out. trickest/resolvers on GitHub.

`--resolvers` is the public pool for bulk queries. `--resolvers-trusted` is a smaller set that re-checks hits so poisoned or load-balanced answers from the public pool do not land in the final list. `--trusted-only` skips the public pool.

It detects catch-all DNS and validates candidates against trusted resolvers, dropping names that only resolve because of a wildcard. `--wildcard-tests` sets probe count for load balancing (default 3). `--skip-wildcard-filter` turns detection off on the Trickest node.

Bruteforce generates names from a wordlist against a domain. Resolve skips generation and confirms which names in an existing list answer. Use resolve to clean subfinder or crt.sh output before probing.

Prefer puredns when you want massdns speed plus wildcard filtering and trusted validation. Use massdns alone when you skip that filter. shuffledns is another massdns wrapper with a different wildcard algorithm for the same job.

Download a binary release from GitHub, or run `go install github.com/d3mondev/puredns/v2@latest` with a current Go toolchain. puredns also needs massdns: build it from github.com/blechschmidt/massdns (`make && sudo make install`) so it is on your PATH, or point puredns at the binary with `--bin`.

Run puredns yourself

A domain and a wordlist feed puredns, which brute-forces and resolves names, filters out wildcards, and writes the clean resolved subdomains as output.

Facts on this page come from the live Trickest tool library.