Honeypot 000 : .env.local.php

from flask import Flask, render_template, request, make_response
import random
import string
import datetime
from faker import Faker  # pip install Faker

app = Flask(__name__)
fake = Faker()

# Configuration - Customize these!
HONEYPOT_FILE = "/.env.local.php"
RESPONSE_DELAY_SECONDS = 2  # Artificial delay to slow down bots
MAX_LOG_SIZE = 1024  10  # Maximum size of the honeypot log file in kb (10 kb)

# --- Helper Functions ---

def generate_fake_credentials():
    """Generates a realistic-looking set of fake credentials."""
    username = fake.user_name()
    email = fake.email()
    password = fake.password(length=12, special_chars=True, digits=True, upper_case=True, lower_case=True)  # Strong password
    db_host = fake.ipv4() #Fake to look like a database
    db_name = "".join(random.choices(string.ascii_lowercase, k=8)) #short name like dbname
    db_user = fake.user_name() #username look a like
    db_pass = fake.password(length=10, special_chars=False, digits=True, upper_case=True, lower_case=True)
    api_key = ''.join(random.choices(string.ascii_letters + string.digits, k=32)) #Long random API
    secret_key = ''.join(random.choices(string.ascii_letters + string.digits, k=32)) #another key as secrets
    return {
        "APP_USERNAME": username,
        "APP_EMAIL": email,
        "APP_PASSWORD": password,
        "DATABASE_HOST": db_host,
        "DATABASE_NAME": db_name,
        "DATABASE_USER": db_user,
        "DATABASE_PASSWORD": db_pass,
        "API_KEY": api_key,
        "SECRET_KEY": secret_key,
        "DEBUG": "false",
        "APP_ENV": "production",
        "APP_URL": fake.url()
    }



def log_access(request):
    """Logs access attempts to the honeypot file with relevant details."""
    timestamp = datetime.datetime.now().isoformat()
    ip_address = request.remote_addr
    user_agent = request.user_agent.string
    requested_path = request.path

    log_entry = f"[{timestamp}] IP: {ip_address}, User-Agent: {user_agent}, Path: {requested_path}\n"

    try:
        with open("honeypot.log", "a") as log_file:
            log_file.write(log_entry)

        # Check log file size and truncate if necessary
        if os.path.getsize("honeypot.log") > MAX_LOG_SIZE:
          truncate_log("honeypot.log", MAX_LOG_SIZE)


    except Exception as e:
        print(f"Error writing to log file: {e}")


def truncate_log(filename, max_size):
    """Truncates the log file to a maximum size in bytes."""
    try:
        with open(filename, "r+") as f:
            lines = f.readlines()
            total_size = sum(len(line.encode('utf-8')) for line in lines)

            while total_size > max_size and lines:
                removed_line = lines.pop(0)
                total_size -= len(removed_line.encode('utf-8'))

            f.seek(0)  # Rewind to the beginning
            f.writelines(lines)
            f.truncate()  # Remove the remaining part of the old file
    except Exception as e:
        print(f"Error truncating log file: {e}")


# --- Routes ---

@app.route(HONEYPOT_FILE)
def env_file():
    """
    Serves a fake .env.local.php file.  This is the core of the honeypot.
    It generates realistic, but fake, credentials and configuration settings
    that will hopefully keep bots interested and engaged.
    """
    log_access(request)  # Log the attempt

    fake_data = generate_fake_credentials()

    # Format the output as a PHP file containing environment variables

    php_output = "<?php\n\n"
    php_output += "// This file contains environment variables.\n"
    php_output += "// DO NOT COMMIT THIS FILE TO VERSION CONTROL!\n\n"

    for key, value in fake_data.items():
        php_output += f"putenv('{key}={value}');\n"

    php_output += "\n// End of file\n"
    # Slow down the response (very important for honeypots)
    import time
    time.sleep(RESPONSE_DELAY_SECONDS)

    response = make_response(php_output)
    response.headers['Content-Type'] = 'application/php'   # Important: Trick the bot

    return response

@app.route("/robots.txt")
def robots_txt():
    """Serves a standard robots.txt file to prevent accidental crawling."""
    return "User-agent: \nDisallow: /", {"Content-Type": "text/plain"}


@app.route("/")
def index():
    """A basic index page to prevent directory listing and avoid simple errors."""
    return "Honeypot active."

@app.errorhandler(404)
def page_not_found(e):
    """Handles 404 errors. Logs the attempt."""
    log_access(request)
    return "Page not found. Honeypot active.", 404

# --- Main ---
if __name__ == "__main__":
    import os
    #Check if the log exists, if not, create one
    if not os.path.exists("honeypot.log"):
        open("honeypot.log", "w").close()

    app.run(debug=False, host="0.0.0.0", port=5000) # NEVER RUN IN DEBUG MODE IN PRODUCTION.