process-manager.py

#!/usr/bin/env python3
"""
Secure process execution manager
"""

import os
import subprocess
import resource
import signal
from typing import List, Dict

class SecureProcessManager:
    def __init__(self,
                 max_memory_mb: int = 4096,
                 max_cpu_time_sec: int = 300,
                 max_processes: int = 100):
        self.max_memory = max_memory_mb * 1024 * 1024
        self.max_cpu_time = max_cpu_time_sec
        self.max_processes = max_processes

    def set_limits(self):
        """Set resource limits before process execution"""
        # Memory limit
        resource.setrlimit(
            resource.RLIMIT_AS,
            (self.max_memory, self.max_memory)
        )

        # CPU time limit
        resource.setrlimit(
            resource.RLIMIT_CPU,
            (self.max_cpu_time, self.max_cpu_time)
        )

        # Process/thread limit
        resource.setrlimit(
            resource.RLIMIT_NPROC,
            (self.max_processes, self.max_processes)
        )

        # File descriptor limit
        resource.setrlimit(
            resource.RLIMIT_NOFILE,
            (20000, 20000)
        )

        # File size limit (prevent large files)
        resource.setrlimit(
            resource.RLIMIT_FSIZE,
            (100 * 1024 * 1024, 100 * 1024 * 1024)  # 100MB
        )

    def execute_command(self,
                       cmd: List[str],
                       env: Dict[str, str] = None,
                       timeout: int = 30) -> Dict:
        """Execute command with security constraints"""

        try:
            # Create restricted environment
            safe_env = {
                'PATH': '/usr/local/bin:/usr/bin:/bin',
                'HOME': '/home/developer',
                'USER': 'developer',
                'SHELL': '/bin/bash'
            }
            if env:
                safe_env.update(env)

            # Execute with preexec_fn to set limits
            proc = subprocess.Popen(
                cmd,
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE,
                env=safe_env,
                preexec_fn=self.set_limits,
                start_new_session=True  # Create new process group
            )

            # Wait with timeout
            try:
                stdout, stderr = proc.communicate(timeout=timeout)
                return {
                    'returncode': proc.returncode,
                    'stdout': stdout.decode('utf-8', errors='replace'),
                    'stderr': stderr.decode('utf-8', errors='replace')
                }
            except subprocess.TimeoutExpired:
                # Kill entire process group
                os.killpg(os.getpgid(proc.pid), signal.SIGKILL)
                return {
                    'returncode': -1,
                    'stdout': '',
                    'stderr': 'Process killed: timeout exceeded'
                }

        except Exception as e:
            return {
                'returncode': -1,
                'stdout': '',
                'stderr': f'Execution error: {str(e)}'
            }

# Usage
if __name__ == '__main__':
    manager = SecureProcessManager()
    result = manager.execute_command(['python3', 'user_script.py'])
    print(f"Exit code: {result['returncode']}")
    print(f"Output: {result['stdout']}")