🥇 Trappola (tarpit) per connessioni SSH in entrata

Non è un segreto che Internet sia un ambiente molto ostile. Non appena si avvia un server, questo è subito soggetto a massicci attacchi e numerose scansioni. L'esempio di un honeypot da parte dei professionisti della sicurezza può illustrare l'ampiezza di questo traffico spazzatura. Infatti, su un server medio, il 99% del traffico può essere dannoso.

Un Tarpit è una trappola per porte che viene utilizzata per rallentare le connessioni in ingresso. 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, oppure romperla manualmente.

I tarpits vengono utilizzati principalmente per la protezione. Questa tecnica è stata sviluppata per la prima volta per proteggere dai worm informatici. Oggi può essere utilizzata per rendere la vita difficile agli spammer e ai ricercatori che effettuano scansioni imponenti su tutti gli indirizzi IP consecutivi (esempi su Habr: Австрия, Ucraina).

A un amministratore di sistema di nome Chris Vellons, evidentemente, è stufato di osservare questa situazione — e ha scritto un piccolo programma Endlessh, tarpit per SSH che rallenta le connessioni in entrata. Il programma apre una porta (di default, per test è indicata la porta 2222) e si finge un server SSH, mentre in realtà stabilisce una connessione infinita con il client in ingresso, finché non si arrende. Questo può durare giorni o più, finché il client non si disconnette.

Installazione dell'utility:

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

Un tarp ben implementato consumerà più risorse per l'attaccante che per te. Ma non si tratta solo di risorse. L'autore scrive, afferma che il programma crea dipendenza. Al momento, nella sua trappola ci sono 27 clienti, alcuni dei quali sono connessi da settimane. Nel picco dell'attività, 1378 clienti erano bloccati per 20 ore!

In modalità operativa, il server Endlessh deve essere installato sulla porta standard 22, dove le bande di hacker tentano l'accesso. Le raccomandazioni di sicurezza standard suggeriscono sempre di spostare SSH su un'altra porta, il che riduce immediatamente la dimensione dei log.

Chris Wellons dice 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 di identificazione. E lì anche una nota: «Il server PUÒ inviare altre stringhe di dati prima di inviare la stringa con la versione». E nessun limite sul volume di questi dati, basta che ogni stringa inizi con SSH-.

È esattamente ciò che fa il programma Endlessh: genera invia un flusso infinito di dati casualmente generati, che sono conformi a RFC 4253, ovvero inviati prima dell'identificazione, e ogni stringa inizia con SSH- e non supera 255 caratteri, incluso il carattere di fine stringa. In generale, tutto secondo lo standard.

Per impostazione predefinita, il programma attende 10 secondi tra l'invio dei pacchetti. Ciò previene la disconnessione per timeout, così 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 e supportare numerosi protocolli.

L'autore si è impegnato affinché l'utilità consumasse il minor numero possibile di risorse e funzionasse in modo assolutamente discreto sulla macchina. A differenza dei moderni antivirus e di altri "sistemi di sicurezza", non dovrebbe rallentare il computer. È riuscito a minimizzare sia il traffico che il consumo di memoria grazie a un'implementazione software leggermente più sofisticata. Se avesse semplicemente avviato un processo separato per ogni nuova connessione, gli aggressori potenziali avrebbero potuto eseguire un attacco DDoS aprendo molte connessioni per esaurire le risorse sulla macchina. Un singolo flusso per connessione non è nemmeno la soluzione migliore, perché il kernel spenderebbe risorse nella gestione dei flussi.

Perciò, Chris Vellons ha scelto per Endlessh l'opzione più leggera: un server a thread singolo. poll(2), dove i clienti sono praticamente bloccati e 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 ad accesso diretto e trasmette direttamente i pacchetti TCP, ignorando quasi completamente lo stack TCP/IP del sistema operativo. Il buffer in ingresso non è affatto necessario, poiché i dati in ingresso non ci interessano.

L'autore afferma che al momento della sua programmazione non sapeva dell'esistenza di asyncio in Python e di altri tarpiti. Se avesse saputo di asyncio, avrebbe potuto realizzare 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 tarpiti. Ad esempio, una tale trappola può bloccare Firefox, Chrome o un altro client che tenta di connettersi al tuo server HTTP per molte ore:

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 burloni di Internet. Tuttavia, c'è un certo rischio di attirare la loro attenzione sul comportamento anomalo di un server specifico. Qualcuno potrebbe pensare a una vendetta e a un attacco DDoS mirato al tuo IP. Tuttavia, finora non si sono verificati casi simili e i tarp si sono rivelati molto efficaci.

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

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

A un amministratore di sistema di nome Chris Vellons, evidentemente, è stufato di osservare questa situazione — e ha scritto un piccolo programma Endlessh, tarpit per SSH che rallenta le connessioni in entrata. Il programma apre una porta (di default, per test è indicata la porta 2222) e si finge un server SSH, mentre in realtà stabilisce una connessione infinita con il client in ingresso, finché non si arrende. Questo può durare giorni o più, finché il client non si disconnette.

Installazione dell'utility:

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

Per impostazione predefinita, il programma attende 10 secondi tra l'invio dei pacchetti. Ciò previene la disconnessione per timeout, così 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 tarpiti. Ad esempio, una tale trappola può bloccare Firefox, Chrome o un altro client che tenta di connettersi al tuo server HTTP per molte ore:

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