Desbloqueie o poder do Kali Linux em redes Docker adicionando uma GUI de volta ao contêiner e aumente o nível da coleta de informações com a raspagem anônima da Web desenvolvida por Python, Selenium e Tor Browser.

Como engenheiro de DevOps, enviei e permiti que outros engenheiros enviassem muitas centenas de milhares de contêineres. Eu uso entrega contínua e uma variedade de métodos de orquestração: Kubernetes, Lambda Containers na AWS, Elastic Container Service (ECS) apoiado por Elastic Compute Cloud (EC2) e Fargate. Os contêineres são úteis para sistemas de construção personalizados, implantações automatizadas, verificação de vulnerabilidades, fins de pesquisa, análise de dados, aprendizado de máquina, arquivamento de software legado, desenvolvimento local e raspagem da web.

Neste guia, examinarei as etapas pelas quais passei para adicionar uma GUI ao contêiner Kali Linux oficial do DockerHub usando Xvfb e um servidor VNC. O código que discuto aqui é publicado no repositório de código aberto kalilinux-xvfb e é entregue continuamente ao Docker Hub para uso geral. Por fim, na Parte 2 desta série, tudo o que há nos contêineres será posto à prova. Usarei um script Python personalizado, Pytest e Selenium para automatizar a instância do navegador Tor e coletar dados da web.

Redes de Contêineres

Parte da motivação por trás de ter o Kali Linux em um contêiner é ganhar visibilidade no espaço de rede privada criado pela máquina host para contêineres. A configuração padrão do Docker Desktop é usar uma rede NAT. A menos que as portas estejam vinculadas à máquina host, com docker run -p , esse serviço não estará acessível a partir do host.

O software

Aqui estão as seções de resumo adicionadas com links para cada um dos seguintes pacotes de software:

• Kali LinuxGenericName

• Docker Desktop

• Navegador Tor

• Iniciador do navegador Tor

• Xvfb

• Selênio

  
  

Links adicionais para o software que usei:

• Xfce 4

• Servidor VNC apertado

• Servidor OpenSSH

• Python3 e Pip3

• Geckodriver

  
  

Kali LinuxGenericName

Kali Linux é uma distribuição Linux baseada em Debian voltada para testes avançados de penetração e auditoria de segurança. 1

Escolhi o Kali Linux pela grande quantidade de ferramentas com foco em segurança disponíveis. A equipe do Kali Linux fornece uma imagem do Docker que é atualizada regularmente. Grande parte do software necessário está disponível para a imagem Kali Linux Docker e usarei o gerenciador de pacotes para instalá-los.

Docker Desktop

O Docker Desktop é uma estrutura para executar contêineres localmente. Os contêineres são uma forma de empacotar o sistema operacional e o estado do aplicativo em uma imagem reutilizável do sistema operacional. Recursos adicionais estão disponíveis no site do Docker .

Contêineres e máquinas virtuais têm benefícios semelhantes de isolamento e alocação de recursos, mas funcionam de maneira diferente porque os contêineres virtualizam o sistema operacional em vez do hardware. 2

Como os contêineres do Docker são mais leves do que as máquinas virtuais, eu os favoreço fortemente em meus esforços de desenvolvimento. A longo prazo, esse estado pode ser armazenado como um pequeno arquivo de texto e é muito mais fácil acompanhar as alterações ao longo do tempo com git e ferramentas semelhantes. A capacidade de derivar uma imagem novamente de um arquivo de texto é poderosa. No entanto, é totalmente possível que um Dockerfile caia em desuso ao longo do tempo e possa falhar na construção em uma data posterior. Assim como qualquer outro Sistema Operacional e Infraestrutura como Código, é importante manter tudo atualizado.

Uma alternativa ao Docker seria usar uma máquina virtual ou uma instalação bare metal. No entanto, acredito que os contêineres são o ambiente de teste perfeito para executar rastreadores efêmeros da Web porque são fáceis de provisionar e limpar. Posso executar muitos contêineres em uma única máquina, em paralelo, que podem ser iniciados e interrompidos quase instantaneamente. Então, sempre que eu precisar de isolamento adicional, toda essa configuração também pode ser executada de dentro de uma máquina virtual.

Navegador Tor

O Onion Router (Tor) é uma rede global de computadores que roteiam o tráfego por meio de uma série de saltos criptografados. Isso permite que um usuário navegue na Internet anonimamente e também permite que um usuário acesse sites que estão disponíveis apenas na Rede Tor.

• O Navegador Tor é uma versão fortemente configurada do Firefox com foco em privacidade e segurança. Ele pode usar a Rede Tor pronta para uso.

• O torbrowser-launcher está incluído em muitos sistemas operacionais Linux e torna extremamente fácil iniciar um navegador da Web na Rede Tor.

  
  

Selênio

Selenium é uma ferramenta para automatizar navegadores da web. Optei pelo Python neste exemplo, mas há muitas linguagens e ferramentas disponíveis.

Estarei usando o Selenium para automatizar este navegador Tor na rede Tor. Estou tentando aproveitar a configuração existente do navegador preocupado com a segurança para limitar o compartilhamento de informações aos alvos. Serei capaz de limpar os estados de tempo de execução dos contêineres parando-os. A sessão resultante do WebDriver terá um endereço IP aleatório fornecido pelo Tor, tornando-o uma ferramenta muito poderosa para web scraping.

Xvfb

O componente XOrg Xvfb pode ser usado para simular uma tela para o sistema X window. Em seguida, usarei esta tela para iniciar um servidor X no contêiner. Essa técnica de emulação não é particularmente rápida e os aplicativos gráficos pesados se beneficiarão de uma GPU.

Visão geral dos arquivos

Os Dockerfiles devem ser construídos em qualquer distribuição Linux, macOS ou Windows que possa executar o Docker. Eu testei isso no Docker Desktop usando um processador Intel. Existe uma variante ARM para o contêiner base oficial do Kalilinux. Agradeceria o feedback de qualquer pessoa que tente executar isso no ARM.

1. Dockerfile
2. TorBrowser.Dockerfile
3. TorBrowser-root.Dockerfile
4. startx-once.sh
5. start-vnc-server-once.sh
6. ssh-keys.sh
7. torrc
8. .github/workflows/main.yml

Dockerfile

Este é o Dockerfile que usei para criar a imagem base. Eu adicionei alguns comentários para explicar o que cada linha faz.

 # From the official Kali Linux Docker image rolling release FROM kalilinux/kali-rolling # Leaving this here for now, but it's not needed ARG DISPLAY_NUMBER=1 ENV DISPLAY=:$DISPLAY_NUMBER # Install the packages we need # Got lucky with this one, there was a ticket about this: # https://github.com/dnschneid/crouton/issues/4461 `xfce4 dbus-launch not found` in this version of the image so installing dbus-x11 RUN apt-get update -y -q \ && apt-get install -y -q xvfb xfce4 xfce4-goodies tightvncserver net-tools curl openssh-server dbus-x11 # This line copies the shell scripts from the local directory to the container, and makes them executable. COPY *.sh /opt/ RUN chmod 755 /opt/*.sh # This line runs the shell scripts that start the X server, and generate the SSH keys. RUN /opt/startx-once.sh RUN /opt/ssh-keys.sh # This line sets the entrypoint to bash, so that we can run commands in the container. ENTRYPOINT /bin/bash

startx-once.sh

Ajuda a iniciar o servidor X. Estou usando o comando Xvfb para iniciar o servidor X. Se houver um PID e algo estiver errado com o servidor X, posso interromper o processo e iniciá-lo novamente. Eu experimentei bloquear sessões X da rede, embora possa ser desnecessário, ainda estou adicionando de qualquer maneira: -nolisten tcp discussão no superusuário

 #!/bin/bash FILE=/opt/.x.pid if [[ -f "$FILE" ]]; then echo "$FILE exist" echo "PID: " `cat $FILE` else Xvfb -nolisten tcp $DISPLAY & echo $? > $FILE fi

ssh-keys.sh

Clientes VNC não são ideais para copiar e colar texto. Isso pode ser remediado adicionando chaves SSH ao contêiner para ajudar outros hosts a se conectarem a ele. Isso abre a possibilidade de usar túneis SSH para se conectar ao contêiner.

O seguinte comando ssh-keygen foi referenciado neste Artigo do Stack Exchange

 #!/bin/bash # Generate SSH keys ssh-keygen -b 2048 -t rsa -f ~/.ssh/id_rsa -q -N "" cat ~/.ssh/id_rsa >> ~/.ssh/authorized_keys

Se vou usar essas chaves, preciso da chave privada em minha estação de trabalho. Estou usando os seguintes comandos para copiar a chave privada para minha máquina host do docker, mas há várias maneiras de fazer isso. Houve uma boa discussão sobre isso no Stack Overflow .

Encontrando o ID do contêiner com o comando ps :

 docker ps 

Usando o ID do contêiner para copiar com o comando cp :

 # For root docker cp <containerId>:/root/.ssh/id_rsa /target/path/on/host # Otherwise for the user configured in the Dockerfile docker cp <containerId>:/home/username/.ssh/id_rsa /target/path/on/host

torrc

Isso precisa ser copiado para o contêiner, mas são apenas seções não comentadas da configuração clichê que o Projeto Tor fornece aqui .

 # /etc/tor/torrc ## Tor opens a SOCKS proxy on port 9050 by default -- even if you don't ## configure one below. Set "SOCKSPort 0" if you plan to run Tor only ## as a relay, and not make any local application connections yourself. SOCKSPort 9050 # Default: Bind to localhost:9050 for local connections. #SOCKSPort 192.168.0.1:9100 # Bind to this address:port too. ## Uncomment this to start the process in the background... or use ## --runasdaemon 1 on the command line. This is ignored on Windows; ## see the FAQ entry if you want Tor to run as an NT service. RunAsDaemon 1 ## The port on which Tor will listen for local connections from Tor ## controller applications, as documented in control-spec.txt. ControlPort 9051 ## If you enable the controlport, be sure to enable one of these ## authentication methods, to prevent attackers from accessing it. #HashedControlPassword 16:872860B76453A77D60CA2BB8C1A7042072093276A3D701AD684053EC4C CookieAuthentication 1

TorBrowser.Dockerfile

Este Dockerfile se baseia no Dockerfile anterior e adiciona o Navegador Tor e o Python à mistura. Estou usando o pacote torbrowser-launcher para instalar o Navegador Tor.

 # From the base Dockerfile: FROM excitingtheory/kalilinux-xvfb ARG DISPLAY_NUMBER=1 ENV DISPLAY=:$DISPLAY_NUMBER # More info about torbrowser-launcher: # https://github.com/micahflee/torbrowser-launcher RUN apt-get update -y -q \ && apt-get install -y -q torbrowser-launcher python3 python3-pip # Create a user and add them to the sudo group, sudo still TBD but leaving for now, will not be able to switch users in this container. RUN useradd -s /bin/bash -m username \ && usermod -aG sudo username # Install python packages RUN pip3 install selenium pytest COPY torrc /etc/tor/torrc # Set the user and home directory for the container USER username ENV USER=username ENV HOME=/home/username # Run the shell scripts that start the X server, and generate the SSH keys. RUN /opt/startx-once.sh RUN /opt/ssh-keys.sh # This line sets the entrypoint to bash, so that we can run commands in the container. ENTRYPOINT /bin/bash

TorBrowser-root.Dockerfile

Assim como antes, mas com menos configuração. Usará o usuário root.

 # From the base Dockerfile: FROM excitingtheory/kalilinux-xvfb ARG DISPLAY_NUMBER=1 ENV DISPLAY=:$DISPLAY_NUMBER # More info about torbrowser-launcher: # https://github.com/micahflee/torbrowser-launcher RUN apt-get update -y -q \ && apt-get install -y -q torbrowser-launcher python3 python3-pip # Install python packages RUN pip3 install selenium pytest # Copy the tor config file into the containera COPY torrc /etc/tor/torrc # Run the shell scripts that start the X server, and generate the SSH keys. RUN /opt/startx-once.sh RUN /opt/ssh-keys.sh # This line sets the entrypoint to bash, so that we can run commands in the container. ENTRYPOINT /bin/bash

.github/workflows/main.yml

O arquivo de fluxo de trabalho do Github Actions cria a imagem do Docker e a envia para o Docker Hub. Este é o fluxo de trabalho de estoque da documentação do Docker , com tags adicionais sendo enviadas. Adicionei umaprogramação para acionar esta ação uma vez por dia.

 name: docker build and push on: push: branches: - "main" schedule: - cron: '20 16 * * *' jobs: build: runs-on: ubuntu-latest steps: - name: Checkout uses: actions/checkout@v3 - name: Login to Docker Hub uses: docker/login-action@v2 with: username: ${{ secrets.DOCKERHUB_USERNAME }} password: ${{ secrets.DOCKERHUB_TOKEN }} - name: Set up Docker Buildx uses: docker/setup-buildx-action@v2 - name: Build and push base image uses: docker/build-push-action@v4 with: context: . file: ./Dockerfile push: true tags: excitingtheory/kalilinux-xvfb:latest - name: Build and push torbrowser root image uses: docker/build-push-action@v4 with: context: . file: ./TorBrowser-root.Dockerfile push: true tags: excitingtheory/kalilinux-xvfb:torbrowser-root - name: Build and push torbrowser image uses: docker/build-push-action@v4 with: context: . file: ./TorBrowser.Dockerfile push: true tags: excitingtheory/kalilinux-xvfb:torbrowser

Usando os Contêineres

Agora posso testar os contêineres e ver se funcionam. Vou usar a tag torbrowser para este exemplo.

Construindo os Contêineres (Opcional)

Consulte a documentação do Docker CLI Build para obter mais informações sobre o comando docker build . Para criar contêineres localmente, uso os seguintes comandos, caso contrário, eles podem ser extraídos do Docker Hub sob demanda durante as próximas etapas.

 docker build -t excitingtheory/kalilinux-xvfb . docker build -t excitingtheory/kalilinux:torbrowser -f TorBrowser.Dockerfile . docker build -t excitingtheory/kalilinux:torbrowser-root -f TorBrowser-root.Dockerfile .

Executando os contêineres com um volume

Preciso montar um volume no contêiner para poder acessar os arquivos nos quais estou trabalhando. Estou usando o diretório ${HOME}/src como um volume.

Algumas notas breves sobre os sinalizadores que estamos usando estão incluídas abaixo, caso contrário, consulte a documentação de execução da CLI do Docker para obter mais informações sobre o comando docker run .

• -it usado para executar o contêiner no modo interativo.

• --rm é usado para remover as camadas do contêiner ao sair.

• -p é usado para mapear a porta do contêiner para a máquina host.

• -v é usado para montar um volume da máquina host para o contêiner.

  
  

 # Run the base container docker run -it --rm -p 5901:5901 -v "${HOME}/src":/src excitingtheory/kalilinux-xvfb # Run the container with the default user docker run -it --rm -p 5901:5901 -v "${HOME}/src":/src excitingtheory/kalilinux-xvfb:torbrowser # Run the container with the root user docker run -it --rm -p 5901:5901 -v "${HOME}/src":/src excitingtheory/kalilinux-xvfb:torbrowser-root

Usando o Navegador Tor a partir do Contêiner

Em seguida, quero abrir o contêiner do usuário, fazer login por meio do VNC e executar o Tor Browser Launcher para verificar se tudo está funcionando até agora. O iniciador do navegador Tor não funcionará com o usuário root.

Inicie o contêiner com o usuário padrão:

 docker run -it --rm -p 5901:5901 -v "${HOME}/src":/src excitingtheory/kalilinux-xvfb:torbrowser

Iniciando o servidor VNC no contêiner, o servidor solicitará a senha principal, estou definindo uma senha adicional somente para visualização.

 /opt/start-vnc-server-once.sh

Abaixo está um exemplo da saída.

Conectar no macOS

A caixa de diálogo conectar ao servidor pode ser encontrada no menu localizador: Go -> Connect to Server .

Quando a caixa de diálogo estiver aberta, insira o endereço vnc://localhost:5901 e clique em Connect . Salvei este endereço como favorito para facilitar o acesso.

Conectar no Windows

Um cliente vnc como o TightVNC pode se conectar a ele em localhost:5901 .

Conectado ao Kali Linux Xfce4 Desktop

Uma vez conectado, posso ver a área de trabalho do xfce4.

Agora posso iniciar o Tor Browser Launcher a partir do terminal na sessão VNC.

 torbrowser-launcher 

Assim que o navegador estiver aberto, posso verificar se está funcionando acessando o Verificador de conexão do projeto Tor

Um exemplo de teste bem-sucedido:

Abri o site na minha máquina host, que não estava conectada, para comparar:

Progresso até agora

Esta é a configuração do sistema operacional que eu queria terminar antes de começar a trabalhar com Selenium e Python. Para recapitular, fiz o seguinte:

1. Dependências instaladas para Selenium, Python e um ambiente de desktop xfce4 simples.
2. Construiu e enviou três imagens interdependentes do Docker com o GitHub Actions.
3. Iniciado com sucesso um servidor VNC em um contêiner do Docker.
4. Conectado ao ambiente de área de trabalho de um contêiner em execução com um cliente VNC.
5. Testei a execução do Tor Browser Launcher a partir do contêiner e verifiquei se ele está se conectando à rede Tor.

Agora que existe um ambiente de contêiner funcional. Confira o próximo post desta série sobre a raspagem da web Python secreta.