🥇 Tarpit para conexões SSH recebidas

Não é segredo que a internet é um ambiente muito hostil. Assim que você lança um servidor, ele é imediatamente alvo de ataques massivos e múltiplas varreduras. Tomemos como exemplo um honeypot criado por especialistas em segurança , que permite avaliar a magnitude desse tráfego indesejado. Na verdade, em um servidor médio, 99% do tráfego pode ser malicioso.

Tarpit é um porta-armadilha usado para retardar conexões de entrada. Se um sistema externo se conecta a esta porta, não será possível fechar a conexão rapidamente. Ele terá que gastar recursos do sistema e esperar até que a conexão seja encerrada por um timeout ou ser interrompida manualmente.

Os tarpits são mais frequentemente usados para proteção. A técnica foi desenvolvida pela primeira vez para proteção contra worms de computador e agora pode ser usada para dificultar a vida de spammers e pesquisadores que realizam varreduras amplas em todos os endereços IP consecutivamente (exemplos no Habr: Áustria, Ucrânia).

. Um dos administradores de sistemas, chamado Chris Vellons, aparentemente se cansou de observar essa bagunça — e escreveu um pequeno programa Endlessh, um tarpit para SSH que retarda as conexões de entrada. O programa abre uma porta (por padrão para testes, a porta 2222) e se finge de servidor SSH, mas na realidade estabelece uma conexão infinita com o cliente de entrada até que ele desista. Isso pode durar dias ou mais, até que o cliente desista.

Instalação do utilitário:

$ make
$ ./endlessh &
$ ssh -p2222 localhost

Um tarpit bem implementado gastará mais recursos do atacante do que você. Mas a questão não é apenas sobre recursos. O autor escrevediz que o programa provoca vício. Neste momento, em sua armadilha, há 27 clientes, alguns dos quais estão conectados há semanas. No auge da atividade, 1378 clientes estavam na armadilha por 20 horas!

No modo de operação, o servidor Endlessh deve ser instalado na porta padrão 22, onde os agressores costumam atacar. As recomendações padrão de segurança sempre sugerem mover o SSH para outra porta, o que reduz drasticamente o tamanho dos logs.

Chris Vellons diz que seu programa explora um parágrafo da especificação RFC 4253 sobre o protocolo SSH. Imediatamente após o estabelecimento da conexão TCP, mas antes da aplicação da criptografia, ambas as partes devem enviar uma string de identificação. E lá está a observação: «O servidor PODE enviar outras linhas de dados antes de enviar a linha com a versão». E não há limite para o volume desses dados, apenas cada linha precisa começar com SSH-.

É exatamente isso que o programa Endlessh faz: ele envia um fluxo infinito de dados gerados aleatoriamente, que estão em conformidade com o RFC 4253, ou seja, enviados antes da identificação, e cada linha começa com SSH- e não excede 255 caracteres, incluindo o caractere de final de linha. Em geral, tudo conforme o padrão.

Por padrão, o programa espera 10 segundos entre os envios de pacotes. Isso evita desconexões por timeout, fazendo com que o cliente fique preso para sempre.

Como o envio de dados ocorre antes da aplicação da criptografia, o programa é extremamente simples. Não é necessário implementar cifrados ou suporte a múltiplos protocolos.

O autor se esforçou para que a utilidade consumisse o mínimo de recursos e funcionasse de forma absolutamente invisível na máquina. Ao contrário dos antivírus modernos e de outros "sistemas de segurança", ele não deve desacelerar o computador. Ele conseguiu minimizar tanto o tráfego quanto o consumo de memória através de uma implementação de software um pouco mais engenhosa. Se ele simplesmente iniciasse um processo separado para cada nova conexão, potenciais invasores poderiam realizar um ataque DDoS, abrindo várias conexões para esgotar os recursos da máquina. Um único fluxo por conexão também não é a melhor opção, pois o núcleo gastaria recursos para gerenciar os fluxos.

Portanto, Chris Vellons escolheu para o Endlessh a opção mais leve: um servidor de thread única poll(2), onde clientes presos praticamente não consomem recursos extras, exceto o objeto de socket no núcleo e mais 78 bytes para rastreamento no Endlessh. Para não alocar buffers de recebimento e envio para cada cliente, o Endlessh abre um socket de acesso direto e retransmite pacotes TCP diretamente, ignorando quase toda a pilha TCP/IP do sistema operacional. O buffer de entrada é completamente desnecessário, pois os dados de entrada não nos interessam.

O autor afirma que, na época de seu programa, não sabia sobre a existência do asyncio do Python e outros trapdoors. Se ele soubesse sobre o asyncio, poderia ter implementado sua utilidade em apenas 18 linhas no Python:

import asyncio
import random

async def handler(_reader, writer):
try:
while True:
await asyncio.sleep(10)
writer.write(b'%xrn' % random.randint(0, 2**32))
await writer.drain()
except ConnectionResetError:
pass

async def main():
server = await asyncio.start_server(handler, '0.0.0.0', 2222)
async with server:
await server.serve_forever()

asyncio.run(main())

O Asyncio é perfeito para escrever tarpits. Por exemplo, este tarpit pode parar o Firefox, Chrome ou outro cliente que tenta se conectar ao seu servidor HTTP por várias horas:

import asyncio
import random

async def handler(_reader, writer):
writer.write(b'HTTP\/1.1 200 OKrn')
try:
while True:
await asyncio.sleep(5)
header = random.randint(0, 2**32)
value = random.randint(0, 2**32)
writer.write(b'X-%x: %xrn' % (header, value))
await writer.drain()
except ConnectionResetError:
pass

async def main():
server = await asyncio.start_server(handler, '0.0.0.0', 8080)
async with server:
await server.serve_forever()

asyncio.run(main())

Um tarpit é uma ótima ferramenta para punir hooligans da internet. Contudo, há um risco de atrair a atenção deles para o comportamento incomum de um servidor específico. Alguém pode pensar em retaliação e em um ataque DDoS direcionado ao seu IP. No entanto, até agora não houve tais casos, e os tarpits funcionam muito bem.

Tags:
Python, Segurança da Informação, Software, Administração de Sistemas

Etiquetas:
SSH, Endlessh, tarpit, tarpit, armadilha, asyncio
Uma armadilha (tar Pit) para conexões SSH de entrada

. Um dos administradores de sistemas, chamado Chris Vellons, aparentemente se cansou de observar essa bagunça — e escreveu um pequeno programa Endlessh, um tarpit para SSH que retarda as conexões de entrada. O programa abre uma porta (por padrão para testes, a porta 2222) e se finge de servidor SSH, mas na realidade estabelece uma conexão infinita com o cliente de entrada até que ele desista. Isso pode durar dias ou mais, até que o cliente desista.

Instalação do utilitário:

$ make
$ ./endlessh &
$ ssh -p2222 localhost

Por padrão, o programa espera 10 segundos entre os envios de pacotes. Isso evita desconexões por timeout, fazendo com que o cliente fique preso para sempre.

Como o envio de dados ocorre antes da aplicação da criptografia, o programa é extremamente simples. Não é necessário implementar cifrados ou suporte a múltiplos protocolos.

import asyncio
import random

async def handler(_reader, writer):
    try:
        while True:
            await asyncio.sleep(10)
            writer.write(b'%xrn' % random.randint(0, 2**32))
            await writer.drain()
    except ConnectionResetError:
        pass

async def main():
    server = await asyncio.start_server(handler, '0.0.0.0', 2222)
    async with server:
        await server.serve_forever()

asyncio.run(main())

O Asyncio é perfeito para escrever tarpits. Por exemplo, este tarpit pode parar o Firefox, Chrome ou outro cliente que tenta se conectar ao seu servidor HTTP por várias horas:

import asyncio
import random

async def handler(_reader, writer):
    writer.write(b'HTTP\/1.1 200 OKrn')
    try:
        while True:
            await asyncio.sleep(5)
            header = random.randint(0, 2**32)
            value = random.randint(0, 2**32)
            writer.write(b'X-%x: %xrn' % (header, value))
            await writer.drain()
    except ConnectionResetError:
        pass

async def main():
    server = await asyncio.start_server(handler, '0.0.0.0', 8080)
    async with server:
        await server.serve_forever()

asyncio.run(main())

Fonte: habr.com