Httptap - veja as requisições HTTP/HTTPS de qualquer programa Linux

 (github.com/monasticacademy)
8 pontos por GN⁺ 2025-02-04 | 2 comentários | Compartilhar no WhatsApp
  • httptap é uma ferramenta que executa programas Linux no formato httptap -- <command> e mostra no terminal um resumo das requisições e respostas HTTP/HTTPS geradas por esse programa
  • Funciona sem privilégios de root, sem daemon, sem mudanças globais no sistema, sem regras de iptables e sem alterar a tabela de roteamento; o executável é um binário Go estático sem dependências
  • No momento, é exclusivo para Linux e informa que é difícil portar para outros sistemas operacionais por usar chamadas de sistema específicas do Linux, como network namespace
  • O tráfego HTTPS é descriptografado injetando em tempo de execução uma autoridade certificadora criada na hora no ambiente do subprocesso, e o funcionamento é baseado em um proxy TCP transparente que processa pacotes IP/TCP/UDP brutos
  • Em Ubuntu 23.10 ou superior, ou em distribuições que desativam por padrão user namespace sem privilégios, pode ser necessária configuração de sysctl; também há limitações como não aceitar conexões de entrada e exigir acesso a /dev/net/tun

O que o httptap faz

Instalação e requisitos de execução

  • O binário pré-compilado pode ser instalado baixando o tarball da release mais recente
    • Todas as versões e arquiteturas de CPU podem ser consultadas em releases
  • Também há a opção de instalação com Go
    • go install github.com/monasticacademy/httptap@latest
  • Em geral, a execução não exige privilégios de root, nem daemon, nem configuração global do sistema
    • Não cria regras de iptables
    • Não altera a tabela de roteamento
    • Em geral, não afeta outros processos no mesmo sistema
  • No Ubuntu 23.10 ou superior, são necessárias as seguintes configurações
    • sudo sysctl -w kernel.apparmor_restrict_unprivileged_unconfined=0
    • sudo sysctl -w kernel.apparmor_restrict_unprivileged_userns=0
  • Essas configurações desativam recursos recentes do kernel que restringem user namespace sem privilégios
    • Também podem ser necessárias em outras distribuições que desativam por padrão user namespace sem privilégios
    • O projeto está investigando uma forma de eliminar essa necessidade fornecendo junto um perfil AppArmor para o httptap

Exemplos de uso

  • O exemplo com curl -s https://buddhismforai.sutra.co -o /dev/null mostra que o servidor retornou um redirecionamento 302
  • Se você seguir os redirecionamentos com curl -sL, as requisições adicionais também serão exibidas
    • A primeira requisição retorna 302
    • A segunda retorna 200 para a URL de destino do redirecionamento
  • No exemplo com gcloud compute instances list, é possível ver os endpoints HTTP usados internamente pela Google Cloud CLI
  • No exemplo com kubectl get all, ele mostra as requisições ao servidor de API do Kubernetes
    • --https 443 6443 faz com que conexões TCP nas portas 443 e 6443 sejam tratadas como HTTPS
    • --insecure-skip-tls-verify é necessário porque o kubectl não usa a autoridade certificadora gerada pelo httptap
  • O exemplo com curl --doh-url https://cloudflare-dns.com/dns-query mostra o fluxo de DNS-over-HTTP
    • As duas primeiras requisições são consultas DNS
    • As duas seguintes são requisições HTTP normais ao site de destino
  • Usando as opções --head e --body juntas, ele imprime os cabeçalhos HTTP e a carga útil bruta

Saída HAR

Acesso a localhost

  • Para acessar uma porta localhost do host a partir de dentro do httptap, use host.httptap.local ou 169.254.77.65 em vez de localhost
  • Cada network namespace no Linux tem seu próprio dispositivo loopback 127.0.0.1, então 127.0.0.1:1234 dentro do httptap não é o mesmo endereço e porta do host
  • O httptap contorna isso roteando de forma fixa 169.254.77.65 para 127.0.0.1

Subprocessos que viram daemon

  • No Linux, é possível criar subprocessos que continuam existindo mesmo depois que o processo original termina
    • Isso é comum em daemons e em aplicativos GUI executados pela linha de comando
  • Ao executar esses processos sob o httptap, o processo daemonizado continua dentro do network namespace do httptap
  • A opção --no-exit faz o httptap continuar com o proxy e o registro mesmo depois que o subprocesso executado diretamente termina
    • No exemplo com Visual Studio Code, usa-se httptap --no-exit -- code --ignore-certificate-errors .
    • Para encerrar, é preciso fechar o VS Code e depois finalizar o httptap com Ctrl+C
  • Se o httptap terminar primeiro sem --no-exit, o network namespace pode continuar existindo, mas como não haverá processo lendo os pacotes do dispositivo TUN, a conexão de rede do app será interrompida
  • Nos exemplos com setsid setsid curl http://httpbin.org/get e com fork, setsid, fork em Python, sem --no-exit ocorre o erro Could not resolve host

Como funciona

  • httptap -- <command> executa o <command> em um network namespace isolado e injeta uma autoridade certificadora criada na hora para descriptografar o tráfego HTTPS
  • Ele cria um dispositivo TUN no Linux e configura o ambiente do subprocesso para que todo o tráfego de rede passe por esse dispositivo
    • O tráfego escrito no dispositivo TUN é entregue ao descritor de arquivo mantido pelo processo que criou esse dispositivo
  • Como alterar o network namespace raiz afetaria o tráfego do sistema inteiro, o httptap cria um network namespace separado
    • Nesse namespace existem apenas o dispositivo loopback e o dispositivo TUN
    • O subprocesso é executado dentro desse namespace
  • O tráfego recebido pelo dispositivo TUN consiste em pacotes IP brutos
    • O httptap faz o parse dos pacotes IP e dos pacotes TCP/UDP internos
    • Depois precisa escrever de volta pacotes IP brutos para o subprocesso
    • Sua implementação própria de TCP/IP não cobre muitas partes do protocolo TCP completo, mas funciona de forma razoável para esse objetivo
  • Quando o subprocesso faz uma requisição para www.example.com, o httptap recebe um TCP SYN destinado ao IP de destino e responde com SYN+ACK
    • Em separado, ele usa a API normal de sockets do kernel Linux para abrir uma conexão TCP real com o IP de destino
    • Depois retransmite os dados nos dois sentidos
    • Essa estrutura é um proxy TCP transparente tradicional
  • A descriptografia HTTPS é feita por meio da injeção da autoridade certificadora
    • Na inicialização, ele gera uma autoridade certificadora correspondente a uma private key e a um x509 certificate
    • Grava o certificado em um sistema de arquivos visível apenas para o subprocesso
    • Define variáveis de ambiente visíveis apenas para o subprocesso para adicionar essa autoridade certificadora à lista de confiança
    • Como o httptap possui a private key da autoridade certificadora, ele consegue se apresentar como se fosse o servidor com o qual o subprocesso quer se comunicar e ler a requisição HTTP em texto puro

Limitações

  • Atualmente é exclusivo para Linux e depende de chamadas de sistema específicas do Linux, como network namespace
  • O processo não pode aceitar conexões de rede de entrada
  • É necessário ter permissão de acesso a /dev/net/tun
  • Todas as requisições ICMP echo são simplesmente respondidas em eco, sem enviar pacotes ICMP para a rede real

Leituras relacionadas

2 comentários

 
halfenif 2025-02-06

it was developed at the Monastic Academy in Vermont in the US. We believe that a monastic schedule, and the practice of the Buddhist spiritual path more generally, provide ideal conditions for technological development.

Testando e olhando o GitHub, fiquei pensando se talvez tenha sido criado por pessoas em treinamento monástico? como parte de uma realização espiritual.
 
GN⁺ 2025-02-04
Opiniões do Hacker News

  • A seção “How it was made” do README foi tão interessante quanto a própria ferramenta
    Diz que eles vivem e praticam juntos em uma propriedade de pouco mais de 100 acres, recitam cânticos e meditam juntos de manhã e à noite, e, todo mês, por cerca de uma semana, organizam e participam de retiros de meditação. No restante do tempo, trabalham juntos no cuidado da terra, manutenção dos prédios, cozinha, limpeza, planejamento, captação de recursos e, nos últimos anos, também no desenvolvimento de software

    • Isso me lembrou uma passagem de “Soul of a new machine”
      Numa época em que microcódigo e lógica causavam problemas em escala de nanossegundos, um engenheiro exausto, ao pedir demissão, teria deixado no terminal uma nota como carta de renúncia: “Vou para uma comuna em Vermont e não vou lidar com nenhuma unidade de tempo menor que uma estação do ano”
    • Sinceramente, soa como uma das muitas seitas de ioga/espiritualidade que já existem pelo Ocidente
    • O trecho “Nos últimos anos, temos gravado uma série de palestras chamada Buddhism for AI. Ela trata de um esforço para projetar uma religião baseada no budismo — sim, uma religião — que sistemas de IA possam consumir diretamente. Considerando a situação do mundo, sentimos que esse trabalho é muito importante” parece um indicador de quão estranha é a época em que vivemos
      Se é uma boa ideia, ou se levará ao resultado que eles imaginam, é outra questão
    • Achei que a primeira foto rural fosse uma imagem gerada, mas agora parece ser uma foto real
      A combinação de tecnologia e meditação é atraente. A ideia em si é interessante, mas colocá-la em prática provavelmente deve ser difícil. Parece uma espécie de Recurse budista

  • httptap é um rastreador HTTP no escopo do processo que pode ser executado sem privilégios de root
    Ao executar um programa Linux como httptap <programa>, você vê no stdout o rastreamento das requisições e respostas HTTP/HTTPS

    httptap -- python -c "import requests; requests.get('https://monasticacademy.org')"
    ---> GET https://monasticacademy.org/
    <--- 308 https://monasticacademy.org/ (15 bytes)
    ---> GET https://www.monasticacademy.org/
    <--- 200 https://www.monasticacademy.org/ (5796 bytes)

    Ele funciona executando o processo dentro de um namespace de rede isolado e usa o gVisor como sua própria pilha TCP/IP. Como não é um proxy HTTP, não depende de configurações de proxy. O tráfego TLS é descriptografado com a criação de uma CA em tempo real, sem instalar regras de iptables nem fazer alterações globais no sistema

    • Fico curioso se daria para fazer isso funcionar no macOS. Pelo que sei, o Tailscale usa a biblioteca TCP/IP do gVisor como a biblioteca netstack em alguns recursos do macOS
    • Fico curioso se é possível modificar requisições ou respostas. À medida que a web atual fica cada vez mais hostil ao usuário, a necessidade de ferramentas assim é maior do que nunca
      Especialmente se não exigir configuração de proxy, fica ainda mais útil
    • Será que todo mundo esqueceu do Wireshark, que também pode ser executado sem root?
      https://blog.wireshark.org/2010/02/running-wireshark-as-you/

  • A ideia de executar o processo em um namespace de rede isolado é genial
    A parte de HTTPS é ainda mais interessante. Parece que ele define variáveis de ambiente comuns[1] para que o programa use o bundle de CA em um diretório temporário, mas há o problema de que, assim como nas variantes de http_proxy, o programa pode simplesmente ignorar essas variáveis

    Também vi que ele monta um sistema de arquivos overlay em /etc/resolv.conf[2]. Fico imaginando se ajudaria o httptap montar o diretório /etc/ca-certificates com o bundle temporário de CA

    [1] https://github.com/monasticacademy/httptap/blob/cb92ee3acfb2...
    [2] https://github.com/monasticacademy/httptap/blob/cb92ee3acfb2...

    • Concordo que é frustrante praticamente não existir uma forma consensual ou imposta pelo sistema de especificar uma CA raiz para processos arbitrários
      O motivo de o httptap montar um overlay em /etc/resolv.conf é que, de modo parecido com as CAs raiz, também não há uma forma confiável de dizer a um processo arbitrário qual servidor DNS usar. Ainda assim, /etc/resolv.conf é uma opção bastante confiável. No momento em que você coloca o processo em um namespace de rede, ele não consegue mais acessar localhost:53, o resolvedor do systemd, que é a configuração mais comum em desktops Linux, então é preciso fornecer resolução DNS
      Montar /etc/ca-certificates como overlay também poderia ajudar. Porém, ao olhar a estrutura desse diretório, fiquei surpreso com a falta de consistência entre distribuições. Ainda assim, é possível. Se alguém souber como adicionar certificados a esse diretório de um modo que pelo menos algumas implementações de TLS reconheçam, eu gostaria de ouvir
    • Acho que, para a parte de HTTPS, não existe uma solução geral que cubra todos os tipos de programa e a longa cauda de implementações de certificate pinning
      Como contraexemplo, dá para imaginar um malware que se comunica por TLS e tem o código compilado fortemente ofuscado. Poderia ser um programa que inclui no binário um conjunto fixo de certificados de CA e nunca abre o sistema de arquivos. Mesmo assim, ele conseguiria criar conexões TLS seguras e válidas por cerca de 10 anos, até a maioria dos certificados de CA raiz expirar. TLS é todo tratado em espaço de usuário, e não há garantia de que use OpenSSL ou alguma outra biblioteca comum, então também não dá para contar com hooks em funções específicas do OpenSSL. Se o servidor usar um certificado autoassinado e o cliente, por qualquer motivo, aceitá-lo, fica ainda pior
      Ainda assim, com um pouco de trabalho, certamente é possível lidar de forma confiável com 99% dos casos. É melhor do que não ter nada

  • Usar um dispositivo TUN aqui é uma ideia realmente genial. A seção “How it was made” do README também é uma das melhores que já li em um README do GitHub
    Estou criando algo chamado Subtrace[1], que consegue interceptar automaticamente tanto requisições de entrada quanto de saída. É engraçado que a interface para iniciar programas parece ter convergido para o mesmo formato[2]. Mas o objetivo do Subtrace é um pouco diferente do httptap, mais voltado para observabilidade/monitoramento de serviços de backend em nuvem, por isso ele enfatiza requisições nos dois sentidos. A abordagem também é diferente. Com Seccomp BPF, ele intercepta cerca de 10 chamadas de sistema, como socket, connect, listen, accept etc., e faz proxy de todas as conexões TCP por meio do Subtrace. Depois, faz o parsing das requisições HTTP no stream TCP e reaproveita a aba Network do Chrome DevTools para rodar no navegador como um webapp comum e mostrar isso ao usuário

    Fico curioso se há alguma história interessante surgida ao executar programas sob o httptap. Também queria saber qual programa é o que mais “liga para casa”

    [1] https://github.com/subtrace/subtrace
    [2] https://docs.subtrace.dev/quickstart

    • Isso me lembra o NetGuard, que faz filtragem de pacotes usando o serviço de VPN do Android. Ele usa o serviço de VPN do Android em vez de TUN bruto
      https://github.com/M66B/NetGuard
    • Também é interessante conectar o conteúdo capturado ao Chrome DevTools, e também é interessante usar eBPF. Fazer as ferramentas de desenvolvedor rodarem como um webapp independente também é excelente
      Pode ser difícil de acreditar, mas há uma tentativa meio pronta de fazer a mesma coisa com a aba de rede do Firefox no diretório networktab do repositório. É um projeto muito bacana; quero aprender mais e também ficaria feliz em conversar mais sobre ele

  • Outra ferramenta para um usuário sem privilégios analisar tráfego de rede é usar rootless Podman com Pasta
    Basta adicionar o seguinte às opções de podman run

    --network=pasta:--pcap,myfile.pcap

    Então o Pasta registra o tráfego de rede em um arquivo PCAP, que pode ser analisado depois. Também escrevi um exemplo simples de análise de um arquivo PCAP gravado usando tshark
    https://github.com/eriksjolund/podman-networking-docs?tab=re...

    • Muito bom saber, mas ainda resta o problema de descriptografar tráfego TLS

  • Bem interessante. Já escrevi uma biblioteca que faz uma função parecida de “tap” em aplicações Go: https://github.com/henvic/httpretty
    https://asciinema.org/a/297429

    Também pensei em fazer algo assim para programas arbitrários, mas nunca fui muito a fundo em como implementar de fato. Fico contente em ver que alguém criou isso

  • Fico me perguntando por que não usar eBPF. Assim daria para ver de uma vez as requisições HTTP de todos os processos, inclusive os que já estão em execução. Além disso, talvez nem fosse preciso se preocupar com TLS; bastaria, por exemplo, fazer hook em write(2)

    • Não entendo como fazer hook em write(2) resolveria TLS. Você até poderia ler e modificar o texto cifrado, mas como o processo não chama write(2) com bytes em texto puro, não conseguiria ler a requisição HTTP real. No fim, você só veria os bytes criptografados que vão para a rede, e isso até a NSA consegue ver
      É preciso um truque de certificado CA como o que o httptap usa. Claro que há ressalvas como certificate pinning, mas na maioria dos cenários práticos dá para fazer isso funcionar de forma confiável
      Ao criar o Subtrace[1], pensei absurdamente muito sobre esse problema específico, então tenho interesse genuíno se houver uma abordagem mais simples ou elegante
      [1] https://github.com/subtrace/subtrace
    • Infelizmente, TLS acontece dentro da aplicação, não no kernel, então fazer hook na chamada de sistema write com eBPF não ajuda na descriptografia TLS
    • Fico imaginando se, colocando um uprobe na biblioteca SSL, seria possível inspecionar e modificar coisas como respostas HTTP descriptografadas para filtrar conteúdo
    • Acho que eBPF provavelmente exige privilégios de root
    • Esse método não exigiria root? O grande “argumento de venda” do httptap parece ser justamente não precisar de privilégios de root
      De qualquer forma, quanto mais opções, melhor

  • Legal. Acho que vou usar imediatamente para debugar configurações do nginx
    Hoje uso curl -v e preciso vasculhar manualmente a saída para descobrir o que deu errado; com essa ferramenta, coisas como loops de redirecionamento devem aparecer na hora

    • Gostaria de ouvir como ele funciona em contextos reais de uso, especialmente quais recursos seriam úteis

  • Parece muito bom para dar uma olhada rápida e grosseira na pilha de chamadas HTTP/S de um app
    Pessoalmente, prefiro eBPF para ver tudo, mas esse utilitário pode ajudar a restringir as partes importantes em um tracing com eBPF

  • Parece bom
    O perfil no GitHub aponta para https://www.monasticacademy.org/about; não tenho uma opinião específica sobre isso em si, mas fiquei curioso para entender como os retiros de treinamento monástico deles se conectam ao projeto no GitHub
    No fim do README, a conexão estava explicada: https://github.com/monasticacademy/httptap?tab=readme-ov-fil...

    • Para quem está lendo esta thread, o ponto de conexão é simplesmente que o httptap é um projeto da Monastic Academy
      Isso significa que, em uma propriedade de 123 acres em Vermont, as pessoas vivem juntas seguindo uma estrutura relativamente tradicional de mosteiro budista. Só que não são monges formalmente ordenados. Durante o dia, trabalham juntos em vários projetos técnicos e não técnicos. O link do README acima dá uma boa visão geral
      https://github.com/monasticacademy/httptap?tab=readme-ov-fil...