Honeypot: 001 admin_info.php

from flask import Flask, request, render_template_string, Response
import random
import datetime
import secrets
import string
from faker import Faker

app = Flask(__name__)
fake = Faker()

# Configuration - Adjust these for realism
NUM_USERS = 100
NUM_SERVERS = 10
NUM_DATABASES = 5
PASSWORD_LENGTH = 16
EMAIL_DOMAINS = ["example.com", "fakemail.net", "securedomain.org", "private-email.biz"]

#  Utility Functions
def generate_password(length=16):
    """Generates a cryptographically secure random password."""
    alphabet = string.ascii_letters + string.digits + string.punctuation
    return ''.join(secrets.choice(alphabet) for i in range(length))

def generate_realistic_datetime():
    """Generates a somewhat realistic-looking recent datetime."""
    now = datetime.datetime.now()
    # Go back up to 3 months
    delta = datetime.timedelta(days=random.randint(0, 90),
                               seconds=random.randint(0, 86400)) # Seconds in a day
    past_datetime = now - delta
    return past_datetime.strftime("%Y-%m-%d %H:%M:%S")

# Honeypot Data Generation
def generate_user_data(num_users):
    """Generates fake user data."""
    users = []
    for _ in range(num_users):
        users.append({
            "username": fake.user_name(),
            "email": fake.email(domain=random.choice(EMAIL_DOMAINS)),
            "password": generate_password(PASSWORD_LENGTH),
            "created_at": generate_realistic_datetime(),
            "last_login": generate_realistic_datetime(),
            "is_admin": random.choice([True, False]),  # Some users are admins
            "session_id": secrets.token_hex(16)
        })
    return users


def generate_server_data(num_servers):
    """Generates fake server data."""
    servers = []
    for _ in range(num_servers):
        servers.append({
            "hostname": fake.domain_name(),
            "ip_address": fake.ipv4(),
            "os": random.choice(["Linux", "Windows Server", "FreeBSD"]),
            "uptime": f"{random.randint(1, 365)} days, {random.randint(0, 23)} hours, {random.randint(0, 59)} minutes",
            "cpu_usage": round(random.uniform(0.5, 99.5), 2),  # Realistic CPU Usage
            "memory_usage": round(random.uniform(10.0, 95.0), 2),  # Realistic Memory Usage
            "disk_usage": round(random.uniform(5.0, 98.0), 2), #Realistic disk usage
            "last_reboot": generate_realistic_datetime()
        })
    return servers


def generate_database_data(num_databases):
    """Generates fake database data."""
    databases = []
    for _ in range(num_databases):
        databases.append({
            "name": fake.word().capitalize() + "DB",
            "type": random.choice(["MySQL", "PostgreSQL", "MongoDB"]),
            "version": f"{random.randint(5, 10)}.{random.randint(0, 9)}", #realistic versioning
            "size_gb": random.randint(10, 500),
            "last_backup": generate_realistic_datetime(),
            "num_tables": random.randint(10, 1000),
            "user": fake.user_name(),
            "password": generate_password(PASSWORD_LENGTH)
        })
    return databases

# Generate initial fake data
users = generate_user_data(NUM_USERS)
servers = generate_server_data(NUM_SERVERS)
databases = generate_database_data(NUM_DATABASES)


# Flask Route

@app.route('/admin/info.php')
def admin_info():
    """Serves fake admin information in a markdown-friendly format."""

    markdown_output = """
# Admin Information (Honeypot)

This is a simulated admin panel designed to mislead unauthorized access attempts.
All information is fabricated.

## System Information

   Server Time: {}
   Server Load: {:.2f}
   PHP Version: 7.4.20 (Simulated)
   Operating System: Linux (Simulated)

## User Accounts

Total users: {}

| Username | Email | Password | Last Login | Admin |
|---|---|---|---|---|
""".format(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"), random.uniform(0.1, 2.5), len(users))  # Add server time and load

    for user in users:
        markdown_output += f"| {user['username']} | {user['email']} | {user['password']} | {user['last_login']} | {user['is_admin']} |\n"

    markdown_output += """

## Server Details

Total servers: {}

| Hostname | IP Address | OS | Uptime | CPU Usage | Memory Usage | Disk Usage | Last Reboot |
|---|---|---|---|---|---|---|---|
""".format(len(servers))

    for server in servers:
        markdown_output += f"| {server['hostname']} | {server['ip_address']} | {server['os']} | {server['uptime']} | {server['cpu_usage']}% | {server['memory_usage']}% | {server['disk_usage']}% | {server['last_reboot']} |\n"

    markdown_output += """

## Database Information

Total databases: {}

| Name | Type | Version | Size (GB) | Last Backup | Tables | User | Password |
|---|---|---|---|---|---|---|---|
""".format(len(databases))

    for db in databases:
        markdown_output += f"| {db['name']} | {db['type']} | {db['version']} | {db['size_gb']} | {db['last_backup']} | {db['num_tables']} | {db['user']} | {db['password']} |\n"
    markdown_output += "\nNote: All data is fabricated for honeypot purposes."

    return Response(markdown_output, mimetype='text/plain')  # Serve as plain text/markdown


# Example custom error handler - You can add more
@app.errorhandler(404)
def page_not_found(e):
    """Custom 404 handler.  Can add a logging/trap function here."""
    return "<h1>Error 404 - Page Not Found</h1><p>This is a fake error page. Your activity is being monitored.</p>", 404

@app.errorhandler(500)
def internal_server_error(e):
    """Custom 500 handler, for realism."""
    return "<h1>Error 500 - Internal Server Error</h1><p>A simulated server error has occurred.  Please try again later.</p>", 500


if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0')  # Make sure debug is OFF in production!