Files
harbor-security/proxy-harbor.py
T

272 lines
11 KiB
Python

import os
import http.server
import urllib.request
import urllib.error
import json
import ssl
from urllib.parse import urlparse, parse_qs, urlencode
import base64
HARBOR_URL = os.environ.get("HARBOR_URL", "https://harbor.tu-dominio.com").rstrip("/")
PORT = int(os.environ.get("PORT", 8080))
HARBOR_ROBOT = os.environ.get("HARBOR_ROBOT", "")
HARBOR_TOKEN = os.environ.get("HARBOR_TOKEN", "")
DEFAULT_AUTH_HEADER = None
if HARBOR_ROBOT and HARBOR_TOKEN:
credentials = f"{HARBOR_ROBOT}:{HARBOR_TOKEN}"
encoded_credentials = base64.b64encode(credentials.encode("utf-8")).decode("utf-8")
DEFAULT_AUTH_HEADER = f"Basic {encoded_credentials}"
print(f"[*] Autenticación por defecto configurada mediante variables de entorno para el usuario robot: {HARBOR_ROBOT}")
SSL_CONTEXT = ssl._create_unverified_context()
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, context=SSL_CONTEXT) 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()}
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 ESTADO DE CONEXIÓN
if path == "/api/status":
connected = False
try:
# Probamos a consultar proyectos o summary para validar las credenciales del robot
target_api = f"{HARBOR_URL}/api/v2.0/systeminfo"
req = urllib.request.Request(target_api)
req.add_header("Accept", "application/json")
if DEFAULT_AUTH_HEADER:
req.add_header("Authorization", DEFAULT_AUTH_HEADER)
with urllib.request.urlopen(req, timeout=5, context=SSL_CONTEXT) as response:
if response.status == 200:
connected = True
except Exception:
connected = False
status_data = {
"connected": connected,
"harbor_url": HARBOR_URL,
"robot_user": HARBOR_ROBOT if HARBOR_ROBOT else "No configurado"
}
self.send_json_response(status_data)
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 DEFAULT_AUTH_HEADER:
req.add_header("Authorization", DEFAULT_AUTH_HEADER)
try:
with urllib.request.urlopen(req, timeout=10, context=SSL_CONTEXT) 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)
return
# BÚSQUEDA NATIVA /security/vul CON PAGINACIÓN
if path == "/api/search":
self.handle_native_vulnerability_search(query_params)
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 DEFAULT_AUTH_HEADER:
req.add_header("Authorization", DEFAULT_AUTH_HEADER)
try:
with urllib.request.urlopen(req, context=SSL_CONTEXT) 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):
self._process_vul_search(params, is_export=False)
def handle_export_vulnerabilities(self, params):
self._process_vul_search(params, is_export=True)
def _process_vul_search(self, params, 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:
projects_data = fetch_json(f"{HARBOR_URL}/api/v2.0/projects?page_size=100", DEFAULT_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:
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 DEFAULT_AUTH_HEADER:
req.add_header("Authorization", DEFAULT_AUTH_HEADER)
with urllib.request.urlopen(req, timeout=15, context=SSL_CONTEXT) 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 corriendo en el puerto {PORT}, conectado a: {HARBOR_URL}")
server.serve_forever()