RECON7 DOCS

DEFENSIVE RECONNAISSANCE ENGINE
GitHub
Recon7 Architecture & Operator Manual

Defensive Attack Surface Intelligence

Complete technical reference for deploying, operating, and integrating the Recon7 autonomous reconnaissance pipeline, async worker, and evidence graph engine.

Recon7 Emblem
RECON7 // ENGINE v1.0.0

Platform Overview & Architecture

Recon7 is an autonomous security reconnaissance engine for authorized assessments. It discovers exposed assets, maps their relationships, and turns the findings into actionable security intelligence.

Single-Port Monolith

Runs on a single designated port (:8000 in Docker / production, :8080 in direct local dev). FastAPI serves both backend REST endpoints under /api and the pre-built React SPA at root.

Async DAG Worker

Autonomous worker engine (worker.py) executes pipeline stages asynchronously, persisting state and telemetry to PostgreSQL.

Evidence Graph Topology

Every node and relationship is backed by cryptographic evidence chains, support IDs, and multi-hop pivot path tracing.

Air-Gapped & Offline Ready

No mandatory external SaaS dependencies. Functions completely offline or self-hosted with local rule-based heuristic triage.

Architecture Invariant: All frontend build artifacts are served directly by FastAPI from frontend/dist. You never need to run separate development proxy servers in production.

Local Quickstart (2-Terminal Workflow)

Running Recon7 locally in development requires only two terminal windows: one for the combined API & Web Console server, and one for the async pipeline worker.

Step 1: Clone & Configure Environment

TERMINAL 1 // BASH / POWERSHELL
# 1. Clone repository
git clone https://github.com/johnojabo2/recon7.git
cd Recon7

# 2. Setup Python virtual environment
python -m venv .venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate

# 3. Install core dependencies
pip install -r requirements.txt

# 4. Configure environment
cp .env.example .env

Step 2: Launch Web Console & API Server

TERMINAL 1 // API & WEB APP
python main.py
# Server starts at: http://127.0.0.1:8080
# Interactive Portal: http://127.0.0.1:8080/portal
# Operator Console: http://127.0.0.1:8080

Step 3: Launch Async Recon Worker

TERMINAL 2 // RECON WORKER
python worker.py
# Worker starts polling database for queued scan jobs

Docker & Compose Production Deployment

Recon7 is packaged into an all-in-one container image containing all scanning binaries (Nmap, Masscan, Amass, Sublist3r, Nuclei templates) alongside the web application. Production uses Docker Compose to orchestrate PostgreSQL, the Web/API Server (r7-app on port 8000), and the Async Pipeline Worker (r7-worker).

DOCKER COMPOSE COMMAND
# Launch PostgreSQL + API Server + Recon Worker
docker-compose up -d

# Check live logs
docker-compose logs -f app worker

Complete docker-compose.yml Configuration

DOCKER-COMPOSE.YML
version: '3.8'

services:
  postgres:
    image: postgres:16-alpine
    container_name: r7-postgres
    restart: unless-stopped
    environment:
      POSTGRES_DB: recon7
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: reconpassword123
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres -d recon7"]
      interval: 5s
      timeout: 5s
      retries: 5

  app:
    image: johnojabo1/recon7:latest
    build: .
    container_name: r7-app
    restart: unless-stopped
    depends_on:
      postgres:
        condition: service_healthy
    environment:
      DATABASE_URL: postgresql://postgres:reconpassword123@postgres:5432/recon7
      ALLOW_ALL_SCOPES_DEV: ${ALLOW_ALL_SCOPES_DEV:-false}
      GITHUB_TOKEN: ${GITHUB_TOKEN:-}
      GOOGLE_SEARCH_API_KEY: ${GOOGLE_SEARCH_API_KEY:-}
      GOOGLE_SEARCH_ENGINE_ID: ${GOOGLE_SEARCH_ENGINE_ID:-}
    ports:
      - "8000:8000"
    command: uvicorn main:app --host 0.0.0.0 --port 8000

  worker:
    image: johnojabo1/recon7:latest
    build: .
    container_name: r7-worker
    restart: unless-stopped
    depends_on:
      postgres:
        condition: service_healthy
    environment:
      DATABASE_URL: postgresql://postgres:reconpassword123@postgres:5432/recon7
      ALLOW_ALL_SCOPES_DEV: ${ALLOW_ALL_SCOPES_DEV:-false}
      GITHUB_TOKEN: ${GITHUB_TOKEN:-}
      GOOGLE_SEARCH_API_KEY: ${GOOGLE_SEARCH_API_KEY:-}
      GOOGLE_SEARCH_ENGINE_ID: ${GOOGLE_SEARCH_ENGINE_ID:-}
    command: python worker.py

volumes:
  postgres_data:
Port Specification Guide:
  • Docker Container / Production: Uses port 8000 (exposed and mapped via 8000:8000). Access at http://localhost:8000.
  • Direct Local Development (python main.py): Uses port 8080 (or configured PORT environment variable) to avoid collision with standard developer databases on 8000. Access at http://127.0.0.1:8080.

Setup Wizard & First-Time Onboarding

When you start Recon7 on a clean database, navigating to / automatically routes you to the setup onboarding wizard.

1. Root Admin Credentialing

Set the primary administrator email and an entropy-validated password (minimum 8 characters with complexity requirements).

2. Primary Workspace

Define your initial organization / team workspace name (e.g., Security Operations).

3. Immediate Console Entry

Upon initialization, your session is authenticated immediately and routes directly into the dashboard with zero redundant login screens.

10-Stage DAG Reconnaissance Pipeline

The pipeline executes an ordered, non-linear Directed Acyclic Graph (DAG) designed to minimize scanning noise while maximizing correlated threat discovery.

STAGE SUBSYSTEM OPERATIONAL FUNCTION
01 Subdomain Enumeration Passive DNS, Certificate Transparency (crt.sh), AlienVault OTX, and HackerTarget feeds.
02 DNS & Origin Resolution Mass multi-resolver DNS lookups (A, AAAA, CNAME, MX, TXT) resolving IP addresses.
03 CDN & WAF Bypass Detection Fingerprints Cloudflare, Akamai, CloudFront, and Fastly to prevent blacklisting.
04 Port Sweep & Fingerprinting High-performance SYN sweeps followed by deep Nmap service and version banner extraction.
05 HTTP & Tech Fingerprinting TLS inspection, server header analysis, and technology stack identification (Wappalyzer signatures).
06 Storage & Bucket Auditing Permutation enumeration for AWS S3, Azure Blob, GCS, and DigitalOcean Spaces.
07 CVE & Vulnerability Mapping Maps service versions against NIST NVD CVE databases and OWASP Top 10 indicators.
08 Identity & People OSINT Extracts employee names, authors, and email structures from public records and metadata.
09 Evidence Graph Synthesis Builds relational knowledge topology linking domains, hosts, credentials, and assets.
10 Executive Triage & Synthesis Synthesizes findings into prioritized attack vectors and downloadable reports.

Evidence Graph & Path Tracing Engine

The interactive graph canvas visualizes relational connections between discovered infrastructure, personnel, identities, and vulnerabilities.

Multi-Lens Filtering

Filter by Executive View (high-risk assets), Attack Surface (domains & ports), or Composite View (all 13 entity types).

Multi-Hop Pivot Path Tracing

Select any Origin Node and Target Node to compute the shortest relational evidence path (e.g. Person βž” Supervises βž” Org βž” Authors βž” Vulnerability).

Dynamic Canvas Highlighting

Tracing a path automatically dims unrelated nodes to 15% opacity, draws glowing neon vectors, and displays sequence badges (ORIGIN, HOP 1, TARGET).

Evidence Backlinks

Clicking any edge opens the exact raw supporting evidence record, HTTP response snippet, or DNS record that substantiated the link.

Multi-Cloud Storage & Exposure Hunting

Discovers orphaned or misconfigured cloud storage repositories across four major cloud providers using domain permutations and wordlists.

PROVIDER URL FORMAT STATUS CODES
AWS S3 https://{target}-data.s3.amazonaws.com 200 (Accessible), 403 (Discovered)
Azure Blob https://{target}assets.blob.core.windows.net 200 (Accessible), 400 / 403 (Discovered)
Google Cloud (GCS) https://storage.googleapis.com/{target}-backup 200 (Accessible), 403 (Discovered)
DigitalOcean Spaces https://{target}-media.nyc3.digitaloceanspaces.com 200 (Accessible), 403 (Discovered)

Zero-Trust Local Triage & Offline Privacy

Recon7 is designed with a strict zero-leak architecture. All reconnaissance data, hostnames, and credentials remain on your host infrastructure.

Heuristic Severity Matrix

Evaluates finding severity using local deterministic scoring (CVSS base scores, exposure exposure metrics, public accessibility factors).

Optional LLM Inference

Optionally connect an OpenAI, Anthropic, or Ollama local endpoint for enhanced executive summaries. Raw data is scrubbed before submission.

Scope Enforcement & Legal Governance

To maintain adherence to the Computer Fraud and Abuse Act (CFAA), GDPR, and professional red-teaming standards, every scan requires explicit target authorization.

Scope Attestation Registry

Target domains must be registered under Scope Governance with an authorization type (Engagement Letter or Self-Attested Lab).

Pre-Flight Scope Gate

The worker validates every single target subdomain against authorized scopes before dispatching active packets. Unscoped hosts are automatically dropped.

Security Engineering & Hardening Controls

Hardened backend security architecture protecting system integrity in hostile network environments:

  • Anti-Lockout Safeguards: Root and IAM user passwords must satisfy length and complexity checks, preventing common, easily guessed keys.
  • Timing Attack Mitigation: Failed login lookups execute constant-time dummy bcrypt hashes (DUMMY_TIMING_HASH) to prevent user enumeration.
  • Brute-Force Rate Limiting: In-memory sliding-window limiter blocks IP addresses after consecutive failed authentication attempts.
  • Strict JWT Validation: Cryptographically signed HS256 tokens with short expiration windows and tenant isolation claims.

Administrator Password Recovery CLI

If an operator forgets their administrator password, Recon7 provides a standalone emergency recovery CLI that can be executed directly on the host or inside a running container.

Interactive Reset Prompt

NATIVE HOST EXECUTION
python scripts/reset_password.py

Automated Non-Interactive CLI Reset

DIRECT CLI FLAGS
# Reset password directly
python scripts/reset_password.py --email [email protected] --password "NewSecurePass!2026"

# List all registered users
python scripts/reset_password.py --list

Inside Docker Container

DOCKER EXEC COMMAND
docker exec -it r7-app python scripts/reset_password.py --email [email protected] --password "NewSecurePass!2026"

OpenAPI REST Endpoints

All API routes are mounted strictly under the /api prefix with Bearer JWT authentication:

METHOD ENDPOINT DESCRIPTION
GET /api/setup/status Returns initialization status of the platform.
POST /api/setup/initialize Initializes root administrator account and workspace.
POST /api/auth/login Authenticates user and returns Bearer JWT.
GET /api/tenants Lists accessible organization workspaces.
POST /api/tenants Creates a new organization workspace.
GET /api/scopes Lists authorized target domains for the active tenant.
POST /api/scopes Registers a target domain with engagement attestation.
POST /api/scan Queues an autonomous reconnaissance job against a target domain.
GET /api/scans Lists recent and active reconnaissance jobs.
GET /api/scan/{id}/graph Returns the complete node and edge graph topology.
GET /api/scan/{id}/graph/path Calculates the shortest relational evidence path between two nodes.
GET /api/scan/{id}/report Retrieves synthesized executive and technical vulnerability report.