Add results endpoint

env/fake_server.py

@@ -1,33 +1,36 @@
 from flask import Flask, request, jsonify
 import time
+import logging
+
+log = logging.getLogger('werkzeug')
+log.setLevel(logging.ERROR)
 
 app = Flask(__name__)
 
-# Global logs
 logs = {
     "failed_logins": 0,
+    "port_scans": 0,
     "suspicious_ips": [],
     "requests": []
 }
 
+# ---------------- Login Attack ----------------
 
 @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,
+        "type": "login_attempt",
         "username": username,
         "time": time.time()
     })
 
-    # Fake login check
     if password == "admin123":
         return jsonify({"status": "success"})
-
     else:
         logs["failed_logins"] += 1
 
@@ -37,55 +40,118 @@ def login():
         return jsonify({"status": "failed"})
 
 
-@app.route("/logs", methods=["GET"])
-def get_logs():
-    return jsonify(logs)
+# ---------------- Port Scan ----------------
 
-def run_server():
-    app.run(
-        host="0.0.0.0",
-        port=7860,
-        debug=False,
-        use_reloader=False
-    )
+@app.route("/scan", methods=["GET"])
+def scan():
+    ip = request.remote_addr
 
-@app.route("/")
-def home():
-    return "AI Cyber Deception Server Running"
+    logs["port_scans"] += 1
 
-@app.route("/admin")
-def admin():
     logs["requests"].append({
+        "ip": ip,
         "type": "port_scan",
-        "endpoint": "/admin",
         "time": time.time()
     })
+
+    if ip not in logs["suspicious_ips"]:
+        logs["suspicious_ips"].append(ip)
+
+    return jsonify({"status": "scan detected"})
+
+
+# Common scan endpoints
+
+@app.route("/admin")
+def admin():
+    logs["port_scans"] += 1
     return "Forbidden", 403
 
 
 @app.route("/config")
 def config():
-    logs["requests"].append({
-        "type": "port_scan",
-        "endpoint": "/config",
-        "time": time.time()
-    })
+    logs["port_scans"] += 1
     return "Forbidden", 403
 
 
 @app.route("/backup")
 def backup():
-    logs["requests"].append({
-        "type": "port_scan",
-        "endpoint": "/backup",
-        "time": time.time()
-    })
+    logs["port_scans"] += 1
     return "Forbidden", 403
 
 
+# ---------------- Logs ----------------
+
+@app.route("/logs", methods=["GET"])
+def get_logs():
+    return jsonify(logs)
+
+
+# ---------------- State API ----------------
+
+@app.route("/state")
+def state():
+    return jsonify({
+        "failed_logins": logs["failed_logins"],
+        "port_scans": logs["port_scans"],
+        "suspicious_ips": logs["suspicious_ips"],
+        "total_requests": len(logs["requests"])
+    })
+
+
+# ---------------- Reset API ----------------
+
+@app.route("/reset", methods=["POST"])
+def reset():
+    global logs
+    logs = {
+        "failed_logins": 0,
+        "port_scans": 0,
+        "suspicious_ips": [],
+        "requests": []
+    }
+    return jsonify({"status": "reset"})
+
+
+# ---------------- Step API (IMPORTANT) ----------------
+
+@app.route("/step", methods=["POST"])
+def step():
+
+    action = request.json.get("action")
+
+    reward = 0.0
+    done = False
+
+    # Detect brute force
+    if action == "detect_bruteforce":
+        if logs["failed_logins"] > 3:
+            reward = 0.4
+
+    # Detect port scan
+    elif action == "detect_portscan":
+        if logs["port_scans"] > 0:
+            reward = 0.3
+
+    # Mitigation step
+    elif action == "mitigate_attack":
+        if len(logs["suspicious_ips"]) > 0:
+            reward = 1.0
+            done = True
+
+    return jsonify({
+        "state": logs,
+        "reward": reward,
+        "done": done,
+        "info": {}
+    })
+
+
+# ---------------- Status ----------------
+
 @app.route("/status")
 def status():
-    return {
+    return jsonify({
         "environment": "AI Cyber Deception",
         "attacks": [
             "brute_force",
@@ -93,25 +159,22 @@ def status():
             "credential_stuffing"
         ],
         "status": "running"
-    }
-RESULTS = {}
+    })
 
-@app.route("/results")
 
-def results():
-    return RESULTS
-@app.route("/reset", methods=["POST"])
+# ---------------- Home ----------------
 
-def reset():
-    global logs
-    logs = {
-        "failed_logins": 0,
-        "suspicious_ips": [],
-        "requests": []
-    }
-    return {"status": "reset"}
+@app.route("/")
+def home():
+    return "AI Cyber Deception Server Running"
 
-@app.route("/state")
-def state():
-    return logs
 
+# ---------------- Run Server ----------------
+
+def run_server():
+    app.run(
+        host="0.0.0.0",
+        port=7860,
+        debug=False,
+        use_reloader=False
+    )

inference.py

@@ -1,57 +1,102 @@
 import threading
 import time
+import os
+import random
+from openai import OpenAI
 
-from env.fake_server import run_server, RESULTS
-from tasks.easy import run as easy
-from tasks.medium import run as medium
-from tasks.hard import run as hard
+random.seed(42)
 
-# Start fake server in background
-server_thread = threading.Thread(target=run_server, daemon=True)
-server_thread.start()
+from env.fake_server import run_server
+from env.env import DeceptionEnv
+from env.attacker import simulate_attack
 
-time.sleep(2)  # wait for server to start
+# Start server
+threading.Thread(target=run_server, daemon=True).start()
+time.sleep(2)
 
-print("[START] task=ai-deception env=cyber-security model=baseline", flush=True)
+API_BASE_URL = os.getenv("API_BASE_URL", "https://router.huggingface.co/v1")
+MODEL_NAME = os.getenv("MODEL_NAME", "Qwen/Qwen2.5-7B-Instruct")
+HF_TOKEN = os.getenv("HF_TOKEN")
 
-# Run continuously
-while True:
+if not HF_TOKEN:
+    print("[ERROR] HF_TOKEN not set. Please set your Hugging Face token.")
+    exit(1)
 
-    # Easy Task
-    easy_score = easy()
-    print(
-        f"[STEP] step=1 action=easy reward={easy_score:.2f} done=false error=null",
-        flush=True
-    )
+client = OpenAI(
+    base_url=API_BASE_URL,
+    api_key=HF_TOKEN
+)
 
-    # Medium Task
-    medium_score = medium()
-    print(
-        f"[STEP] step=2 action=medium reward={medium_score:.2f} done=false error=null",
-        flush=True
-    )
+env = DeceptionEnv()
+state = env.reset()   # reset only once
 
-    # Hard Task
-    hard_score = hard()
-    print(
-        f"[STEP] step=3 action=hard reward={hard_score:.2f} done=true error=null",
-        flush=True
+print("[START] task=ai-deception env=cyber-security model=AI-agent", flush=True)
+
+rewards = []
+history = []
+
+for step in range(1, 4):
+
+    simulate_attack()
+
+    summary = {
+        "failed_logins": state["failed_logins"],
+        "port_scans": state.get("port_scans", 0),
+        "suspicious_ips": len(state["suspicious_ips"])
+    }
+
+    prompt = f"""
+You are a cybersecurity decision system.
+
+Previous actions:
+{history}
+
+Current summary:
+{summary}
+
+STRICT RULES (must follow exactly):
+
+1. If no previous action → detect_attack
+2. If last action == detect_attack → deploy_honeypot
+3. If last action == deploy_honeypot → block_ip
+4. If last action == block_ip → block_ip
+
+Return ONLY one word:
+detect_attack
+deploy_honeypot
+fake_database
+block_ip
+"""
+
+    response = client.chat.completions.create(
+        model=MODEL_NAME,
+        messages=[{"role": "user", "content": prompt}],
+        temperature=0.2,
+        max_tokens=20
     )
 
+    action = response.choices[0].message.content.strip()
+
+    # deterministic fallback
+    if history:
+        last = history[-1]
+        if last == "detect_attack":
+            action = "deploy_honeypot"
+        elif last == "deploy_honeypot":
+            action = "block_ip"
+
+    history.append(action)
+
+    state, reward, done, _ = env.step(action)
+    rewards.append(reward)
+
     print(
-        f"[END] success=true steps=3 rewards={easy_score:.2f},{medium_score:.2f},{hard_score:.2f}",
+        f"[STEP] step={step} action={action} reward={reward:.2f} "
+        f"done={str(done).lower()} error=null",
         flush=True
     )
 
-    # Update results for judges
-    RESULTS["status"] = "completed"
-    RESULTS["steps"] = 3
-    RESULTS["rewards"] = [easy_score, medium_score, hard_score]
-    RESULTS["attacks"] = [
-        "brute_force",
-        "port_scan",
-        "credential_stuffing"
-    ]
-
-    # wait before next attack cycle
-    time.sleep(60)
+print(
+    f"[END] success=true steps=3 rewards={','.join(f'{r:.2f}' for r in rewards)}",
+    flush=True
+)