🥇Fælde (tarpit) for indkommende SSH-forbindelser

Det er ingen hemmelighed, at internettet er et meget fjendtligt miljø. Så snart du opretter en server, bliver den straks udsat for masser af angreb og mange scanninger. Et eksempel er honeypoten fra sikkerhedseksperter , hvor man kan vurdere omfanget af denne rådne trafik. Faktisk kan 99% af trafikken på en gennemsnitlig server være ondsindet.

Tarpit er en port-trap, der bruges til at bremse indkommende forbindelser. Hvis et fremmed system forsøger at oprette forbindelse til denne port, kan det ikke hurtigt lukke forbindelsen. Det vil skulle bruge sine systemressourcer og vente på, at forbindelsen afbrydes ved timeout, eller manuelt afbryde den.

Tarpits anvendes oftest til beskyttelse. Teknologien blev første gang udviklet for at beskytte mod computerorme. Og nu kan den bruges til at gøre livet surt for spammerne og forskerne, der laver omfattende scanninger af alle IP-adresser i rækkefølge (eksempler på Habr: Østrig, Ukraine).

En af systemadministratorerne ved navn Kris Vellons, var tilsyneladende træt af at overvåge dette kaos — og han skrev et lille program Endlessh, en tarpit for SSH, der bremser indkommende forbindelser. Programmet åbner en port (standard til test er port 2222) og udgiver sig for at være en SSH-server, mens det i virkeligheden etablerer en uendelig forbindelse med den indkommende klient, indtil den giver op. Dette kan fortsætte i flere dage eller mere, indtil klienten falder fra.

Installation af værktøjet:

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

En korrekt implementeret tarpit vil tage flere ressourcer fra angriberen end fra dig. Men det handler ikke engang om ressourcerne. Forfatteren skriver, der bemærker, at programmet kan være vanedannende. Lige nu er der 27 klienter i hans fælde, nogle af dem har været tilsluttet i flere uger. På toppen af aktiviteten sad der 1378 klienter i fælden i 20 timer!

Når den er i drift, bør serveren Endlessh placeres på den almindelige port 22, hvor skurke ofte banker på. Standard sikkerhedsanbefalinger råder altid til at flytte SSH til en anden port, hvilket straks reducerer størrelsen på logfilerne.

Kris Vellons siger, at hans program udnytter et afsnit fra specifikationen RFC 4253 over the SSH protocol. Immediately after establishing a TCP connection, but before applying any cryptography, both parties must send an identification string. And there is an addition there: The server MAY send other data strings before sending the version string. Og no limit to the volume of this data, just each string must start with SSH-.

This is precisely what the Endlessh program does: it sends an endless stream of randomly generated data, which complies with RFC 4253, meaning sending before identification, with each string starting with SSH- and not exceeding 255 characters, including the line ending character. Overall, everything according to the standard.

By default, the program waits 10 seconds between packet transmissions. This prevents timeouts, so the client will be stuck forever.

Since data is sent before applying cryptography, the program is exceptionally simple. There is no need to implement any encryption or support for multiple protocols.

The author made an effort to ensure that the utility consumes minimal resources and operates completely unnoticed on the machine. Unlike modern antivirus programs and other 'security systems', it should not slow down the computer. He was able to minimize both traffic and memory consumption through a slightly more clever software implementation. If he simply launched a separate process for each new connection, potential attackers could conduct a DDoS attack by opening multiple connections to exhaust resources on the machine. One stream per connection is also not the best option because the kernel will waste resources managing threads.

Therefore, Chris Wellons chose the lightest option for Endlessh: a single-threaded server poll(2), where trapped clients consume virtually no extra resources, aside from the socket object in the kernel and another 78 bytes for tracking in Endlessh. To avoid allocating receive and send buffers for each client, Endlessh opens a direct access socket and directly streams TCP packets, ignoring almost the entire TCP/IP stack of the operating system. The incoming buffer is not needed at all, as incoming data is not of interest to us.

The author states that at the time of his program, he was unaware om eksistensen af Python's asyncio og andre tarpit. Hvis han havde vidst om asyncio, kunne han have implementeret sit værktøj med kun 18 linjer i 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 er ideelt til at skrive tarpits. For eksempel vil sådan en fælde hænge Firefox, Chrome eller en anden klient, der forsøger at forbinde til din HTTP-server, i flere timer:

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

En tarpit er et fremragende værktøj til at straffe internet-bullies. Der er dog en vis risiko for at tiltrække deres opmærksomhed til en bestemt servers usædvanlige opførsel. Nogen kan tænke på hævn og en målrettet DDoS-angreb på din IP. Men indtil videre har der ikke været sådanne tilfælde, og tarpits fungerer fremragende.

Hubs:
Python, Informationssikkerhed, Software, Systemadministration

Tags:
SSH, Endlessh, tarpit, fælde, asyncio
Trap (tarpit) for incoming SSH connections

En af systemadministratorerne ved navn Kris Vellons, var tilsyneladende træt af at overvåge dette kaos — og han skrev et lille program Endlessh, en tarpit for SSH, der bremser indkommende forbindelser. Programmet åbner en port (standard til test er port 2222) og udgiver sig for at være en SSH-server, mens det i virkeligheden etablerer en uendelig forbindelse med den indkommende klient, indtil den giver op. Dette kan fortsætte i flere dage eller mere, indtil klienten falder fra.

Installation af værktøjet:

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

By default, the program waits 10 seconds between packet transmissions. This prevents timeouts, so the client will be stuck forever.

Since data is sent before applying cryptography, the program is exceptionally simple. There is no need to implement any encryption or support for multiple protocols.

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 er ideelt til at skrive tarpits. For eksempel vil sådan en fælde hænge Firefox, Chrome eller en anden klient, der forsøger at forbinde til din HTTP-server, i flere timer:

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

Kilde: habr.com