🥇Trappola (tarpit) per le connessioni SSH in entrata

Non è un segreto che internet sia un ambiente molto ostile. Non appena si avvia un server, esso viene immediatamente sottoposto a massicci attacchi e numerose scansioni. Ad esempio, un honeypot degli esperti di sicurezza può mettere in evidenza l'entità di questo traffico spazzatura. In effetti, su un server medio, il 99% del traffico può essere dannoso.

Il Tarpit è una porta trappola, usata per rallentare le connessioni in entrata. Se un sistema esterno si collega a questa porta, non sarà possibile chiudere rapidamente la connessione. Dovrà spendere le sue risorse di sistema e attendere che la connessione venga interrotta per timeout, o interromperla manualmente.

I tarpit vengono spesso usati per protezione. Questa tecnica è stata sviluppata per la prima volta per difendersi dai worm informatici. Oggi può essere usata per rovinare la vita agli spammer e ai ricercatori che effettuano scansioni ampie di tutti gli indirizzi IP di seguito (esempi su Habr: Austria, Ucraina).

Uno degli amministratori di sistema di nome Chris Wellons, evidentemente stanco di osservare questo caos, ha scritto un piccolo programma Endlessh, un tarpit per SSH che rallenta le connessioni in entrata. Il programma apre una porta (per impostazione predefinita, per il test è indicata la porta 2222) e finge di essere un server SSH, mentre in realtà stabilisce una connessione infinita con il client in arrivo, finché quest'ultimo non si arrende. Questo può durare giorni o più, finché il client non si disconnette.

Installazione dell'utilità:

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

Un tarpit ben realizzato consumerà più risorse per l'attaccante che per voi. Ma non si tratta nemmeno solo di risorse. L'autore scrive, ha affermato che il programma crea dipendenza. Proprio ora nella sua trappola ci sono 27 clienti, alcuni dei quali sono connessi da settimane. Al culmine dell'attività, nella trappola erano collegati 1378 clienti per 20 ore!

In operatività, il server Endlessh deve essere installato sulla porta standard 22, dove colpiscono massicciamente i malintenzionati. Le raccomandazioni standard sulla sicurezza suggeriscono sempre di spostare SSH su un'altra porta, riducendo immediatamente la dimensione dei log.

Chris Wellons afferma che il suo programma sfrutta un paragrafo della specifica RFC 4253 sul protocollo SSH. Subito dopo l'instaurazione della connessione TCP, ma prima di applicare la crittografia, entrambe le parti devono inviare una stringa identificativa. E lì viene anche aggiunto: «Il server PUÒ inviare altre stringhe di dati prima di inviare la stringa della versione». E non c'è alcun limite sul volume di questi dati, basta solo iniziare ogni stringa con SSH-.

È proprio questo che fa il programma Endlessh: invia un flusso infinito di dati generati casualmente, che corrispondono alla RFC 4253, cioè l'invio prima dell'identificazione, e ogni stringa inizia con SSH- e non supera i 255 caratteri, compreso il carattere di fine riga. In generale, tutto secondo lo standard.

Per impostazione predefinita, il programma attende 10 secondi tra l'invio dei pacchetti. Questo previene la disconnessione per timeout, quindi il client rimarrà bloccato per sempre.

Poiché l'invio dei dati avviene prima dell'applicazione della crittografia, il programma è estremamente semplice. Non è necessario implementare alcun algoritmo di crittografia né supportare molteplici protocolli.

L'autore ha cercato di far sì che l'utilità consumasse il minimo di risorse e funzionasse in modo completamente invisibile sulla macchina. A differenza dei moderni antivirus e altri «sistemi di sicurezza», non deve rallentare il computer. È riuscito a minimizzare sia il traffico che il consumo di memoria grazie a un'implementazione software leggermente più astuta. Se avesse semplicemente avviato un processo separato per ogni nuova connessione, i potenziali malintenzionati avrebbero potuto eseguire un attacco DDoS aprendo molteplici connessioni per esaurire le risorse della macchina. Un flusso per connessione non è neanche la migliore opzione, perché il kernel spenderebbe risorse per gestire i flussi.

Pertanto, Chris Wellons ha scelto per Endlessh l'opzione più leggera: un server monothread poll(2), dove i client intrappolati praticamente non consumano risorse extra, a parte l'oggetto socket nel kernel e altri 78 byte per il monitoraggio in Endlessh. Per evitare di allocare buffer di ricezione e invio per ogni cliente, Endlessh apre un socket di accesso diretto e trasmette direttamente i pacchetti TCP, ignorando quasi tutto lo stack TCP/IP del sistema operativo. Il buffer in ingresso non è affatto necessario, perché i dati in arrivo non ci interessano.

L'autore afferma che al momento della creazione del suo programma non sapeva esistenza di asycio di Python e altri tarpits. Se avesse conosciuto asycio, avrebbe potuto implementare la sua utility in sole 18 righe di 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())

Asyncio è perfetto per scrivere tarpits. Ad esempio, un tale tarpit può bloccare Firefox, Chrome o un altro client per ore, se cerca di connettersi al tuo server HTTP:

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())

Il tarpit è uno strumento eccellente per punire i bulli di internet. Tuttavia, c'è un certo rischio di attirare la loro attenzione sul comportamento insolito di un server specifico. Qualcuno potrebbe pensare a una vendetta e a un attacco DDoS mirato sul tuo IP. Tuttavia, finora non ci sono stati casi simili, e i tarpits funzionano alla grande.

Hub:
Python, Sicurezza informatica, Software, Amministrazione di sistema

Tag:
SSH, Endlessh, tarpit, tarpiti, trappola, asycio
Trappola (tarpit) per connessioni SSH in ingresso

Uno degli amministratori di sistema di nome Chris Wellons, evidentemente stanco di osservare questo caos, ha scritto un piccolo programma Endlessh, un tarpit per SSH che rallenta le connessioni in entrata. Il programma apre una porta (per impostazione predefinita, per il test è indicata la porta 2222) e finge di essere un server SSH, mentre in realtà stabilisce una connessione infinita con il client in arrivo, finché quest'ultimo non si arrende. Questo può durare giorni o più, finché il client non si disconnette.

Installazione dell'utilità:

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

Per impostazione predefinita, il programma attende 10 secondi tra l'invio dei pacchetti. Questo previene la disconnessione per timeout, quindi il client rimarrà bloccato per sempre.

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())

Asyncio è perfetto per scrivere tarpits. Ad esempio, un tale tarpit può bloccare Firefox, Chrome o un altro client per ore, se cerca di connettersi al tuo server HTTP:

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