Instalação do Tor + Privoxy, em um container Docker

Instalando o Tor e o proxy Privoxy, para navegar com segurança e privacidade pela Internet.

Primeiro passo é escolher a forma de instalação dos Serviços necessários, podem ser feitos de três formas distintas:

- A primeira, é instalando num Servidor dedicado rodando como sistema operacional o Debian, Kali Lininux, CentOS, ou outra distro qualquer.

- A segunda, é instalando numa VM (Máquina Virtual), Virtual Box, Xen, VMWare.

-A terceira opção, seria através do Docker, criando um container, rodando apenas o Tor e o Privoxy, propriamente dito.

Vou utilizar a terceira opção.

O intuito de utilizar o Tor e o Privoxy, não tem nenhuma natureza Hacker, e sim para fins didáticos e pessoais (como navegar em rádios online, com Server fora do país).

Vamos lá.

Primeiramente será necessário ter em mãos um computador com sistema Linux instalado (eu utilizo o Debian Jessie). O importante, é o Sistema operacional ser de 64 bits e o kernel, acima da versão 3.10, para poder rodar o docker.

#uname -a

Instalação do docker:

#apt-get update && apt-get upgrade

#apt-get install curl

#curl –sSL http://get.docker.com | sh

Esse comando instala o Docker em seu sistema.

Para iniciar o docker no sistema:

#/etc/init.d/docker start

Para ver se o docker está rodando:

#netstat -rn | grep docker

Depois de instalado, é só procurar por uma imagem do kali linux ou outra que preferir.

#docker search kali-linux

Estou usando esta imagem:  kalilinux/kali-linux-docker

Agora vamos criar um pequeno script para rodar o container kali linux:

#touch container_kali.sh

#chmod +x container_kali.sh

#nano container_kali.sh

Conteudo:

#!/bin/sh

docker rm kali-proxy

docker run -d -it -h kali -p 22:22 -p 8118:8118 -p 9050:9050 -m 1024M --priveleged \

-v /home/kali:/root/kali --name kali-proxy kalilinux/kali-linux-docker /bin/bash

echo “salve”

Uma prévia dos comandos do docker utilizados:

run=run

-d – roda em background

-it – interativo com o shell

-p - portas utilizadas pelo sistema e para o container (ssh, privoxy proxy e tor socks)

-m – limita a memória a 1 Gb

--privileged – uso para poder rodar o iptables dentro do container

-v – essa é a mellhor sacada do docker, vai compartilhar a pasta home/kali da máquina com o diretório root/kali do container

--name – é o nome do container

 kalilinux/kali-linux-docker – é a imagem que está na nuvem

/bin/bash – abre dentro do terminal

Crie o diretório kali no home:

#mkdir /home/kali

No mesmo diretório do script, rode o comando (uso o /root):

#./container_kali.sh

Isso pode demorar um pouco, conforme o poder de cada link.

Ele deve baixar a imagem kalilinux/kali-linux-docker

Após baixar a imagem:

#docker ps

#docker attach kali-proxy

Pronto, agora você está dentro do container.

Ele está totalmente cru, sem nada instalado.

Primeiramente, mude a senha do root

#passwd

#sua senha

#sua senha

Teremos que instalar todos pacotes necessários:

#apt-get update && apt-get upgrade

#apt get install openssh-server

#apt-get install dnsutils iftop htop inetutils-tools netstat-nat ulogd2

#apt-get install qualquer pacote que for utilizar em modo texto

#apt-get install tor privoxy

Instalei o ssh, para poder abrir várias instâncias do container (uma telinha é pouco).

A configuração do ssh, não tem segredo, no /etc/sshd.conf pode-se mudar a porta de acesso e nunca deixe logar como root.

Crie um usuário:

#useradd fulano

#passwd fulano

#/etc/init.d/ssh start

Agora pode-se utilizar via putty (ifconfig para pegar o ip do container)

Pelo terminal pode-se acessar via ssh :

#ssh fulano@172.17.0.3

Geralmente o primeiro container utiliza o ip 172.17.0.2 e o segundo 172.17.0.3, e assim por diante. A rede do docker está numa interface chamada docker0, de rede 172.17.0.0/16

 É preciso saber o ip do container para poder configurar os serviços e o browser para navegar sob o proxy.

Agora vamos a configuração do tor e do privoxy

 #nano /etc/tor/torsocks.conf

Descomente  e edite as linhas:

TorAddress 172.17.0.3

TorPort 9050

No meu caso o ip é 172.17.0.3, pois já possuo um outro container rodando outro serviço.

#nano /etc/tor/torrc

Descomente e edite as seguintes linhas:

SOCKSPort 9050 # Default: Bind to localhost:9050 for local connections.

SOCKSPort 172.17.0.3:9050 # Bind to this address:port too.

SOCKSPolicy accept 192.168.1.0/28

Talves nem precise editar esse arquivo torrc, mas não testei sem editar ele.

Agora vamos ao privoxy, o arquivo de configuração é bem extenso e está em:

#nano /etc/privoxy/config

Descomente e edite as seguintes linhas:

listen-address  172.17.0.3:8118
listen-address  [::1]:8118

 

forward-socks4   /                172.17.0.3:9050  .

forward-socks5t   /              172.17.0.3:9050  .

O importante é ter certeza do ip address do container, não esqueça este . (pontinho no final da linha)

O pulo do gato, são essas duas linhas referentes ao forward-socks. Se você comentar essas duas linhas (desabilitar usando #) o privoxy funciona apenas como um proxy, semelhante ao squid. Com o Forward habilitado, ele usa o tor para mascarar o ip de origem.

Agora se tudo estiver certo, reiniciar os serviços:

#/etc/init.d/privoxy restart

#/etc/init.d/tor restart

Para ver se estão ativos:

#htop

Agora vamos a configuração do navegador (utilizo o Firefox):

/opções/avançado/rede/configurar conexão

http  172.17.0.3  porta 8118

ssl    172.17.0.3  porta 8118

socks 172.17.0.3  porta 9050

Se tudo estiver certo, deve estar navegando, sob um proxy de rede e com uma VPN complexa, que altera seu source IP. Mas isso não o torna invisível na internet, todo ip é rastreável, é só dar um traceroute no shell, sempre terá uma origem e um destino rastreável.

Agora vem o bruto, se este container, por algum motivo, sair do ar (queda de energia, por exemplo) perde-se tudo. Terá que refazer tudo do zero.

Vamos salvar os arquivos importantes e depois dar um commit no container:

#cp –r /etc/tor /root/kali/

#cp –r /etc/privoxy /root/kali/

Dar um commit no container (salvar todas as configurações feitas)

#docker ps

#docker commit [id do container]  kalilinux/kali-linux-docker-02

ou

#docker commit kali-proxy kalilinux/kali-linux-docker-02

Se preferir, pode-se exportar o container para uma partição maior:

#cd /home/fulano

#docker export –o [novo nome] [container id]

 Depois:

#docker import [nome do container]

#docker images

Precisará tagear esse novo container

#docker tag [image id] [novo nome]

Depois teremos que modificar o script container_kali.sh:

#nano /root/container_kali.sh

#!/bin/sh

docker rm kali-proxy

docker run -d -it -h kali -p 22:22 -p 8118:8118 -p 9050:9050 -m 1024M --priveleged \ 

-v /home/kali:/root/kali --name kali-proxy kalilinux/kali-linux-docker-02 /bin/bash

docker exec kali-proxy /etc/init.d/ssh start

docker exec kali-proxy cp –r /root/kali/ulogd.conf /etc/

docker exec kali-proxy /etc/init.d/ulogd2 start

docker exec kali-proxy /etc/init.d/privoxy start

docker exec kali-proxy /etc/init.d/tor start

docker exec kali-proxy /root/kali/firewall_kali.sh

echo "Container Kali-proxy ativado"

Coloque o nome do container atualizado (no caso utilizei o nome kalilinux/kali-linux-docker-02).

Para inicializar o conntainer:

#/nano /etc/rc.local

Adicionar:

/root/container_kali.sh

Pronto, agora vamos por segurança neste container:

#cd /home/kali

#touch firewall_kali.sh

#chmod +x firewall_kali.sh

#nano firewall_kali.sh

Inserir:

#!/bin/sh

#Firewall Script desenvolvido por Henrique Kobayashi

IPT="/sbin/iptables"

#Reescrevendo as regras
$IPT --flush
$IPT --delete-chain
$IPT -t nat -F
$IPT -t mangle -F

$IPT -N C_TOR

$IPT -t nat -A POSTROUTING -o eth0 -j MASQUERADE

#enable packet forwarding
echo 1 > /proc/sys/net/ipv4/ip_forward
echo 1 > /proc/sys/net/ipv4/conf/default/rp_filter

$IPT -A INPUT -p tcp -m multiport --dports 8118,9050 -j C_TOR
$IPT -A INPUT -p tcp --dport 22 ! -s 192.168.1.14 -j DROP
$IPT -A INPUT -s 192.168.1.14 -d 172.17.0.3 -p tcp --sport 1024:65535 --dport 22 -j ACCEPT
$IPT -A C_TOR -s 192.168.1.0/28 -j ACCEPT
$IPT -A C_TOR -s 172.17.0.0/29 -j ACCEPT
$IPT -A C_TOR -m limit --limit 1/s --limit-burst 1 -j ULOG --ulog-prefix "FW_TOR__Ulog:"
$IPT -A C_TOR -j DROP
$IPT -t filter -A INPUT -m limit --limit 1/min --limit-burst 1 -j ULOG \
 --ulog-prefix "FW_INPUT_Ulog:"
$IPT -A INPUT -p udp -m udp -s 201.6.2.0/24 --sport 53 --dport 1024:65535 -j ACCEPT
$IPT -A INPUT -p tcp -m tcp -s 0/0 -d 172.17.0.3 --sport 80:443 --dport 1024:65535 \
-j ACCEPT
$IPT -A INPUT -s 192.168.1.0/28 -j ACCEPT
$IPT -A INPUT -s 172.17.0.0/29 -j ACCEPT
$IPT -t mangle -A PREROUTING -i eth0 -s 172.17.0.1 -j ACCEPT
$IPT -A INPUT -p tcp -m tcp --sport 22:23 -j DROP
$IPT -A INPUT -m state --state INVALID -j DROP
$IPT -A INPUT -p tcp --syn -j DROP
$IPT -A INPUT -p udp --dport 1:1024 -j DROP

iptables -t mangle -I PREROUTING -i eth0 -p tcp ! -s 192.168.1.14/32 -m multiport \ 
--dports 22,23,80,135,139,443,445 -j DROP
iptables -t mangle -I POSTROUTING -p tcp --tcp-flags SYN,RST SYN -o eth1 \ 
-j TCPMSS --set-mss 1492

iptables-save

echo "Firewall de rede ativo"

#EOF

F2 salvar

Para utilizar o script de Firewall, mude a rede ( uso 192.168.1.0/28) e o host para acesso ao container utilizo o ip 192.168.1.14, no caso é só alterar o ip para o acesso via ssh. Com esse Firewall rodando dentro do container, o nível de segurança aumenta consideravelmente.

Agora temos que configurar o arquivo de configuração do ulogd2, o qual vai gerar os logs do firewall.

#nano /etc/ulogd.conf

O item principal de configuração do arquivo é:

[emu1]
#file="/var/log/ulog/syslogemu.log"
file="/var/log/iptables.log"
sync=1

#deixe apenas esta linha descomentada (no início)

# this is a stack for ULOG packet-based logging via LOGEMU
stack=ulog1:ULOG,base1:BASE,ip2str1:IP2STR,print1:PRINTPKT,emu1:LOGEMU

Salve o arquivo:

#cp -r /etc/ulogd.conf /root/kali/

Para iniciar o Firewall:

#/root/kali/firewall_kali.sh

Para visualizar o firewall rodando:

#watch –n 1 –d iptables -nvL

Ufa, por hora é isso.

Gostaria de lembrar, que não sou especialista em docker, tenho consciência que a melhor maneira, seria usar dois containers, o mais enxuto possível, separando o tor e o privoxy em cada container, utilizando o docker file ou docker compose. Mas esta foi a maneira que consegui fazer funcionar.