Pular para o conteúdo

Referência

Segurança

Esta página cobre o modelo de ameaças, o que o middleware de autenticação faz, o que as NetworkPolicies impõem e o que não impõem, a postura de cadeia de suprimentos e as perguntas que um revisor corporativo vai fazer, respondidas antecipadamente, porque este produto é vendido para ambientes com um gate de revisão de segurança.

Modelo de ameaças

O SRE Orbit é auto-hospedado: cada contêiner roda na sua conta, no seu cluster, e o architecture.md estabelece que nada sai dali. Isso elimina a maior parte da modelagem de ameaças de SaaS (sem plano de dados multi-tenant compartilhado, sem vazamento no fornecedor que alcance os seus dados) e deixa quatro coisas contra as quais este desenho precisa se defender:

  1. Um chamador não autenticado na sua rede lendo o parque ou gastando o seu orçamento de modelo. A rodada 1 deste produto entregou tanto o orbit-api quanto o nocturne sem autenticação alguma; o Adendo v0.2 do CONTRACT.md existe porque "an unauthenticated caller could read the whole estate and choose which model tier to bill" (um chamador não autenticado poderia ler o parque inteiro e escolher qual tier de modelo faturar). A autenticação obrigatória (abaixo) fecha isso.
  2. O navegador carregando uma credencial que não deveria ter. Um token que chega ao JavaScript do cliente é um token que um bug de XSS, uma extensão maliciosa de navegador ou um source map vazado consegue exfiltrar. O proxy server-side no web (veja architecture.md) faz com que ORBIT_AUTH_TOKEN e NOCTURNE_AUTH_TOKEN nunca cheguem ao navegador, então não há nada lá para roubar.
  3. Um workload em um namespace sem relação alcançando um serviço que ele não tem por que alcançar: a API do parque ou, pior, um endpoint de LLM que cobra por token. As NetworkPolicies (abaixo) restringem isso na camada de rede, além da camada de autenticação, para que um defeito em uma não seja a defesa inteira.
  4. Uma pessoa fazendo mais do que o papel dela permite, seja com a própria conta, com uma sessão roubada ou com uma página de outro site pegando carona no navegador dela. Toda rota confere, no servidor, a sessão e uma permissão; o cookie nunca chega ao JavaScript; uma requisição que altera estado precisa provar que vem da mesma origem; e toda mudança e toda recusa viram um evento de auditoria (abaixo).

Fora do escopo deste documento, porque são decisões suas e não decisões que este produto toma por você: a escolha do provedor de identidade para o modo oidc, o RBAC vinculado à service account do ORBIT_KUBECONFIG contra o seu cluster real e a política de gestão de chaves da sua organização para os tokens que você gerar.

O que o middleware de autenticação faz

Um middleware, à frente do router, nos dois serviços de backend, apenas no listener da API (nunca no listener de métricas; não há nada de que isentá-lo, veja abaixo).

  • Modo static (default): Authorization: Bearer <token> comparado com ORBIT_AUTH_TOKEN / NOCTURNE_AUTH_TOKEN usando comparação em tempo constante, para evitar um canal lateral de temporização que vazaria o token um byte por vez. O serviço se recusa a iniciar se o seu token estiver vazio ou tiver menos de 32 bytes: uma configuração errada falha fechada, no boot, e não aberta, na hora da requisição.
  • Modo oidc: o bearer é interpretado como um JWT, tem a assinatura verificada (RS256/ES256) contra o JWKS do emissor e é conferido quanto a exp, iss e aud. As chaves ficam em cache com renovação limitada, em vez de serem buscadas a cada requisição.
  • Modo disabled: toda requisição passa. O serviço registra um WARN nomeando o risco em cada inicialização (não apenas na primeira) e se recusa a iniciar se ORBIT_DEMO_DATA=false: não há como rodar sem autenticação contra dados reais de cluster, por construção, não por convenção.
  • Caminhos isentos, incondicionalmente, em todos os modos: GET /healthz, GET /readyz. Nada mais. Em particular, /api/v1/version exige uma credencial válida como tudo o mais no listener da API.
  • Formato da falha: 401, corpo {"error":{"code":"unauthorized","message":"..."}}. A mensagem nunca diz se o token estava ausente, malformado ou apenas expirado. Um atacante sondando um token que está perto de ser válido quer essa distinção, e omiti-la não custa nada a um chamador legítimo (ou ele tem o token certo ou o regenera).

O que as NetworkPolicies impõem e o que não impõem

Tanto o chart Helm quanto os manifestos kubectl puros renderizam uma política de negação por padrão por namespace e então abrem exatamente os caminhos que o CONTRACT.md exige: ingress → apenas web, web → orbit-api, orbit-api → nocturne, tudo → CoreDNS e (somente depois que você nomear o namespace) o seu namespace de monitoramento → a porta de métricas :9090 de cada serviço. O nocturne só ganha egress para a internet quando você define explicitamente allowInternetEgress: true para ele e, mesmo assim, a regra de egress exclui 169.254.0.0/16 (metadados de instância da nuvem), as faixas RFC1918 e 100.64.0.0/10 (a faixa de NAT de operadora que o custom networking do EKS dá aos pods), então um SSRF por prompt injection no caminho do modelo não consegue emitir credenciais de nuvem nem pivotar para a sua VPC ou para os seus pods por esse buraco. Todo outro egress para a internet que o chart abre (o orbit-api para SSO, a fatura da AWS e os webhooks de alerta, o orbit-agent para o CloudWatch) exclui as mesmas faixas, e o deploy/check_hardening.py reprova um render que deixe uma de fora.

Um objeto NetworkPolicy pode ser aplicado sem erro e mesmo assim não ser imposto, como dizem os comentários do próprio chart. O Kubernetes só impõe NetworkPolicy se a CNI do cluster a implementar.

  • O flannel sozinho não implementa NetworkPolicy, mas o k3s (e portanto o k3d) não roda só o flannel: ele embute o controlador de políticas do kube-router, que escreve uma cadeia de iptables por política em cada node. No cluster de install/local-k3d.md as políticas são impostas, e o fluxo de telemetria funciona através delas.
  • Calico e Cilium impõem. A EKS só impõe com o agente de políticas de rede da VPC CNI ligado (ou com um add-on Calico/Cilium); a maioria dos clusters EKS roda sem ele, e aí os objetos são aplicados e não bloqueiam nada.

Se um revisor de segurança perguntar "isso é imposto?", a resposta tem duas partes: a política está definida corretamente independentemente do cluster, e se ela é imposta depende de uma propriedade do seu cluster que este produto não controla. Prove você mesmo antes de confiar nisso: implante na sua CNI real, depois tente a conexão que a política deveria bloquear a partir de um pod em um namespace sem relação e confirme que ela dá timeout.

/metrics é a borda mais afiada aqui. networkPolicy.monitoringNamespace tem como default vazio, de propósito: sem valor definido, nenhuma regra de scrape é renderizada, e :9090 continua inalcançável de fora do namespace mesmo com NetworkPolicy plenamente imposta. O chart costumava delimitar isso com um label de pod isolado (app.kubernetes.io/name: prometheus) sem restrição de namespace, o que não é uma verificação de identidade: qualquer pessoa que escrevesse um workload em qualquer namespace poderia colocar esse label no próprio pod e alcançar a porta de métricas. Nomear o namespace explicitamente é o que faz a regra significar alguma coisa; o seletor de label de pod dentro de monitoringPodLabels só restringe ainda mais depois que o namespace já é confiável.

Em quem o collector acredita

O collector do chart (apm.collector, engine orbit) recebe OTLP nas portas 4317 e 4318 de todos os namespaces, porque um app com SDK envia de onde estiver rodando. Nenhuma NetworkPolicy consegue restringir isso, e um SDK não traz credencial OTLP por padrão. Por isso o collector procura, no watch de pods, o endereço de onde vem cada requisição e decide o que o remetente pode declarar:

RemetentePode falar porO collector grava
Um pod no namespace de node do release ou em apm.collector.orbit.trustedNamespacesOutros pods: o orbit-node lê os arquivos de log deles, o orbit-probe e o OBI rastreiam os sockets delesOs atributos k8s.* que ele enviou, completados pelo watch de pods onde faltarem
Qualquer outro podEle mesmoO k8s.pod.name, o k8s.namespace.name, o k8s.pod.uid, o workload e o node do próprio pod, no lugar de todo k8s.* que ele enviou. O k8s.container.name quando ele nomeia um dos contêineres do pod, senão o único contêiner do pod. O service.name quando o spec do pod o declara, senão o serviço do próprio pod
Um endereço que nenhum pod ocupa (um node, um processo em hostNetwork)Nada no KubernetesO service.name dele, sem nenhum dos k8s.* que enviou

O spec de um pod declara um nome de serviço com a anotação resource.opentelemetry.io/service.name, um OTEL_SERVICE_NAME literal (ou service.name num OTEL_RESOURCE_ATTRIBUTES literal) em qualquer contêiner, o label app.kubernetes.io/name ou app.kubernetes.io/instance, o nome do workload, o nome do pod ou o de um contêiner. O OpenTelemetry Operator grava o OTEL_SERVICE_NAME no spec, então os apps que ele instrumenta mantêm os nomes. Um app que define o nome só no código recebe o serviço do próprio pod, o primeiro de: a anotação, OTEL_SERVICE_NAME, OTEL_RESOURCE_ATTRIBUTES, app.kubernetes.io/name, o deployment, statefulset, daemonset, cronjob ou job, o nome do pod. Para escolher o nome, coloque a anotação no template do pod. O collector nunca resolve o valueFrom de uma entrada de env.

Seja em quem for que ele acredite para os k8s.*, um remetente fora dos namespaces confiáveis fica sem nenhum atributo de span com nome orbit.* e sem telemetry.sdk.name igual a orbit-probe. Esses são do orbit-probe, e o engine age sobre eles: o orbit.hop.trace_id de um span move o trace que ele nomeia para dentro do trace do próprio span por 15 minutos, e as chamadas sem pai do probe são costuradas dentro de requisições. Sem esse corte, um pod que viu um trace id num traceparent de entrada poderia tomar aquele trace para si.

Uma checagem por endereço não distingue os processos que compartilham o endereço de um node. Onde roda um pod hostNetwork de um namespace confiável (o OBI com apm.autoInstrument.contextPropagation, o node-exporter com telemetry.nodeExporter.engine: upstream), qualquer pod hostNetwork desse node fala por outros pods, e em qualquer node um pod hostNetwork ainda pode declarar um service.name. Esse é o teto: aplique nos seus namespaces o label pod-security.kubernetes.io/enforce: baseline (ou restricted) e o Kubernetes recusa pods hostNetwork neles. APM cobre um gateway Collector seu e o caso do service mesh. Com apm.collector.engine=upstream vale a associação do próprio otelcol, que acredita no pod e no serviço que o payload nomeia.

O que a autenticação própria do web faz

O proxy server-side do architecture.md mantém o ORBIT_AUTH_TOKEN fora do navegador, mas isso só protege o token, não o caminho até ele. Nada impedia que outro pod no mesmo cluster chamasse <release>-web:3000/api/... diretamente: nenhuma CNI impondo NetworkPolicy é o caso comum na EKS, não a exceção (veja acima), e a única autenticação voltada ao usuário era a basic auth opcional do ingress-nginx, que uma chamada direta dentro do cluster ignora por completo. Um chamador que alcança o web desse jeito pega carona no bearer server-side dele de graça e consegue ler logs de pod, ConfigMaps, literais de env, eventos, inventário e PromQL bruto. Agora o web autentica cada requisição por conta própria, então esse caminho exige uma credencial mesmo sem nenhuma CNI impondo NetworkPolicy na frente dele.

  • Toda rota, menos uma. A autenticação HTTP Basic roda no proxy do próprio web (apps/web/src/proxy.ts, o middleware do Next.js, sem matcher, então roda em toda requisição) na frente das páginas, do Orbit Deck, do /api/* incluindo os streams SSE, e de todo arquivo estático. A única isenção é GET /healthz: o próprio proxy responde a ela, antes da autenticação e antes do roteamento de locale.
  • Checado três vezes. O Next.js pula o apps/web/src/proxy.ts para uma requisição cujo cabeçalho x-prerender-revalidate bate com o id de preview do build, e esse id viaja dentro da própria imagem (.next/prerender-manifest.json), então quem tiver a imagem consegue pular o proxy. A credencial é checada de novo no handler de /api/* que guarda o bearer, antes de qualquer chamada upstream, e de novo em toda leitura server-side da orbit-api (apps/web/src/lib/orbit-api.ts, e apps/web/src/lib/prom-fetch.ts antes do memo compartilhado de PromQL), então uma página renderizada sem a credencial não carrega dado nenhum. O apps/web/next.config.ts também redireciona para / qualquer requisição que carregue esse cabeçalho, já que nada aqui revalida sob demanda.
  • O que fica guardado é o verificador, nunca a senha. WEB_AUTH_VERIFIER guarda pbkdf2-sha256$<iterations>$<base64 salt>$<base64 hash>: PBKDF2-HMAC-SHA256 via Web Crypto, salt aleatório de 16 bytes, hash de 32 bytes, com no mínimo 210.000 iterações aceitas. node apps/web/scripts/hash-password.mjs < password-file gera isso: só por stdin, nunca por argv, recusa um terminal interativo para que a senha nunca seja ecoada, remove uma quebra de linha final e recusa qualquer coisa com menos de 15 caracteres (o mínimo da NIST SP 800-63B-4 para uma senha que é o único fator). O próprio script grava 600.000 iterações, a cifra atual da OWASP para PBKDF2-HMAC-SHA256. Tanto o nome de usuário quanto o hash derivado são comparados em tempo constante, e as duas comparações sempre rodam.
  • Falha fechada. WEB_AUTH_MODE=basic com WEB_AUTH_USER ou WEB_AUTH_VERIFIER ausente ou malformado devolve 503 not_ready em todo path, inclusive /healthz, e registra uma linha web auth:. O pod nunca fica Ready, então um verificador ruim trava o rollout em vez de substituir pods que funcionam por pods quebrados.
  • Duas camadas de limitação. Uma credencial correta é derivada uma vez por processo e fica em cache; bater com ela nas vezes seguintes custa um HMAC sob uma chave aleatória por processo, não outra rodada de PBKDF2, então quem já entrou nunca espera. A camada global: mais de duas derivações de senha em andamento ao mesmo tempo devolve 429 rate_limited com Retry-After: 1, não importa qual cliente as disparou. A camada por cliente: depois de 5 palpites errados, cada novo erro dobra a espera (1, 2, 4 s, até 60 s) e, enquanto isso, os novos palpites desse cliente recebem 429 com Retry-After ajustado para os segundos que faltam; 15 minutos sem errar esquece a contagem, e um login certo a zera na hora. O cliente é o último salto do X-Forwarded-For (a visão do ingress sobre quem chama, ou o endereço de socket que o Next preenche quando o cabeçalho não vem), e qualquer pod capaz de alcançar o web diretamente consegue forjar e trocar esse cabeçalho; é por isso que a camada global continua existindo: uma enxurrada de dentro do cluster ainda consegue queimar CPU e atrasar novos logins, não importa quantas identidades de cliente alegue. O values-eks.yaml também limita as requisições na borda, por IP de origem, com nginx.ingress.kubernetes.io/limit-rps: "20" e nginx.ingress.kubernetes.io/limit-connections: "20". Nada disso substitui uma senha forte. Gere uma (openssl rand -base64 24); nenhum limite de taxa resolve uma senha adivinhável.
  • Mutuamente exclusivo com a basic auth do ingress, imposto no render. O ingress-nginx limpa o cabeçalho Authorization assim que a própria basic auth dele dá certo (proxy_set_header Authorization ""), então ligar as duas trancaria todo mundo do lado de fora do ingress. O render do chart Helm falha se ingress.basicAuth.enabled e components.web.auth.enabled estiverem ligados ao mesmo tempo, em vez de entregar essa configuração. O deploy/check_hardening.py confirma essa recusa, e confirma que todo caminho de instalação (defaults do Helm, dev, EKS, prod e kubectl puro) dá ao web WEB_AUTH_MODE=basic com WEB_AUTH_USER e WEB_AUTH_VERIFIER vindos do Secret do release, sem optional.

Sessões, papéis e a trilha de auditoria

O Adendo v0.5 coloca uma pessoa por trás de cada chamada. O que isso acrescenta à defesa, e onde cada controle fica:

  • A sessão nunca chega ao JavaScript. O orbit-api emite um token opaco: um session id com assinatura HMAC-SHA256 (chave ORBIT_SESSION_SECRET, ou 32 bytes aleatórios em ORBIT_DATA_DIR/session.key). A rota de login do próprio web move esse token para o cookie __Host-orbit_session no https (HttpOnly, SameSite=Lax, Path=/, Secure e sem Domain, então um subdomínio vizinho não consegue gravá-lo nem lê-lo) ou orbit_session no http puro, e o tira do corpo da resposta. No https o web só lê o nome com __Host-. O web o repassa como X-Orbit-Session e nunca encaminha o header Cookie do navegador, então nada mais que um navegador guarde para este domínio chega a um serviço.
  • Sessões acabam. 24 horas depois do login, aconteça o que acontecer nesse meio-tempo; depois de 8 horas sem nenhuma requisição; no logout; e, para todas as sessões de um usuário, quando ele é desativado, excluído ou recebe uma senha nova. Cada sessão é um documento que o orbit-api apaga, então um token revogado já é recusado na requisição seguinte, e não só quando expiraria. Um token forjado ou alterado é recusado antes de qualquer busca.
  • As permissões são conferidas onde os dados estão. O orbit-api resolve o papel do usuário a cada requisição e recusa com 403 forbidden uma rota cuja permissão esse papel não tem. O Deck esconde o que um papel não pode usar, mas esconder é só cortesia: uma requisição montada à mão passa pela mesma checagem. Uma rota sem permissão própria continua exigindo sessão, inclusive uma adicionada mais tarde que ninguém se lembrou de proteger. As ferramentas do Nocturne carregam a sessão de quem pergunta, então o assistente não consegue ler o que essa pessoa não poderia.
  • Requisições vindas de outro site. O SameSite=Lax impede que o cookie acompanhe requisições POST, PUT, PATCH e DELETE disparadas de outro site, e o web recusa qualquer um desses métodos quando Sec-Fetch-Site ou Origin indica outro site, login e logout incluídos: um login forjado a partir de outra página colocaria a vítima dentro da conta do atacante. Uma requisição sem nenhum dos dois headers não vem de um navegador e segue para as checagens seguintes. Escritas em workloads continuam exigindo o token de operador no salto do web, além de workloads.write (Adendo v0.4), então uma sessão sequestrada, sozinha, não consegue alterar um cluster.
  • Links não agem sozinhos. Um link compartilhado do Orbit SQL preenche o editor e a conexão e espera você clicar em Executar. O terminal do pod só abre um shell sozinho quando um clique dentro do Deck levou até ele (Sec-Fetch-Site: same-origin); um link de outro site, um favorito ou um recarregamento espera o seu clique. Um link não executa consulta nem abre shell em seu nome.
  • O token de operador fica fora da página. O Deck envia o token digitado uma única vez para o POST /api/operator do web, que responde com um cookie HttpOnly e SameSite=Strict (__Host-orbit_operator no https) contendo uma validade e um HMAC com o token como chave, nunca o próprio token. Ele dura uma hora, o logout o apaga e trocar o ORBIT_DECK_WRITE_TOKEN o invalida. O web só aceita o cookie numa requisição cujo Sec-Fetch-Site ou Origin prove que ela veio deste console. Scripts continuam enviando X-Orbit-Operator-Token.
  • O login resiste a palpites. As falhas são contadas por nome de usuário (5 sem penalidade, depois uma espera que começa em 1 s e dobra até 1 minuto) e por endereço do cliente (20 sem penalidade, depois até 15 minutos) antes de qualquer senha ser conferida, somados aos limites de requisição por endereço. Todo login faz o mesmo trabalho de PBKDF2, exista o usuário ou não, e a resposta é a mesma, então nem a mensagem nem o tempo que ela leva revelam quais contas existem. As senhas ficam guardadas como verificadores PBKDF2-HMAC-SHA256 com 600.000 iterações e salt de 16 bytes, e uma senha nova precisa ter 12 caracteres ou mais.
  • A primeira conta. ORBIT_ADMIN_USER com um verificador vindo de um Secret, ou um código de configuração de uso único que só existe na memória do processo e no log dele. Com ORBIT_DEMO_DATA=true, em vez disso, são criadas três contas com uma senha publicada: nunca exponha uma instalação com dados de demonstração e nunca leve o diretório de dados dela para produção, porque essas contas sobrevivem à flag de demonstração.
  • Tudo fica registrado. Logins e falhas de login, logouts, toda mudança em usuários, papéis, dashboards, alertas e workloads e toda recusa de permissão, com o autor, o endereço do cliente, o user agent e o request id, gravados com fsync antes de a resposta sair. O endereço do cliente é o que o ingress controller enxerga: atrás de um load balancer de nuvem ou de uma CDN, é o endereço deles até que a borda repasse o cliente adiante, e isso é um ajuste que vale para o controller inteiro (audit.md → "Como o IP do cliente é determinado"). Um login que falha nunca registra o nome de usuário digitado, a menos que ele exista, de modo que uma senha digitada no campo errado fica fora da trilha. Veja audit.md.
  • O diretório de dados é um segredo. Ele guarda verificadores de senha, a chave de sessão quando ORBIT_SESSION_SECRET não está definida, session ids em uso e uma trilha de auditoria cheia de endereços IP. Criptografe o volume dele, restrinja os backups dele como você restringe o Secret de credenciais e defina ORBIT_SESSION_SECRET para que uma cópia do volume não consiga assinar sessões.

Proteções no navegador

Em produção, toda resposta do web leva uma Content-Security-Policy sem unsafe-inline nem unsafe-eval para scripts: uma página renderizada por requisição libera seus scripts e estilos por um nonce novo, e uma página pré-renderizada pelos hashes dos seus blocos inline. Ela também define frame-ancestors 'none', base-uri 'self', form-action 'self' e object-src 'none', além de Strict-Transport-Security: max-age=31536000; includeSubDomains (os navegadores só o aplicam no https), X-Frame-Options: DENY, X-Content-Type-Options: nosniff, Referrer-Policy: strict-origin-when-cross-origin, uma Permissions-Policy que desliga câmera, microfone, localização, pagamentos, USB, serial, HID, Bluetooth e captura de tela, e Cross-Origin-Opener-Policy, -Embedder-Policy e -Resource-Policy. O build de produção não publica source maps, e /api/v1/version só responde a um usuário logado. Uma resposta JSON sob /api leva Content-Disposition: attachment, então abri-la como página salva o arquivo em vez de exibi-lo. Um método que nada aqui atende (PROPFIND, MKCOL) recebe 405; o Node recusa TRACE e TRACK antes que o Deck os leia, com um 500 ou 400 que não ecoa nada. Sair da conta apaga o que o navegador guardou para você: rascunhos e histórico de SQL, consultas do Explore e avulsas, páginas recentes e visões salvas localmente. As preferências de exibição ficam. O Markdown que o Deck renderiza a partir de um texto que ele não escreveu (uma resposta do Nocturne, que carrega o que diziam os logs que ele leu, e o painel de texto de um dashboard, que uma importação traz) mostra HTML como texto, descarta links javascript: e data: e mostra uma imagem pelo seu texto alternativo: nenhuma resposta ou dashboard consegue fazer o navegador de quem lê buscar um endereço escolhido por ela, com ou sem a política acima.

Cadeia de suprimentos

  • Runtime distroless, sempre. O web roda sobre gcr.io/distroless/nodejs26-debian13:nonroot; o orbit-api, o nocturne e todas as outras imagens em Rust rodam sobre gcr.io/distroless/cc-debian13:nonroot. Sem shell, sem gerenciador de pacotes, sem curl em nenhuma camada final de imagem. Os health checks que de outro modo precisariam de curl entregam, em vez disso, um pequeno binário em Rust feito só com a biblioteca padrão e construído no mesmo estágio de builder (veja install/docker-compose.md).
  • As imagens base são travadas por tag e por digest. Uma tag sozinha é um alvo móvel; atualizar uma sem a outra anula o propósito de travar.
  • Varredura antes da publicação. Na main e nas tags, o CI constrói cada imagem para amd64 e arm64 em um registry que existe só no runner, roda o trivy nas duas plataformas ali e só depois que a varredura passa copia esse mesmo digest para o GHCR. Uma imagem com achado HIGH ou CRITICAL nunca chega ao registry de onde os clusters puxam.
  • Nenhum arquivo de ignore, nunca. Não existe .trivyignore, não existe .snyk e não existe arquivo de ignore de scanner de nenhum tipo em lugar algum deste repositório, e a posição do projeto é que nunca pode existir um: um achado é corrigido na imagem base ou na dependência, ou fica vermelho até que possa ser corrigido. Se você fizer um fork disto, não adicione um sob pressão de prazo. Corrija a imagem base ou a dependência, ou registre a CVE com o id do advisory e trate-a como uma exceção conhecida e rastreada, com dono e data, não como um scanner silenciado.
  • Não-root, capabilities removidas, sistema de arquivos raiz somente-leitura, em todo lugar. runAsNonRoot: true, runAsUser/Group: 65532, allowPrivilegeEscalation: false, capabilities.drop: [ALL] sem nada devolvido, readOnlyRootFilesystem: true, seccompProfile: RuntimeDefault, definidos de forma idêntica no docker-compose.yml (para que um problema apareça em um laptop, e não primeiro em um cluster) e em cada manifesto Kubernetes. Todo caminho gravável de que um contêiner precisa é um emptyDir explícito e com tamanho limitado; não há sistema de arquivos gravável implícito para servir de rede de segurança.
  • Pod Security Admission. O chart renderiza o próprio namespace com pod-security.kubernetes.io/enforce: restricted, de modo que o admission controller do próprio cluster, e não só os manifestos deste repositório, recusa um pod que viole o hardening acima.
  • Rollbacks imutáveis em produção. values-prod.yaml define requireDigest: true; o chart se recusa a renderizar se o image.digest de qualquer componente habilitado estiver vazio, nomeando o --set-string exato que resolve. Uma tag pode apontar para bytes diferentes amanhã; um digest não pode, e essa é a única razão pela qual helm rollback significa alguma coisa. Veja install/helm.md.
  • deploy/check_hardening.py é um gate. Ele interpreta tanto a saída renderizada do Helm quanto os manifestos puros (os dois podem divergir independentemente) e verifica cada item acima, por pod, mais: requests e limits definidos em cada contêiner, liveness em /healthz, readiness em /readyz, porta de contêiner batendo com o CONTRACT.md, um PDB e topologySpreadConstraints em todo Deployment com múltiplas réplicas (e, verificado com o mesmo rigor, ausentes em qualquer um de réplica única, porque um PDB sobre uma réplica bloqueia drains de node para sempre), todo emptyDir com tamanho definido e nenhum Secret carregando um valor versionado.

Controles do Kubescape que os agentes de node não conseguem passar

Escaneamos o chart renderizado com o Kubescape (frameworks NSA, MITRE, CIS v1.10 e CIS v1.12) ao lado do chart cost-analyzer do Kubecost. No namespace da release, todos os controles passam. Os controles abaixo falham no namespace de node e nos seus dois DaemonSets, porque um agente de node precisa ler o node para fazer o seu trabalho. Cada linha diz a configuração mais estreita que o chart usa; o deploy/check_hardening.py recusa qualquer coisa mais ampla.

ControleOndePor que falhaConfiguração mais estreita
C-0193, C-0197 a C-0204 (CIS 5.2.2 a 5.2.12)Namespace <release>-nodeO Pod Security baseline recusa qualquer volume hostPath, inclusive os somente leitura, então o namespace impõe privileged.warn e audit continuam restricted: um pod ali que peça mais do que esses dois DaemonSets aparece nos avisos do kubectl e no log de auditoria. O namespace da release impõe restricted.
C-0048 (montagem hostPath)orbit-node, orbit-probeO orbit-node lê /proc/1/net, /proc/1/mountinfo, /sys/class/net, /sys/devices, /run/udev/data e /etc/os-release, mais /var/log/pods com telemetry.logs, e o diretório de cada fonte de telemetry.logs.files. O orbit-probe lê /sys/kernel/btf e /sys/fs/cgroup.Cada caminho do host somente leitura, nunca o / do node. Um diretório de telemetry.logs.files é recusado quando é um diretório do sistema, fica dentro de um ou contém um (/etc, /var/lib/kubelet, /var/log/pods ...). O orbit-node guarda as posições dos logs num emptyDir e roda sem hostNetwork nem hostPID.
C-0211 (supplementalGroups)orbit-node com telemetry.logsO kubelet grava /var/log/pods com modo 0750 e cada arquivo de log com 0640, do grupo do root.uid 65534 com todas as capabilities removidas; o grupo 0 entra só quando telemetry.logs está ligado. Root ou DAC_READ_SEARCH leriam mais do que os logs.
C-0038, C-0275 (PID do host)orbit-probeEle liga cada socket ao seu processo, cgroup e pod por /proc/<pid>.Só hostPID: sem hostNetwork, sem hostIPC.
C-0046 (capabilities), C-0013 e C-0211 (root)orbit-probeCarregar programas eBPF exige BPF e PERFMON; ler os mapas de memória e os binários de outros processos exige SYS_PTRACE e DAC_READ_SEARCH. O Kubernetes não define capabilities ambientes, então só o uid 0 as mantém.uid 0 com essas quatro adicionadas e todas as outras removidas (SYS_RESOURCE também com apm.autoInstrument.lowKernel, para kernels anteriores ao Linux 5.11), raiz somente leitura, seccomp RuntimeDefault e sem privileged, a não ser que você ligue apm.autoInstrument.privileged por causa do SELinux do Bottlerocket.

Desligue telemetry.nodeExporter e apm.autoInstrument e o namespace de node some com todas as linhas acima, junto com as métricas de node, os logs de contêineres e os spans eBPF.

O que este produto hoje não especifica

Um revisor encontra estas lacunas mais rápido do que um questionário de fornecedor, então esta página as lista:

  • Nenhum mTLS ou criptografia em trânsito entre os quatro componentes está especificado no CONTRACT.md. O TLS termina no seu ingress (o ingress.tls de install/helm.md); o tráfego entre web, orbit-api e nocturne dentro do cluster é HTTP puro, protegido por segmentação de rede (NetworkPolicy, acima), não por criptografia. Se o seu ambiente exige criptografia pod a pod, isso é uma decisão de service mesh (Linkerd, Istio, a criptografia transparente do Cilium) colocada por cima. Nada aqui impede isso, e nada aqui fornece isso.
  • Secrets do Kubernetes são base64, não criptografia. O chart e os manifestos puros tratam um Secret como a interface correta (referenciado, nunca um default de chart; veja configuration.md), mas criptografia em repouso para Secrets é uma propriedade do seu cluster (EncryptionConfiguration com KMS, ou um gerenciador de segredos externo) que este repositório não configura por você.
  • Nada neste repositório gera hoje um SBOM ou atestado de proveniência. Se o seu processo de compras exige um, trate isso como uma lacuna a fechar no seu pipeline de build, não como uma afirmação que esta documentação faça em nome do produto.
  • Operar o emissor e a audiência do modo OIDC é responsabilidade sua. Este produto verifica um JWT; ele não opera um provedor de identidade. Do jeito que está construído hoje, o oidc se recusa a iniciar: as contas são locais, sem single sign-on, sem segundo fator e sem SCIM.
  • A trilha de auditoria não detecta adulteração. Ela é feita de arquivos comuns no volume do orbit-api. Se a trilha precisar valer como prova, mande as linhas de log audit para um armazenamento que quem administra a trilha não consiga reescrever.
  • Uma única réplica concentra a identidade. O orbit-api roda um só pod sobre um armazenamento de escritor único; a perda de um node deixa o login indisponível até o pod voltar.

Checklist: o que um revisor de segurança corporativo vai perguntar

PerguntaResposta
Plano de dados multi-tenant?Não: auto-hospedado, uma instalação por conta de cliente, nada compartilhado.
Algum componente liga para casa ou envia telemetria ao fornecedor?Não. Veja architecture.md → "O que sai da sua conta: nada".
Como a API é autenticada?Token bearer (comparação em tempo constante) entre os componentes, obrigatório por padrão, e, por cima dele, uma sessão de usuário assinada e revogável em todas as rotas, exceto as probes e o login; veja "O que o middleware de autenticação faz" e "Sessões, papéis e a trilha de auditoria" acima.
Contas por usuário e menor privilégio?Sim: usuários locais, três papéis embutidos e papéis personalizados sobre um conjunto fechado de doze permissões, impostos pelo orbit-api em todas as rotas. Veja identity.md.
Existe trilha de auditoria?Sim: todo login, toda mudança e toda recusa, com autor, endereço e request id, consultável e exportável em CSV, mantida por ORBIT_AUDIT_RETENTION (default de 90 dias). Sozinha, não detecta adulteração. Veja audit.md.
Single sign-on e MFA?Ainda não. ORBIT_AUTH_MODE=oidc se recusa a iniciar em vez de entregar meio verificador.
CSRF?Cookie de sessão SameSite=Lax e HttpOnly, mais uma checagem de mesma origem no web em toda requisição que altera estado, login incluído.
A autenticação pode ser desligada?Apenas em um modo que se recusa a iniciar contra dados que não sejam de demonstração, com um WARN registrado a cada boot enquanto estiver ligado.
A credencial é exposta ao navegador em algum momento?Não: proxy server-side no web; veja architecture.md.
O endpoint de IA/LLM é alcançável pela internet?Não existe regra de ingress alguma para o nocturne; ele só é alcançado pelo reverse proxy interno do orbit-api.
/metrics é público?Não: listener separado, sem rota de ingress e (no Kubernetes) inalcançável até você nomear explicitamente o seu namespace de monitoramento.
Os contêineres rodam como root?Não: UID 65532 não-root, todas as capabilities removidas, sistema de arquivos raiz somente-leitura, em todo lugar.
As imagens são escaneadas, e os achados são suprimidos?Escaneadas conforme a política do seu próprio CI; este repositório não entrega arquivo de ignore para nenhum scanner, por regra.
As imagens base de terceiros são travadas de forma reprodutível?Sim: tag e digest juntos.
A criptografia em trânsito é exigida de ponta a ponta, inclusive dentro do cluster?TLS no ingress; o tráfego interno é HTTP puro protegido por NetworkPolicy, não por criptografia. Veja a lacuna registrada acima.
A criptografia em repouso para segredos está configurada?O Secret do Kubernetes é a interface; a criptografia em repouso é responsabilidade do seu cluster (criptografia com KMS ou um gerenciador de segredos externo).
Existe rate limiting contra abuso?Sim: um limitador por IP em todas as rotas dos dois serviços de backend (Adendo v0.2), com o contact adicionalmente limitado a 5 requisições por minuto, burst 3. O IP é o peer do socket, a menos que a requisição traga o bearer do próprio orbit-api (só o web o tem, e o web só repassa o X-Forwarded-For tal como um proxy de borda o escreveu, WEB_TRUST_PROXY) ou que o peer esteja em ORBIT_TRUSTED_PROXIES / NOCTURNE_TRUSTED_PROXIES; nesses casos, é o salto não confiável mais próximo no X-Forwarded-For, nunca um cabeçalho que um chamador possa forjar sozinho. Veja configuration.md, audit.md e api.md.
O que acontece com uma CVE em uma dependência?É corrigida na origem (upgrade, patch ou substituição); não existe mecanismo de supressão neste repositório para servir de saída.

Para onde ir em seguida

  • O comportamento exato de falha de autenticação em contexto, e como gerar os tokens que esta página pressupõe que você já tem: configuration.md.
  • Cada rota à frente da qual estes controles ficam, e o conjunto fechado de códigos de erro: api.md.
  • Como é, na prática, uma NetworkPolicy que é aplicada mas não é imposta, quando você esbarra nisso: troubleshooting.md.