Три способа защиты разговоров по мобильному телефону от «прослушки» – Гаджеты. Технологии. Интернет – 10 января – 43046546400 – Медиаплатформа МирТесен

Часть 1: основные моменты gsm безопасности

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

На данном рисунке схематично представлены следующие шаги:

1. Телефон оператора подключается к сети.
2. Для подтверждения своей подлинности телефон посылает специальный идентификационный код, называемый TMSI(Temporary Mobile Subscriber Identity).
3. Центр Аутентификации(ЦА) генерирует 128-битное случайное число RAND и посылает его на Мобильную Станцию(МС).
4. МС зашифровывает полученное число RAND, используя свой секретный ключ K_i и алгоритм аутентификации A3.
5. MC берет первые 32 бита из последовательности, полученной на предыдущем шаге(назовем их SRES(signed response)) и отправляет их обратно на ЦА.
6. ЦА проделывает ту же операцию и получает 32 битную последовательность XRES(expected response).
7. После чего ЦА сравнивает SRES и XRES. В случае, если оба значения равны, телефон считается аутентифицированным.
8. МС и ЦА вычисляют сессионный ключ шифрования, используя секретный ключ K_i и алгоритм формирования ключа A8 K_c=A8_ki(RAND)

Говоря об алгоритмах аутентификации A3 и алгоритме формирования ключа A8, следует отметить что на практике большинство сотовых операторов используют для этих целей один алгоритм, называемый COMP128(он имеет множество модификаций COMP128-1, COMP128-2, COMP128-3).

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

SRES=Первые 32 бита от COMP128(Ki||RAND)Kс=Последние 64 бита COMP128(Ki||RAND).Как всегда в криптографии, попытка сэкономить время разработчикам обернулась полным провалом. Безопасность GSM сетей изначально основывалась на принципе «безопасность за счёт неизвестности».

И когда в 1998 году алгоритм был вскрыт группой исследователей состоящих из Marc Briceno, Ian Goldberg и David Wagner обранужилась одна занятная особенность: последние 10 бит секретного ключа Ki всегда равнялись нулю. Используя это любопытное свойство, а так же уязвимость COMP128 к «атаке дней рождений» Marc Briceno, Ian Goldberg и David Wagner смогли извлечь секретный ключ Ki из SIM-карты.

3.3. Способы защиты информации от утечки по каналам сотовой связи. Электронные устройства для глушения беспроводных сигналов [GSM, Wi-Fi, GPS и некоторых радиотелефонов]

Антивирусы

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

Но не зря тут стоит фраза «для большинства людей». Подцепить заразу при желании может кто угодно, и причем довольно просто: распаковали левый .apk-файл, загрузили новое и не успевшее пройти контроль порно-приложение в Play Store – и готово, можете прощаться с деньгами на счете телефона или же с личными данными в лучшем случае.

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

Антивирусы для мобильных устройств сегодня делают все производители «взрослых» антивирусов: ESET, Dr.Web, Symantec и другие. Это пока что не такая уж и весомая статья их доходов, но с все большим распространением Android данная ситуация может и измениться.

Белогривые лошадки

Относительно новым способом защиты можно назвать перенос данных в облачные сервисы. Благо таких сервисов развелось уже достаточно много: от SkyDrive, в 7 ГБ которых могут переносить данные обладатели гаджетов на Windows Phone, до какого-нибудь российскогоЯндекс.

Примерно так выглядит суть облачных сервисов

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

И в самом деле: можно сдублировать данные даже в два или три облака (это уже для совсем параноиков). А тем, кому не жалко денег, можно посоветовать сделать облачный аккаунт платным, купить дополнительные десятки или сотни гигабайт и спать крепким сном.

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

Защита данных: фаза первая, физическая

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

И с защитой этих самых данных сегодня дело обстоит очень вяло. Лишь недавно в новом Apple iPhone 5S показали сканер отпечатков пальцев, встроенный в кнопку Home. Без преувеличения можно утверждать, что данный продукт открывает новую страницу истории систем мобильной безопасности:

если Apple смогла встроить сканер в свой смартфон, то и другие, как обычно, побегут это решение копировать. Более благоразумные посмотрят на ошибки других и предоставят более совершенный, чем iPhone 5S, продукт. А что уж говорить про чипыTPM или аналогичное решение, что сейчас можно найти во многих лэптопах!

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

Схема дактилоскопического сенсора в iPhone 5s в деталях

Вообще, отпечатки пальцев выглядят достаточно перспективным средством защиты. Нелишним будет упомянуть про то, что не только Айфон стал в этом деле новым Колумбом: тоже самое можно сказать про новый японский планшет Fujitsu Arrows Tab FJT21, в котором тоже внедрили дактилоскопический датчик.

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

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

Информационная безопасность на мобильных устройствах – взгляд потребителей

Обновляем

В сегодняшнем мире обновления программ являются еще одним надежным способом уберечь себя от кражи данных. Поскольку новые уязвимости обнаруживаются в ОС и популярных приложениях постоянно, не менее постоянно выходят и обновления, в которых «латают дырки».

Именно по этой причине рекомендуется обновлять как отдельные приложения, так и саму систему регулярно. Особенно это касается продуктов Adobe и Microsoft: различные вредители и прочие энтузиасты со всего мира обожают копать и находить уязвимости в Windows, Office и Acrobat, причем новые обнаруживаются с завидной регулярностью.

Профили и установки

Заметным нововведением последнего времени можно назвать появившиеся уже во вполне работоспособном виде системы разделения профилей. Наиболее совершенной системой обладает одна из последних версий ОС Android 4.3 и не менее новая Windows Phone 8.

Добавляем нового пользователя

Каждый из профилей ОС Android 4.3, зарегистрированных в системе, предоставляет собой надежно огражденное от шаловливых ручек окружение с собственным локальным хранилищем, домашними экранами, виджетами и настройками, и в том числе административными ограничениями касаемо конкретных приложений.

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

Он может просто передать трубку вам, а если нет – то что? Модуль мобильной связи будет отключен? А если нужно принять важный звонок? В общем, вопросов пока больше, чем ответов. И вот поэтому данную систему пока нельзя назвать проработанной до совершенства.

Раз защита, два защита

Грозное словосочетание «двухфакторная аутентификация» на самом деле значит авторизацию по двум параметрам, а не по одному. Например, не только постоянный пароль, но и одноразовый, который пришлют вам на телефон: для параноиков вариант идеальный по своей стоимости.

Смартфоны в данном аспекте не являются каким-то ключом: скорее, проводником решений по защите. Например, в Android можно поставить программу-OTP от того или иного сервиса вроде Amazon и с его помощью успешно проходить двухфакторную авторизацию на данном ресурсе.

Современный защищенный гаджет

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

Ответ тут весьма прост и известен многим: вендорам выгодно делать неизносостойкие и вообще слабые в плане защиты аппараты, чтобы продавать постоянно новые. Например, у французскогосотового оператора Orange можно заключить такой контракт, по которому владельцу каждый год будет предоставляться в собственность новый современный смартфон с утилизацией и зачетом цены старого. Хотя по сути это и является договором аренды, выглядит ведь это совсем не так. Nuff said, как говорится.

В качестве противоположного приведем в пример новинки от Sony серии Xperia Z (планшет и смартфон): их можно в данном случае поставить эталонными к данной статье, поскольку они соответствуют максимальным стандартам защиты IPX67 (погружение в воду до получаса и полная защита от пыли).

Вообще, именно по стандартам IP сейчас измеряется степень защищенности смартфонов. Сегодня недостаточно сказать «он не пропускает воду», нужно указать, настолько именно он ее не пропускает, как глубоко его можно уронить и какому классу защиты по стандартам IP все это соответствует.

Формально большинство смартфонов могут соответствовать начальным и уровням стандартов, конечно (можно указать IP11 или вообще IP00 – ерунда, но зато буковки красивые). Но именно Sony доказывает нам, что можно сделать современный красивый стильный аппарат, и при этом его можно хоть сто раз в ванну уронить – ему все равно.

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

О клиенте мало кто думает, скажем честно.

Средства защиты переговоров в сетях сотовой связи

	Комплекс «GSM-контроль» предназначен для мониторинга сотовых сетей стандарта GSM900/1800 и интеллектуального/выборочного блокирования абонентских устройств заданного оператора связи. Путем имитации работы базовой станции GSM происходит регистрация абонентов с возможностью классификации «свой-чужой», при этом работа абонентов классифицированных как «чужой» блокируется, «свои» абоненты продолжают беспрепятственную работу в сети оператора.
	Комплекс «GSM-транк» предназначен для создания мобильного пункта связи на базе защищенных телефонов М-539 (или на базе телефонов с модифицированным ПО). Пункт связи позволяет одновременно устанавливать соединения между 4 абонентами (7 абонентами). Зона покрытия может составлять до 1 км.
	Комплекс «GSM-защита» предназначен для мониторинга сотовых сетей стандарта GSM900/1800 и интеллектуального/выборочного блокирования абонентских устройств с целью защиты объектов от несанкционированного использования GSM-устройств. Путем имитации работы базовой станции GSM происходит регистрация абонентов с возможностью классификации «свой-чужой», при этом работа абонентов классифицированных как «чужой» блокируется, соединения «своих» абонентов ретранслируются в сеть оператора (возможна ретрансляция открытых/шифрованных соединений, также возможна ретрансляция в ТфОП).
	Устройство «ЛБС-сканер» предназначено для обнаружения активных базовых станций GSM и выявления базовых станций, не принадлежащих официальным провайдерам GSM-услуг, работающих в данном регионе.
	Система разграничения доступа к сети GSM с возможностью маскировки местоположения абонента.
	Аппарат предназначен для защиты разговоров от прослушивания. Аппарат работает в трёх режимах в зависимости от настроек пользователя – при каждом звонке (при каждом запросе IMEI оператором). при каждом включении аппарата, не меняется и остается таким как был прошит при изготовлении аппарата.
	Программно-аппаратный продукт “Референт-PDA” разработан для устройств типа смартфон (коммуникатор), работающих под управлением операционной системы Windows Mobile 2003. Референт-PDA позволяет предотвратить прослушивание переговоров, ведущихся между двумя коммуникаторами. Комплект состоит из SD-модуля и программного обеспечения.
	Предназначен для предотвращения возможности прослушивания разговоров по мобильному телефону как на уровне операторов сотовой связи, так и с помощью комплексов перехвата GSM.
	УКС-001, совместно с подключенным к нему мобильным телефоном Ericsson-R520m, обеспечивает проведение сеансов защищённых переговоров по каналу передачи данных.
	Устройство защиты переговоров в каналах мобильной связи стандарта GSM.

Часть 2: алгоритм шифрования a5/1

Давайте теперь перейдем от вещей более общих к вещам более частным и поговорим о том как в GSM реализовано шифрование телефонных разговоров.

В качестве алгоритма шифрования в GSM используются алгоритмы из семейства A5. На сегодняшний день их всего 3:

Рассмотрим подробнее алгоритм A5/1.

Итак, как уже было сказано выше A5/1 это поточный шифр. И вновь на помощь спешит картинка с википедии:

Внутреннее состояние шифра A5/1 состоит из трех линейных регистров сдвига с обратной связью R1, R2, R3, длиной 19, 22 и 23 бита соответственно(всего 64 бита).

Сдвиг в регистрах R1, R2, R3 происходит только при выполнении определенного условия. Каждый регистр содержит ” бит управления тактированием”. В R1 это 8-й бит, а в R2 и R3 — 10-й. На каждом шаге сдвигаются только те регистры у которых значение бита синхронизации равно большинству значений синхронизирующих битов всех трех регистров.

Перед работой алгоритма выполняется инициализация регистров. Происходит это следующим образом:

1. R1=R2=R3=0
2. For i=0 to 63 do
   R1[0]=R1[0]⊕Kc[i]
   R2[0]=R2[0]⊕Kc[i]
   R2[0]=R2[0]⊕Kc[i]
   Сдвинуть все регистры на одну позицию, игнорируя биты синхронизации.
3. For i=0 to 22 do
   R1[0]=R1[0]⊕FrameCount[[i]
   R2[0]=R2[0]⊕FrameCount[[i]
   R2[0]=R2[0]⊕FrameCount[[i]
   Сдвинуть все регистры на одну позицию, игнорируя биты синхронизации.
4. For i=0 to 99 do
   Сдвинуть регистры на одну позицию, с учетом битов синхронизации.

Где FrameCount 32-х битная запись номера текущего фрейма.

После инициализации производится вычисление 228 бит выходной последовательности. 114 бит используется для шифрования данных исходящего из сети к мобильному телефону, остальные 114 бит для шифрования данных идущих от телефона к сети. Само шифрование представляет собой обыкновенный XOR между данными и произведенным алгоритмом A5/1 ключевым потоком. После передачи данных номер фрейма увеличивается на единицу и заново производится инициализация регистров.

Воспользуемся приведенным выше описанием и реализуем шифрование A5/1 на С#.

Проверить правильность кода можно, запустив программу с ключом {0x12, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF} и номером фрейма 0x134. Две сгенерированные последовательности по 114 бит каждая, должны быть равны соответственно { 0x53, 0x4E, 0xAA, 0x58, 0x2F, 0xE8, 0x15, 0x1A, 0xB6, 0xE1, 0x85, 0x5A, 0x72, 0x8C, 0x00 } и { 0x24, 0xFD, 0x35, 0xA3, 0x5D, 0x5F, 0xB6, 0x52, 0x6D, 0x32, 0xF9, 0x06, 0xDF, 0x1A, 0xC0 }.

Именно такие тестовые данные использовали Marc Briceno, Ian Goldberg и David Wagner в своей самой первой реализации алгоритма, написанной на С.

Функция шифрования/расшифровки, использующая данный класс, будет выглядеть следующим образом:

private byte[] A5Encyptor(byte[] msg,byte[] key)
        {
            A5Enc a5 = new A5Enc();
            int[] frame = new int[1];  
            bool[] resbits = new bool[msg.Count];
            int framesCount = msg.Length / 228;
            if ((msgbits.Length % 228) != 0)
                framesCount  ;
            for (int i = 0; i < framesCount; i  )
            {
                frame[0] = i;
                a5.KeySetup(key, frame);
                bool[] KeyStream = a5.A5(true);
                for (int j = 0; j < 228; j  )
                {
                    resbits[i * 228   j] = msgbits[i * 228   j] ^ KeyStream[j];
                }
            }
            return a5.FromBoolToByte(resbits, false);
        }

Теперь когда у нас есть функция, позволяющая шифровать и расшифровывать данные, давайте поговорим об уязвимостях алгоритма A5/1. На сегодняшний день известно большое количество успешных атак на GSM шифрование и все они относятся к атакам типа known-plaintext, т.е. для восстановления ключа атакующему помимо зашифрованных фреймов необходимо знать так же незашифрованные данные, которые соответствуют этим фреймам.

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

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

Часть 3: атака на алгоритм a5/1

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

Раcсматриваемая нами атака была впервые описана в 2002 году двумя исследователями: Patrik Ekdahl и Thomas Johansson.

Из определения процедуры инициализации можно заключить, что начальное состояние регистров является линейной функцией от сессионного ключа K и номера фрейма F

_n

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

1),

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

Так же из определения инициализации мы знаем, что первые 100 циклов алгоритм работает «в холостую», т.е. не производит никаких выходных битов, и первый бит выходной последовательности на самом деле является 101-м сгенерированным битом. Таким образом, если учесть, что на каждом шаге вероятность сдвига для каждого регистра равняется 3/4, можно сделать предположение, что после 101 шага, каждый регистр сдвигался ровно 76 раз. Следовательно, формула (1) преобразуется в:

2)Обозначив правую часть (2) как 3)

Т.к. выражение в правой части (3) нам известно, мы получаем 1 бит информации о ключевой последовательности S, а именно о состоянии 76-й позиции каждого регистра после инициализации. Действуя подобным образом, мы можем предположить, что на 102 позиции R1 остался также на позиции 76, а регистры R2 и R3 сдвинулись на позицию 77, таким образом мы получаем информацию о 77-й позиции регистра, и т.д. Всего нам необходимо вскрыть 64 бита, для успешного восстановления начального состояния.

Разумеется ситуация (76,76,76) возникает именно на 101 шаге с крайне низкой вероятностью, и если бы мы решили действовать подобным образом, то нам понадобилось бы перебрать огромное количество фреймов, пока наконец не попадется именно тот, в котором после 101 сдвига каждый регистр прокрутился на 76 позиций. Для того, чтобы уменьшить необходимое количество фреймов Ekdahl и Johansson предложили следующий метод.

Нет нужды угадывать конкретную позицию в которой регистры проворачиваются (cl₁,cl₂,cl₃) раз. Достаточно просто знать, что с большой долей вероятности каждый регистр провернется от 76 до 102 на отрезке I=[100,140] выходных бит каждого фрейма.
Таким образом, для каждого фрейма мы можем вычислить вероятность: 4),

где

и обозначает вероятность того, что t-й бит был порожден позициями регистров (cl1, cl2, cl3).

Вычислив (4) для каждого доступного фрейма усредним полученные вероятности при помощи логарифма:

Если (5)> 0, значит s1(cl1)⊕s2(cl2)⊕s3(cl3)=0, в противном случае s1(cl1)⊕s2(cl2)⊕s3(cl3)=1.

Опишем атаку полностью в виде алгоритма:

1. Выбираем интервал C. Например С=[79,86]
2. Пусть переменные cl₁,cl₂,cl₃ пробегают все значения из интервала C, для каждого фрейма вычисляем (4)
3. Для всех полученный значений вычисляем (5)
4. На основании значения Δ выбираем значение s₁(cl1)⊕s₂(cl2)⊕s₃(cl3)

Результатом выполнения данного алгоритма будут 512 уравнений вида s

₁

(79)⊕s

₂

(79)⊕s

₃

(79)=0, состоящие из 8 неизвестных. Решив эту систему уравнений простым перебором, мы получим по 8 бит начального значения каждого регистра.

Повторив алгоритм еще два раза для интервалов [87, 94] и [95, 102] мы получим по 24 бита начального состояния каждого из регистров. Этого нам более чем достаточно. Прокрутим каждый из регистров 101 раз назад мы получим как раз то состояние регистров, которое было после второго шага инициализации, т.е. после загрузки в регистры ключевых битов. И теперь мы можем сгенерировать всю ключевую последовательность целиком.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;

namespace A5project
{
    class A5attack
    {
        private double[] factorials = new double[150];

        //Вычисление Pr(cl1,cl2,cl3 в позиции v)
        private double PinVth(int cl1, int cl2, int cl3, int v)
        {            
            double  y=0;
            double x = 0;
            double z = 0;
            double w = 0;
            if((v - (v - cl1) - (v - cl2) - (v - cl3))>=0)
                y=factorials[v - (v - cl1) - (v - cl2) - (v - cl3)];
            else
                y=1;
            if ((v - cl1) >= 0)
                x = factorials[v - cl1];
            else
                x = 1;
            if ((v - cl3) >= 0)
                z = factorials[v - cl3];
            else
                z = 1;
            if ((v - cl2) >= 0)
                w = factorials[v - cl2];
            else
                w = 1;
            double a = factorials[v] / (x * factorials[v - (v - cl1)]);
            double b = factorials[v - (v - cl1)] / (w * factorials[v - (v - cl1) - (v - cl2)]);
            double c = factorials[v - (v - cl1) - (v - cl2)] / (z * y);
            double d = Math.Pow(4, v);
            return (a * b * c) / d;
        }

        private double factorial(int x)
        {
            double result=1;
            for (int i = x; i > 1; i--)
                result = result * i;
            return result;
        }

        private bool[] reg = new bool[19];
        private bool[] reg2 = new bool[22];
        private bool[] reg3 = new bool[23];

        //неполная инициализация, предполагается что ключевые биты уже загруженные в регистры
        public void KeySetup(int[] frame)
        {
            for (int i = 0; i < 19; i  )
                reg[i] = false;
            for (int i = 0; i < 22; i  )
                reg2[i] = false;
            for (int i = 0; i < 23; i  )
                reg3[i] = false;
            BitArray FrameBits = new BitArray(frame);
            for (int i = 0; i < 22; i  )
            {
                clockall();
                reg[0] = reg[0] ^ FrameBits[i];
                reg2[0] = reg2[0] ^ FrameBits[i];
                reg3[0] = reg3[0] ^ FrameBits[i];
            }
        }

        //процедуры по управлению сдвигами регистров
        private void clock()
        {
            bool majority = ((reg[8] & reg2[10]) | (reg[8] & reg3[10]) | (reg2[10] & reg3[10]));
            if (reg[8] == majority)
                clockone(reg);

            if (reg2[10] == majority)
                clocktwo(reg2);

            if (reg3[10] == majority)
                clockthree(reg3);
        }

        private bool[] clockone(bool[] RegOne)
        {
            bool temp = false;
            for (int i = RegOne.Length - 1; i > 0; i--)
            {
                if (i == RegOne.Length - 1)
                    temp = RegOne[13] ^ RegOne[16] ^ RegOne[17] ^ RegOne[18];
                RegOne[i] = RegOne[i - 1];
                if (i == 1)
                    RegOne[0] = temp;
            }
            return RegOne;
        }

        private bool[] clocktwo(bool[] RegTwo)
        {
            bool temp = false;
            for (int i = RegTwo.Length - 1; i > 0; i--)
            {
                if (i == RegTwo.Length - 1)
                    temp = RegTwo[20] ^ RegTwo[21];
                RegTwo[i] = RegTwo[i - 1];
                if (i == 1)
                    RegTwo[0] = temp;
            }
            return RegTwo;
        }

        private bool[] clockthree(bool[] RegThree)
        {
            bool temp = false;
            for (int i = RegThree.Length - 1; i > 0; i--)
            {
                if (i == RegThree.Length - 1)
                    temp = RegThree[7] ^ RegThree[20] ^ RegThree[21] ^ RegThree[22];
                RegThree[i] = RegThree[i - 1];
                if (i == 1)
                    RegThree[0] = temp;
            }
            return RegThree;
        }

        private void clockall()
        {
            reg = clockone(reg);
            reg2 = clocktwo(reg2);
            reg3 = clockthree(reg3);
        }

        //вычисление возвращаемого бита, когда регистры находятся в положениях cl1, cl2 и cl3
        public bool Oj(int cl1,int cl2, int cl3)
        {            
            for (int i = 0; i < cl1; i  )
            {
                clockone(reg);                
            }
            for (int i = 0; i < cl2; i  )
            {                
                clocktwo(reg2);                
            }
            for (int i = 0; i < cl3; i  )
            {                
                clockthree(reg3);
            }
            return (reg[18] ^ reg2[21] ^ reg3[22]);
        }

        //Вероятность того, что для данного фрейма XOR выходных битов регистра равен нулю
        public double Pj(int cl1, int cl2, int cl3, int j, bool[] frame)
        {
            double result = 0;
            double rightPart = 0;
            int[] framenumb=new int[1]{j};            
            KeySetup(framenumb);
            bool[] tempReg = new bool[19];
            bool[] tempReg2 = new bool[22];
            bool[] tempReg3 = new bool[23];
            Array.Copy(reg, tempReg, 19);
            Array.Copy(reg2, tempReg2, 22);
            Array.Copy(reg3, tempReg3, 23);
            bool FramesBit = Oj(cl1, cl2, cl3);
            for (int i = 100; i < 100   50; i  )
            {
                Array.Copy(tempReg, reg, 19);
                Array.Copy(tempReg2, reg2, 22);
                Array.Copy(tempReg3, reg3, 23);
                double temp = PinVth(cl1, cl2, cl3, i);
                rightPart  = temp;                
                if((FramesBit^frame[i-100])==false)
                    temp=temp*1;
                else
                    temp=0;
                result  = temp;
            }
            result = result   ((1 - rightPart) / 2);
            return result;
        }

        //Общая вероятность того, что биты cl1, cl2, cl3 в сумме дают 0. Если >0 тогда значение записывается как 0
        //в другом случае, как 1
        public double LikehoodRatio(int cl1, int cl2, int cl3, bool[] keystream)
        {
            double result = 0;
            for (int i = 0; i < keystream.Length/228; i  )
            {
                bool[] temp=new bool[228];
                Array.Copy(keystream,i*228,temp,0,228);
                double x=Pj(cl1, cl2, cl3, i, temp);
                result = result   Math.Log(( x/ (1 - x)));
            }
            return result;
        }

        public bool FindKeyBit(int cl1, int cl2, int cl3, bool[] keystream)
        {
            for (int i = 0; i < 150; i  )
                factorials[i] = factorial(i);
            if (LikehoodRatio(cl1, cl2, cl3, keystream) >= 0)
                return false;
            else
                return true;
        }

        //Загружает в регистры полученные биты и восстанавливае начальное значение
        public bool[][] checkSol(byte[] first, byte[] second, byte[] third)
        {
            byte[] newFirst = new byte[3];
            newFirst[0] = first[0];
            newFirst[1] = second[0];
            newFirst[2] = third[0];
            byte[] newSecond = new byte[3];
            newSecond[0] = first[1];
            newSecond[1] = second[1];
            newSecond[2] = third[1];
            byte[] newThird = new byte[3];
            newThird[0] = first[2];
            newThird[1] = second[2];
            newThird[2] = third[2];
            bool[] firstArr1 = new BitArray(newFirst).Cast<bool>().ToArray().Reverse().ToArray();
            bool[] firstArr = new bool[19];
            Array.Copy(firstArr1, 5, firstArr, 0, 19);
            bool[] secondArr1 = new BitArray(newSecond).Cast<bool>().ToArray().Reverse().ToArray();
            bool[] secondArr = new bool[22];
            Array.Copy(secondArr1, 2, secondArr, 0, 22);
            bool[] thirdArr1 = new BitArray(newThird).Cast<bool>().ToArray().Reverse().ToArray();
            bool[] thirdArr = new bool[23];
            Array.Copy(thirdArr1, 1, thirdArr, 0, 23);
            for (int i = 0; i < 101; i  )
            {
                BackClockone(firstArr);
            }
            for (int i = 0; i < 101; i  )
            {
                BackClocktwo(secondArr);
            }
            for (int i = 0; i < 101; i  )
            {
                BackClockthree(thirdArr);
            }
            bool[][] result = new bool[3][];
            result[0] = firstArr;
            result[1] = secondArr;
            result[2] = thirdArr;
            return result;
        }

        private void BackClockone(bool[] RegOne)
        {
            bool temp = false;
            for (int i = 0; i < RegOne.Length-1; i  )
            {
                if (i == 0)
                    temp = RegOne[0];
                RegOne[i] = RegOne[i 1];
                if (i == (RegOne.Length-2))
                    RegOne[RegOne.Length - 1] = temp ^ RegOne[13] ^ RegOne[16] ^ RegOne[17];
            }            
        }

        private void BackClocktwo(bool[] RegTwo)
        {
            bool temp = false;
            for (int i = 0; i < RegTwo.Length-1; i  )
            {
                if (i == 0)
                    temp = RegTwo[0];
                RegTwo[i] = RegTwo[i   1];
                if (i == (RegTwo.Length-2))
                    RegTwo[RegTwo.Length - 1] = temp ^ RegTwo[20];
            }            
        }

        private void BackClockthree(bool[] RegThree)
        {
            bool temp = false;
            for (int i = 0; i < RegThree.Length-1; i  )
            {
                if (i == 0)
                    temp = RegThree[0];
                RegThree[i] = RegThree[i   1];
                if (i == (RegThree.Length-2))
                    RegThree[RegThree.Length - 1] = temp ^ RegThree[7] ^ RegThree[20] ^ RegThree[21];
            }            
        }
    }
}

Используя функцию FindKeyBit следующим образом:

private bool[] attack()
{            
            bool[] keypart=new bool[512];
            int count = 0;
            A5attack tryattack = new A5attack();
            for(int i=79; i<87;i  )
                for(int j=79; j<87; j  )
                    for (int k = 79; k < 87; k  )
                    {
                        bool temp=tryattack.FindKeyBit(i, j, k, keystream);
                        int time = finish - start;
                        keypart[count] = temp;
                        count  ;
                    }
        return keypart;
        }

мы получим массив из 512 значений в котором записаны XOR ключевых бит начиная с позиции 79 по позицию 86.

Получив все 24 бита из каждого регистра, и переведя их в байтовые массивы проверяем наше решение:

Private void checkSolution()
{
A5attack LetsAttack = new A5attack();
int[] testframe = new int[1] { 0 };
bool[][] startState = LetsAttack.checkSol(first, second, third);
A5Enc a5check = new A5Enc(startState);
bool[] TempFrame = new bool[228];
a5check.KeySetup(testframe);
TempFrame = a5check.A5(true);
for (int l = 0; l < 228; l  )
{
     find = true;
     if (keystream[l] != TempFrame[l])
      {
           find = false;
           break;
       }
}
}

Если полученный фрейм совпадает с первым фреймом известного ключевого потока, значит атака была реализована успешно и мы вскрыли сеансовый ключ алгоритма A5/1.

Итоги

В общем, средств защиты на самом деле у современного смартфона масса. Сегодня вполне реально купить полностью защищенный девайс вроде упомянутых выше продуктов Fujitsu и Sony, если вы любите ронять своего карманного друга в ванну.

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

Потому что никто не ловит, в общем-то.