236 lines
9.8 KiB
Python
236 lines
9.8 KiB
Python
import os
|
|
import http.server
|
|
import urllib.request
|
|
import urllib.error
|
|
import json
|
|
from urllib.parse import urlparse, parse_qs, urlencode
|
|
|
|
HARBOR_URL = os.environ.get("HARBOR_URL", "https://demo.goharbor.io").rstrip("/")
|
|
PORT = 8080
|
|
|
|
def fetch_json(url, auth_header):
|
|
req = urllib.request.Request(url)
|
|
req.add_header("Accept", "application/json")
|
|
if auth_header:
|
|
req.add_header("Authorization", auth_header)
|
|
try:
|
|
with urllib.request.urlopen(req, timeout=8) as response:
|
|
return json.loads(response.read().decode("utf-8"))
|
|
except Exception:
|
|
return None
|
|
|
|
class HarborProxyHandler(http.server.BaseHTTPRequestHandler):
|
|
|
|
def do_OPTIONS(self):
|
|
self.send_response(200)
|
|
self.send_header("Access-Control-Allow-Origin", "*")
|
|
self.send_header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
|
|
self.send_header("Access-Control-Allow-Headers", "Authorization, Content-Type")
|
|
self.end_headers()
|
|
|
|
def do_GET(self):
|
|
parsed_url = urlparse(self.path)
|
|
path = parsed_url.path
|
|
query_params = {k: v[0] for k, v in parse_qs(parsed_url.query).items()}
|
|
auth_header = self.headers.get("Authorization")
|
|
|
|
if path == "/" or path == "/index.html":
|
|
self.serve_file("index.html", "text/html")
|
|
return
|
|
elif path.startswith("/assets/"):
|
|
self.serve_static_asset()
|
|
return
|
|
|
|
# ENDPOINT DE MÉTRICAS GLOBALES (SUMMARY)
|
|
if path == "/api/summary":
|
|
target_api = f"{HARBOR_URL}/api/v2.0/security/summary?with_dangerous_cve=false&with_dangerous_artifact=false"
|
|
req = urllib.request.Request(target_api)
|
|
req.add_header("Accept", "application/json")
|
|
if auth_header:
|
|
req.add_header("Authorization", auth_header)
|
|
try:
|
|
with urllib.request.urlopen(req, timeout=10) as response:
|
|
data = response.read()
|
|
self.send_response(response.status)
|
|
self.send_header("Content-Type", "application/json")
|
|
self.send_header("Access-Control-Allow-Origin", "*")
|
|
self.end_headers()
|
|
self.wfile.write(data)
|
|
except Exception as e:
|
|
self.send_json_response({})
|
|
return
|
|
|
|
# ENDPOINT DE EXPORTACIÓN MASIVA (CSV/EXCEL)
|
|
if path == "/api/export":
|
|
self.handle_export_vulnerabilities(query_params, auth_header)
|
|
return
|
|
|
|
# BÚSQUEDA NATIVA /security/vul CON PAGINACIÓN
|
|
if path == "/api/search":
|
|
self.handle_native_vulnerability_search(query_params, auth_header)
|
|
return
|
|
|
|
target_url = f"{HARBOR_URL}{path}"
|
|
if parsed_url.query:
|
|
target_url += f"?{parsed_url.query}"
|
|
|
|
req = urllib.request.Request(target_url)
|
|
req.add_header("Accept", "application/json")
|
|
if auth_header:
|
|
req.add_header("Authorization", auth_header)
|
|
|
|
try:
|
|
with urllib.request.urlopen(req) as response:
|
|
data = response.read()
|
|
self.send_response(response.status)
|
|
self.send_header("Content-Type", "application/json")
|
|
self.send_header("Access-Control-Allow-Origin", "*")
|
|
self.end_headers()
|
|
self.wfile.write(data)
|
|
except urllib.error.HTTPError as e:
|
|
self.send_response(e.code)
|
|
self.send_header("Content-Type", "application/json")
|
|
self.send_header("Access-Control-Allow-Origin", "*")
|
|
self.end_headers()
|
|
self.wfile.write(e.read())
|
|
except Exception as e:
|
|
self.send_response(500)
|
|
self.send_header("Content-Type", "application/json")
|
|
self.send_header("Access-Control-Allow-Origin", "*")
|
|
self.end_headers()
|
|
self.wfile.write(json.dumps({"error": str(e)}).encode("utf-8"))
|
|
|
|
def handle_native_vulnerability_search(self, params, auth_header):
|
|
self._process_vul_search(params, auth_header, is_export=False)
|
|
|
|
def handle_export_vulnerabilities(self, params, auth_header):
|
|
self._process_vul_search(params, auth_header, is_export=True)
|
|
|
|
def _process_vul_search(self, params, auth_header, is_export=False):
|
|
filter_type = params.get("filter_type", "All")
|
|
query = params.get("query", "").strip()
|
|
severity_raw = params.get("severity", "").strip()
|
|
cvss_from = params.get("cvss_from", "").strip()
|
|
cvss_to = params.get("cvss_to", "").strip()
|
|
|
|
page = "1" if is_export else params.get("page", "1")
|
|
page_size = "500" if is_export else params.get("page_size", "10")
|
|
|
|
q_conditions = []
|
|
project_map = {}
|
|
|
|
try:
|
|
# Mapeo rápido de proyectos opcional solo para mostrar nombres bonitos en la tabla si hiciera falta
|
|
projects_data = fetch_json(f"{HARBOR_URL}/api/v2.0/projects?page_size=100", auth_header)
|
|
if projects_data:
|
|
for p in projects_data:
|
|
project_map[p.get("project_id")] = p.get("name")
|
|
|
|
if filter_type == "CVE ID" and query:
|
|
q_conditions.append(f"cve_id={query}")
|
|
elif filter_type == "Package" and query:
|
|
q_conditions.append(f"package={query}")
|
|
elif filter_type == "Repository Name" and query:
|
|
# Búsqueda directa por repositorio (ej: demo8/mysql)
|
|
q_conditions.append(f"repository_name={query}")
|
|
elif filter_type == "Digest" and query:
|
|
q_conditions.append(f"digest={query}")
|
|
elif filter_type == "Severity" and severity_raw and severity_raw.upper() != "ALL":
|
|
sev_map = {
|
|
"CRITICAL": "Critical",
|
|
"HIGH": "High",
|
|
"MEDIUM": "Medium",
|
|
"LOW": "Low",
|
|
"N/A": "n/a",
|
|
"NONE": "None"
|
|
}
|
|
mapped_sev = sev_map.get(severity_raw.upper(), severity_raw.capitalize())
|
|
q_conditions.append(f"severity={mapped_sev}")
|
|
elif filter_type == "CVSS3":
|
|
min_val = cvss_from if cvss_from else "0"
|
|
max_val = cvss_to if cvss_to else "10"
|
|
q_conditions.append(f"cvss_score_v3=[{min_val}~{max_val}]")
|
|
|
|
api_params = {
|
|
"page": page,
|
|
"page_size": page_size,
|
|
"tune_count": "false",
|
|
"with_tag": "true"
|
|
}
|
|
|
|
if q_conditions:
|
|
api_params["q"] = ",".join(q_conditions)
|
|
|
|
target_api = f"{HARBOR_URL}/api/v2.0/security/vul?{urlencode(api_params)}"
|
|
print(f"[*] Consultando API nativa de Harbor: {target_api}")
|
|
|
|
req = urllib.request.Request(target_api)
|
|
req.add_header("Accept", "application/json")
|
|
if auth_header:
|
|
req.add_header("Authorization", auth_header)
|
|
|
|
with urllib.request.urlopen(req, timeout=15) as response:
|
|
raw_data = json.loads(response.read().decode("utf-8"))
|
|
|
|
formatted_results = []
|
|
for item in raw_data:
|
|
p_id = item.get("project_id")
|
|
project_name = project_map.get(p_id, str(p_id))
|
|
repo_name = item.get("repository_name", "")
|
|
|
|
formatted_results.append({
|
|
"cve_id": item.get("cve_id", "N/A"),
|
|
"severity": item.get("severity", "UNKNOWN").upper(),
|
|
"package": item.get("package", "Desconocido"),
|
|
"version": item.get("version", "-"),
|
|
"fixed_version": item.get("fixed_version", "N/A"),
|
|
"project": project_name,
|
|
"repository": repo_name,
|
|
"tag": item.get("tags", ["latest"])[0] if item.get("tags") else "latest",
|
|
"digest": item.get("digest", "N/A"),
|
|
"cvss3": float(item.get("cvss_v3_score", 0)),
|
|
"description": item.get("desc", "Sin descripción.")
|
|
})
|
|
|
|
self.send_json_response(formatted_results)
|
|
except urllib.error.HTTPError as e:
|
|
print(f"[!] Error HTTP de Harbor en /security/vul: {e.code}")
|
|
self.send_json_response([])
|
|
except Exception as e:
|
|
print(f"[!] Error en consulta nativa: {e}")
|
|
self.send_json_response([])
|
|
|
|
def send_json_response(self, data):
|
|
self.send_response(200)
|
|
self.send_header("Content-Type", "application/json")
|
|
self.send_header("Access-Control-Allow-Origin", "*")
|
|
self.end_headers()
|
|
self.wfile.write(json.dumps(data).encode("utf-8"))
|
|
|
|
def serve_file(self, filename, content_type):
|
|
if os.path.exists(filename):
|
|
with open(filename, "rb") as f:
|
|
content = f.read()
|
|
self.send_response(200)
|
|
self.send_header("Content-Type", content_type)
|
|
self.end_headers()
|
|
self.wfile.write(content)
|
|
else:
|
|
self.send_response(404)
|
|
self.end_headers()
|
|
|
|
def serve_static_asset(self):
|
|
filepath = self.path.lstrip("/")
|
|
if os.path.exists(filepath):
|
|
content_type = "text/plain"
|
|
if filepath.endswith(".js"): content_type = "application/javascript"
|
|
elif filepath.endswith(".css"): content_type = "text/css"
|
|
self.serve_file(filepath, content_type)
|
|
else:
|
|
self.send_response(404)
|
|
self.end_headers()
|
|
|
|
if __name__ == "__main__":
|
|
server = http.server.HTTPServer(("0.0.0.0", PORT), HarborProxyHandler)
|
|
print(f"[*] Proxy Harbor con repositorio directo corriendo en el puerto {PORT}, conectado a: {HARBOR_URL}")
|
|
server.serve_forever() |