Asterisk - Configuração de Voip para uso de Smartphones, numa rede interna - Lan

Instalação e configuração do Asterisk, dentro de um container Docker.

O Asterisk é um poderoso software de PABX, open source, desenvolvido por Mark Spencer, fundador da Digium inc. Empresa que desenvolve o Asterisk sob a licença GPL e vende as placas (periféricos) para conectar o Asterisk a malha de telefonia convencional (FX0, FXS, E1/T1, ISDN).

Este tutorial, visa apenas o uso básico do Asterisk, vou apenas implementá-lo em minha rede WiFi, para o uso da comunicação de dispositivos móveis (smatphones), numa rede já existente. Não possuo nenhuma placa específica (Digion, Digivoice, Khomp), então o uso, limita-se apenas a rede interna.

Preferi instalá-lo, dentro de um container docker, uma maneira ágil para implantação, num ambiente de testes e aprendizados.

Para instalar o docker:

#apt-get update && apt-get upgrade

#apt-get install curl

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

Para iniciar o Docker:

#/etc/init.d/docker start

Para ver se o docker está ativo:

#netstat -rn | grep docker

Agora vamos subir um container docker com algum SO (estou usando o debian:7.10)

#docker run -it -h Asterisk -p 5060:5060/udp -m 1024M --name server-asterisk \
-v /opt/asterisk:/etc/asterisk debian:7.10 /bin/bash

Este comando vai baixar a imagem do debian7.10, logo depois você estará dentro do container Asterisk, ai vamos ter que instalar todos os pacotes necessários.

#apt-get update && apt-get upgrade

Primeiramente mudar a senha de admin:

#passwd
#senha nova
#senha nova

Dar o comando date:
#date

Temos que arrumar a data e horário:
#rm /etc/localtime

#ln -s /usr/share/zoneinfo/America/Sao_Paulo /etc/localtime

#date        #(agora deve estar com horário certo)

Necessário instalar um editor de texto, vim, nano ou outro qualquer:

#apt-get install nano -y

Necessário instalar pacotes de uso no dia a dia:

#apt-get install -y libnet-ifconfig-wrapper-perl dnsutils netstat-nat

Instalação do Asterisk:

#apt-get install asterisk asterisk-config asterisk-modules

Se preferir, você pode instalar através do código fonte e compilá-lo:

#cd /usr/src

#wget http://downloads.asterisk.org/pub/telephony/asterisk/asterisk-11-current.tar.gz

#tar xzf  asterisk-11-current.tar.gz

#cd asterisk*

# ./configure && make menuselect && make && make install && make
config && make install-logrotate

#make samples

Antes de compilar o Asterisk, é preciso instalar suas dependências:

# apt-get install linux-headers-$(uname -r) build-essential libxml2-dev
libncurses5-dev libsqlite3-dev libssl-dev libsrtp0-dev unixodbc-dev subversion
libmysqlclient-dev

Depois de instalado, reinicie o serviço:

#/etc/init.d/asterisk restart

De um comando netstat -nudl para ver se a porta 5060 udp está ativa:

#netstat -nudl

Tudo certo, com o Asterisk instalado, precisamos configurá-lo:

#cd /etc/asterisk

#ls

Aqui estão os principais arquivos de configuração do Asterisk.

Vamos editar dois arquivos importantes, o sip.conf e o extensions.conf.

O SIP, é um protocolo de comunicação voip, ele por padão utiliza a porta udp 5060 para criar a chamada e depois de estabelecida a conexão, ele envia os pacotes através de portas udp altas (10000 a 20000).

O arquivo extensions.conf, é onde está toda a programação lógica do asterisk, o dial plan, o coração do asterisk.

Primeiramente faremos uma cópia desses dois arquivos:

#cp sip.conf /etc/asterisk/sip.conf_orig

#cp extensions.conf /etc/asterisk/extensions.conf_orig

Depois:

#> sip.conf

#>extensions.conf

Agora vamos editar os dois arquivos:

#nano sip.conf

Conteúdo:

[general]
transport=udp
dindaddr=192.168.1.10  ;(ip do servidor)
disallow=all
allow=ulaw
allow=gsm
nat=yes
localnet=192.168.1.0/24   ;(rede local)
language=pt_br

;-----------------------------------------------------

[template](!)
port=5060
host=dynamic
dtmfmode=rfc2833
pickupgroup=1
callgroup=1
musicclass=musica

;-----------------------------------------------------

[001](template)
callerid=nome de usuário
secret=123456   ;(senha de acesso)
host=192.168.1.2
type=friend
context=ramais   ;(contexto é importante usar o mesmo nome no extensions.conf)
disallow=all
allow=ulaw

[002](template)
callerid=nome de usuário
secret=123456
host=192.168.1.3
type=friend
context=ramais
disallow=all
allow=ulaw

[003](template)
callerid=nome de usuário
secret=123456
host=192.168.1.11
type=friend
context=ramais
disallow=all
allow=ulaw

;se tiver mais dispositivos, continue com a configuração

Agora o arquivo extensions.conf:

#nano extensions.conf:

Conteúdo:

[General]
AUTOFALLTHROUGH = NO

[Globals]
include => features.conf

[ramais]
        exten => _00Z,1,Dial(SIP/${EXTEN})
        exten => _00Z,2,Hangup()

;
;Configuração bem simples e básica.

Para acessar o console do asterisk:

#rasterisk -cvvvv
Agora de os comandos:

>sip reload

>dialplan reload

>dialplan show ramais

>sip show peers

Temos que configurar os smartfones para se comunicarem através da rede Wifi.

Instale o programa Zoiper (uso android), é so buscar na Play Store “zoiper”

Depois de instalado acesse o menu “config” :

-Accounts - +add account

Account name = 003 (pelas configurações pode ser de 001 a 009)

Host=192.168.1.10  (Ip do Servidor onde está instalado o asterisk)

Username=nome de usuário

Password=123456

Outbond proxy=(Ip do Servidor)


















Pronto, com essas configurações, já deve estar funcionando.

Na tela aparecerá 003 is ready.


















Agora teremos que configurar uma máquina Windows para testar:

Instale o programa X-Lite, procure pela versão 3.0

Estou usando este: goo.gl/EtytFv

Para configurar o x-lite:

Sip Account Settings>>Add

Display Name=seu nome

Username=001 (pela configuração é de 001 a 009)

Password=senha

Authorization user name=001

Domain=ip do servidor

Pronto, salvar e depois discar para o celular, no meu caso é 003. O celular vai tocar.




















No pronpt (CLI) no Servidor, aparecem todos os tramites executados.

Depois temos que salvar todas as configurações feitas até então no container Asterisk:

#docker ps

#docker commit server-asterisk debian7.10-asterisk

ou

 #docker commit (container id) debian7.10-asterisk (nome aleatório)

Temos que criar um script para inicializar o container Asterisk:

#cd /root/

#touch container_asterisk.sh

#chmod +x container_asterisk.sh

#nano container_asterisk.sh

Conteúdo:

#!/bin/sh

docker rm server-asterisk

docker run -d -it -h Asterisk -p 5060:5060/udp -m 1024M --name server-asterisk -v /opt/asterisk:/etc/asterisk debian7.10-asterisk /bin/bash

docker exec server-asterisk /etc/init.d/asterisk start

echo “Container Asterisk ativado”

Depois é só colocar no /etc/rc.local, caso queira que o container suba junto com o sistema na inicialização.

Basicamente é isso, uma configuração simples para o Asterisk. A grande vantagem de se usar o Asterisk é o custo da aplicação, esse exemplo, mostra como é possível usá-lo dentro de uma rede Wifi interna (lan), com equipamentos móveis, a custo de ligação, praticamente zero (custo da estrutura da rede), por exemplo, em muitos lugares, toda a comunicação interna é feita através do aplicativo WatsApp, um ônus desnecessário.

O Asterisk, como toda aplicação Voip, existente no mercado, é totalmente dependente da rede de dados (baseada no TCP/IP), se a rede não estiver bem estruturada, o voip não funcionará direito. Todo áudio é encapsulado em pacotes Ips que trafegam pela rede de dados. A rede deve priorizar o tráfego de pacotes voip (SIP, RPC, IAX), através de QoS, o ideal seria uma vlan exclusiva para o serviço de voip, no caso de rede wireless, usar bons Acess Points (padão 802.11ac).

Fazendo uma analogia, o áudio resultante de uma conexão voip, é proporcional a qualidade de toda rede estruturada (camada física e camada de enlace), é como um equipamento de áudio HiEnd, começa pelo cabeamento, qualidade dos componentes empregados, construção primorosa, bem projetado, resulta numa excelente qualidade sonora.

Outro ponto importante, é a segurança do Servidor, o protocolo SIP, é bem manjado, com certeza, sua porta 5060/udp será bastante explorada. Neste caso o protocolo IAX,IAX2 leva vantagem, oferece mais segurança, pois utiliza apenas a porta 4569/udp.

Regras de firewall para o Servidor Asterisk:

#iptables -I INPUT -i eth1 -p udp -m udp --dport 5060 -j DROP

-i eth1 (interface wan)
    
 #iptables -A INPUT -i eth0 -p udp -m udp --dport 5060 ! -s 192.168.1.0/24 -j DROP

- eth0 (interface lan)
 
Todo container docker habilitado, inclui regras de iptables no sistemas. O protocolo Sip, usa o RTP para enviar os pacotes com áudio encapsulados, e usa um range de portas altas udp (de 10000 a 20000), caso essas portas não funcionem teremos que adicionar essa regra no firewall, na chain docker, criada por ele no sistema:

iptables -A DOCKER -d 172.17.0.0/29 ! -i docker0 -o docker0 -p udp -m udp --dport 10000:20000 -j ACCEPT

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.