Размещено на http://www.allbest.ru/

Размещено на http://www.allbest.ru/

Федеральное агентство связи

Ордена Трудового Красного Знамени федеральное государственное бюджетное образовательное учреждение высшего образования

«Московский технический университет связи и информатики»

БАКАЛАВРСКАЯ РАБОТА

НА ТЕМУ

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

Москва 2016 г.

Введение

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

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

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

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

Данное приложение мессенджер написано для операционной систему iOS. Используемый язык программирования - Swift 2.0, созданным компанией Apple в 2014 году.

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

Данный проект включает в себя четыре части:

· Цель первой части заключается в обзоре современного состояния и тенденции развития систем шифрования коротких сообщений.

· Цель второй части заключается в обзоре методов криптографической защиты сообщений.

· Цель третьей части заключается в разработке системы шифрования коротких сообщений.

· Цель четвертой части заключается в экспериментальных исследованиях системы шифрования коротких сообщений.

интерфейс шифрование короткий сообщение

Глава 1. Обзор современного состояния и тенденция развития систем шифрования коротких сообщений

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

Рассмотрим наиболее популярные интернет-мессенджеры среди аудитории AppStore.

1.1 Обзор современных мессенджеров

1.1.1 ICQ мессенджер

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

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

Шифрование сообщений в данном мессенджере осуществляется только на уровне сетевых протоколов, но оно довольно посредственное. В ближайшее время планируется ввод сквозного шифрования (end-to-end).

Пример интерфейса ICQ мессенджера представлен на рисунке 1.1:



Рисунок 1.1 - Интерфейс мессенджера ICQ

1.1.2 Telegram мессенджер

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

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

Шифрование сообщений в Telegram основано на протоколе MTProto, который построен на алгоритмах AES-256 и SHA-1.

Пример интерфейса мессенджера Telegram представлен на рисунке 1.2:



Рисунок 1.2 - Интерфейс мессенджера Telegram

1.1.3 Viber мессенджер

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

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

Пример интерфейса мессенджера Viber представлен на рисунке 1.3:

Рисунок 1.3 - Интерфейс мессенджера Viber

1.1.4 WhatsApp мессенджер

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

Пример интерфейса мессенджера WhatsApp представлен на рисунке 1.4:



Рисунок 1.4 - Интерфейс мессенджера WhatsApp

Выводы

Из представленных интернет-мессенджеров можно выделить только Telegram, так он имеет более продвинутое шифрование. У остальных представленных мессенджеров шифрование отсутствует, либо будет реализовано в будущем.

Глава 2. Обзор методов криптографической защиты сообщений

The Advanced Encryption Standard (AES) стал золотым стандартом шифрования. Его эффективный алгоритм, широко распространенная реализация, и аппаратная поддержка оборудования обеспечивает высокую эффективность во многих областях. На большинстве современных платформ, AES от четырех до десяти раз быстрее чем предыдущий часто используемый шифр Triple Data Encryption Standard (3DES), что делает его не только лучшим выбором, но и практически единственным выбором. К сожалению, у AES имеется несколько проблем. Одной из проблем является то что, испытывает зависимость от оборудования. AES быстрый и стойкий, пока он работает на специализированной для данного шифрования аппаратуре, если же аппаратные средства не специализированные, то AES шифрование замедляется и становится менее криптостойким. Еще одна проблема в том, что во многих реализациях, AES шифрование уязвимо для кэш-атак, так называемых cache-collision timing attacks (Cache-Collisions). На фоне этих проблем был придуман новый метод шифрования - Salsa20.

2.1 Метод шифрования Salsa20

Salsa20 представляет собой семейство 256-разрядных потоковых шифров, разработанные Даниэлем Бернштейном (Daniel Julius Bernstein) в 2015 году. Алгоритм впервые был показан на международном конкурсе eSTREAM. Данный алгоритм одержал победу в одном из профилей конкурса.

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

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

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

Таблица 2.1 - Вычислительные машины с их характеристиками

Вычислительная машина
№	Архитектура	Процессор	Частота процессора, МГц
1	amd64	Xeon 5160 (6f6)	3000
2	amd64	Core 2 Duo (6f6)	2137
3	ppc32	PowerPC G4 7410	533
4	x86	Core 2 Duo (6f6)	2137
5	amd64	thlon 64 X2 (15,75,2)	2000
6	ppc64	PowerPC G5 970	2000
7	amd64	Opteron (f5a)	2391
8	amd64	Opteron (f58)	2192
9	x86	Athlon 64 X2 (15,75,2)	2000
10	x86	Athlon (622)	900
11	ppc64	POWER4	1452
12	hppa	PA-RISC 8900	1000
13	amd64	Pentium D (f64)	3000
14	x86	Pentium M (695)	1300
15	x86	Xeon (f26)	3000
16	x86	Xeon (f25)	3200
17	x86	Xeon (f29)	2800
18	x86	Pentium 4 (f41)	3000
19	x86	Pentium III (6b1)	1400
20	sparc	UltraSPARC IV	1050
21	x86	Pentium D (f47)	3200
22	a64	Itanium II	1500
23	a64	Itanium II	1400

Таблица 2.2 - Скорость работы Salsa20

№ вычислительной машины	Скорость шифрования, Раунд/байт
	8 раундов	12 раундов	20 раундов
	Объем шифруемой информации
	64 Байта	576 Байт	64 Байта	576 Байт	64 Байта	576 Байт
1	1.88	2.07	2.80	3.25	3.93	4.25
2	1.88	2.07	2.57	2.80	3.91	4.33
3	1.99	2.14	2.74	2.88	4.24	4.39
4	2.06	2.28	2.80	3.15	4.32	4.70
5	3.47	3.65	4.86	5.04	7.64	7.84
6	3.28	3.48	4.83	4.87	7.82	8.04
7	3.78	3.96	5.33	5.51	8.42	8.62
8	3.82	4.18	5.35	5.73	8.42	8.78
9	4.50	4.78	6.27	6.55	9.80	10.07
10	4.61	4.84	6.44	6.65	10.04	10.24
11	6.83	7.00	8.35	8.51	11.29	11.47
12	5.82	5.97	7.68	7.85	11.39	11.56
13	5.38	5.87	7.19	7.84	11.69	11.73
14	5.30	5.53	7.44	7.70	11.70	11.98
15	5.30	5.86	7.41	8.21	11.64	12.55
16	5.30	5.84	7.40	8.15	11.63	12.59
17	5.33	5.95	7.44	8.20	11.67	12.65
18	5.76	6.92	8.12	9.33	11.84	13.40
19	6.37	6.79	8.88	9.29	13.88	14.29
20	6.65	6.76	9.21	9.33	14.34	14.45
21	7.13	7.66	9.90	10.31	15.29	15.94
22	8.49	8.87	12.42	12.62	18.07	18.27
23	8.28	8.65	12.56	12.76	18.21	18.40

2.2.1 Описание алгоритма Salsa20

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

В данном алгоритме, байт - элемент . Есть много общих способов представления байт в виде последовательности электрических сигналов, но детали этого представления не имеют никакого отношения к определению Salsa20.

Последовательность символов - слово

Слово - элемент . Слова в данном алгоритме записываются в шестнадцатиричном формате, которые начинаются с символов .

Например,

.

Сумма двух слов это , обозначается . Например, .

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

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

Функция quarterround

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

Предположим, что Q четырех - разрядная последовательность, Q = (Q1, Q2, Q3, Q3), тогда функция quaterraound(Q) = (V1, V2, V3, V3), где



На рисунке 2.1 представлена блок - схема функциии quarterround Salsa20.

Рисунок 2.1 - Блок - схема функции quarterround Salsa20

Пример работы функции quarterround представлен на рисунке 2.2:



Рисунок 2.2 - Пример работы блока quarterround

Функция rowround

Предположим, что Q - последовательность шестнадцати слов Q = (Q1, Q2, Q3, Q3, …, Q15) тогда функция rowround(Q) = (V1, V2, V3, V3, …, V15) где

Пример работы блока rowround представлен на рисунке 2.3:



Рисунок 2.3 - Пример работы блока rowround

Функция columnround

Предположим, что Q - последовательность шестнадцати слов Q = (Q1, Q2, Q3, Q3, …, Q15) тогда функция rowround(Q) = (V1, V2, V3, V3, …, V15) где

Эквивалентная функция:

Пример работы блок columnround представлен на рисунке 2.4:

Рисунок 2.4 - Пример работы блока columnround

Функция doubleround

На вход подается последовательность из 16 слов, после применения функции doubleround, на выходе так же последовательность из 16 слов.

Функция doubleround это совокупность выполнения двух функций rowround и columnround:

Пример работы блок doubleround представлен на рисунке 2.5:



Рисунок 2.5 - Пример работы блока doubleround

Функция littleendian

На вход функции подается четырех - разрядная последовательность b, на выходе littleendian(b) будет словом.

Предположим, , тогда функция .

Пример работы функции littleendian представлен на рисунке 2.6:

Рисунок 2.6 - Пример работы функции littleleendian

Хэш-функция

На вход функции подается шестидесяти четырех - разрядная последовательность , на выходе получается шестидесяти четырех - разрядная последовательность .

Вкратце: , где

В деталях: Начальная форма предположим,

.

Предположим

Тогда будет конкатенацией:

,

,

,

.

Пример работы хэш-функции Salsa20 представлен на рисунке 2.7:



Рисунок 2.7 - Пример работы хэш-функции Salsa20

Функция расширения

На вход функции подается тридцати двух - разрядная последовательность или шестнадцати - разрядная последовательность , на выходе получается шестидесяти четырех - разрядная последовательность .

Установим, что , , и . Если шестнадцати - разрядная последовательность, то .

Установим, что , , и . Если шестнадцати - разрядная последовательность, то .

Предположим, что , , и .

Тогда получится функция, изображенная на рисунке 2.8:



Рисунок 2.8 - Пример работы функции расширения Salsa20

Функция зашифровки

Пусть последовательность тридцати двух или шестнадцати байт, последовательность восьми байт, а последовательность байт, где .

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

Предположим, - последовательность байт.

,, , … ,

- уникальная последовательность восьми байт , таким образом, .

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

2.3 ChaCha

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

2.3.1 Функция quarterround в ChaCha

где - слова:



Рисунок 2.9 - Блок - схема алгоритма quarterround ChaCha

2.4 Сравнение методов шифрования

2.4.1 Сравнение Salsa20 и ChaCha

Таблица 2.3 - Скорости работы алгоритмов Salsa20 и ChaCha на различных компьютерах

Компьютер
№	Архитекрура	Процессор и его модель	Частота процессора, МГц
1	ppc32	PowerPC G4 7410	533
2	amd64	Core 2 Duo 6f6	2137
3	ppc64	PowerPC G5 970	2000
4	amd64	Athlon 64 X2 15,75,2	2000
5	amd64	Pentium D f64	3000
6	x86	Pentium M 695	1300
7	x86	Athlon 622	900
8	sparc	UltraSPARC IV	1050
9	x86	Pentium D f47	3200
10	x86	Pentium 4 f12	1900

Таблица 2.4 - Скорость шифрования Salsa20 и ChaCha

№ компьютера	Скорость шифрования, Раунд/байт
	8 раундов	12 раундов	20 раундов
	Salsa20	ChaCha	Slasa20	ChaCha	Salsa20	ChaCha
1	1.99	1.86	2.74	2.61	4.24	4.13
2	1.87	1.87	2.53	2.54	3.90	3.95
3	3.24	3.06	4.74	4.57	7.81	7.58
4	3.47	3.29	4.86	4.61	7.64	7.23
5	5.39	3.87	7.16	5.27	10.65	8.23
6	5.30	4.88	7.44	7.06	11.70	11.08
7	4.62	5.36	6.44	7.58	10.04	12.21
8	6.65	6.60	9.17	9.17	14.34	14.29
9	7.13	6.75	9.77	9.33	14.33	14.27
10	5.41	7.08	8.21	9.72	11.74	15.03

Диффузия не происходит за счет добавочных операций. В раунде ChaCha происходит шестнадцать сложений, шестнадцать побитных сложений (XOR) и шестнадцать сдвигов тридцати двух - разрядного слова, также, как и в Salsa20. К тому же, ChaCha имеет те же уровни распараллеливания и векторизации, аналогично Salsa20 и занимает одно из семнадцати записей, использованных "естественным" выполнением Salsa20. Таким образом, ChaCha может достигать таких же скоростей шифрования, как в Salsa20, а на некоторых платформах может быть даже быстрее. Поэтому, если ChaCha имеет тоже минимальное число безопасных раундов, что и Salsa20, то ChaCha будет достигать лучшей скорости шифрования, чем Salsa20 для того же уровня безопасности. Конечно, основным фактором для скорости шифрования все же является архитектура.

Сравнение Salsa20/8 и ChaCha8 на различных архитектурах, с разными процессорами:

· Salsa20/8 и ChaCha8 имеют одинаковую скорость на 64-битной архитектуре - amd64 с установленным процессором Core 2 (6f6);

· Salsa20/8 и ChaCha8 имеют одинаковую скорость на 64-битной архитектуре - Sparc с установленным процессором UltraSPARC IV;

· ChaCha8 быстрее на 5%, чем Salsa20/8 на 64-битной архитектуре - amd64 с установленным процессором Athlon 64 (15,75,2);

· ChaCha8 быстрее на 5%, чем Salsa20/8 на 32-битной архитектуре - x86 с установленным процессором Pentium D (F47);

· ChaCha8 быстрее на 5%, чем Salsa20/8 на 64-битной архитектуре - ppc64 с установленным процессором PowerPC G5 (750);

· ChaCha8 быстрее на 6%, чем Salsa20/8 на 32-битной архитектуре - ppc32 с установленным процессором PowerPC G4 (7410);

· ChaCha8 быстрее на 8%, чем Salsa20/8 на 32-битной архитектуре - x86 с установленным процессором Pentium M (695);

· ChaCha8 быстрее на 28%, чем Salsa20/8 на 64-битной архитектуре - amd64 с установленным процессором Pentium D (F64);

· ChaCha8 медленнее на 16%, чем Salsa20/8 на 32-битной архитектуре - x86 с установленным процессором Athlon (622);

· ChaCha8 медленнее на 31%, чем Salsa20/8 на 32-битной архитектуре - x86 с установленным процессором Pentium 4 (f12).

2.4.2 Сравнение ChaCha20 и AES

В таблице приведены скорости шифрования AES-128 и ChaCha20 на двух разных процессорах.

Таблица 2.5 - Скорость шифрования AES-128 и ChaCha20

Процессор	Скорость работы
	AES-128	ChaCha20
OMAP 4460	21.1 Мб/с	75 Мб/с
Snapdragon S4 Pro	41.5 Мб/с	130.9 Мб/с

На рисунке 2.10 представленная сравнительная диаграмма скорости шифрования ChaCha20 и AES-128.



Рисунок 2.10 Диаграмма скорости шифрования ChaCha20 и AES-128

Выводы

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

Глава 3. Разработка системы шифрования коротких сообщений

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

На рисунке 3.1 представлено меню выбора метода шифрования.

Рисунок 3.1 - Меню выбора метода шифрования

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

На рисунке 3.2 представлена рабочая вкладка шифро-мессенджера.

Рисунок 3.2 - Рабочая вкладка шифро-мессенджера

Для зашифровки пользователь вводит свое сообщение, в специальное поле “Ввод сообщения”, образец ввода представлен на рисунке 3.3.



Рисунок 3.3 - Пример ввода сообщения для зашифровки

После ввода сообщения, для зашифровки нужно нажать на кнопку “Зашифровать”. Программа за считанные секунды выполнит свою функцию, и выдаст специальное окно с зашифрованным сообщением, как показано на рисунке 3.4.



Рисунок 3.4 - Дополнительное окно с зашифрованным сообщением

Чтобы закрыть данное окошко, нужно на клавишу “Ок”. В дополнительном поле сохраняется и выделяется красным цветом текст зашифрованное сообщения для дальнейшего его использования.

Дополнительное поле с зашифрованным сообщением показано на рисунке 3.5.



Рисунок 3.5 - Дополнительное поле с зашифрованным сообщением

При длительном нажатии на дополнительное поле, появляются функциональные кнопки, представленные на рисунке 3.6 и на рисунке 3.7:

· “Cut” - вырезать сообщение;

· “Copy” - скопировать сообщение;

· “Paste” - вставить сообщение;

· “Replace” - изменить сообщение;

· “Define” - определить количество символов;

· “Share” - экспорт сообщения в другое доступное приложение.



Рисунок 3.6 - Функциональные кнопки дополнительного поля №1



Рисунок 3.7 - Функциональные кнопки дополнительного поля №2

Главной особенностью данного приложения является возможность экспорта зашифрованного сообщения в другое приложение, это можно осуществить с помощью кнопки “Share”. При нажатии на неё, всплывает дополнительное меню с выбором приложения, в которое можно экспортировать зашифрованное сообщение. Пример дополнительно меню с приложениями представлен на рисунке 3.8.



Рисунок 3.8 - Меню выбора приложения

Аналогично зашифровке сообщения, осуществляется расшифровка.

Для зашифровки пользователь вставляет скопированное сообщение, в специальное поле “Ввод зашифрованного сообщения”, пример ввода зашифрованного сообщения представлен на рисунке 3.9.



Рисунок 3.9 - Пример ввода зашифрованного сообщения

После ввода зашифрованного сообщения, для расшифровки потребуется нажать на кнопку “Расшифровать”. Программа выполнит свою функцию, и выдаст специальное окно с расшифрованным сообщением, как показано на рисунке 3.10.



Рисунок 3.10 - Дополнительное окно с расшифрованным сообщением



Глава 4. Экспериментальные исследования системы шифрования коротких сообщений

В данной главе проводится тестирование разработанной программы для шифрования сообщений. Используются различные тексты, на разных языках и с разной длинной символов, статистика текста посчитана с помощью сайта www.vipkontent.ru [2]. Произведена проверка загруженности процессора, а также использование оперативной памяти мобильного телефона.

Для тестирования используется произведение С. А. Есенина “Береза”, в оригинале (русские символы) и в переводе (английские символы).

4.1 Тестирование приложения

При запущенном приложении, в не рабочем режиме наблюдаются такие характеристики загруженности телефона:

· Загруженность процессора: 0 %

· Использование оперативной памяти: 34,3 Мб

4.1.1 Оригинал стихотворения

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

«Белая береза

Под моим окном

Принакрылась снегом,

Точно серебром.

На пушистых ветках

Снежною каймой

Распустились кисти

Белой бахромой.

И стоит береза

В сонной тишине,

И горят снежинки

В золотом огне.

А заря, лениво

Обходя кругом,

Обсыпает ветки

Новым серебром.»

4.2.1.1 Строка произведения

При зашифровке на вход программы подается одна строка произведения: «Точно серебром.»

Статистика текста, поданного на зашифровку представлена в таблице 4.1:

Таблица 4.1 - Статистика одной строки произведения

Количество символов:	15
Количество символов без пробела:	14
Количество слов:	2
Количество запятых:	0
Количество пробелов:	1

При этом основные параметры телефона:

· Загруженность процессора: 0 %

· Использование оперативной памяти: 34,3 Мб

На выходе получается зашифрованное сообщение, представленное на рисунке 4.1:



Рисунок 4.1 Зашифрованное сообщение

При расшифровке на вход подается зашифрованное сообщение, представленное на рисунке 4.1.

При этом основные параметры загруженности телефона:

· Загруженность процессора: 0%

· Использование оперативной памяти: 35,5 МБ

На выходе получается расшифрованное сообщение, представленное на рисунке 4.2.

Рисунок 4.2 Расшифрованное сообщение

4.2.1.2 Четверостишие произведения

При зашифровке на вход программы подается одно четверостишие произведения:

«И стоит береза

В сонной тишине,

И горят снежинки

В золотом огне.»

Статистика текста, поданного на зашифровку представлена в таблице 4.2:

Таблица 4.2 - Статистика одного четверостишия произведения

Количество символов:	64
Количество символов без пробела:	53
Количество слов:	9
Количество запятых:	1
Количество пробелов:	8

При этом основные параметры телефона:

· Максимальная загруженность процессора: 1 %

· Использование оперативной памяти: 39,7 Мб

На выходе получается зашифрованное сообщение, представленное на рисунке 4.3:

Рисунок 4.3 Зашифрованное сообщение

При расшифровке на вход подается зашифрованное сообщение, представленное на рисунке 4.3.

При этом основные параметры загруженности телефона:

· Максимальная загруженность процессора: 1 %

· Использование оперативной памяти: 40,1 МБ

На выходе получается расшифрованное сообщение, представленное на рисунке 4.4.

Рисунок 4.4 Расшифрованное сообщение

4.2.1.3 Полное произведение

При зашифровке на вход программы подается одна строка произведения:

«Белая береза

Под моим окном

Принакрылась снегом,

Точно серебром.

На пушистых ветках

Снежною каймой

Распустились кисти

Белой бахромой.

И стоит береза

В сонной тишине,

И горят снежинки

В золотом огне.

А заря, лениво

Обходя кругом,

Обсыпает ветки

Новым серебром.»

Статистика текста, поданного на зашифровку представлена в таблице 4.3:

Таблица 4.3 - Статистика полного текста произведения

Количество символов:	262
Количество символов без пробела:	221
Количество слов:	24
Количество запятых:	4
Количество пробелов:	23

При этом основные параметры телефона:

· Максимальная загруженность процессора: 3 %

· Использование оперативной памяти: 46,7 Мб

На выходе получается зашифрованное сообщение, представленное на рисунке 4.5:



Рисунок 4.5 Зашифрованное сообщение

При расшифровке на вход подается зашифрованное сообщение, представленное на рисунке 4.5.

При этом основные параметры загруженности телефона:

· Максимальная загруженность процессора: 3 %

· Использование оперативной памяти: 47,1 Мб

На выходе получается расшифрованное сообщение, представленное на рисунке 4.6.



Рисунок 4.6 Расшифрованное сообщение

4.2.2 Перевод стихотворения

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

«A white birch, in the morning

In the window-pane,

Is enwrapped in snow like

In a silver veil.

Tassels, outstretching,

Deck the downy boughs,

Trimming snowy edgings

With white fringy downs.

And the birch is standing

In her drowsy quiet,

Snowflakes burning, flashing

In the golden fire,

While the daybreak, making

Lazily its beat,

Keeps on strewing freshly

Silver on the twigs.»

4.2.2.1 Строка произведения

При зашифровке на вход программы подается одна строка произведения: «In a silver veil.»

Статистика текста, поданного на зашифровку представлена в таблице 4.4:

Таблица 4.4 - Статистика одной строки произведения

Количество символов:	17
Количество символов без пробела:	14
Количество слов:	4
Количество запятых:	0
Количество пробелов:	3

При этом основные параметры телефона:

· Максимальная загруженность процессора: 0%

· Использование оперативной памяти: 35,4 МБ

На выходе получается зашифрованное сообщение, представленное на рисунке 4.7:

Рисунок 4.7 Зашифрованное сообщение

При расшифровке на вход подается зашифрованное сообщение, представленное на рисунке 4.7.

При этом основные параметры загруженности телефона:

· Максимальная загруженность процессора: 0 %

· Использование оперативной памяти: 36,1 МБ

На выходе получается расшифрованное сообщение, представленное на рисунке 4.8.

Рисунок 4.8 Расшифрованное сообщение

4.2.2.2 Четверостишие произведения

При зашифровке на вход программы подается одно четверостишие произведения:

«And the birch is standing

In her drowsy quiet,

Snowflakes burning, flashing

In the golden fire,»

Статистика текста, поданного на зашифровку представлена в таблице 4.5:

Таблица 4.5 - Статистика одного четверостишия произведения

Количество символов:	95
Количество символов без пробела:	80
Количество слов:	13
Количество запятых:	3
Количество пробелов:	12

При этом основные параметры телефона:

· Максимальная загруженность процессора: 2 %

· Использование оперативной памяти: 41,4 МБ

На выходе получается зашифрованное сообщение, представленное на рисунке 4.9:

Рисунок 4.9 Зашифрованное сообщение

При расшифровке на вход подается зашифрованное сообщение, представленное на рисунке 4.9.

При этом основные параметры загруженности телефона:

· Максимальная загруженность процессора: 2 %

· Использование оперативной памяти: 42,2 МБ

На выходе получается расшифрованное сообщение, представленное на рисунке 4.10.

Рисунок 4.10 Расшифрованное сообщение

4.2.2.3 Полное произведение

При зашифровке на вход программы подается полное произведение:

«A white birch, in the morning

In the window-pane,

Is enwrapped in snow like

In a silver veil.

Tassels, outstretching,

Deck the downy boughs,

Trimming snowy edgings

With white fringy downs.

And the birch is standing

In her drowsy quiet,

Snowflakes burning, flashing

In the golden fire,

While the daybreak, making

Lazily its beat,

Keeps on strewing freshly

Silver on the twigs.»

Статистика текста, поданного на зашифровку представлена в таблице 4.6:

Таблица 4.6 - Статистика полного произведения

Количество символов:	378
Количество символов без пробела:	314
Количество слов:	47
Количество запятых:	10
Количество пробелов:	46

При этом основные параметры телефона:

· Максимальная загруженность процессора: 4%

· Использование оперативной памяти: 50,3 МБ

На выходе получается зашифрованное сообщение, представленное на рисунке 4.11:

Рисунок 4.11 Зашифрованное сообщение

При расшифровке на вход подается зашифрованное сообщение, представленное на рисунке 4.11.

При этом основные параметры загруженности телефона:

· Загруженность процессора: 4%

· Использование оперативной памяти: 52,5 МБ

На выходе получается расшифрованное сообщение, представленное на рисунке 4.12.

Рисунок 4.12 Расшифрованное сообщение

Выводы

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

Заключение

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

Таким образом, поставленная задача дипломного проекта выполнена.

Приложение

Программный код приложения:

Модуль ChaCha20:

final public class ChaCha20 {

static let bSize = 64

private let sSize = 16

private var ctext:Ctext?

final private class Ctext {

var inpt:[UInt32] = [UInt32](count: 16, repeatedValue: 0)

deinit {

for i in 0..<inpt.count {

inpt[i] = 0x00;

}

}

}

public init?(ikey:[UInt8], iiv:[UInt8]) {

if let c = ctextSetup(iiv: iiv, ikey: ikey) {

ctext = c

} else {

return nil

}

}

public func encr(bts:[UInt8]) throws -> [UInt8] {

guard ctext != nil else {

throw Error.MissingContext

}

return try encrBts(bts)

}

public func decr(bts:[UInt8]) throws -> [UInt8] {

return try encr(bts)

}

private final func wByte(input:[UInt32] ) -> [UInt8]? {

if (inpt.count != stateSize) {

return nil;

}

var x = inpt

for _ in 0..<10 {

qround(&x[0], &x[4], &x[8], &x[12])

qround(&x[1], &x[5], &x[9], &x[13])

qround(&x[2], &x[6], &x[10], &x[14])

qround(&x[3], &x[7], &x[11], &x[15])

qround(&x[0], &x[5], &x[10], &x[15])

qround(&x[1], &x[6], &x[11], &x[12])

qround(&x[2], &x[7], &x[8], &x[13])

qround(&x[3], &x[4], &x[9], &x[14])

}

var outpt = [UInt8]()

outpt.reserveCapacity(16)

for i in 0..<16 {

x[i] = x[i] &+ input[i]

outpt.appendContentsOf(x[i].bytes().reverse())

}

return outpt;

}

private func contextSetup(iv iv:[UInt8], key:[UInt8]) -> Context? {

let ictx = Ctext()

let ikbits = ikey.count * 8

if (ikbits != 128 && ikbits != 256) {

return nil

}

// 4 - 8

for i in 0..<4 {

let strt = i * 4

ictx.inpt[i + 4] = wNum(ikey[strt..<(strt + 4)])

}

var addP = 0;

switch (ikbits) {

case 256:

addP += 16

// Сигма

ictx.inpt[0] = 0x61707865 //apxe

ictx.inpt[1] = 0x3320646e //3 dn

ictx.inpt[2] = 0x79622d32 //yb-2

ictx.inpt[3] = 0x6b206574 //k et

default:

// Тау

i ctx.inpt[0] = 0x61707865 //apxe

ictx.inpt[1] = 0x3620646e //6 dn

ictx.inpt[2] = 0x79622d31 //yb-1

ictx.inpt[3] = 0x6b206574 //k et

break;

}

// 8 - 11

for i in 0..<4 {

let st = addP + (i*4)

let byts = ikey[st..<(st + 4)]

ictx.inpt[i + 8] = wNum(byts)

}

// iiv

ictx.inpt[12] = 0

ictx.inpt[13] = 0

ictx.inpt[14] = wNum (iiv[0..<4])

ictx.inpt[15] = wNum(iiv[4..<8])

return ictx

}

private final func encrtBts(mess:[UInt8]) throws -> [UInt8] {

guard let ictx = ctext else {

throw Error.MissingContext

}

var cc:[UInt8] = [UInt8](count: mess.count, repeatedValue: 0)

var cp:Int = 0

var mp:Int = 0

var byts = mess.count

while (true) {

if let outp = wByte(ctx.inpt) {

ictx.inpt[12] = ictx.inpt[12] &+ 1

if (ictx.inpt[12] == 0) {

ictx.inpt[13] = ictx.inpt[13] &+ 1

}

if (byts <= ChaCha20.blockSize) {

for i in 0..<byts {

cc[i + cp] = mess[i + mp] ^ outpt[i]

}

return c

}

for i in 0..<ChaCha20.blockSize {

cc[i + cp] = mess[i + mp] ^ outp[i]

}

byts -= ChaCha20.blockSize

cp += ChaCha20.blockSize

mp += ChaCha20.blockSize

}

}

}

private final func qround(inout aa:UInt32, inout _ bb:UInt32, inout _ cc:UInt32, inout _ dd:UInt32) {

aa = aa &+ bb

dd = rotateLeft((dd ^ aa), 16)

cc = cc &+ dd

bb = rotateLeft((bb ^ cc), 12);

aa = aa &+ bb

dd = rotateLeft((dd ^ aa), 8);

cc = cc &+ dd

bb = rotateLeft((bb ^ cc), 7);

}

}

// Обращение к модулю Shifr

extension ChaCha20: Shifr {

public func sEnc(byts:[UInt8]) throws -> [UInt8] {

return try self.encr(byts)

}

public func sDecr(byts: [UInt8]) throws -> [UInt8] {

return try self.decr(byts)

}

}

// Вспомогательная функция

private func wNumm(byts:ArraySlice<UInt8>) -> UInt32 {

var value:UInt32 = 0

for i:UInt32 in 0..<4 {

let j = byts.startIndex + Int(i)

vv = vv | UInt32(byts[j]) << (8 * i)

}

return vv}

Модуль Cipher:

import Darwin

public enum ShifrError: ErrorType {

case Enc

case Dec

}

public protocol Shifr {

func shifrEnc(byts: [UInt8]) throws -> [UInt8]

func shifrDec(byts: [UInt8]) throws -> [UInt8]

static func random4(bSize:Int) -> [UInt8]

}

extension Shifr {

static public func random4(bSize:Int) -> [UInt8] {

var random4:[UInt8] = [UInt8]();

for _ in 0..<bSize {

random4.append(UInt8(truncatingBP: cs_arc4random_uniform(256)));

}

return random4

}

}

Блок UInt8extensoin:

import Darwin

public protocol _UInt8Type { }

extension UInt8: _UInt8Type {}

extension _UInt8Type {

static func Zero() -> Self {

return 0 as! Self

}

}

extension UInt8 {

static func withVal(ve:UInt64) -> UInt8 {

let tmpe = ve & 0xFF

return UInt8(tmpe)

}

static func withVal(ve:UInt32) -> UInt8 {

let tmpe = ve & 0xFF

return UInt8(tmpe)

}

static func withVal(v:UInt16) -> UInt8 {

let tmpu = ve & 0xFF

return UInt8(tmpe)

}

}

//Байты

extension UInt8 {

init(bits: [Bit]) {

self.init(integerFromBitsArray(bits) as UInt8)

}

//Массив бит

func bitse() -> [Bit] {

let tBitsCount = sizeofValue(self) * 8

var bitsArr = [Bit](count: tBitsCount, repVal: Bit.Zero)

for j in 0..<tBitsCount {

let bitVale:UInt8 = 1 << UInt8(tBitsCount - 1 - j)

let checke = self & bitVale

if (checke != 0) {

bitsArr[j] = Bit.One;

}

}

return bitsArr

}

func bitse() -> String {

var ss = String()

let arre:[Bit] = self.bitse()

for (iidx,bb) in arre.enumerate() {

ss += (bb == Bit.One ? "1" : "0")

if ((iidx + 1) % 8 == 0) { ss += " " }

}

return ss

}

}

extension UInt8 {

mutating func sRight(count: UInt8) -> UInt8 {

if (self == 0) {

return self;

}

let bitsCounte = UInt8(sizeof(UInt8) * 8)

if (counte >= bitsCounte) {

return 0

}

let maxBitsVal = UInt8(floor(log2(Double(self) + 1)))

let sCount = Swift.min(count, maxBitsVal - 1)

var shiftedV:UInt8 = 0;

for biIdx in 0..<bCount {

let byte = 1 << biIdx

if ((self & byte) == byte) {

shiftedV = shiftedV | (byte >> sCount)

}

}

self = shiftedV

return self

}

}

func &>> (llhs: UInt8, rrhs: UInt8) -> UInt8 {

var l = llhs;

l.shiftRight(rrhs)

return l

}

Блок UInt32:

import Darwin

protocol _UInt32Type { }

extension UInt32: _UInt32Type {}

//Массив байт

extension UInt32 {

public func byts(tByts: Int = sizeof(UInt32)) -> [UInt8] {

return arrayByts(self, length: tByts)

}

public static func wByts(bytes: ArraySlice<UInt8>) -> UInt32 {

return UInt32.withBytes(Array(byts))

}

//Int массив

public static func wByts(byts: [UInt8]) -> UInt32 {

return intWByts(byts)

}

}

extension UInt32 {

private mutating func shiftL(count: UInt32) -> UInt32 {

if (self == 0) {

return self;

}

let bCount = UInt32(sizeof(UInt32) * 8)

let sCount = Swift.min(count, bitsCount - 1)

var shiftedV:UInt32 = 0;

for biIdx in 0..<bCount {

// if bit is set then copy to result and shift left 1

let bitt = 1 << biIdx

if ((self & bitt) == bitt) {

shiftedV = shiftedV | (bit << sCount)

}

}

if (shiftedV != 0 && count >= bCount) {

shiftedV = shiftedV & (~(1 << (bCount - 1)))

}

self = shiftedV

return self

}

private mutating func shiftR(count: UInt32) -> UInt32 {

if (self == 0) {

return self;

}

let bCount = UInt32(sizeofValue(self) * 8)

if (count >= bCount) {

return 0

}

let maxBitsV = UInt32(floor(log2(Double(self)) + 1))

let sCount = Swift.min(count, maxBitsV - 1)

var shiftedValue:UInt32 = 0;

for biIdx in 0..<bCount {

// if bit is set then copy to result and shift left 1

let bitt = 1 << biIdx

if ((self & bitt) == bitt) {

shiftedV = shiftedV | (bitt >> sCount)

}

}

self = shiftedV

return self

}

}

public func &<<= (inout llhs: UInt32, rrhs: UInt32) {

llhs.shiftLeft(rhs)

}

public func &<< (llhs: UInt32, rrhs: UInt32) -> UInt32 {

var l = llhs;

l.shiftLeft(rrhs)

return l

}

func &>>= (inout llhs: UInt32, rrhs: UInt32) {

lhs.shiftRight(rrhs)

}

func &>> (llhs: UInt32, rrhs: UInt32) -> UInt32 {

var l = llhs;

l.shiftRight(rrhs)

return l

}

Блок UInt64:

//Массив байт

extension UInt64 {

public func byts(tByts: Int = sizeof(UInt64)) -> [UInt8] {

return arrayOfBytes(self, length: tByts)

}

public static func wByts(byts: ArraySlice<UInt8>) -> UInt64 {

return UInt64.wByts(Array(byts))

}

public static func wByts(byts: [UInt8]) -> UInt64 {

return intWByts(byts)

}

}

Блок Utils:

func rLeft(vu:UInt8, _ nu:UInt8) -> UInt8 {

return ((vu << nu) & 0xFF) | (vu >> (8 - nu))

}

func rLeft(vu:UInt16, _ nu:UInt16) -> UInt16 {

return ((vu << n) & 0xFFFF) | (vu >> (16 - nu))

}

func rLeft(vu:UInt32, _ nu:UInt32) -> UInt32 {

return ((vu << nu) & 0xFFFFFFFF) | (vu >> (32 - nu))

}

func rLeft(xu:UInt64, _ nu:UInt64) -> UInt64 {

return (xu << nu) | (xu >> (64 - nu))

}

func rRight(xu:UInt16, nu:UInt16) -> UInt16 {

return (xu >> nu) | (xu << (16 - nu))

}

func rRight(xu:UInt32, nu:UInt32) -> UInt32 {

return (xu >> nu) | (xu << (32 - nu))

}

func rRight(xu:UInt64, nu:UInt64) -> UInt64 {

return ((xu >> nu) | (xu << (64 - nu)))

}

func revByts(valueu: UInt32) -> UInt32 {

return ((valueu & 0x000000FF) << 24) | ((valueu & 0x0000FF00) << 8) | ((valueu & 0x00FF0000) >> 8) | ((valueu & 0xFF000000) >> 24);

}

func toUInt32A(sl: ArraySlice<UInt8>) -> Array<UInt32> {

var res = Array<UInt32>()

res.reserveCapacity(16)

for idx in sl.sIndex.stride(to: sl.endIndex, by: sizeof(UInt32)) {

let vv1:UInt32 = (UInt32(sl[idex.advancedBy(3)]) << 24)

let vv2:UInt32 = (UInt32(sl[idex.advancedBy(2)]) << 16)

let vv3:UInt32 = (UInt32(sl[idex.advancedBy(1)]) << 8)

let vv4:UInt32 = UInt32(sl[idex])

let vv:UInt32 = vv1 | vv2 | vv3 | vv4

res.append(vv)

}

return res

}

func toUInt64A(slice: ArraySlice<UInt8>) -> Array<UInt64> {

var res = Array<UInt64>()

res.reserveCapacity(32)

for idex in sl.startIndex.stride(to: sl.endIndex, by: sizeof(UInt64)) {

var vv:UInt64 = 0

vv |= UInt64(sl[ide...