Neste artigo, quero contar como implementei um ( mais um ) script Bash para conectar dois computadores atrás do NAT usando a tecnologia UDP hole punching usando o exemplo do sistema operacional Ubuntu / Debian.
O estabelecimento de uma conexão consiste em várias etapas:
- Iniciando um nó e aguardando o nó remoto estar pronto;
- Determinando o endereço IP externo e a porta UDP;
- Transferência de endereço IP externo e porta UDP para o host remoto;
- Obtenção de um endereço IP externo e uma porta UDP de um host remoto;
- Organização de um túnel IPIP;
- Monitoramento de conexão;
- Se a conexão for perdida, exclua o túnel IPIP.
Pensei por um longo tempo e ainda acho que você pode usá-lo para trocar dados entre nós, o mais simples e rápido para mim no momento é trabalhar com o Yandex.Disk.
- Primeiro, é a facilidade de uso - você precisa de 3 etapas: criar, ler, excluir. Com curl, é o seguinte:
Criar:
curl -s -X MKCOL --user "$usename:$password" https://webdav.yandex.ru/$folder
Ler:
curl -s --user "$usename:$password" -X PROPFIND -H "Depth: 1" https://webdav.yandex.ru/$folder
Excluir:
curl -s -X DELETE --user "$usename:$password" https://webdav.yandex.ru/$folder - Em segundo lugar, é fácil de instalar:
apt install curl
Para determinar o endereço IP externo e a porta UDP, use o comando stun-client:
stun stun.sipnet.ru -v -p $1 2>&1 | grep "MappedAddress"Instalação com o comando:
apt install stun-clientPara organizar o encapsulamento, são usadas as ferramentas padrão do SO do pacote iproute2. Existem muitos túneis que podem ser configurados por meios padrão (L2TPv3, GRE etc.), mas eu escolhi o IPIP porque ele cria uma carga adicional mínima no sistema. Eu tentei o L2TPv3 sobre o UDP e fiquei desapontado, a velocidade caiu em um fator de 10, mas pode haver várias restrições relacionadas a provedores ou algo mais. Como o túnel IPIP opera no nível IP, o túnel FOU é usado para operar no nível da porta UDP. Para organizar um túnel IPIP, você precisa:
- carregar o módulo FOU:
modprobe fou- ouça a porta local:
ip fou add port $localport ipproto 4- crie um túnel:
ip link add name fou$name type ipip remote $remoteip local $localip encap fou encap-sport $localport encap-dport $remoteport- abrir a interface do túnel:
ip link set up dev fou$name- atribua o endereço IP interno e interno do túnel remoto:
ip addr add $intIP peer $peerip dev fou$nameExcluir túnel:
ip link del dev fou$nameip fou del port $localportO status do túnel é monitorado periodicamente, executando ping no endereço IP interno do túnel do host remoto usando o comando:
ping -c 1 $peerip -s 0O ping periódico é necessário principalmente para manter o canal; caso contrário, se o túnel estiver ocioso nos roteadores, as tabelas NAT poderão ser limpas e a conexão será interrompida.
Se o ping for perdido, o túnel IPIP será descartado e aguardará a conclusão do host remoto.
O script em si:
#!/bin/bash
username="username@yandex.ru"
password="password"
folder="vpnid"
intip="10.0.0.1"
localport=`shuf -i 10000-65000 -n 1`
cid=`shuf -i 10000-99999 -n 1`
tid=`shuf -i 10-99 -n 1`
function yaread {
curl -s --user "$1:$2" -X PROPFIND -H "Depth: 1" https://webdav.yandex.ru/$3 | sed 's/></>\n</g' | grep "displayname" | sed 's/<d:displayname>//g' | sed 's/<\/d:displayname>//g' | grep -v $3 | grep -v $4 | sort -r
}
function yacreate {
curl -s -X MKCOL --user "$1:$2" https://webdav.yandex.ru/$3
}
function yadelete {
curl -s -X DELETE --user "$1:$2" https://webdav.yandex.ru/$3
}
function myipport {
stun stun.sipnet.ru -v -p $1 2>&1 | grep "MappedAddress" | sort | uniq | awk '{print $3}' | head -n1
}
function tunnel-up {
modprobe fou
ip fou add port $4 ipproto 4
ip link add name fou$7 type ipip remote $1 local $3 encap fou encap-sport $4 encap-dport $2
ip link set up dev fou$7
ip addr add $6 peer $5 dev fou$7
}
function tunnel-check {
sleep 10
pings=0
until [[ $pings == 4 ]]; do
if ping -c 1 $1 -s 0 &>/dev/null;
then echo -n .; n=0
else echo -n !; ((pings++))
fi
sleep 15
done
}
function tunnel-down {
ip link del dev fou$1
ip fou del port $2
}
trap 'echo -e "\nDisconnecting..." && yadelete $username $password $folder; tunnel-down $tunnelid $localport; echo "IPIP tunnel disconnected!"; exit 1' 1 2 3 8 9 14 15
until [[ -n $end ]]; do
yacreate $username $password $folder
until [[ -n $ip ]]; do
mydate=`date +%s`
timeout="60"
list=`yaread $username $password $folder $cid | head -n1`
yacreate $username $password $folder/$mydate:$cid
for l in $list; do
if [ `echo $l | sed 's/:/ /g' | awk {'print $1'}` -ge $(($mydate-65)) ]; then
#echo $list
myipport=`myipport $localport`
yacreate $username $password $folder/$mydate:$cid:$myipport:$intip:$tid
timeout=$(( $timeout + `echo $l | sed 's/:/ /g' | awk {'print $1'}` - $mydate + 3 ))
ip=`echo $l | sed 's/:/ /g' | awk '{print $3}'`
port=`echo $l | sed 's/:/ /g' | awk '{print $4}'`
peerip=`echo $l | sed 's/:/ /g' | awk '{print $5}'`
peerid=`echo $l | sed 's/:/ /g' | awk '{print $6}'`
if [[ -n $peerid ]]; then tunnelid=$(($peerid*$tid)); fi
fi
done
if ( [[ -z "$ip" ]] && [ "$timeout" -gt 0 ] ) ; then
echo -n "!"
sleep $timeout
fi
done
localip=`ip route get $ip | head -n1 | sed 's|.*src ||' | cut -d' ' -f1`
tunnel-up $ip $port $localip $localport $peerip $intip $tunnelid
tunnel-check $peerip
tunnel-down $tunnelid $localport
yadelete $username $password $folder
unset ip port myipport
done
exit 0As variáveis de nome de usuário , senha e pasta devem ser as mesmas nos dois lados, mas a intip deve ser diferente, por exemplo: 10.0.0.1 e 10.0.0.2. O horário nos nós deve ser sincronizado. Você pode executar o script assim:
nohup script.sh &Chamo sua atenção para o fato de que o túnel IPIP é inseguro do ponto de vista do fato de que o tráfego não é criptografado, mas isso é facilmente resolvido usando IPsec para este artigo , me pareceu simples e direto.
Uso esse script para conectar-me a um PC em funcionamento há várias semanas e não percebi nenhum problema. Conveniente em termos de configuração e esquecimento.
Talvez você tenha comentários e sugestões, ficarei feliz em ouvir.
Agradecimentos para sua atenção!