Componentes internos del corredor

Los corredores son responsables de compilar y ejecutar los envíos de los usuarios en un entorno seguro y aislado. Reciben tareas del Grader y devuelven resultados de ejecución.

Arquitectura

flowchart TB
    subgraph Runner
        API[Runner API]
        Compiler[Compiler]
        Sandbox[Minijail Sandbox]
        Validator[Output Comparator]
    end

    Grader[Grader] -->|Task| API
    API --> Compiler
    Compiler --> Sandbox
    Sandbox --> Validator
    Validator -->|Results| API
    API -->|Response| Grader

Compilación

Idiomas admitidos

Banderas de compilación

C/C++

# C
gcc -std=c11 -O2 -lm -o program program.c

# C++17 (default)
g++ -std=c++17 -O2 -lm -o program program.cpp

# C++20
g++ -std=c++20 -O2 -lm -o program program.cpp

Java

# Compile
javac -encoding UTF-8 Main.java

# Run
java -Xmx{memory}m Main

Pitón

# Python 3 (no compilation)
python3 program.py

# Byte-compile check
python3 -m py_compile program.py

Límites de compilación

Caja de arena (minicárcel)

Runner utiliza Minijail, bifurcado de Chrome OS, para la ejecución segura de código.

Funciones de seguridad

flowchart LR
    subgraph "Minijail Sandbox"
        Process[User Process]
        subgraph Restrictions
            NS[Namespace Isolation]
            SC[Seccomp Filters]
            RL[Resource Limits]
            FS[Filesystem Isolation]
        end
    end

    Process --> NS
    Process --> SC
    Process --> RL
    Process --> FS

Mecanismos de aislamiento

Llamadas al sistema permitidas

El filtro seccomp permite solo llamadas al sistema esenciales:

• Operaciones de archivos: read, write, open, close
• Memoria: mmap, munmap, brk
• Proceso: exit, exit_group
• Hora: clock_gettime (limitada)

Operaciones prohibidas: - Llamadas al sistema de red (socket, connect, etc.) - Creación de procesos (fork, clone, execve) -IPC (shmget, msgget, etc.)

Límites de recursos

Aplicado a través de cgroups y rlimits:

Flujo de ejecución

Ejecución por caso de prueba

sequenceDiagram
    participant R as Runner
    participant M as Minijail
    participant P as User Program

    R->>R: Prepare input file
    R->>M: Start sandbox
    M->>P: Execute program
    P->>P: Read input
    P->>P: Compute
    P->>P: Write output
    P-->>M: Exit
    M-->>R: Exit code + metrics
    R->>R: Compare output
    R->>R: Determine verdict

Medición de recursos

El Runner mide:

• Tiempo de CPU: ciclos de CPU reales utilizados
• Tiempo de pared: tiempo real transcurrido
• Memoria: uso máximo de memoria (a través de cgroup)
• Tamaño de salida: Bytes escritos en la salida estándar

Validación de salida

Modos de comparación

Comparación de tokens

Modo de comparación predeterminado: 1. Dividir la salida en tokens (separados por espacios en blanco) 2. Comparar secuencias de tokens 3. Ignorar los espacios en blanco finales 4. Ignorar las nuevas líneas finales

Validadores personalizados

Los problemas pueden incluir validadores personalizados:

problem/
├── cases/
│   ├── 1.in
│   └── 1.out
└── validator
    └── validator.cpp

Devoluciones: - Puntuación (0,0 a 1,0) - Mensaje de veredicto

Problemas interactivos

Para problemas interactivos, Runner usa libinteractive:

flowchart LR
    subgraph Sandbox
        User[User Program]
        Inter[Interactor]
    end

    User <-->|Pipes| Inter
    Inter -->|Results| Runner

Manejo de errores

Determinación del veredicto

Detalles del error de tiempo de ejecución

El corredor captura: - Código de salida - Número de señal (si muere) - Última llamada al sistema (si es RFE) - Memoria en caso de accidente

Configuración

Configuración del corredor

{
  "Runner": {
    "RuntimePath": "/var/lib/omegaup/runner",
    "GraderURL": "https://grader:21680/",
    "CompileTimeLimit": 30,
    "CompileMemoryLimit": 536870912,
    "PreserveFiles": false
  },
  "Sandbox": {
    "Path": "/usr/bin/minijail0",
    "TimeLimit": 60,
    "OutputLimit": 67108864
  }
}

Estructura del directorio

/var/lib/omegaup/runner/
├── cache/           # Compiled binaries cache
├── input/           # Test input files
├── runs/            # Active execution directories
│   └── {guid}/
│       ├── source   # User source code
│       ├── program  # Compiled binary
│       ├── input    # Current test input
│       ├── output   # User output
│       └── error    # Stderr capture
└── problems/        # Problem files cache

Rendimiento

Almacenamiento en caché

• Caché de compilación: reutiliza archivos binarios para fuentes idénticas
• Caché de entrada: Archivos de prueba de problemas almacenados en caché localmente
• Caché de problemas: metadatos y validadores de problemas

Ejecución paralela

• Cada corredor maneja una presentación a la vez.
• Los casos de prueba dentro de un envío pueden ejecutarse en paralelo
• Múltiples corredores proporcionan escala horizontal

Consideraciones de seguridad

Defensa en profundidad

1. Validación de código: comprobaciones básicas del código fuente
2. Sandbox de compilación: entorno de compilación limitado
3. Sandbox de ejecución: aislamiento completo de Minijail
4. Límites de recursos: límites estrictos para todos los recursos
5. Aislamiento de red: sin comunicación externa

Limitaciones conocidas

• Posibles ataques de sincronización (tiempo de CPU visible)
• Los canales laterales de memoria no están completamente mitigados.
• Los problemas interactivos tienen una mayor superficie de ataque.

Código fuente

El Runner es parte del repositorio quark:

• runner/ - Lógica del corredor principal
• sandbox/ - Integración de minicárcel
• compiler/ - Compilación específica del idioma

Documentación relacionada

• Grader Internals - Cola y envío
• Función Sandbox - Descripción general del Sandbox
• Veredictos - Tipos de veredicto