Upload AI deception env

Dockerfile

@@ -0,0 +1,11 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+COPY . .
+
+RUN pip install --no-cache-dir -r requirements.txt
+
+EXPOSE 5000
+
+CMD ["python", "inference.py"]

README.md

@@ -1,11 +1,80 @@
----
-title: Ai Deception Openenv
-emoji: 🦀
-colorFrom: green
-colorTo: pink
-sdk: docker
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# AI Cyber Deception OpenEnv
+
+## Overview
+
+AI Cyber Deception OpenEnv is a real-world cybersecurity simulation environment where an AI agent learns to detect attackers and deploy deception strategies such as honeypots.
+
+## Features
+
+- Fake server simulation
+- Attacker simulation
+- AI deception environment
+- Reward-based learning
+- Multiple difficulty tasks
+
+## Tasks
+
+### Easy
+Detect brute force attack
+
+### Medium
+Deploy honeypot
+
+### Hard
+Full incident response (detect, deceive, block)
+
+## Actions
+
+- detect_attack
+- deploy_honeypot
+- block_ip
+
+## Reward System
+
+- Detect attack → +0.5
+- Deploy honeypot → +0.3
+- Block attacker → +0.2
+
+## Project Structure
+ai_deception_env/
+├── env/
+├── tasks/
+├── inference.py
+├── openenv.yaml
+├── Dockerfile
+
+
+## Run
+
+### Local
+
+
+python inference.py
+
+
+### Docker
+
+
+docker build -t ai-deception-env .
+docker run ai-deception-env
+
+
+## Example Output
+
+
+[START]
+[STEP]
+[STEP]
+[STEP]
+[END]
+
+
+## Requirements
+
+- Python 3.10
+- Flask
+- Requests
+
+## Author
+
+Bytecore team

env/attacker.py

@@ -0,0 +1,25 @@
+import requests
+import time
+
+TARGET = "http://127.0.0.1:5000"
+
+def brute_force():
+
+    print("Starting brute force attack...")
+
+    for i in range(5):
+        response = requests.post(
+            f"{TARGET}/login",
+            data={
+                "username": "admin",
+                "password": "wrong"
+            }
+        )
+
+        print("Attempt:", i+1, response.json())
+
+        time.sleep(1)
+
+
+if __name__ == "__main__":
+    brute_force()

env/deception.py

@@ -0,0 +1,28 @@
+def deploy_honeypot():
+
+    print("Honeypot deployed")
+
+    return {
+        "action": "honeypot",
+        "status": "deployed"
+    }
+
+
+def fake_database():
+
+    print("Fake database exposed")
+
+    return {
+        "action": "fake_db",
+        "status": "active"
+    }
+
+
+def block_attacker(ip):
+
+    print(f"Blocked attacker: {ip}")
+
+    return {
+        "action": "block",
+        "ip": ip
+    }

env/env.py

@@ -0,0 +1,52 @@
+import requests
+from env.deception import deploy_honeypot, fake_database, block_attacker
+
+SERVER = "http://127.0.0.1:5000"
+
+class DeceptionEnv:
+
+    def __init__(self):
+        self.state = {}
+        self.done = False
+
+    def reset(self):
+
+        self.done = False
+
+        logs = requests.get(f"{SERVER}/logs").json()
+
+        self.state = logs
+
+        return self.state
+
+
+    def step(self, action):
+
+        reward = 0
+
+        logs = requests.get(f"{SERVER}/logs").json()
+
+        failed_logins = logs["failed_logins"]
+
+        if action == "detect_attack":
+            if failed_logins > 3:
+                reward += 0.5
+
+        if action == "deploy_honeypot":
+            deploy_honeypot()
+            reward += 0.3
+
+        if action == "fake_database":
+            fake_database()
+            reward += 0.2
+
+        if action == "block_ip":
+            if logs["suspicious_ips"]:
+                ip = logs["suspicious_ips"][0]
+                block_attacker(ip)
+                reward += 0.2
+                self.done = True
+
+        self.state = logs
+
+        return self.state, reward, self.done, {}

env/fake_server.py

@@ -0,0 +1,50 @@
+from flask import Flask, request, jsonify
+import time
+
+app = Flask(__name__)
+
+# Global logs
+logs = {
+    "failed_logins": 0,
+    "suspicious_ips": [],
+    "requests": []
+}
+
+
+@app.route("/login", methods=["POST"])
+def login():
+
+    ip = request.remote_addr
+    username = request.form.get("username")
+    password = request.form.get("password")
+
+    logs["requests"].append({
+        "ip": ip,
+        "username": username,
+        "time": time.time()
+    })
+
+    # Fake login check
+    if password == "admin123":
+        return jsonify({"status": "success"})
+
+    else:
+        logs["failed_logins"] += 1
+
+        if ip not in logs["suspicious_ips"]:
+            logs["suspicious_ips"].append(ip)
+
+        return jsonify({"status": "failed"})
+
+
+@app.route("/logs", methods=["GET"])
+def get_logs():
+    return jsonify(logs)
+
+
+def run_server():
+    app.run(port=5000)
+
+@app.route("/")
+def home():
+    return "AI Cyber Deception Server Running"

env/test_env.py

@@ -0,0 +1,12 @@
+from env import DeceptionEnv
+
+env = DeceptionEnv()
+
+state = env.reset()
+
+print("Initial State:", state)
+
+state, reward, done, _ = env.step("deploy_honeypot")
+
+print("After step:", state)
+print("Reward:", reward)

env/test_server.py

@@ -0,0 +1,3 @@
+from fake_server import run_server
+
+run_server()

inference.py

@@ -0,0 +1,28 @@
+import threading
+import time
+
+from env.fake_server import run_server
+from tasks.easy import run as easy
+from tasks.medium import run as medium
+from tasks.hard import run as hard
+
+
+# Start fake server in background
+server_thread = threading.Thread(target=run_server, daemon=True)
+server_thread.start()
+
+time.sleep(2)  # wait for server to start
+
+
+print("[START] task=ai-deception env=cyber-security model=baseline")
+
+easy_score = easy()
+print(f"[STEP] step=1 action=easy reward={easy_score:.2f} done=false error=null")
+
+medium_score = medium()
+print(f"[STEP] step=2 action=medium reward={medium_score:.2f} done=false error=null")
+
+hard_score = hard()
+print(f"[STEP] step=3 action=hard reward={hard_score:.2f} done=true error=null")
+
+print(f"[END] success=true steps=3 rewards={easy_score:.2f},{medium_score:.2f},{hard_score:.2f}")

openenv.yaml

@@ -0,0 +1,10 @@
+name: ai-deception-env
+description: AI Cyber Deception Environment
+version: 1.0
+
+tasks:
+  - easy
+  - medium
+  - hard
+
+entry_point: inference.py

requirements.txt

@@ -0,0 +1,5 @@
+flask
+requests
+numpy
+pydantic
+openai

tasks/easy.py

@@ -0,0 +1,14 @@
+from env.env import DeceptionEnv
+from env.attacker import brute_force
+
+def run():
+
+    brute_force()
+
+    env = DeceptionEnv()
+
+    env.reset()
+
+    state, reward, done, _ = env.step("detect_attack")
+
+    return reward

tasks/hard.py

@@ -0,0 +1,23 @@
+from env.env import DeceptionEnv
+from env.attacker import brute_force
+
+def run():
+
+    brute_force()
+
+    env = DeceptionEnv()
+
+    env.reset()
+
+    total_reward = 0
+
+    _, r, _, _ = env.step("detect_attack")
+    total_reward += r
+
+    _, r, _, _ = env.step("deploy_honeypot")
+    total_reward += r
+
+    _, r, _, _ = env.step("block_ip")
+    total_reward += r
+
+    return total_reward

tasks/medium.py

@@ -0,0 +1,11 @@
+from env.env import DeceptionEnv
+
+def run():
+
+    env = DeceptionEnv()
+
+    env.reset()
+
+    state, reward, done, _ = env.step("deploy_honeypot")
+
+    return reward

tasks/test_tasks.py

@@ -0,0 +1,7 @@
+from tasks.easy import run as easy
+from tasks.medium import run as medium
+from tasks.hard import run as hard
+
+print("Easy:", easy())
+print("Medium:", medium())
+print("Hard:", hard())