Teletransporte de Arquivos: Enviando Dados com Segurança para Sandboxes Zero-Trust
Já se perguntou como colocar arquivos de dados em um ambiente sandbox zero-trust que não tem acesso à rede, nenhuma persistência de sistema de arquivos e nenhum armazenamento compartilhado? É como tentar transmitir dados para uma caixa preta que já está selada.
Hoje apresentamos suporte a arquivos de entrada - um recurso que permite “teletransportar” arquivos diretamente para ambientes de execução isolados. Veja como funciona e por que é importante.
O Desafio: Colocando Dados no Isolamento
Ambientes tradicionais de execução de código enfrentam um dilema:
Opção 1: Acesso à Rede ❌
- Dar ao código acesso à rede para baixar arquivos
- Pesadelo de segurança - código pode exfiltrar dados, fazer chamadas de API, ataques DDoS
- Derrota o propósito do sandbox
Opção 2: Sistema de Arquivos Compartilhado ❌
- Montar armazenamento compartilhado em containers
- Problemas de persistência - dados vazando entre execuções
- Sobrecarga de performance - I/O se torna o gargalo
- Risco de segurança - containers podem ler dados uns dos outros
Opção 3: Conjuntos de Dados Pré-instalados ❌
- Embutir conjuntos de dados comuns em imagens de container
- Inflexível - e se os usuários precisarem de dados personalizados?
- Imagens inchadas - containers de GB para cada caso de uso
Nenhum destes funciona para sandboxes zero-trust. Precisamos de algo melhor.
A Solução: Teletransporte de Arquivos
Em vez de dar ao código acesso para buscar arquivos, teletransportamos arquivos diretamente para o ambiente de execução antes do código ser executado:
┌─────────────┐ ┌──────────────────┐
│ 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')│
└──────────────────┘Processo de três etapas:
- Navegador codifica arquivos - API HTML5 FileReader lê arquivos locais como base64
- Transferência criptografada TLS - Arquivos enviados via HTTPS para a API unsandbox
-
Materialização do container - Arquivos aparecem em
/tmp/input/antes da execução do código
Insight chave: Arquivos nunca tocam um sistema de arquivos persistente. Eles são escritos diretamente em um container efêmero que existe por ~150ms, depois desaparece para sempre.
Como Funciona: Os Detalhes Técnicos
Passo 1: Codificação no Lado do Cliente (Sem Uploads ao Servidor!)
Em vez de uploads de formulário tradicionais para um servidor, usamos JavaScript para ler arquivos diretamente:
// 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];
sendToSandbox(file.name, base64);
};
reader.readAsDataURL(file);
});Por que base64?
- Codificação segura para JSON (API usa payloads JSON)
- Baseado em texto, funciona com quaisquer dados binários
- Sem tratamento especial para diferentes tipos de arquivo
- Sobrecarga de tamanho ~33% é aceitável para limites <10MB
Benefício de segurança: Arquivos nunca chegam ao seu servidor. Eles vão navegador → API → container diretamente.
Passo 2: Transferência Criptografada TLS
Arquivos são enviados como parte da solicitação de execução:
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=="
}
]
}Criptografia TLS 1.3:
- Perfect Forward Secrecy (PFS) - mesmo se as chaves forem comprometidas depois, o tráfego passado permanece criptografado
- Retomada 0-RTT para clientes recorrentes (mais rápido)
- Cifras ChaCha20-Poly1305 ou AES-256-GCM
Passo 3: Materialização do Container
Quando a API recebe sua solicitação:
-
Arquivos decodificados - Base64 → binário, escrito em
/tmp/input/ -
Diretório de trabalho - A execução do código começa com
CWD=/tmp/input/ -
Código é executado - Seu código pode fazer
open('data.csv')diretamente - Container destruído - Após a execução, tudo desaparece
Efêmero por design: Arquivos existem apenas durante a execução. Sem necessidade de limpeza - todo o sistema de arquivos do container é descartado.
Exemplos Funcionais
Aqui estão exemplos testados e funcionais em Python mostrando como ler um arquivo local, codificá-lo como base64 e enviá-lo para o sandbox para processamento.
Exemplo: Python
#!/usr/bin/env python3
import base64
import requests
with open('data.csv', 'rb') as f:
file_content = f.read()
base64_content = base64.b64encode(file_content).decode('utf-8')
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'])Saída:
Output: Alice: 100
Bob: 200
Charlie: 300Benefícios de Segurança
1. Zero Persistência de Dados
Fluxo de upload tradicional:
Browser → Server (disk write) → Process → Delete (maybe?)Fluxo de teletransporte:
Browser → Memory → Container (tmpfs) → Execution → DestroyBenefício: Mesmo que a máquina hospedeira seja comprometida, não há dados persistentes para roubar.
2. Isolado Por Execução
Cada execução recebe seu próprio diretório privado /tmp/input/. Containers não podem ver os arquivos uns dos outros - imposto por isolamento em nível de kernel.
3. TLS de Ponta a Ponta
Bytes de arquivo são criptografados desde o momento em que deixam seu navegador até serem escritos no container. Sem etapas intermediárias em texto simples.
4. Sem Acesso à Rede para Código
Seu código é executado em um sandbox com zero acesso à rede. Mesmo que código malicioso tente exfiltrar os dados que você carregou, não há saída.
Casos de Uso
- Processamento de Dados AI/ML - Sem armazenar dados sensíveis
- Análise Financeira - Processar extratos bancários sem armazenamento em nuvem
- Processamento de Imagens - Transformar imagens sem armazenamento do lado do servidor
- Validação de Configuração - Testar arquivos de configuração com segurança
Limites e Especificações
Restrições de arquivo:
- Máximo 10 arquivos por execução
- Máximo 5MB por arquivo (decodificado)
- Máximo 10MB total (decodificado)
- Codificado Base64 antes de enviar (~33% de sobrecarga)
Performance
Sobrecarga de materialização de arquivo:
- Decodificar base64: ~50ms para arquivo de 5MB
- Escrever para tmpfs: ~10ms (suportado por RAM, não disco)
- Sobrecarga total: ~60ms independentemente do tamanho do arquivo
Experimente Você Mesmo
Visite unsandbox.com e experimente o recurso de upload de arquivo!
Conclusão
O teletransporte de arquivos resolve um problema fundamental na computação zero-trust: como colocar dados no isolamento sem comprometer a segurança.
Ao combinar criptografia TLS, codificação base64 e containers efêmeros, criamos um sistema onde:
✅ Arquivos são criptografados em trânsito ✅ Arquivos nunca persistem em servidores ✅ Cada execução é completamente isolada ✅ Código não tem acesso à rede ✅ Tudo desaparece após a execução
Experimente agora: unsandbox.com - Faça upload de um arquivo e veja-o teletransportar para o sandbox!