RECONSENTIA - Automated Web Puzzle Reconnaissance Framework

Project Overview

ReConsentia is a sophisticated automated reconnaissance and analysis framework designed for systematic exploration and analysis of the Discentia online puzzle game (hosted at discentia-online.de). The project employs intelligent fuzzing, pattern recognition, and content analysis to discover hidden levels, extract easter eggs, and decode puzzle mechanisms within the web-based challenge system.

Vision & Purpose

The framework serves as a comprehensive toolkit for methodical puzzle game analysis, combining automated discovery techniques with structured documentation and analysis. Its primary objectives are:

• Systematic Discovery: Automated identification of hidden levels and content through intelligent fuzzing
• Pattern Analysis: Extraction and analysis of linguistic, numerical, and structural patterns from discovered content
• Resource Management: Organized collection and categorization of all game assets and media files
• Documentation Generation: Comprehensive analysis documentation for each discovered level and component
• Adaptive Learning: Self-improving discovery mechanisms that adapt based on previous findings

Key Benefits

• Efficiency: Reduces manual exploration time from days to hours through automated processes
• Completeness: Ensures systematic coverage of all discoverable content and patterns
• Reproducibility: Consistent and repeatable analysis through configuration-driven architecture
• Scalability: Modular design allows easy extension and customization for different puzzle types
• Intelligence: Adaptive algorithms improve discovery rates over time

Technical Architecture & Components

Core Component Hierarchy

┌─────────────────────────────────────────────────────────────┐
│                  RECONSENTIA FRAMEWORK                      │
├─────────────────────────────────────────────────────────────┤
│  Configuration Layer (config/)                              │
│  ├── config_base.json (Base parameters & patterns)          │
│  ├── config_daughter_*.json (Specialized configurations)    │
│  └── Adaptive configs (Auto-generated from discoveries)     │
├─────────────────────────────────────────────────────────────┤
│  Processing Engine (scripts/)                               │
│  ├── master_recon_modular.py (Core orchestration)           │
│  └── Supporting utilities (Resource management)             │
├─────────────────────────────────────────────────────────────┤
│  Discovery & Analysis                                       │
│  ├── Intelligent Fuzzing (Wordlist-driven URL discovery)    │
│  ├── Content Scraping (Resource extraction & organization)  │
│  ├── Pattern Recognition (Comment/form/media analysis)      │
│  └── Easter Egg Detection (Hidden content identification)   │
├─────────────────────────────────────────────────────────────┤
│  Data Management                                            │
│  ├── Reconnaissance Data (RECON/)                           │
│  ├── Analysis Documentation (analysis/)                     │
│  ├── Central Logging (logs/)                                │
│  └── Resource Archives (_old/)                              │
└─────────────────────────────────────────────────────────────┘

Configuration System

Base Configuration (config/config_base.json):

• Defines core fuzzing parameters (timeout: 2s, rate limiting: 10ms)
• Contains foundational wordlist categories (German numbers, house terms, emotions)
• Establishes file pattern recognition rules and directory structures
• Sets up regex patterns for content extraction

Daughter Configurations (config/config_daughter_*.json):

• Extend base configuration with specialized wordlists
• Override specific parameters for targeted discovery approaches
• Enable/disable modular functionality for different analysis phases
• Support auto-generation based on previous discovery patterns

Adaptive Configuration Generation:

• Automatically creates new daughter configs based on successful discoveries
• Extracts patterns from newly found content to improve future searches
• Implements machine learning-like improvement cycles

Core Processing Engine

ReConsentiaReconModular Class (scripts/master_recon_modular.py):

1. Initialization & Validation:

   • Loads and validates all configuration files with preflight checks
   • Establishes central logging system with file and console output
   • Merges base and daughter configurations into unified working config

2. Wordlist Generation:

   • Aggregates words from all enabled configuration categories
   • Analyzes existing level content for pattern extraction
   • Generates comprehensive wordlist for fuzzing operations

3. Intelligent Fuzzing:

   • Tests URL combinations with configurable suffixes and extensions
   • Implements rate limiting and timeout controls for responsible scanning
   • Maintains persistent results tracking to avoid duplicate work

4. Content Analysis & Organization:

   • Automatically detects level numbers from page content using regex
   • Downloads and organizes all linked resources (CSS, JS, images, audio)
   • Creates structured directories for each discovered level

Discovery & Analysis Subsystems

Pattern Recognition Engine:

• Comment Analysis: Extracts hidden hints from HTML comments
• Form Detection: Identifies input mechanisms and interaction points
• Media Extraction: Discovers and downloads all multimedia resources
• Easter Egg Detection: Finds hidden content and special instructions

Content Organization:

• Automatic Level Detection: Uses regex to identify level numbers from content
• Resource Downloading: Systematically fetches all linked assets
• Structured Storage: Organizes content into logical directory hierarchies
• Metadata Generation: Creates resource logs and analysis documentation

Failsafe Mechanisms

Configuration Validation:

• Preflight Checks: Validates JSON structure and required fields before loading
• Schema Validation: Ensures proper configuration types and references
• Extension Validation: Verifies daughter configs properly extend base config
• Type Checking: Validates data types for all configuration parameters

Operational Safeguards:

• Rate Limiting: Prevents overwhelming target servers (configurable delays)
• Timeout Controls: Prevents hanging on unresponsive requests
• Error Handling: Graceful recovery from network and parsing errors
• Duplicate Prevention: Tracks existing results to avoid redundant operations

Data Integrity:

• Atomic Operations: Ensures complete file writes or rollback on failure
• Backup Systems: Maintains archived versions in _old/ directory
• Logging Redundancy: Multiple log outputs for operation tracking
• Validation Checkpoints: Verifies successful completion of each processing stage

Usage Examples & Operations

Basic Reconnaissance Cycle

# Execute complete discovery and analysis cycle
cd /Users/nikola/Desktop/RECONSENTIA_ROOT
python3 scripts/master_recon_modular.py

Expected Output Structure:

logs/master_recon.log          # Detailed operation log
logs/fuzz_results.txt          # Discovered URLs
RECON/Level X/                 # Auto-organized level directories
├── levelX.php                 # Main level content
├── css_style.css             # Downloaded stylesheets
├── images_*.jpg              # Retrieved images
└── levelX.php.resources      # Resource download log
analysis/Level_X_Analysis.md   # Generated analysis documentation

Configuration Management

Enable/Disable Daughter Configs:

// In config/config_daughter_advanced.json
{
  "enabled": false,  // Disable specific wordlist extensions
  "fuzzing_overrides": {
    "rate_limit_ms": 20  // Slower, more cautious scanning
  }
}

Custom Wordlist Addition:

// Create new daughter config
{
  "config_type": "daughter",
  "extends": "config_base.json",
  "name": "custom_patterns",
  "enabled": true,
  "wordlist_extensions": {
    "new_category": ["word1", "word2", "word3"]
  }
}

Analysis and Monitoring

Check Discovery Status:

# View current findings
cat analysis/Master_Overview.md

# Monitor real-time operations
tail -f logs/master_recon.log

# Review discovered resources
ls -la RECON/Level*/

Current Discovery Status (as of 2025-06-21):

• Found Levels: 11/25 (44% completion)
• Active Levels: 1, 2, 3, 4, 5, 7, 8, 9, 10, 13, 15
• Missing Levels: 6, 11, 12, 14, 16-25
• Easter Eggs: 7 discovered across various levels

Central Logging System

Primary Log Directory: logs/

Key Log Files:

• logs/master_recon.log - Complete operation history with timestamps
• logs/fuzz_results.txt - Cumulative list of discovered URLs
• logs/ - Additional operational logs and status files

Log Level Configuration:

• INFO: Standard operations and discoveries
• WARNING: Non-critical issues and skipped operations
• ERROR: Failed operations requiring attention

Log Rotation: Logs append continuously; manual archival to _old/logs/ recommended for long-term storage.

Project Status & Roadmap

Current Capabilities

• ✅ Automated Level Discovery: Intelligent fuzzing with adaptive wordlists
• ✅ Resource Management: Complete asset downloading and organization
• ✅ Pattern Analysis: Extraction of linguistic and structural patterns
• ✅ Easter Egg Detection: Hidden content identification
• ✅ Comprehensive Logging: Full operation tracking and audit trails
• ✅ Modular Configuration: Flexible and extensible parameter management

Analysis Findings Summary

• Estonian Connection: Evidence of Estonian language elements in puzzles
• Mathematical Themes: Multiplication and calculation-based challenges
• Memory Elements: References to remembering and recall mechanisms
• Steganographic Potential: Hidden content in media files requiring analysis
• Progressive Difficulty: Increasing complexity patterns across level ranges

Next Phase Objectives

• Steganographic Analysis: Deep analysis of discovered media files
• Form Interaction: Systematic testing of input mechanisms
• Source Code Analysis: JavaScript and CSS pattern extraction
• Mathematical Puzzle Solving: Algorithm development for calculation challenges
• Cross-Reference Analysis: Pattern correlation across multiple levels

File Organization Standards

RECONSENTIA_ROOT/
├── config/                    # Configuration management
│   ├── config_base.json       # Core parameters
│   └── config_daughter_*.json # Specialized extensions
├── scripts/                   # Processing engine
│   └── master_recon_modular.py # Main orchestration
├── analysis/                  # Documentation & findings
│   ├── Master_Overview.md     # Current status summary
│   └── Level_*_Analysis.md    # Individual level analysis
├── logs/                      # Central logging
│   ├── master_recon.log       # Operation history
│   └── fuzz_results.txt       # Discovery results
├── RECON/                     # Reconnaissance data
│   ├── Level */               # Discovered level content
│   │   ├── *.php              # Level files
│   │   ├── *_*.{css,js,jpg,png} # Downloaded resources
│   │   └── *.resources        # Resource logs
│   └── Unknown_Levels/        # Non-matchable discoveries
└── _old/                      # Archive directory
    └── (previous iterations)

Note: This documentation automatically reflects the current project state. All changes to project structure, discoveries, and configurations are immediately reflected in this README.md to maintain accuracy and completeness.