Enjaulando o Alonso!

Não tenho mais como negar, cara! Virei vibe codeiro, e pra piorar eu uso o alonso. E como todo mundo sabe, o alonso é um perigo. Então achei que era melhor deixar ele dentro de um sandbox, por que não?

Mas serião, pra quê um sandbox?

Na real são basicamente duas coisas que eu queria ter alguma proteção: comandos errados emitidos pelo modelo e prompt injection. A primeira parte até era tranquilo, não deixa o modelo ler/escrever em lugares que ele não devia e pronto! A segunda…

Não adianta eu deixar no system prompt do modelo algo como: «não seja tonto, não faz merda.» Primeiro que isso seria uma instrução bem ruim e, mais importante, falar algo pro modelo não é garantia de nada. Eu não sou bom de prompt injection, mas tem gente que é, então pelo menos em teoria, prompt injection pode baixar um arquivo e executar, é execução remota de código. Desgraça!

Tem docker, vm… você é doido?

Sou. Mas eu tenho como justificar minha doidice (nesse caso): VM é um treco muito pesado, sem chance. Containers são bem mais leves, mas ocupam muito espaço em disco e ainda por cima eu não gostei da ideia de ter que subir uma vm ou um container só pra rodar um assistente de código. Então resolvi fazer algo pequeno, não deve dar trabalho.

O que eu queria era algo que quando eu rodasse um assistente de código, ele rodasse já num sandbox, sem eu ter que fazer muita coisa, sem ter que subir serviços, sem ter que trocar de usuário, simplesmente um processo travado. Com essa ideia eu fui procurar como fazer a primeira parte da coisa, já que era a parte mais fácil.

Primeiro pensei em chroot, mas chroot precisa de root e não é realmente um sandbox. Esquece. Procurando como eu podia fazer isso achei um tutorial sobre um tal de Landlock, algumas system calls e o processo já não conseguia ler/escrever em determinados paths. Pareceu bom.

O Landlock

O Landlock é um módulo de segurança do linux que permite um processo restringir a si mesmo (e os seus filhos) sem depender de root. E diferente do que eu achava quando vi o tutorial, não é só acesso ao FS que é controlado, acesso à rede e unix sockets também são controlados. A coisa é mais ou menos assim:

Pra começar você tem que declarar quais são os handled accesses, ou seja quais tipos de acesso o Landlock vai controlar. Tudo o que estiver nesses handled accesses vai ser negado por padrão e depois a gente precisa criar regras dizendo quais recursos vão poder ser acessados.

Então basicamente você diz pro landlock: «daqui pra frente eu controlo leitura e escrita em arquivos/diretórios». Depois disso, a leitura e escrita em qualquer lugar vai ser negada e você precisa criar regras para permitir acesso aos recursos.

Tá, mas como funciona?

Indo ao que importa:

#define _GNU_SOURCE
#include <errno.h>
#include <fcntl.h>
#include <linux/landlock.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/prctl.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <unistd.h>

/* Primeiro a gente declara os acessos que o Landlock vai governar.
   A gente declara aqui todos os acessos que o Landlock conhece.
   Isso quer dizer que tudo o que o Landlock conhece vai ser negado
   por padrão. Depois a gente faz regras pra liberar o acesso por
   recurso.
*/

/*
  Aqui uma pegadinha. A abi do Landlock já está na versão 9, mas meu sistema
  roda um kernel que tem a abi 6. Então aqui eu defino o que não existe na
  abi 6 pra eu poder referenciar e compilar no meu sistema. Eu defino
  assim pra que quando eu atualizar meu kernel pra uma abi mais nova eu
  não precise alterar o código, ele já suporta a abi mais nova.
*/

/* FS_RESOLVE_UNIX incluído na abi 9 */
#ifndef LANDLOCK_ACCESS_FS_RESOLVE_UNIX
#define LANDLOCK_ACCESS_FS_RESOLVE_UNIX (1ULL << 16)
#endif

/* Os próximos 3 RESTRICT_SELF_* foram incluídos na abi 7*/
#ifndef LANDLOCK_RESTRICT_SELF_LOG_SAME_EXEC_OFF
#define LANDLOCK_RESTRICT_SELF_LOG_SAME_EXEC_OFF (1ULL << 0)
#endif
#ifndef LANDLOCK_RESTRICT_SELF_LOG_NEW_EXEC_ON
#define LANDLOCK_RESTRICT_SELF_LOG_NEW_EXEC_ON (1ULL << 1)
#endif
#ifndef LANDLOCK_RESTRICT_SELF_LOG_SUBDOMAINS_OFF
#define LANDLOCK_RESTRICT_SELF_LOG_SUBDOMAINS_OFF (1ULL << 2)
#endif

/* RESTRICT_SELF_TSYNC foi incluídos na abi 8 */
#ifndef LANDLOCK_RESTRICT_SELF_TSYNC
#define LANDLOCK_RESTRICT_SELF_TSYNC (1ULL << 3)
#endif

/* Os recursos de acesso ao sistema de arquivos.
   Note que a permissão FS_RESOLVE_UNIX se refere a conectar por path.
   Abstract pipes são governados por outra regra.
*/
#define FS_HANDLED                                                             \
  (LANDLOCK_ACCESS_FS_EXECUTE | /* permissão de execução */                    \
   LANDLOCK_ACCESS_FS_WRITE_FILE | /* permissão de escrita de arquivos */      \
   LANDLOCK_ACCESS_FS_READ_FILE | /* permissão de leitura em arquivo */        \
   LANDLOCK_ACCESS_FS_READ_DIR | /* permissão de leitura em diretório */       \
   LANDLOCK_ACCESS_FS_REMOVE_DIR | /* permissão para remover diretório */      \
   LANDLOCK_ACCESS_FS_REMOVE_FILE | /* permissão para remover arquivo */       \
   LANDLOCK_ACCESS_FS_MAKE_CHAR | /* permissão para criar char devices */      \
   LANDLOCK_ACCESS_FS_MAKE_DIR | /* permissão para fazer diretório */          \
   LANDLOCK_ACCESS_FS_MAKE_REG | /* permissão para criar/renomear arquivo */   \
   LANDLOCK_ACCESS_FS_MAKE_SOCK | /* permissão para criar unix sockets */      \
   LANDLOCK_ACCESS_FS_MAKE_FIFO | /* permissão para criar pipes */             \
   LANDLOCK_ACCESS_FS_MAKE_BLOCK | /* permissão para criar block devices */    \
   LANDLOCK_ACCESS_FS_MAKE_SYM | /* permissão para criar links simbólicos */   \
   LANDLOCK_ACCESS_FS_REFER | /* permissão para fazer link entre diretórios  */\
   LANDLOCK_ACCESS_FS_TRUNCATE | /* permissão para truncar arquivos */         \
   LANDLOCK_ACCESS_FS_IOCTL_DEV | /* permissão para ioctl em devices */        \
   LANDLOCK_ACCESS_FS_RESOLVE_UNIX /* permissão para conectar em  unix sockets por path */)

/* recursos de acesso à rede */
#define NET_HANDLED                                                            \
  (LANDLOCK_ACCESS_NET_BIND_TCP | /* permissão para  bind em  uma porta tcp local */\
   LANDLOCK_ACCESS_NET_CONNECT_TCP /* permissão para connect em porta tcp remota*/)

/* recursos scoped (não faço ideia do porquê isso chama scoped) */
#define SCOPED                                                                 \
  (LANDLOCK_SCOPE_ABSTRACT_UNIX_SOCKET | /*permissão pra conectar a unix      \
                                            sockets abstratos (tipo dbus)*/    \
   LANDLOCK_SCOPE_SIGNAL /* permissão para enviar sinais */)

/* RESTRICT_SELF_* controlam o comportamento do Landlock, não acesso a recursos
   Por padrão o Landlock restringe a thread chamadora e suas threads filhas.
   TSYNC faz com que as threads irmãs também sejam restringidas.
 */

#define RESTRICT_FLAGS                                                         \
  (LANDLOCK_RESTRICT_SELF_LOG_SAME_EXEC_OFF | /* desabilita o log dos calls no \
                                                 executável */                \
   LANDLOCK_RESTRICT_SELF_LOG_NEW_EXEC_ON |   /* desabilita o log dos calls em \
                                                 novo executável */           \
   LANDLOCK_RESTRICT_SELF_LOG_SUBDOMAINS_OFF | /* desabilita o log no          \
                                                  subdomínios */              \
   LANDLOCK_RESTRICT_SELF_TSYNC /* restringe também as threads irmãs*/)

/* permissões de leitura para arquivo e diretório */
#define PERMS_READ                                                             \
  (LANDLOCK_ACCESS_FS_READ_FILE | LANDLOCK_ACCESS_FS_READ_DIR |                \
   LANDLOCK_ACCESS_FS_EXECUTE)

/* permissões de leitura e escrita para arquivo e diretório */
#define PERMS_READ_WRITE                                                       \
  (PERMS_READ | LANDLOCK_ACCESS_FS_WRITE_FILE |                                \
   LANDLOCK_ACCESS_FS_REMOVE_DIR | LANDLOCK_ACCESS_FS_REMOVE_FILE |            \
   LANDLOCK_ACCESS_FS_MAKE_DIR | LANDLOCK_ACCESS_FS_MAKE_REG |                 \
   LANDLOCK_ACCESS_FS_TRUNCATE | LANDLOCK_ACCESS_FS_RESOLVE_UNIX)

/* permissões usadas só por diretórios. elas serão removidas as perms para um
 * arquivo */
#define PERMS_DIRS_ONLY                                                        \
  (LANDLOCK_ACCESS_FS_READ_DIR | LANDLOCK_ACCESS_FS_REMOVE_DIR |               \
   LANDLOCK_ACCESS_FS_REMOVE_FILE | LANDLOCK_ACCESS_FS_MAKE_DIR |              \
   LANDLOCK_ACCESS_FS_MAKE_REG)

/*
  Retorna a versão da api do kernel que está rodando. Usado para saber quais
  recursos são suportados pelo kernel
*/
static long check_abi() {
  return syscall(SYS_landlock_create_ruleset, NULL, 0,
                 LANDLOCK_CREATE_RULESET_VERSION);
}

/*
  Retorna os acessos ao fs governados pelo Landlock. Leva em consideração
  a versão de abi para não passar acessos desconhecidos pelo kernel
*/
static unsigned long long get_handled_access_fs(long abi) {
  unsigned long long handled = FS_HANDLED;
  if (abi < 2) {
    handled &= ~LANDLOCK_ACCESS_FS_REFER;
  }
  if (abi < 3) {
    handled &= ~LANDLOCK_ACCESS_FS_TRUNCATE;
  }
  if (abi < 5) {
    handled &= ~LANDLOCK_ACCESS_FS_IOCTL_DEV;
  }
  if (abi < 9) {
    handled &= ~LANDLOCK_ACCESS_FS_RESOLVE_UNIX;
  }
  return handled;
}

/* Retorna os acessos à rede governados pelo Landlock. */
static unsigned long long get_handled_access_net(long abi) {
  unsigned long long handled = NET_HANDLED;
  if (abi < 4) {
    handled = 0;
  }
  return handled;
}

/* Retorna os acessos scoped governados pelo Landlock */
static unsigned long long get_handled_scopes(long abi) {
  unsigned long long scopes = SCOPED;
  if (abi < 6) {
    scopes = 0;
  }
  return scopes;
}

/*
  Retorna as RESTRICT_SELF_* flags suportadas pelo host
*/
static unsigned long long get_supported_restrict_flags(long abi) {
  unsigned long long flags = RESTRICT_FLAGS;
  if (abi < 7) {
    flags &= ~(LANDLOCK_RESTRICT_SELF_LOG_SAME_EXEC_OFF |
               LANDLOCK_RESTRICT_SELF_LOG_NEW_EXEC_ON |
               LANDLOCK_RESTRICT_SELF_LOG_SUBDOMAINS_OFF);
  }
  if (abi < 8) {
    flags &= ~LANDLOCK_RESTRICT_SELF_TSYNC;
  }
  return flags;
}

/* Retorna as permissões de escrita e leitura suportadas pelo kernel */
static unsigned long long get_perms_read_write(long abi) {
  unsigned long long perms = PERMS_READ_WRITE;
  if (abi < 3) {
    perms &= ~LANDLOCK_ACCESS_FS_TRUNCATE;
  }
  if (abi < 9) {
    perms &= ~LANDLOCK_ACCESS_FS_RESOLVE_UNIX;
  }
  return perms;
}

/*
  cria uma nova ruleset para fs, net ou scoped. Aqui a gente passa tudo
  o que vai ser controlado pelo Landlock aqui e depois criamos as exceções
  para acesso
*/
static long create_ruleset(const struct landlock_ruleset_attr *attr) {
  return syscall(SYS_landlock_create_ruleset, attr,
                 sizeof(struct landlock_ruleset_attr), 0);
}

/* Aqui a gente adiciona a permissão de acesso à um recurso */
static long add_rule(int ruleset_fd,
                     const struct landlock_path_beneath_attr *pb) {
  return syscall(SYS_landlock_add_rule, ruleset_fd, LANDLOCK_RULE_PATH_BENEATH,
                 pb, 0);
}

/*
   é isso aqui que 'trava' o processo. Depois de aplicar as regras e as exceções
   a gente chama isso aqui pra aplicar e travar tudo
*/
static long restrict_self(int ruleset_fd, unsigned long long flags) {
  if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0) < 0) {
    return -1;
  }
  return syscall(SYS_landlock_restrict_self, ruleset_fd, flags);
}

/*
  aqui a gente libera o acesso a algum recurso por path.
  se um path não for um diretório as PERMS_DIRS_ONLY são removidas
  dos acessos concedidos.
*/
static long allow_access(int ruleset_fd, const char *path,
                         struct landlock_path_beneath_attr *pb) {
  long r;
  int parent_fd;
  struct stat st;

  parent_fd = open(path, O_PATH | O_CLOEXEC);
  if (parent_fd < 0) {
    return -1;
  }

  if (fstat(parent_fd, &st) < 0) {
    close(parent_fd);
    return -1;
  }
  if (!S_ISDIR(st.st_mode)) {
    pb->allowed_access &= ~PERMS_DIRS_ONLY;
  }
  pb->parent_fd = parent_fd;
  r = add_rule(ruleset_fd, pb);
  close(pb->parent_fd);
  return r;
}

/* dá acesso de leitura a um dado path */
static long allow_read_access(int ruleset_fd, const char *path) {
  struct landlock_path_beneath_attr pb = {.allowed_access = PERMS_READ};

  return allow_access(ruleset_fd, path, &pb);
}

/* dá acesso de leitura e escrita a um determinado path  */
static long allow_read_write_access(int ruleset_fd, const char *path,
                                    long abi) {
  struct landlock_path_beneath_attr pb = {.allowed_access =
                                              get_perms_read_write(abi)};
  return allow_access(ruleset_fd, path, &pb);
}

/* dá acesso de bind ou connect tcp a uma determinada porta  */
static long add_net_rule(int ruleset_fd, unsigned long long allowed_access,
                         unsigned short port) {
  struct landlock_net_port_attr attr = {
      .allowed_access = allowed_access,
      .port = port,
  };
  return syscall(SYS_landlock_add_rule, ruleset_fd, LANDLOCK_RULE_NET_PORT,
                 &attr, 0);
}

/* dá acesso de connect a uma determinada porta  */
static long allow_net_connect_access(int ruleset_fd, unsigned short port) {
  return add_net_rule(ruleset_fd, LANDLOCK_ACCESS_NET_CONNECT_TCP, port);
}

/* dá acesso de bind a uma determinada porta. */
static long allow_net_bind_access(int ruleset_fd, unsigned short port) {
  return add_net_rule(ruleset_fd, LANDLOCK_ACCESS_NET_BIND_TCP, port);
}

/*
   aqui as opções que a gente vai passar pro setup da coisa toda.
   A ideia aqui é que a gente fecha tudo por padrão e passa uma
   lista de recursos que quer liberar acesso.
*/
struct sandbox_opts {
  /* diretórios com permissão de leitura */
  const char **r_dir;
  int n_r;
  int cap_r;
  /* diretórios com permissão de escrita */
  const char **rw_dir;
  int n_rw;
  int cap_rw;
  /* portas permitidas para connect */
  unsigned short *connect_ports;
  int n_connect;
  int cap_connect;
  /* portas permitidas para bind */
  unsigned short *bind_ports;
  int n_bind;
  int cap_bind;
};

/* Aqui a gente liga todas as retrições e libera só para os recursos pedidos */
int sandbox_setup(const struct sandbox_opts *opts) {
  long abi = check_abi();
  if (abi < 1) {
    return -1;
  }
  unsigned long long handled = get_handled_access_fs(abi);
  unsigned long long handled_net = get_handled_access_net(abi);
  struct landlock_ruleset_attr r_perm = {
      .handled_access_fs = handled,
      .handled_access_net = handled_net,
      .scoped = get_handled_scopes(abi),
  };
  long ruleset_ret = create_ruleset(&r_perm);
  if (ruleset_ret < 0) {
    return -1;
  }
  int ruleset = (int)ruleset_ret;
  for (int k = 0; k < opts->n_r; k++) {
    if (allow_read_access(ruleset, opts->r_dir[k]) < 0) {
      return -1;
    }
  }
  for (int k = 0; k < opts->n_rw; k++) {
    if (allow_read_write_access(ruleset, opts->rw_dir[k], abi) < 0) {
      return -1;
    }
  }
  for (int k = 0; k < opts->n_connect; k++) {
    if (allow_net_connect_access(ruleset, opts->connect_ports[k]) < 0) {
      return -1;
    }
  }
  for (int k = 0; k < opts->n_bind; k++) {
    if (allow_net_bind_access(ruleset, opts->bind_ports[k]) < 0) {
      return -1;
    }
  }
  if (restrict_self(ruleset, get_supported_restrict_flags(abi)) < 0) {
    return -1;
  }
  close(ruleset);
  return 0;
}

/*
   Agora o que a gente usa pra fazer uma cli. A ideia é que a gente
   passa --ro, --rw, --allow-connect-port e --allow-bind-port para
   liberar os recursos que queremos. O fim da linha de comando é um --
   e depois disso é o comando que vamos rodar dentro do sandbox.
*/

/* append um path a lista de paths que vão ser liberadas para ro ou rw */
static int push_path(const char ***list, int *n, int *cap, const char *path) {
  if (*n == *cap) {
    int new_cap = *cap ? *cap * 2 : 4;
    const char **grown =
        realloc((void *)*list, (size_t)new_cap * sizeof **list);
    if (grown == NULL) {
      return -1;
    }
    *list = grown;
    *cap = new_cap;
  }
  (*list)[(*n)++] = path;
  return 0;
}

/* parseia uma string em um int no range de 0..65535 */
static int parse_port(const char *s, unsigned short *out) {
  char *end;
  errno = 0;
  unsigned long v = strtoul(s, &end, 10);
  if (end == s || *end != '\0' || errno != 0 || v > 65535) {
    return -1;
  }
  *out = (unsigned short)v;
  return 0;
}

static int push_port(unsigned short **list, int *n, int *cap,
                     unsigned short port) {
  if (*n == *cap) {
    int new_cap = *cap ? *cap * 2 : 4;
    unsigned short *grown = realloc(*list, (size_t)new_cap * sizeof **list);
    if (grown == NULL) {
      return -1;
    }
    *list = grown;
    *cap = new_cap;
  }
  (*list)[(*n)++] = port;
  return 0;
}

/*
   Parseia a linha de comando preenchendo as opções do sandbox e o
   comando a ser rodado.
*/
int parse_cmd_line(int argc, char *argv[], struct sandbox_opts *opts,
                   char ***cmd) {
  if (cmd != NULL) {
    *cmd = NULL;
  }
  if (argc <= 1) {
    return -1;
  }
  int i = 1;
  while (argc > i) {
    if (strcmp(argv[i], "--ro") == 0) {
      if (i + 1 >= argc) {
        return -1;
      }
      if (push_path(&opts->r_dir, &opts->n_r, &opts->cap_r, argv[i + 1]) < 0) {
        return -1;
      }
      i += 2;
    } else if (strcmp(argv[i], "--rw") == 0) {
      if (i + 1 >= argc) {
        return -1;
      }
      if (push_path(&opts->rw_dir, &opts->n_rw, &opts->cap_rw, argv[i + 1]) <
          0) {
        return -1;
      }
      i += 2;
    } else if (strcmp(argv[i], "--allow-connect-port") == 0) {
      unsigned short port;
      if (i + 1 >= argc) {
        return -1;
      }
      if (parse_port(argv[i + 1], &port) < 0) {
        return -1;
      }
      if (push_port(&opts->connect_ports, &opts->n_connect, &opts->cap_connect,
                    port) < 0) {
        return -1;
      }
      i += 2;
    } else if (strcmp(argv[i], "--allow-bind-port") == 0) {
      unsigned short port;
      if (i + 1 >= argc) {
        return -1;
      }
      if (parse_port(argv[i + 1], &port) < 0) {
        return -1;
      }
      if (push_port(&opts->bind_ports, &opts->n_bind, &opts->cap_bind, port) <
          0) {
        return -1;
      }
      i += 2;
    } else if (strcmp(argv[i], "--") == 0) {
      if (i + 1 >= argc) {
        return -1;
      }
      i++;
      if (cmd != NULL) {
        *cmd = &argv[i];
      }
      return 0;
    } else {
      return -1;
    }
  }
  return -1;
}

int main(int argc, char *argv[]) {
  struct sandbox_opts opts = {0};
  char **cmd = NULL;

  if (parse_cmd_line(argc, argv, &opts, &cmd) < 0) {
    exit(2);
  }

  int r = sandbox_setup(&opts);
  if (r < 0) {
    exit(1);
  }
  if (execvp(cmd[0], cmd) < 0) {
    fprintf(stderr, "sandbox: exec %s: %s\n", cmd[0], strerror(errno));
    exit(1);
  }
  exit(0);
}

E o Landlock é basicamente isso. A gente compila assim:

gcc -Wall -Wextra -g sandbox.c -o sandbox

E agora pode usar. Primeiro a gente tenta rodar um comando:

./sandbox -- ls /etc
sandbox: exec ls: Permission denied

A gente toma um permission denied aí porque o ls fica em /usr/bin e a gente não deu permissão de leitura e execução. Então a gente precisa dar permissão para primeiro achar o comando:

./sandbox --ro /usr -- ls /etc
ls: impossível abrir a pasta '/etc': Permissão recusada

Aí o erro já mudou, o ls foi encontrado, mas não temos permissão em /etc. Dando permissão de leitura deve funcionar.

./sandbox --ro /usr --ro /etc -- ls /etc
[um monte de coisa aqui...]

A gente pode fazer a mesma coisa com permissão de leitura e escrita

./sandbox --ro /usr --ro /etc --rw /tmp --  echo 'oi' > /tmp/oi
./sandbox --ro /usr --ro /etc --rw /tmp --  cat /tmp/oi
oi

Por padrão conectar em portas tcp é bloqueado, então tentando um curl dá erro:

./sandbox --ro /usr --ro /etc --  curl https://poraodojuca.dev
curl: (7) Failed to connect to poraodojuca.dev port 443 after 267 ms: Could not connect to server

Então a gente tem que liberar a conexão na porta também.

./sandbox --ro /usr  --ro /etc  --allow-connect-port 443 -- curl https://poraodojuca.dev
[ um monte de coisa aqui... ]

Note que aí o curl também precisa de leitura em /etc pra poder resolver DNS.

Tudo muito bem, tudo muito bom, o modelo pode dar o comando errado que quiser, se ele não tem perm pra nenhum lugar sensível, tá tranquilo. Mas aproveitando que estamos nessa, vamos testar mais alguns cenários, e nessa de testar mais cenários me liguei na implicação do meu kernel ainda não ter suporte ao LANDLOCK_ACCESS_FS_RESOLVE_UNIX: o processo de dentro do sandbox pode ler/escrever em qualquer socket criado fora do sandbox, tipo em /run/docker.sock, e aí acabou-se o sandbox, né? Alguma coisinha assim já faria o serviço de escapar:

#!/usr/bin/python3
#-*- coding: utf-8 -*-

import json
import socket

def send2docker(path, method, payload):
    req = f'{method} {path} HTTP/1.1\r\nHost: docker\r\nConnection: close\r\n'
    req += 'Content-Type: application/json\r\n'
    req += f'Content-Length: {len(payload)}\r\n'
    req += '\r\n'
    s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
    try:
        s.connect('/run/docker.sock')
        s.sendall(req.encode() + payload)
        data = bytearray()
        while True:
            c = s.recv(65536)
            data += c
            break
    finally:
        s.close()

    _, _, rest = bytes(data).partition(b"\r\n\r\n")
    return bytes(rest)

def create_container():
    img_name = 'alpine:latest'
    cmds = ['sh', '-c', 'echo "boo!" > /host/var/tmp/vazou']

    payload = json.dumps({
        "Image": img_name,
        "Tty": True,
        "Cmd": cmds,
        "HostConfig": {"Binds": ["/:/host"]},
    }).encode()
    path = '/containers/create'
    method = 'POST'

    r = send2docker(path, method, payload)
    cid = json.loads(r)['Id']
    return cid

def start_container(cid):
    print(send2docker(f'/containers/{cid}/start', 'POST', b''))


cid = create_container()
start_container(cid)

Com isso é só executar e já era o sandbox.

./sandbox --ro /usr --ro $PWD/test.py -- ./test.py
b''
cat /var/tmp/vazou
boo!

Com um furo desse a minha opção foi ir pra solução bruta: vamo bloquear qualquer connect no unix socket e fecha esse furo. Pra bloquear o socket a gente vai usar o seccomp.

O Seccomp

Seccomp é um mecanismo do kernel que filtra syscalls. Ele leva em consideração o número e os argumentos do syscall e com isso a gente cria filtros. Então o que a gente vai fazer aqui é deixar a regra inicial do seccomp como permitindo tudo e a gente vai bloquear o que a gente quiser. Pra minha sorte existe uma lib pra seccomp, então não preciso lidar com filtros BPF.

O único ponto aqui é que o seccomp não tem a granularidade do Landlock, por exemplo, não tem como falar «não pode conectar no unix socket x, mas no y pode» ou «só pode usar x recurso com processos criados dentro do sandbox». O seccomp é tudo ou nada: bloquear a criação de sockets unix bloqueia todos de uma vez. E sem mais delongas, ao que importa.

Mais código!

Pra não ficar muito longo, não vou escrever tudo aqui. Vou mostrar só o código do seccomp e no final eu linko para o fonte completo.

/*
  Essa máscara aqui é usada na comparação das flags do socket.
  Ela está declarada aqui porque ela só é declarada internamente
  no kernel.
*/
#ifndef SOCK_TYPE_MASK
#define SOCK_TYPE_MASK 0xf
#endif

/*
  Aqui são os syscalls usados em system v ipc. eles serão bloqueados
  pelo seccomp
*/
static const char *SYSV_IPC_SYSCALLS[] = {
    "msgget",     "msgsnd", "msgrcv", "msgctl", "semget", "semop",
    "semtimedop", "semctl", "shmget", "shmat",  "shmdt",  "shmctl",
};

/*
  Aqui são outros syscalls que mexem em outros processos ou
  usam memória compartilhada. Também serão bloqueados
*/
static const char *DENY_SYSCALLS[] = {
    "ptrace",
    "process_vm_readv",
    "process_vm_writev",
    "pidfd_getfd",
    "process_madvise",
    "kcmp",
    "keyctl",
    "add_key",
    "request_key",
    "io_uring_setup",
    "bpf",
    "perf_event_open",
    "userfaultfd",
};

#define SYSV_IPC_N (sizeof SYSV_IPC_SYSCALLS / sizeof SYSV_IPC_SYSCALLS[0])
#define DENY_SYSCALLS_N (sizeof DENY_SYSCALLS / sizeof DENY_SYSCALLS[0])

/*
  Aqui a gente bloqueia todas as famílias de socket exceto AF_INET, AF_INET6,
  AF_NETLINK e AF_UNIX. Esses vão ter regras individuais pra cada
*/
static int deny_socket_families(scmp_filter_ctx ctx) {
  int r;

  for (int f = 0; f < AF_MAX; f++) {
    if (f == AF_INET || f == AF_INET6 || f == AF_NETLINK || f == AF_UNIX) {
      continue;
    }
    /*
      o seccomp_rule_add_exact funciona assim: o primeiro parâmetro é
      o contexto do seccomp (a gente vai criar isso no setup). O segundo
      argumento é a ação, no caso aqui vai dar um erro EACCES, o terceiro
      é o tipo do syscall, aqui é call pra sockets. O quarto é um número
      indicando quantas comparações vão ser feitas a seguir e os últimos
      parâmetros são comparações com os próximos argumentos do syscall.
    */
    r = seccomp_rule_add_exact(ctx, SCMP_ACT_ERRNO(EACCES),
                               SCMP_SYS(socket), 1,
                               SCMP_A0(SCMP_CMP_EQ, (scmp_datum_t)f));
    if (r < 0) {
      return -1;
    }
  }
  /*
    Aqui é mais uma proteção. Famílias com número acima de AF_MAX também
    são bloqueadas, assim se alguma família for adicionada no futuro também
    é bloqueada
  */
  r = seccomp_rule_add_exact(ctx, SCMP_ACT_ERRNO(EACCES), SCMP_SYS(socket),
                             1, SCMP_A0(SCMP_CMP_GE, AF_MAX));
  if (r < 0) {
    return -1;
  }
  return 0;
}

/*
  Bloqueia AF_INET e AF_INET6 SOCK_RAW. Raw sockets podem ser usados
  pra criar pacotes 'na mão' e burlar os checks do landlock
*/
static int deny_inet_raw(scmp_filter_ctx ctx) {
  int r;

  r = seccomp_rule_add_exact(
      ctx, SCMP_ACT_ERRNO(EACCES), SCMP_SYS(socket), 2,
      SCMP_A0(SCMP_CMP_EQ, AF_INET),
      SCMP_A1(SCMP_CMP_MASKED_EQ, SOCK_TYPE_MASK, SOCK_RAW));
  if (r < 0) {
    return -1;
  }
  r = seccomp_rule_add_exact(
      ctx, SCMP_ACT_ERRNO(EACCES), SCMP_SYS(socket), 2,
      SCMP_A0(SCMP_CMP_EQ, AF_INET6),
      SCMP_A1(SCMP_CMP_MASKED_EQ, SOCK_TYPE_MASK, SOCK_RAW));
  if (r < 0) {
    return -1;
  }
  return 0;
}

/*
  Bloqueia AF_NETLINK NETLINK_USERSOCK porque esse protocolo é
  usado para ipc.
*/
static int deny_netlink_usersock(scmp_filter_ctx ctx) {
  int r;

  r = seccomp_rule_add_exact(ctx, SCMP_ACT_ERRNO(EACCES),
                             SCMP_SYS(socket), 2,
                             SCMP_A0(SCMP_CMP_EQ, AF_NETLINK),
                             SCMP_A2(SCMP_CMP_EQ, NETLINK_USERSOCK));
  if (r < 0) {
    return -1;
  }
  return 0;
}

/* Bloqueia o uso de unix sockets */
static int deny_unix_sockets(scmp_filter_ctx ctx) {
  int r;

  r = seccomp_rule_add_exact(ctx, SCMP_ACT_ERRNO(EACCES),
                             SCMP_SYS(socket), 1,
                             SCMP_A0(SCMP_CMP_EQ, AF_UNIX));
  if (r < 0) {
    return -1;
  }
  return 0;
}

/* Bloqueia AF_INET, AF_INET6 e AF_NETLINK */
static int deny_network_sockets(scmp_filter_ctx ctx) {
  int r;

  r = seccomp_rule_add_exact(ctx, SCMP_ACT_ERRNO(EACCES),
                             SCMP_SYS(socket), 1,
                             SCMP_A0(SCMP_CMP_EQ, AF_INET));
  if (r < 0) {
    return -1;
  }
  r = seccomp_rule_add_exact(ctx, SCMP_ACT_ERRNO(EACCES),
                             SCMP_SYS(socket), 1,
                             SCMP_A0(SCMP_CMP_EQ, AF_INET6));
  if (r < 0) {
    return -1;
  }
  r = seccomp_rule_add_exact(ctx, SCMP_ACT_ERRNO(EACCES),
                             SCMP_SYS(socket), 1,
                             SCMP_A0(SCMP_CMP_EQ, AF_NETLINK));
  if (r < 0) {
    return -1;
  }
  return 0;
}

/*
  Recebe uma lista de nomes de syscalls e bloqueia cada um deles
*/
static int deny_syscall_list(scmp_filter_ctx ctx, const char *const *names,
                             size_t n) {
  for (size_t k = 0; k < n; k++) {
    int nr = seccomp_syscall_resolve_name(names[k]);
    if (nr == __NR_SCMP_ERROR) {
      return -1;
    }
    int r = seccomp_rule_add_exact(ctx, SCMP_ACT_ERRNO(ENOSYS), nr, 0);
    if (r < 0) {
      return -1;
    }
  }
  return 0;
}

/* Bloqueia os syscalls de system V ipc */
static int deny_sysv_ipc(scmp_filter_ctx ctx) {
  return deny_syscall_list(ctx, SYSV_IPC_SYSCALLS, SYSV_IPC_N);
}

/* Bloqueia os syscalls mexem em processo externos e memória
   comparttilhada */
static int deny_dangerous_syscalls(scmp_filter_ctx ctx) {
  return deny_syscall_list(ctx, DENY_SYSCALLS, DENY_SYSCALLS_N);
}

/*
  Aplica os filtros do seccomp. Isso vai ser chamado no final do setup.
*/
static int apply_seccomp(int allow_unix_sockets, int allow_network_sockets) {
  /*
    primeiro a gente cria o contextop do seccomp, aqui dizendo
    que por padrão todos os syscalls são liberados
  */
  scmp_filter_ctx ctx = seccomp_init(SCMP_ACT_ALLOW);

  if (ctx == NULL) {
    return -1;
  }
  int r = 0;

  /* o tsync aqui é igual ao tsync no landlock. trava também as threads
     irmãs */
  r = seccomp_attr_set(ctx, SCMP_FLTATR_CTL_TSYNC, 1);
  if (r < 0) {
    return -1;
  }
  if (deny_socket_families(ctx) < 0) {
    seccomp_release(ctx);
    return -1;
  }
  if (deny_inet_raw(ctx) < 0) {
    seccomp_release(ctx);
    return -1;
  }
  if (deny_netlink_usersock(ctx) < 0) {
    seccomp_release(ctx);
    return -1;
  }
  if (!allow_unix_sockets && deny_unix_sockets(ctx) < 0) {
    seccomp_release(ctx);
    return -1;
  }
  if (!allow_network_sockets && deny_network_sockets(ctx) < 0) {
    seccomp_release(ctx);
    return -1;
  }
  if (deny_sysv_ipc(ctx) < 0) {
    seccomp_release(ctx);
    return -1;
  }
  if (deny_dangerous_syscalls(ctx) < 0) {
    seccomp_release(ctx);
    return -1;
  }
  /* esse load aqui é o que faz as regras serem aplicadas */
  if (seccomp_load(ctx) != 0) {
    seccomp_release(ctx);
    return -1;
  }
  seccomp_release(ctx);
  return 0;
}

E é basicamente isso. Eu também alterei o sandbox_opts e o parser da linha de comando pra ter as opções --allow-unix-sockets e --allow-network-sockets e incluí uma chamada pro apply_seccomp no final do sandbox_setup. O Código com o seccomp ficou assim.

Compila assim:

gcc -Wall -Wextra -g sandbox2.c -o sandbox -lseccomp

E rodando a baguncinha com o docker já não dá nada:

$ ./sandbox --ro /usr --ro $PWD/test.py -- ./test.py
Traceback (most recent call last):
  File "./test.py", line 48, in <module>
    cid = create_container()
  File "./test.py", line 40, in create_container
    r = send2docker(path, method, payload)
  File "./test.py", line 12, in send2docker
    s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
  File "/usr/lib/python3.13/socket.py", line 233, in __init__
    _socket.socket.__init__(self, family, type, proto, fileno)
    ~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
PermissionError: [Errno 13] Permission denied

Testando isso ficou bom, nada de ipc, nada de syscalls estranhos, nada de rede… Mas aí ficou até demais. Tem muita coisa que eu quero fazer bind/connect em localhost, então eu queria liberar só localhost e deixar o resto travado, mas com o seccomp trava tudo.

Um scriptzinho de exemplo:

#!/usr/bin/python3
# -*- coding: utf-8 -*-


import socket
import sys

HOST = "127.0.0.1"
PORT = 4000
OUTSIDE = ("1.1.1.1", 80)
TIMEOUT = 2.0


def connect_bind_loopback():
    srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    srv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    srv.bind((HOST, PORT))
    srv.listen(1)

    cli = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    cli.settimeout(TIMEOUT)
    try:
        cli.connect((HOST, PORT))
        conn, _ = srv.accept()
        cli.sendall(b"ping")
        got = conn.recv(4)
        conn.close()
    except OSError as exc:
        print(f"  loopback: bind e/ou connect error ({exc})")
        return False
    finally:
        cli.close()
        srv.close()

    print(f"  loopback: connect/bind na porta {PORT} ok!")
    return got == b"ping"


def connect_outside():
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.settimeout(TIMEOUT)
    try:
        s.connect(OUTSIDE)
    except OSError as exc:
        print(f"  externo {OUTSIDE[0]}:{OUTSIDE[1]}: error ({exc})")
        return str(exc)
    finally:
        s.close()
    print(f"  externo {OUTSIDE[0]}:{OUTSIDE[1]}: ok!")
    return None


def main():
    local = connect_bind_loopback()
    ext = connect_outside()

    # o teste é "o loopback funciona". Se o mundo de fora é alcançável é o
    # sandbox que decide, e isso já foi impresso acima.
    return 0 if local else 1


if __name__ == "__main__":
    sys.exit(main())

Rodando esse script dentro do sandbox a gente tem só duas opções: libera tudo ou nega tudo de rede. Com --allow-network-sockets a gente libera conexão/bind em qualquer lugar não só localhost e sem ele não conecta nem em localhost.

Com allow network:

$ ./sandbox  --allow-network-sockets \
     --allow-bind-port 4000 \
     --allow-connect-port 4000 \
     --allow-connect-port 80 \
     --ro /usr --ro $PWD/test2.py \
     -- ./test2.py
 loopback: connect/bind na porta 4000 ok!
 externo 1.1.1.1:80: ok!

Sem allow network:

$ ./sandbox  --allow-bind-port 4000 \
     --allow-connect-port 4000 \
     --allow-connect-port 80 \
     --ro /usr --ro $PWD/test2.py \
     -- ./test2.py
Traceback (most recent call last):
  File "./test2.py", line 61, in <module>
    sys.exit(main())
             ~~~~^^
  File "./test2.py", line 54, in main
    local = connect_bind_loopback()
  File "./test2.py", line 15, in connect_bind_loopback
    srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  File "/usr/lib/python3.13/socket.py", line 233, in __init__
    _socket.socket.__init__(self, family, type, proto, fileno)
    ~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
PermissionError: [Errno 13] Permission denied

Pra resolver isso, liberar só em localhost e travar pra fora, a solução vai ser usar namespaces

Namespaces

Namespaces são abstrações que isolam recursos globais de maneira que um recurso alterado dentro do namespace só é visto por outros processos dentro do mesmo namespace, processos fora do namespace não veem a mudança. Existem 8 namespaces:

  • Cgroup: Isola o diretório raiz de cgroup.

  • IPC: Isola system V IPC e POSIX message queues

  • Mount: Isola mount points

  • Network: Isola interfaces, pilhas e portas de rede.

  • PID: Isola os ids de processo

  • Time: Isola boot e monotonic clocks

  • User: Isola user ids e group ids

  • UTS: Isola hostname e domain name (NIS)

Todos esses namespaces precisam de CAP_SYS_ADMIN para poder funcionar com exceção do user namespace, mas dentro do namespace criado a gente ganha CAP_SYS_ADMIN, então é por aí que iremos.

Primeiro a gente vai criar um user namespace, depois dentro desse namespace a gente cria namespace pra rede (aí que deixaremos só localhost) e, já que estamos aqui, vamos criar também um /tmp e um /dev/shm só para o namespace.

E, como sempre, o que vale é código:

#include <linux/capability.h>
#include <net/if.h>
#include <sched.h>
#include <sys/ioctl.h>
#include <sys/mount.h>
#include <sys/prctl.h>

/* só um helper que vamos usar depois */
static int write_file(const char *path, const char *text) {
  size_t len = strlen(text);
  int fd = open(path, O_WRONLY | O_CLOEXEC);

  if (fd < 0) {
    return -1;
  }
  ssize_t written = write(fd, text, len);
  int write_errno = errno;
  close(fd);
  if (written < 0) {
    errno = write_errno;
    return -1;
  }
  if ((size_t)written != len) {
    /*
      aqui a gente quebra porque uma escrita truncada pode acabar
      sendo mapeada pro usuário errado.
     */
    errno = EIO;
    return -1;
  }
  return 0;
}

/*
  Mapeia o uid do usuário fora do namespace pra dentro do ns.
*/
static int write_id_map(const char *path, unsigned int id) {
  char map[64];

  (void)snprintf(map, sizeof map, "%u %u 1\n", id, id);
  return write_file(path, map);
}

/*
  sobe a interface de loopback. quando um netns é criado, ele é
  criado com uma interface loopback down.
*/
static int loopback_up(void) {
  struct ifreq ifr = {0};
  int fd = socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);

  if (fd < 0) {
    return -1;
  }
  memcpy(ifr.ifr_name, "lo", sizeof "lo");
  if (ioctl(fd, SIOCGIFFLAGS, &ifr) < 0) {
    close(fd);
    return -1;
  }
  ifr.ifr_flags = (short)(ifr.ifr_flags | IFF_UP);
  if (ioctl(fd, SIOCSIFFLAGS, &ifr) < 0) {
    close(fd);
    return -1;
  }
  close(fd);
  return 0;
}

/*
  Remove todas as capabilities do user namespace.
  Quando um user namespace é criado o processo
  tem diversas capabilities que poderiam ser usadas
  para escapar do sandbox, então depois de usarmos
  as capabilities que precisamos pra criar os
  namespaces dentro do user namespace, a gente precisa
  remover tudo.
*/
static int drop_capabilities(void) {
  struct __user_cap_header_struct header = {
      .version = _LINUX_CAPABILITY_VERSION_3,
      .pid = 0,
  };
  struct __user_cap_data_struct data[2] = {{0}};

  for (int c = 0; c <= CAP_LAST_CAP; c++) {
    if (prctl(PR_CAPBSET_DROP, c, 0, 0, 0) < 0 && errno != EINVAL) {
      return -1;
    }
  }
  if (prctl(PR_CAP_AMBIENT, PR_CAP_AMBIENT_CLEAR_ALL, 0, 0, 0) < 0) {
    return -1;
  }
  if (syscall(SYS_capset, &header, data) < 0) {
    return -1;
  }
  return 0;
}

/*
  Cria um novo user namespace
*/
static int setup_userns(void) {
  unsigned int uid = (unsigned int)geteuid();
  unsigned int gid = (unsigned int)getegid();

  /* é isso aqui que cria o novo user namespace.
     o unshare cria um namespace e a flag indica que tipo de
     namespace será criado.
  */
  if (unshare(CLONE_NEWUSER) < 0) {
    return -1;
  }
  /*
    Escrever "deny" no setgroups aqui é obrigatório, sem
    isso o kernel não deixa mapear os uids e gids.
  */
  if (write_file(PROC_SELF_SETGROUPS, "deny") < 0) {
    return -1;
  }
  if (write_id_map(PROC_SELF_UID_MAP, uid) < 0) {
    return -1;
  }
  if (write_id_map(PROC_SELF_GID_MAP, gid) < 0) {
    return -1;
  }
  return 0;
}

/*
  Cria um novo mount namespace
*/
static int setup_mountns(void) {
  if (unshare(CLONE_NEWNS) < 0) {
    return -1;
  }

  /* o unshare copia a lista de mounts, mas não a propagação: cada mount
     copiado continua no mesmo peer group do host. Sem essa linha, o mount
     lá de baixo apareceria no host também, então a gente quebra os peer
     groups antes de montar qualquer coisa. O MS_REC aplica em toda a
     subárvore, porque /tmp e /dev/shm podem estar com propagação
     diferente da raiz.
  */
  if (mount(NULL, "/", NULL, MS_REC | MS_PRIVATE, NULL) < 0) {
    return -1;
  }
  return 0;
}

/* monta um novo tmpfs */
static int mount_tmpfs(const char *target) {
  return mount("tmpfs", target, "tmpfs", MS_NOSUID | MS_NODEV,
               PRIVATE_TMPFS_OPTS);
}

/*
  cria um /tmp pro processo
  se src for NULL um novo tmpfs será criado, se src existir
  será feito um bind em src pra dentro do namespace.

*/
static int setup_private_tmp(const char *src) {
  if (src == NULL) {
    return mount_tmpfs(PRIVATE_TMP);
  }
  if (mount(src, PRIVATE_TMP, NULL, MS_BIND | MS_REC, NULL) < 0) {
    return -1;
  }
  /* esse segundo mount na verdade não está montando nada: ele só troca as
     mnt_flags do mount point que a gente acabou de criar. Tem que ser
     MS_REMOUNT junto com MS_BIND, senão a remontagem atinge o superbloco
     inteiro em vez de só esse mount point. E as flags são substituídas, não
     somadas, por isso nosuid e nodev vão escritos de novo.
  */
  if (mount(NULL, PRIVATE_TMP, NULL,
            MS_BIND | MS_REMOUNT | MS_NOSUID | MS_NODEV, NULL) < 0) {
    return -1;
  }
  return 0;
}

/*
  Cria um novo tmpfs para /dev/shm
*/
static int setup_private_shm(void) {
  if (mount_tmpfs(PRIVATE_SHM) < 0) {
    return -1;
  }
  return 0;
}

/*
  Cria um novo namespace de rede e sobe a interface loopback
*/
static int setup_netns(void) {
  if (unshare(CLONE_NEWNET) < 0) {
    return -1;
  }
  if (loopback_up() < 0) {
    return -1;
  }
  return 0;
}

/*
  Cria os namespaces que o processo vai usar. Primeiro cria um user
  namespace e depois cria /tmp, /dev/shm e loopback se necessário.
  Por fim todas as capabilities são removidas de modo que o processo
  que vai rodar no sandbox não as tenha.

*/
static int setup_namespaces(int private_tmp, const char *private_tmp_src,
                            int private_shm, int loopback_only) {
  int r = setup_userns();

  if (r != 0) {
    return r;
  }
  if (private_tmp || private_shm) {
    r = setup_mountns();
    if (r != 0) {
      return r;
    }
  }
  if (private_tmp) {
    r = setup_private_tmp(private_tmp_src);
    if (r != 0) {
      return r;
    }
  }
  if (private_shm) {
    r = setup_private_shm();
    if (r != 0) {
      return r;
    }
  }
  if (loopback_only) {
    r = setup_netns();
    if (r != 0) {
      return r;
    }
  }
  if (drop_capabilities() < 0) {
    return -1;
  }
  return 0;
}

Também alterei o sandbox_opts e o parser da linha de comando pra ter as opções --loopback-only, --private-tmp, --private-tmp-src e --private-shm e incluí uma chamada pro setup_namespaces no começo do sandbox_setup. O Código com o seccomp ficou. A terceira versão do código ficou assim.

Compila assim:

gcc -Wall -Wextra -g sandbox3.c -o sandbox -lseccomp

Agora rodando o scripzinho de teste de connect/bind, a gente pode liberar só localhost com --loopback-only:

$ ./sandbox  --allow-network-sockets \
     --loopback-only \
     --allow-bind-port 4000 \
     --allow-connect-port 4000 \
     --allow-connect-port 80 \
     --ro /usr --ro $PWD/test2.py \
     -- ./test2.py
 loopback: connect/bind na porta 4000 ok!
 externo 1.1.1.1:80: error ([Errno 101] Network is unreachable)

Bom, com isso eu achei que tinha o mínimo pra poder usar no dia-a-dia. Aí foi só dar mais um tapa pra limpar variáveis de ambiente, setar rlimits, fechar file descriptors… mas a ideia é basicamente essa que a gente viu até aqui. O código final virou o caged.

Legal, bacana, agora tenho um programa que trava um processo. E o que eu faço com isso? Ah! Enfia no… llm-bridge! :)

Mas como esse post tá muito grande, essa parte vai ficar pro próximo (que tem um prazo de 5 anos úteis pra ser publicado).