[opensourcedex]

Raccoon is a free, open source threat detection & response project written in Python and released under MIT. It has 4,025 GitHub stars, 501 forks and 14 open issues, and was last pushed 5 months ago. On this registry it ranks #11 of 15 tracked projects in Threat Detection & Response, with 5 head-to-head comparisons available.

What is Raccoon?

Raccoon is an open-source, MIT-licensed offensive security tool written in Python for reconnaissance and information gathering, built for penetration testers, bug bounty hunters, and security analysts who need to map a target's DNS, TLS, network, and web footprint from a single command line.

What it is

Raccoon lives in the Python command-line security ecosystem and concentrates on the reconnaissance phase of a penetration test. It is written for Linux and macOS, requires Python 3.5 or newer, and states its emphasis plainly as simplicity. Version 0.8.5 carries scanning work across the whole target surface: fetching DNS records, retrieving WHOIS information, obtaining TLS data, detecting WAF presence, and running threaded directory busting and subdomain enumeration. Because most of its scans are independent and do not rely on each other's results, it uses Python's asyncio to run them asynchronously. Every scan writes to a corresponding file, separating targets by folders and modules by files.

The concrete problem it solves is the manual, piecemeal workflow that surrounds early recon work. Rather than running separate utilities one at a time for DNS queries, WHOIS lookups, TLS inspection, port scanning, and directory brute forcing, Raccoon bundles those steps into one asynchronous run. It leans on Nmap for port scanning and Nmap scripts and features, on OpenSSL for TLS and SSL scans, and on default wordlists from the SecLists repository for URL fuzzing and subdomain discovery.

Key capabilities

  • DNS enumeration and visual mapping, covering DNS records and DNS dumpster based mapping.
  • WHOIS retrieval and TLS data collection, including supported ciphers, TLS versions, certificate details, and SANs.
  • Port scanning through Nmap, plus services and scripts scans that use Nmap features.
  • URL fuzzing and directory and file detection, with alternative wordlists passed as arguments instead of the SecLists defaults.
  • Subdomain enumeration combining Google dorking, DNS dumpster queries, SAN discovery, and bruteforce.
  • Web application data retrieval: CMS detection, web server info and X-Powered-By, robots.txt and sitemap extraction, cookie inspection, fuzzable URL extraction, HTML form discovery, email address harvesting, and scanning of vulnerable S3 buckets with enumeration for sensitive files.
  • Known WAF detection, anonymous routing through Tor or proxies, asyncio-based concurrency, and output written to files grouped by target folder and module file.

Who users and how

  • Penetration testers running scoped engagements against one named target, since the invocation is raccoon [OPTIONS] TARGET.
  • Red teams and bug bounty hunters who require anonymous routing, which Raccoon supports through Tor and proxies.
  • Analysts working from containers, building the image as evyatarmeged/raccoon and running it non-root, which forces output under the container user's home directory at /home/raccoon.
  • Teams with their own wordlists, who pass different lists as arguments rather than relying on the SecLists defaults.
  • macOS users, who must have gtimeout available, installed by running brew install coreutils.

Getting started

The stable version installs with pip install raccoon-scanner, or pip3 install raccoon-scanner on systems where Python 3 is versioned separately, and then runs as raccoon [OPTIONS] TARGET. A container route exists as well: build with docker build -t evyatarmeged/raccoon . and run with docker run --name raccoon evyatarmeged/raccoon:latest example.com -o /home/raccoon, provided Nmap and OpenSSL are already installed, since both are mandatory prerequisites.

How it compares

No competing or paid products are listed in the facts, so Raccoon stands alone in this registry. What it wraps instead are dependencies rather than rivals: Nmap for port and service scanning, OpenSSL for TLS work, SecLists for wordlists, and DNS dumpster for DNS mapping.

When to use it — and when not to

A self-hoster must install Nmap and OpenSSL before anything works, and on macOS must add gtimeout through brew install coreutils, so this is not a drop-in binary. It should be avoided by anyone needing machine-readable output, multiple hosts read from a file, IP range or CIDR notation support, or rate limit evasion, since all of those appear as unfinished roadmap items rather than shipped features. JSON output sits at the top of that same pending list, which means results currently land only in files separated by target and module.

project readme (upstream, from github) — read inline

Raccoon

Racoon

Offensive Security Tool for Reconnaissance and Information Gathering

Build Status license os pythonver raccoonver

Features
  • DNS details
  • DNS visual mapping using DNS dumpster
  • WHOIS information
  • TLS Data - supported ciphers, TLS versions, certificate details and SANs
  • Port Scan
  • Services and scripts scan
  • URL fuzzing and dir/file detection
  • Subdomain enumeration - uses Google dorking, DNS dumpster queries, SAN discovery and bruteforce
  • Web application data retrieval:
    • CMS detection
    • Web server info and X-Powered-By
    • robots.txt and sitemap extraction
    • Cookie inspection
    • Extracts all fuzzable URLs
    • Discovers HTML forms
    • Retrieves all Email addresses
    • Scans target for vulnerable S3 buckets and enumerates them for sensitive files
  • Detects known WAFs
  • Supports anonymous routing through Tor/Proxies
  • Uses asyncio for improved performance
  • Saves output to files - separates targets by folders and modules by files
Roadmap and TODOs
  • Expand, test, and merge the "owasp" branch with more web application attacks and scans (#28)
  • Support more providers for vulnerable storage scan (#27)
  • Add more WAFs, better detection
  • Support multiple hosts (read from file)
  • Rate limit evasion
  • IP ranges support
  • CIDR notation support
  • More output formats (JSON at the very least)

About

Raccoon is a tool made for reconnaissance and information gathering with an emphasis on simplicity.
It will do everything from fetching DNS records, retrieving WHOIS information, obtaining TLS data, detecting WAF presence and up to threaded dir busting and subdomain enumeration. Every scan outputs to a corresponding file.

As most of Raccoon's scans are independent and do not rely on each other's results, it utilizes Python's asyncio to run most scans asynchronously.

Raccoon supports Tor/proxy for anonymous routing. It uses default wordlists (for URL fuzzing and subdomain discovery) from the amazing SecLists repository but different lists can be passed as arguments.

For more options - see "Usage".

Installation

For the latest stable version:

pip install raccoon-scanner
# To run:
raccoon [OPTIONS]

Please note Raccoon requires Python3.5+ so may need to use pip3 install raccoon-scanner.
You can also clone the GitHub repository for the latest features and changes:

git clone https://github.com/evyatarmeged/Raccoon.git
cd Raccoon
python setup.py install # Subsequent changes to the source code will not be reflected in calls to raccoon when this is used
# Or
python setup.py develop # Changes to code will be reflected in calls to raccoon. This can be undone by using python setup.py develop --uninstall
# Finally
raccoon [OPTIONS] [TARGET]
macOS

To support Raccoon on macOS you need to have gtimeout on your machine.
gtimeout can be installed by running brew install coreutils.

Docker
# Build the docker image
docker build -t evyatarmeged/raccoon .
# Run a scan, As this a non-root container we need to save the output under the user's home which is /home/raccoon
docker run --name raccoon evyatarmeged/raccoon:latest  example.com -o /home/raccoon
Prerequisites

Raccoon uses Nmap to scan ports as well as utilizes some other Nmap scripts and features. It is mandatory that you have it installed before running Raccoon.
OpenSSL is also used for TLS/SSL scans and should be installed as well.

Usage


Usage: raccoon [OPTIONS] TARGET

Options:
  --version                      Show the version and exit.
  -d, --dns-records TEXT         Comma separated DNS records to query.
                                 Defaults to: A,MX,NS,CNAME,SOA,TXT
  --tor-routing                  Route HTTP traffic through Tor (uses port
                                 9050). Slows total runtime significantly
  --proxy-list TEXT              Path to proxy list file that would be used
                                 for routing HTTP traffic. A proxy from the
                                 list will be chosen at random for each
                                 request. Slows total runtime
  -c, --cookies TEXT             Comma separated cookies to add to the
                                 requests. Should be in the form of key:value
                                 Example: PHPSESSID:12345,isMobile:false
  --proxy TEXT                   Proxy address to route HTTP traffic through.
                                 Slows total runtime
  -w, --wordlist TEXT            Path to wordlist that would be used for URL
                                 fuzzing
  -T, --threads INTEGER          Number of threads to use for URL
                                 Fuzzing/Subdomain enumeration. Default: 25
  --ignored-response-codes TEXT  Comma separated list of HTTP status code to
                                 ignore for fuzzing. Defaults to:
                                 302,400,401,402,403,404,503,504
  --subdomain-list TEXT          Path to subdomain list file that would be
                                 used for enumeration
  -sc, --scripts                 Run Nmap scan with -sC flag
  -sv, --services                Run Nmap scan with -sV flag
  -f, --full-scan                Run Nmap scan with both -sV and -sC
  -p, --port TEXT                Use this port range for Nmap scan instead of
                                 the default
  --vulners-nmap-scan            Perform an NmapVulners scan. Runs instead of
                                 the regular Nmap scan and is longer.
  --vulners-path TEXT            Path to the custom nmap_vulners.nse script.If
                                 not used, Raccoon uses the built-in script it
                                 ships with.
  -fr, --follow-redirects        Follow redirects when fuzzing. Default: False
                                 (will not follow redirects)
  --tls-port INTEGER             Use this port for TLS queries. Default: 443
  --skip-health-check            Do not test for target host availability
  --no-url-fuzzing               Do not fuzz URLs
  --no-sub-enum                  Do not bruteforce subdomains
  --skip-nmap-scan               Do not perform an Nmap scan
  -q, --quiet                    Do not output to stdout
  -o, --outdir TEXT              Directory destination for scan output
  --help                         Show this message and exit.

Screenshots

poc2

Web application data including vulnerable S3 bucket:
somepoc

HTB challenge example scan:
poc

Nmap vulners scan results:
vulnerspoc

Results folder tree after a scan:
poc3

Contributing

Any and all contributions, issues, features and tips are welcome.

Frequently asked questions

Is Raccoon free to use?

Raccoon is open source under the MIT licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does Raccoon do?

A high performance offensive security tool for reconnaissance and vulnerability scanning

What is Raccoon written in?

Raccoon is primarily written in Python. Its source is publicly available at https://github.com/evyatarmeged/Raccoon, and it has 4,025 GitHub stars.