asdas

backend/routers/setup.py

@@ -0,0 +1,223 @@
+from fastapi import APIRouter, HTTPException, UploadFile, File
+from pydantic import BaseModel
+import json
+from typing import List, Optional
+from utils.models import StatusMessageModel
+from routers import nfproxy, nfregex, porthijack, firewall
+
+class ServiceConfig(BaseModel):
+    name: str
+    port: int
+    proto: str
+    ip_int: str
+    fail_open: bool = True
+
+class PortHijackServiceConfig(BaseModel):
+    name: str
+    public_port: int
+    proxy_port: int
+    proto: str
+    ip_src: str
+    ip_dst: str
+
+class FirewallRuleConfig(BaseModel):
+    mode: str
+    src: str
+    dst: str
+    in_int: str
+    out_int: str
+    proto: str
+    sport: str
+    dport: str
+
+class SetupConfig(BaseModel):
+    services: Optional[List[ServiceConfig]] = []
+    porthijack: Optional[List[PortHijackServiceConfig]] = []
+    firewall: Optional[List[FirewallRuleConfig]] = []
+
+class SetupResponse(BaseModel):
+    status: str
+    services_created: int = 0
+    porthijack_created: int = 0
+    firewall_created: int = 0
+    errors: List[str] = []
+
+app = APIRouter()
+
+@app.post("/import", response_model=SetupResponse)
+async def import_setup(config: SetupConfig):
+    """
+    Import services and rules from a setup configuration.
+    Creates basic services without filters or regex rules.
+    """
+    errors = []
+    services_count = 0
+    porthijack_count = 0
+    firewall_count = 0
+
+    # Import Services
+    if config.services:
+        for service_config in config.services:
+            try:
+                # Determine which module to use based on protocol
+                # HTTP -> NFProxy, TCP/UDP -> can use either (prefer NFProxy)
+                if service_config.proto in ["tcp", "http", "udp"]:
+                    # Create NFProxy service
+                    try:
+                        add_form = nfproxy.ServiceAddForm(
+                            name=service_config.name,
+                            port=service_config.port,
+                            proto=service_config.proto,
+                            ip_int=service_config.ip_int,
+                            fail_open=service_config.fail_open
+                        )
+                        result = await nfproxy.add_service(add_form)
+                        
+                        if result.status == "ok":
+                            services_count += 1
+                        else:
+                            errors.append(f"Service '{service_config.name}': Failed to create")
+                    except Exception as e:
+                        errors.append(f"Service '{service_config.name}': {str(e)}")
+                else:
+                    errors.append(f"Service '{service_config.name}': Unsupported protocol '{service_config.proto}'")
+                    
+            except Exception as e:
+                errors.append(f"Service '{service_config.name}': {str(e)}")
+
+    # Import PortHijack services
+    if config.porthijack:
+        for service_config in config.porthijack:
+            try:
+                add_form = porthijack.ServiceAddForm(
+                    name=service_config.name,
+                    public_port=service_config.public_port,
+                    proxy_port=service_config.proxy_port,
+                    proto=service_config.proto,
+                    ip_src=service_config.ip_src,
+                    ip_dst=service_config.ip_dst
+                )
+                result = await porthijack.add_service(add_form)
+                
+                if result.status == "ok":
+                    porthijack_count += 1
+                else:
+                    errors.append(f"PortHijack service '{service_config.name}': Failed to create")
+            except Exception as e:
+                errors.append(f"PortHijack service '{service_config.name}': {str(e)}")
+
+    # Import Firewall rules
+    if config.firewall:
+        for rule_config in config.firewall:
+            try:
+                rule_form = firewall.RuleFormAdd(
+                    mode=rule_config.mode,
+                    src=rule_config.src,
+                    dst=rule_config.dst,
+                    in_int=rule_config.in_int,
+                    out_int=rule_config.out_int,
+                    proto=rule_config.proto,
+                    sport=rule_config.sport,
+                    dport=rule_config.dport
+                )
+                await firewall.add_rule(rule_form)
+                firewall_count += 1
+            except Exception as e:
+                errors.append(f"Firewall rule: {str(e)}")
+
+    return SetupResponse(
+        status="ok" if len(errors) == 0 else "partial",
+        services_created=services_count,
+        porthijack_created=porthijack_count,
+        firewall_created=firewall_count,
+        errors=errors
+    )
+
+@app.post("/import/file")
+async def import_setup_file(file: UploadFile = File(...)):
+    """
+    Import services from an uploaded JSON file.
+    """
+    try:
+        content = await file.read()
+        config_dict = json.loads(content.decode('utf-8'))
+        config = SetupConfig(**config_dict)
+        return await import_setup(config)
+    except json.JSONDecodeError as e:
+        raise HTTPException(status_code=400, detail=f"Invalid JSON: {str(e)}")
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Error processing file: {str(e)}")
+
+@app.get("/export")
+async def export_setup():
+    """
+    Export all current services and rules as a JSON configuration.
+    Exports only service definitions without filters or regexes.
+    """
+    config = {
+        "services": [],
+        "porthijack": [],
+        "firewall": []
+    }
+
+    # Export NFProxy services
+    try:
+        nfproxy_services = await nfproxy.get_services()
+        for service in nfproxy_services:
+            config["services"].append({
+                "name": service.name,
+                "port": service.port,
+                "proto": service.proto,
+                "ip_int": service.ip_int,
+                "fail_open": service.fail_open
+            })
+    except:
+        pass
+
+    # Export NFRegex services
+    try:
+        nfregex_services = await nfregex.get_services()
+        for service in nfregex_services:
+            config["services"].append({
+                "name": service.name,
+                "port": service.port,
+                "proto": service.proto,
+                "ip_int": service.ip_int,
+                "fail_open": service.fail_open
+            })
+    except:
+        pass
+
+    # Export PortHijack services
+    try:
+        porthijack_services = await porthijack.get_services()
+        for service in porthijack_services:
+            config["porthijack"].append({
+                "name": service.name,
+                "public_port": service.public_port,
+                "proxy_port": service.proxy_port,
+                "proto": service.proto,
+                "ip_src": service.ip_src,
+                "ip_dst": service.ip_dst
+            })
+    except:
+        pass
+
+    # Export Firewall rules
+    try:
+        fw_rules = await firewall.get_rules()
+        for rule in fw_rules:
+            config["firewall"].append({
+                "mode": rule.mode,
+                "src": rule.src,
+                "dst": rule.dst,
+                "in_int": rule.in_int,
+                "out_int": rule.out_int,
+                "proto": rule.proto,
+                "sport": rule.sport,
+                "dport": rule.dport
+            })
+    except:
+        pass
+
+    return config