🥇Fälla (tarpit) för inkommande SSH-anslutningar

Det är ingen hemlighet att internet är en väldigt fiendtliga miljö. Så snart du startar en server utsätts den omedelbart för massiva attacker och flera skanningar. Ett exempel är honeypoten från säkerhetsleverantörerna som kan ge en uppfattning om omfattningen av denna skräptrafik. Faktum är att på en genomsnittlig server kan 99% av trafiken vara skadlig.

Tarpit är en portfälla som används för att sakta ner inkommande anslutningar. Om ett externt system ansluter till denna port, kan det inte snabbt stänga anslutningen. Det måste använda sina systemresurser och vänta på att anslutningen avbryts på grund av tidsgräns, eller manuellt bryta den.

Tarpits används oftast för skydd. Tekniken utvecklades ursprungligen för att skydda mot datormaskar. Nu kan den användas för att göra livet surt för spammare och forskare som sysslar med bred skanning av alla IP-adresser i följd (exempel på Habr): Österrike, Ukraina).

En av systemadministratörerna, vid namn Kris Vellons, tyckte uppenbarligen att han hade tröttnat på detta elände – och han skrev ett litet program Endlessh, en tarpit för SSH som saktar ner inkommande anslutningar. Programmet öppnar en port (standard för testning är port 2222) och låtsas vara en SSH-server, men i verkligheten upprättar det en oändlig anslutning med den inkommande klienten, tills den ger upp. Detta kan pågå i flera dagar eller längre, tills klienten slutar.

Installation av verktyget:

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

En väl implementerad tarpit kommer att ta mer resurser från angriparen än från er. Men det handlar inte ens om resurser. Författaren skriver, att programmet skapar en beroendeframkallande effekt. Just nu finns 27 klienter i hans fälla, och några av dem har varit anslutna i flera veckor. Vid högnivåaktivitet satt 1378 klienter i fällan under 20 timmar!

I driftläge måste servern Endlessh installeras på standardport 22, dit många brottslingar ansluter. Standard säkra rekommendationer föreslår alltid att flytta SSH till en annan port, vilket omedelbart minskar loggstorleken med en storleksordning.

Kris Vellons säger att hans program utnyttjar ett stycke ur specifikationen RFC 4253 för SSH-protokollet. Omedelbart efter att TCP-anslutningen har upprättats, men innan kryptografi används, måste båda parter skicka en identifieringssträng. Och där finns även en notering: «Servern KAN skicka andra datalinjer innan den skickar versionlinjen». Och inga begränsningar för mängden av dessa data, varje rad måste börja med SSH-.

Det är just detta programmet Endlessh gör: det skickar oändlig ström av slumpmässigt genererade data, som följer RFC 4253, det vill säga sända före identifiering, och varje rad börjar med SSH- och överstiger inte 255 tecken, inklusive radslutstecken. Allt enligt standard.

Som standard väntar programmet 10 sekunder mellan paketsändningar. Detta förhindrar tidsavbrott, så att klienten kommer vara fast för alltid.

Eftersom data skickas innan kryptografi används, är programmet extremt enkelt. Det kräver ingen integrering av några krypteringar och stöd för många protokoll.

Författaren har strävat efter att verktyget ska konsumera minimalt med resurser och arbeta helt osynligt på maskinen. Till skillnad från moderna antivirusprogram och andra "säkerhetssystem" bör det inte bromsa datorn. Han lyckades minimera både trafik och minnesanvändning genom en något mer intrikat programimplementering. Om han bara hade kört en separat process för varje ny anslutning, skulle potentiella angripare kunna genomföra en DDoS-attack genom att öppna många anslutningar för att höja resursanvändningen på maskinen. En ström per anslutning är inte heller det bästa alternativet, eftersom kärnan skulle spendera resurser på att hantera trådarna.

Därför valde Chris Vellons den lättaste versionen för Endlessh: en entrådad server poll(2), där klienterna i fångenskap praktiskt taget inte konsumerar extra resurser, förutom socket-objektet i kärnan och ytterligare 78 byte för övervakning i Endlessh. För att inte allokera mottagnings- och sändningsbuffrar för varje klient, öppnar Endlessh en direktåtkomstsocket och sänder TCP-paket direkt, och ignorerar nästan hela TCP/IP-stacken i operativsystemet. Den inkommande bufferten behövs egentligen inte, eftersom inkommande data inte intresserar oss.

Författaren säger att han vid tidpunkten för sitt program inte visste om existensen av Python asycio och andra trappar. Om han hade känt till asycio, skulle han ha kunnat implementera sitt verktyg med bara 18 rader kod 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 är perfekt för att skriva tarpits. Till exempel kan en sådan fälla hänga Firefox, Chrome eller en annan klient i flera timmar som försöker ansluta till din HTTP-server:

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 är ett utmärkt verktyg för att straffa internetvettar. Det finns dock en viss risk för att det istället drar till sig deras uppmärksamhet för att ett specifikt servers beteende är ovanligt. Någon kan tänka sig att hämnas och rikta en DDoS-attack mot din IP. Även om det hittills inte har förekommit sådana fall, fungerar tarpits utmärkt.

Kategorier:
Python, Informationssäkerhet, Programvara, Systemadministration

Taggar:
SSH, Endlessh, tarpit, fälla, asyncio
Fälla (tar pit) för inkommande SSH-anslutningar

En av systemadministratörerna, vid namn Kris Vellons, tyckte uppenbarligen att han hade tröttnat på detta elände – och han skrev ett litet program Endlessh, en tarpit för SSH som saktar ner inkommande anslutningar. Programmet öppnar en port (standard för testning är port 2222) och låtsas vara en SSH-server, men i verkligheten upprättar det en oändlig anslutning med den inkommande klienten, tills den ger upp. Detta kan pågå i flera dagar eller längre, tills klienten slutar.

Installation av verktyget:

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

Som standard väntar programmet 10 sekunder mellan paketsändningar. Detta förhindrar tidsavbrott, så att klienten kommer vara fast för alltid.

Eftersom data skickas innan kryptografi används, är programmet extremt enkelt. Det kräver ingen integrering av några krypteringar och stöd för många protokoll.

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 är perfekt för att skriva tarpits. Till exempel kan en sådan fälla hänga Firefox, Chrome eller en annan klient i flera timmar som försöker ansluta till din HTTP-server:

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

Källa: habr.com