fixing to 1 system

Author: Jose Hernandez

Diff for: Dockerfile

@@ -1,17 +1,38 @@
 FROM python:3.11.4-slim-buster
 
 # install dependencies
-RUN apt-get update 
-RUN apt-get install -y git curl jq
+RUN apt-get update && apt-get install -y \
+    git \
+    curl \
+    jq \
+    python3-venv \
+    build-essential \
+    python3-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install uv for main app dependencies
 COPY --from=ghcr.io/astral-sh/uv:latest /uv /bin/uv
 
 # define work directory
 WORKDIR /app/
-COPY . /app
 
-# install backend
-RUN cd backend && ./setup-sigma-versions.sh
+# Copy pyproject.toml first
+COPY pyproject.toml uv.lock ./
+
+# Install main application dependencies with uv
+RUN uv venv && \
+    . .venv/bin/activate && \
+    uv pip install -e .
+
+# Copy application files
+COPY app /app/app
+
+# Make setup script executable
+RUN chmod +x /app/app/setup.py
+
+# Setup Sigma versions using pip
+RUN cd /app/app && python setup.py
 
-# launch front- and backend
+# launch application
 EXPOSE 8000
-ENTRYPOINT ["./entrypoint.sh"]
+CMD [".venv/bin/python", "-m", "app.main"]

Diff for: README.md

@@ -9,14 +9,22 @@ Welcome to sigconverter.io, a user-friendly converter for Sigma rules. This proj
 - Easy-to-use interface for Sigma rule conversion
 - Supports multiple backends through pySigma
 - Continuously updated to stay in sync with pySigma
+- Multiple Sigma versions support through isolated environments
 
 ## 🚀 Getting Started
 
 ### Without Docker:
 
 ```bash
-poetry install 
-poetry run ./run.py
+# Install dependencies
+cd backend
+pip install .
+
+# Setup Sigma versions
+./setup-sigma-versions.sh
+
+# Run the application
+python backend.py
 ```
 
 ### With Docker:
@@ -26,11 +34,7 @@ poetry run ./run.py
 docker build -t sigconverter.io .
 
 # Run the container
-# Note: We need to expose both the frontend port (8000) and backend ports (8100-8199)
-docker run -d \
-  -p 8000:8000 \
-  -p 8100-8199:8100-8199 \
-  sigconverter.io
+docker run -d -p 8000:8000 sigconverter.io
 ```
 
 Visit the live instance at [https://sigconverter.io](https://sigconverter.io) or locally at [http://localhost:8000](http://localhost:8000).

Diff for: app/main.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+import os
+import json
+import yaml
+import base64
+import subprocess
+from pathlib import Path
+from flask import Flask, render_template, jsonify, request, Response
+
+app = Flask(__name__)
+
+def run_sigma_command(version, endpoint, method='GET', data=None):
+    """Execute command in specific version's virtual environment"""
+    version_path = Path(__file__).parent / "sigma" / version
+    venv_path = version_path / "venv" / "bin" / "python"
+    worker_path = Path(__file__).parent / "worker.py"
+    
+    # Verify paths exist
+    if not venv_path.exists():
+        return None, f"Virtual environment not found for Sigma version {version}"
+    if not worker_path.exists():
+        return None, f"Worker script not found"
+    
+    cmd = [str(venv_path), str(worker_path), endpoint]
+    
+    # Add backend for formats and pipelines endpoints
+    if endpoint in ['formats', 'pipelines'] and data and 'target' in data:
+        cmd.append(data['target'])
+    
+    # Add conversion parameters
+    if endpoint == 'convert' and data:
+        cmd.extend([
+            data['target'],
+            data['rule']
+        ])
+        if data.get('format'):
+            cmd.append(data['format'])
+        if data.get('pipeline'):
+            cmd.append(','.join(data['pipeline']))
+    
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return result.stdout, None
+    except subprocess.CalledProcessError as e:
+        return None, e.stderr
+
+@app.route("/")
+def home():
+    return render_template("index.html")
+
+@app.route("/api/v1/sigma-versions", methods=["GET"])
+def get_versions():
+    sigma_path = Path(__file__).parent / "sigma"
+    versions = [
+        d.name for d in sigma_path.iterdir() 
+        if d.is_dir() and (d / "venv").exists()
+    ]
+    # Filter and sort versions
+    clean_versions = []
+    for version in versions:
+        try:
+            clean_version = version.lstrip('v')
+            [int(x) for x in clean_version.split('.')]
+            clean_versions.append(clean_version)
+        except ValueError:
+            continue
+            
+    return jsonify(sorted(clean_versions, key=lambda v: tuple(map(int, v.split("."))), reverse=True))
+
+@app.route("/api/v1/<version>/targets", methods=["GET"])
+def get_targets(version):
+    output, error = run_sigma_command(version, 'targets')
+    if error:
+        return Response(f"Error: {error}", status=400)
+    return Response(output, mimetype='application/json')
+
+@app.route("/api/v1/<version>/formats", methods=["GET"])
+def get_formats(version):
+    target = request.args.get('target', '').strip()
+    if not target:
+        return Response("Error: No backend specified", status=400)
+    
+    data = {'target': target}
+    output, error = run_sigma_command(version, 'formats', data=data)
+    if error:
+        return Response(error, status=400)
+    return Response(output, mimetype='application/json')
+
+@app.route("/api/v1/<version>/pipelines", methods=["GET"])
+def get_pipelines(version):
+    target = request.args.get('target', '').strip()
+    if not target:
+        return Response("Error: No backend specified", status=400)
+    
+    data = {'target': target}
+    output, error = run_sigma_command(version, 'pipelines', data=data)
+    if error:
+        return Response(error, status=400)
+    return Response(output, mimetype='application/json')
+
+@app.route("/api/v1/<version>/convert", methods=["POST"])
+def convert(version):
+    try:
+        data = request.json
+        rule = str(base64.b64decode(data["rule"]), "utf-8")
+        yaml.safe_load(rule)  # Validate YAML
+        
+        # Prepare data for worker
+        worker_data = {
+            "rule": rule,
+            "target": data["target"],
+            "format": data.get("format"),
+            "pipeline": data.get("pipeline", [])
+        }
+        
+        output, error = run_sigma_command(version, 'convert', data=worker_data)
+        if error:
+            return Response(error, status=400)
+        return Response(output, mimetype='application/json')
+        
+    except yaml.YAMLError:
+        return Response("YamlError: Malformed yaml file", status=400)
+    except Exception as e:
+        return Response(f"Error: {str(e)}", status=400)
+
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=int(os.environ.get("PORT", 8000)))

Diff for: app/setup.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+import os
+import json
+import subprocess
+from pathlib import Path
+
+def install_core_backends(python_path, sigma_version):
+    """Install core backends that are known to work"""
+    # First install required dependencies
+    base_packages = [
+        "pyyaml",
+        f"sigma-cli=={sigma_version}",
+        "pysigma>=0.9.0,<0.12.0",  # Compatible with 1.0.x
+        "setuptools",
+        "wheel"
+    ]
+    
+    # Install using pip instead of uv for better dependency resolution
+    for package in base_packages:
+        try:
+            print(f"Installing {package}...")
+            subprocess.run([
+                python_path, "-m", "pip", "install", package
+            ], check=True)
+        except subprocess.CalledProcessError as e:
+            print(f"Warning: Failed to install {package}: {e}")
+            return False
+    
+    # Install minimal set of backends
+    backends = [
+        "pysigma-backend-splunk>=0.9.0",
+        "pysigma-backend-elasticsearch>=0.9.0"
+    ]
+    
+    for backend in backends:
+        try:
+            print(f"Installing {backend}...")
+            subprocess.run([
+                python_path, "-m", "pip", "install", backend
+            ], check=True)
+        except subprocess.CalledProcessError as e:
+            print(f"Warning: Failed to install {backend}: {e}")
+    
+    # Verify installation
+    try:
+        verify_cmd = [python_path, "-c", "import yaml; import sigma.backends"]
+        subprocess.run(verify_cmd, check=True)
+        return True
+    except subprocess.CalledProcessError:
+        print("Failed to verify package installation")
+        return False
+
+def setup_sigma_versions():
+    """Setup Sigma versions with their virtual environments"""
+    versions = ["1.0.0", "1.0.1", "1.0.2", "1.0.3", "1.0.4"]  # Hardcode versions for now
+    installed_count = 0
+    base_path = Path(__file__).parent / "sigma"
+    base_path.mkdir(parents=True, exist_ok=True)
+    
+    for version in versions:
+        print(f"\nSetting up Sigma version {version}")
+        try:
+            version_path = base_path / version
+            version_path.mkdir(parents=True, exist_ok=True)
+            
+            # Setup virtual environment using venv instead of uv
+            venv_path = version_path / "venv"
+            subprocess.run([
+                "python3", "-m", "venv", str(venv_path)
+            ], check=True)
+            
+            python_path = str(venv_path / "bin" / "python")
+            
+            # Install core backends and verify
+            if install_core_backends(python_path, version):
+                # Copy worker script to version directory
+                worker_path = Path(__file__).parent / "worker.py"
+                if worker_path.exists():
+                    import shutil
+                    shutil.copy2(worker_path, version_path)
+                
+                installed_count += 1
+                print(f"Successfully set up version {version}")
+            else:
+                print(f"Warning: Failed to install backends for version {version}")
+            
+        except Exception as e:
+            print(f"Error setting up version {version}: {e}")
+            continue
+    
+    return installed_count
+
+if __name__ == "__main__":
+    count = setup_sigma_versions()
+    if count == 0:
+        print("Error: No Sigma versions were installed successfully")
+        exit(1)
+    print(f"Successfully installed {count} Sigma versions")