КРИПТОСИСТЕМЫ МАК-ЭЛИСА И НИДЕРРАЙТЕРА В АТАКАХ ДЕКОДИРОВАНИЯ КЛАССИЧЕСКОЙ ИНФОРМАЦИИ

На протяжении многих лет коды с исправлением ошибок занимают важное место в криптографии. Фактически, в 1978 году, всего через пару лет после публикации новаторской работы Диффи и Хеллмана об использовании закрытых и открытых ключей, Мак-Элис предложил криптосистему с открытым ключом, основанной на теории алгебраического кодирования которые показали очень высокий уровень безопасности. Обоснование системы Мак-Элиса, которая принимает генераторную матрицу в качестве личного ключа и преобразованную версию ее в качестве открытого ключа, заключается в трудности декодирования большого линейного кода без видимой структуры, которая на самом деле, как известно, является сложная проблема [1].

Оригинальная криптосистема Мак-Элиса до сих пор не сломлена, в том смысле, что не было найдено никакого алгоритма полиномиального времени для реализации атаки. Более того, система на два-три порядка быстрее, чем конкурирующие решения, такие как RSA. Несмотря на это, меньше внимания уделялось криптосистеме Мак-Элиса по сравнению с другими решениями по двум основным причинам: большой размер ее открытых ключей и ее низкая скорость передачи информации (то есть около 0,5). Фактически, оригинальная криптосистема Мак-Элиса требует открытых ключей с размером порядка нескольких тысяч байтов, в то время как более распространенные решения, такие как RSA, работают с открытыми ключами размером менее одной тысячи байтов. Кроме того, криптосистема Мак-Элиса добавляет избыточность во время шифрования, поэтому шифротексты длиннее, чем соответствующие им открытые тексты [2].

Семейство линейных блочных кодов, известных как коды Гоппа, было введено Гоппой в семидесятых. Многие хорошие алгебраические коды определены как подполевые подкоды обобщенных кодов Рида-Соломона (GRS). Эти коды известны как альтернативные коды и включают в себя коды Бозе-Чаудхури-Хоккенгема (BCH) и коды Гоппы. Данный:

• степень-t полином , and
• набор из n элементов , которые не являются нулями ,

код Гоппы, способный исправить ошибки t, определяется как набор векторов такой, что изображен на рисунке 1:

Рисунок 1. Код Гоппы, способный исправить ошибки

Набор {α₀, α₁,…, α_n-1} называется поддержка кода. Если g(x) неприводимо, то код называется неприводимым кодом Гоппы. В этом случае поддержка кода может содержать все элементы GF(p^m)и код может иметь максимальную длину ^..

Любой неприводимый многочлен степени t генерирует другой неприводимый код, поэтому число различных неприводимых кодов Гоппа с фиксированными параметрами и способностью исправления очень велико. В качестве примера приведем число неприводимых кодов Гоппа с n = 1,024, k= 524 и t=50 близко к 2⁵⁰⁰это впечатляюще высокое число. Алгоритм Паттерсона, работающий во времени O(n * t) обеспечивает быстрый алгоритм декодирования для кодов Гоппа и требует знания полинома g(x) и поддержки кода. Генераторная матрица кода, эквивалентного перестановке, не раскрывает эти параметры, и не существует эффективного алгоритма для извлечения их из такой генераторной матрицы. Следовательно, коды Гоппы удовлетворяют всем вышеупомянутым свойствам, в то время как другие семейства кодов оказались неспособными достичь этой цели. Среди них коды GRS и некоторые типы составных кодов. С другой стороны, характеристические матрицы кодов Гоппы неструктурированы. Фактически матрица проверки четности кода Гоппы имеет следующий вид как на рисунке 2 [3]. который не дает никакой внутренней структуры, которая могла бы облегчить его хранение. Следовательно, для хранения целой матрицы этого типа нам нужно r * n бит.

В 1986 году Харальд Нидеррайтер предложил модификацию криптосисте­мы Мак-Элиса, которая получила название криптосистемы Нидеррайте­ра. Криптосистема Мак-Элиса и криптосистема Нидеррайтера, постро­енные на основе одних и тех же кодов, например, кодов Гоппы, с точки зрения стойкости являются эквивалентными.

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

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

Далее, абонент A должен сформировать открытый и закрытый ключи, и передать свой открытый ключ абоненту B по открытому каналу, чтобы B зашифровал свое сообщение. Рассмотрим этапы работы криптосистемы подробнее [4].

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

Открытым ключом является пара

 (1.1)

где H – порождающая матрица кода, закрытым ключом является тройка

 (1.2)

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

Таким образом, если абонент B хочет отправить зашифрованное сообщение, он должен представить его в виде последовательности m длины n и с весом, не превышающем t, или разбить исходный текст на несколько таких последовательностей.

Затем абонент B вычисляет зашифрованное сообщение по формуле:

 (1.3)

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

Участник A, получив зашифрованное сообщение, вычисляет

 (1.4)

Обозначим . Вес  совпадает с весом  и не превышает t, так как P – матрица перестановок. Используя алгоритм декодирования для кода C, абонент A находит , и вычисляет исходное сообщение по формуле:

. (1.5)

К преимуществам криптосистемы Нидеррайтера можно также отнести высокую скорость шифрования и расшифровывания. Так, например, по сравнению с RSA, скорость шифрования выше приблизительно в 50 раз, а дешифрования — в 100 раз.

Также следует отметить меньший, чем у системы Мак-Элиса, размер открытого ключа. Но все же этот размер превосходит классические криптосистемы с открытым ключом.

В данной криптосистеме, в отличие от криптосистемы Мак-Элиса, не используются случайные параметры. Таким образом, результат шифрования одного и того же текста будет одинаковым. Этот факт позволяет использовать именно систему Нидеррайтера, а не Мак-Элиса, для создания электронно-цифровой подписи. К недостаткам криптосистемы можно отнести необходимость разработки алгоритма перевода исходного сообщения в q-арный вектор длиной n веса не более t, а также большой размер получаемого шифротекста [5].

Криптосистема Мак-Элиса — одна из старейших криптосистем с открытым ключом. Она была предложена в 1978 Р. Дж. Мак-Эли­сом. Алгоритм основан на сложности декодирования полных линейных кодов. Основная идея построения криптосистемы состоит в маскировке некоторого линейного кода, имеющего эффек­тивные алгоритмы декодирования, под код, не обладающий видимой алгебраической и комбинаторной структурой. Такие коды принято на­зывать кодами общего положения. Предполагается, что декодирование кода общего положения является трудной задачей. Не зная структуры кода, невозможно построить эффективный алгоритм декодирования та­кого кода. Именно эта идея и заложена в конструкции криптосистемы, предложенной Р. Дж. Мак-Элисом.

Для использования криптосистемы абоненты выбирают линейный (n, k, d) – код C с порождающей матрицей G, гарантированно исправляющий t ошибок. Этот код называется базовым кодом шифросистемы.

Протокол взаимодействия абонентов (для удобства обозначим их A и B) состоит из 3-х этапов:

• Генерация открытого и секретного ключей.
• Шифрование сообщения.
• Расшифровывание сообщения.

Рассмотрим каждый из этих пунктов подробнее. Допустим, что абонент B хочет отправить зашифрованное сообщение абоненту A. Тогда абонент A выбирает код C и его порождающую матрицу, а затем генерирует открытый и закрытый ключи. Закрытым ключом является тройка , где  - случайная невырожденная матрица,  - перестановочная матрица. Перестановочная матрица должна подбираться таким образом, чтобы в каждой строке и каждом столбце была только одна единица, а все остальные элементы – нули. Таким образом,

 (1.6)

В качестве открытого ключа выступает произведение матриц . После того, как ключи были сгенерированы, абонент A передает получателю свой открытый ключ по общедоступному каналу.

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

 , (1.7)

где  – вектор длины k, содержащий секретную информацию;  – секретный вектор ошибок, который случайно и равновероятно выбирается абонентом B среди всех векторов веса не выше ??;  – открытый ключ. Абонент А, получив вектор , вычисляет обратную матрицу , и строит вектор , который отличается от вектора  не более чем в t разрядах. Затем с помощью любого алгоритма декодирования кода С абонент A находит вектор , который удовлетворяет условию: , при этом .

Секретная информация, посланная абонентом B, восстанавливается в виде

 (1.8)

Криптосистема Мак-Элиса, как и все другие известные кодовые криптосистемы, обладает одним важным преимуществом — высокой скоростью шифрования и расшифровывания. К недостаткам же можно отнести слишком большой размер открытого ключа. Так, например, при использовании кодов Гоппы с параметрами, предложенными Мак-Элисом (n=1024, k=524, t=50), открытый ключ составляет  бит. Также следует отметить тот факт, что зашифрованное сообщение гораздо длиннее исходного. Эта особенность накладывает дополнительные затраты на передачу данных. Для данной криптосистемы, использующей наиболее известные помехоустойчивые коды, были придуманы атаки различной степени эффективности. Большинство из них сводятся к попыткам построить декодер для кода, заданного открытым ключом . Если такая попытка окажется успешной, злоумышленник сможет получить закрытый ключ, что будет равнозначно полному взлому криптосистемы [6].

Перед тем, как приступать к выбору языка программирования, нужно выяснить, какими отличительными особенностями будет обладать разрабатываемое программное средство. Так, оно должно иметь пользовательский интерфес, ориентированный на удобство и безопасность работы клиента, а также обеспечивать клиентско-серверное взаимодействие посредством сокетов. Так как разработка программы подразумевает самостоятельную реализацию алгоритмов шифрования, не последнюю роль играет удобство работы со структурами данных и строками. Первые две особенности можно реализовать средствами практически любого современного языка программирования. Например, C++ предоставляет возможность использования около десятка библиотек для создания графического интерфейса, а также встроенный модуль для программирования сокетов. C# имеет еще больше возможностей по созданию и отрисовке графического интерфейса, так как в его библиотеке изначально имеются классы для работы с формами и геометрическими объектами. Но все же для разработки данного программного средства предпочтительнее выбрать динамически типизированный язык, и не настолько объектно-ориентированный, как C#, в котором каждая функция должна описываться как метод какого-либо класса. В данном случае это будет избыточно [7].

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

Реализация каждой криптосистемы содержится в отдельном проекте. Для этого в среде разработки было создано решение, объединяющее в себе два проекта – McEliece и Niederreiter, в которых реализованы соответствующие криптосистемы. Каждый проект содержит несколько подключаемых модулей, которые будут описаны ниже. Структура решения показана на рисунке 3.

Рисунок 3 – Общая структура решения

Файлы Generate_Matrixes.py и Convert.py являются общими для двух проектов. В первом содержатся такие функции, как формирование случайной невырожденной матрицы S и матрицы перестановок P, а также генерация проверочной матрицы двоичного кода Хэмминга (для криптосистемы Нидеррайтера), перевод ее в систематический вид и генерация порождающей матрицы (для криптосистемы Мак-Элиса). В файле Convert.py содержатся функции для перевода текста в двоичную последовательность и обратно. В проекте с криптосистемой Мак-Элиса запускаемым является файл McEliece.py. В нем описаны сами функции шифрования и расшифровывания. В файле Hamming_Decoder.py описан декодер по минимуму расстояния Хэмминга.

При запуске проекта пользователю будет предложено ввести параметр r кода Хэмминга, затем будут посчитаны параметры n, k и будет сгенерирована сначала проверочная матрица кода в систематическом виде, а затем из нее будет получена порождающая матрица в систематическом виде и сгенерированы ключи.

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

Работа программы показана на рисунке 4.

Рисунок 4 – работа криптосистемы Мак-Элиса

В проекте с криптосистемой Нидеррайтера запускаемый файл – Niederreiter.py. В нем содержатся функции шифрования и дешифрования. Содержание файлов Convert.py и Generate_Matrixes.py было описано выше. Последовательность операций при запуске программы аналогична описанной ранее, за исключением процесса шифрования. В данном случае шифрование происходит посимвольно. Если нужно зашифровать 0, то выбирается вектор ошибки, в котором единица стоит на четной позиции. Если же нужно зашифровать 1, то выбирается вектор ошибки с единицей на нечетной позиции. В обоих случаях сама позиция выбирается случайным образом.

Результат работы программы показан на рисунке 5.

При дешифровке это также учитывается: если в дешифрованном векторе индекс единицы четный, значит был зашифрован 0; в противном случае – 1.

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

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

При достижении поставленной цели были выполнены следующие задачи:
изучены теоретические аспекты кодов Гоппы;

исследованы помехоустойчивые коды и криптосистемы Мак-Элиса и Нидеррайтера;

рассмотрены возможные алгоритмы реализации;

реализованы криптосистемы Мак-Элиса и Нидеррайтера;

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

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

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

import numpy as np

def get_check_matrix(r, n):
H_T = []
for i in range(1, n + 1):
H_T.append([int(elem) for elem in '{:0{}b}'.format(i, r)])
return np.array(H_T, dtype=’uint8′).transpose()

def get_S_matrix(dim):
while True:
S_matrix = np.random.random_integers(0, 1, (dim, dim))
if np.linalg.det(S_matrix) % 2 == 1:
return S_matrix.astype(‘uint8′)

def get_P_matrix(n):
P_matrix = []
indexes = np.random.permutation(n)
for index in indexes:
P_matrix.append([1 if i == index else 0 for i in range(n)])
return np.array(P_matrix, dtype=’uint8′)

def get_Hsys(H, n, k):
H_T_list = H.transpose().tolist()
for i in range(n – k):
H_T_list.append(H_T_list.pop(H_T_list.index([1 if j == i else 0 for j in range(n - k)])))
return np.array(H_T_list, dtype=’uint8′).transpose()

def get_Gsys(Hsys, n, k):
Hsys_T_list = Hsys.transpose().tolist()
Hsys_T_list = Hsys_T_list[:k]
P_part = np.array(Hsys_T_list, dtype=’uint8′)
E_part = np.eye(k, dtype=’uint8′)
return np.hstack((E_part, P_part))

def text_to_bin(text):
return ”.join(map(lambda x: ‘{:016b}’.format(ord(x)), text))

def bin_to_text(bin):
symbols = []
for i in range(len(bin) // 16):
symb = bin[:16]
symbols.append(chr(int(symb, 2)))
bin = bin[16:]
return ”.join(symbols)

import numpy as np

def get_code_words(k, G):
code_words = []
for i in range(2**k):
info_word = ‘{:0{}b}’.format(i, k)
info_word = tuple(map(lambda x: int(x), info_word))
code_words.append(np.dot(info_word, G).astype(‘uint8′) % 2)
return code_words

def decode(v, G, k):
code_words = get_code_words(k, G)
index = 0
d_min = ((v + code_words[0]) % 2).tolist().count(1)
for i in range(1, len(code_words)):
d = ((v + code_words[i]) % 2).tolist().count(1)
if d < d_min:
d_min = d
index = i
info_word = ‘{:0{}b}’.format(index, k)
info_word = list(map(lambda x: int(x), info_word))
return np.array(info_word, dtype=’uint8′)

import sys
sys.path.append(‘C:\\Users\\Admin\\source\\repos\\Course_Task\\Niederreiter_Cryptosystem’)
from Generate_Matrixes import *
import numpy as np
from random import sample
from Hamming_Decoder import decode
from Convert import *

def encrypt(plain_text, open_key, n, k):
error_vectors = [[0 for i in range(n)]]
error_vectors.extend([[1 if j == i else 0 for j in range(n)] for i in range(n)])
cipher_bin = []

while len(plain_text) % k != 0:
plain_text += chr(0×00)

plain_bin = text_to_bin(plain_text)
for i in range(len(plain_bin) // k):
a_bin = plain_bin[:k]
plain_bin = plain_bin[k:]
a = np.array(list(map(lambda x: int(x), a_bin)), dtype = ‘uint8′)
e = sample(error_vectors, 1)[0]
b = (np.dot(a, open_key) + e).astype(‘uint8′) % 2
b_bin = ”.join(map(lambda x: ‘{}’.format(x), b))
cipher_bin.append(b_bin)
cipher_bin = ”.join(cipher_bin)
cipher_text = bin_to_text(cipher_bin)
return cipher_text

def decrypt(cipher_text, priv_key, Gsys, n):
inv_S = np.linalg.inv(priv_key[0]).astype(‘uint8′) % 2
inv_P = np.linalg.inv(priv_key[1]).astype(‘uint8′) % 2
cipher_bin = text_to_bin(cipher_text)
plain_bin = []

for i in range(len(cipher_bin) // n):
b_bin = cipher_bin[:n]
cipher_bin = cipher_bin[n:]
b = np.array(list(map(lambda x: int(x), b_bin)), dtype=’uint8′)
b_ = np.dot(b, inv_P) % 2
a_ = decode(b_, Gsys, Gsys.shape[0])
a = np.dot(a_, inv_S) % 2
a_bin = ”.join(map(lambda x: ‘{}’.format(x), a))
plain_bin.append(a_bin)

plain_bin = ”.join(plain_bin)
plain_text = bin_to_text(plain_bin)
return plain_text

if __name__ == ‘__main__’:
r = int(input(‘Введите параметр r: ‘))
n = 2**r – 1
k = 2**r – 1 – r
H = get_check_matrix(r, n)
Hsys = get_Hsys(H, n, k)
Gsys = get_Gsys(Hsys, n, k)
S = get_S_matrix(k)
P = get_P_matrix(n)
priv_key = (S, P)
open_key = np.dot(S, Gsys) % 2
np.dot(open_key, P, out=open_key)
open_key %= 2
plain_text = input(‘\nВведите открытый текст: ‘)
cipher_text = encrypt(plain_text, open_key, n, k)
print(‘\nЗашифрованный текст: {}’.format(cipher_text))
plain_text = decrypt(cipher_text, priv_key, Gsys, n).rstrip(chr(0×00))
print(‘\nРасшифрованный шифротекст: {}\n’.format(plain_text))

import numpy as np
from Generate_Matrixes import *
from Convert import *
from random import sample

def encrypt(plain_text, Hpub, n):
Hpub_T = Hpub.transpose()
plain_bin = text_to_bin(plain_text)
odd_indexes = [i for i in range(0, n, 2)] #четные
even_indexes = [i for i in range(1, n, 2)] #нечетные
cipher_bin = []

for symb in plain_bin:
if symb == ’0′:
index_1 = sample(odd_indexes, 1)[0]
else:
index_1 = sample(even_indexes, 1)[0]
m = [1 if i == index_1 else 0 for i in range(n)]
c = np.dot(m, Hpub_T).astype(‘uint8′) % 2
c_bin = ”.join(map(lambda x: ‘{}’.format(x), c))
cipher_bin.append(c_bin)

cipher_bin = ”.join(cipher_bin)
cipher = bin_to_text(cipher_bin)
return cipher

def decrypt(cipher, H, P, inv_S, r):
inv_S_T = inv_S.transpose()
H_T = H.transpose().tolist()
P_T_inv = np.linalg.inv(P.transpose()).astype(‘uint8′) % 2
cipher_bin = text_to_bin(cipher)
plain_bin = []
for i in range(len(cipher_bin) // r):
c_bin = cipher_bin[:n - k]
cipher_bin = cipher_bin[n - k:]
c = np.array(list(map(lambda x: int(x), c_bin)), dtype=’uint8′)
s = np.dot(c, inv_S_T) % 2
index_1 = H_T.index(s.tolist())
m_ = np.array([1 if i == index_1 else 0 for i in range(n)], dtype=’uint8′)
m = (np.dot(m_, P_T_inv) % 2).tolist()
if m.index(1) % 2 == 0:
plain_bin.append(’0′)
else:
plain_bin.append(’1′)
plain_bin = ”.join(plain_bin)
plain_text = bin_to_text(plain_bin)
return plain_text

if __name__ == ‘__main__’:
r = int(input(‘Введите r: ‘))
n = 2**r – 1
k = 2**r – 1 – r
H = get_check_matrix(r, n)
S = get_S_matrix(n-k)
P = get_P_matrix(n)
Hpub = np.dot(S, H) % 2
Hpub = np.dot(Hpub, P) % 2
inv_P = np.linalg.inv(P).astype(‘uint8′) % 2
inv_S = np.linalg.inv(S).astype(‘uint8′) % 2
priv_key = (inv_S, H, inv_P)

plain_text = input(‘\nВведите октрытый текст: ‘)
cipher_text = encrypt(plain_text, Hpub, n)
print(‘\nШифротекст: {}’.format(cipher_text.encode(‘utf-8′, errors=’replace’).decode()))
plain_text = decrypt(cipher_text, H, P, inv_S, r)
print(‘\nРасшифрованный текст: {}\n’.format(plain_text))

Библиографический список

1. Адаменко, Михаил Основы классической криптологии. Секреты шифров и кодов / Михаил Адаменко. – Москва: Машиностроение, 2014. – 256 c.
2. Бабаш, А. В. История криптографии. Часть I / А.В. Бабаш, Г.П. Шанкин. – М.: Гелиос АРВ, 2002. – 240 c.
3. Деундяк В.М., Маевский А.Э., Могилевская Н.С. Методы помехоустойчивой защиты данных: учебник / В.М. Деундяк, А.Э Маевский, Н.С. Могилевская. – Ростов н/Д: Издательство Южного федерального университета, 2014. – 309 с.
4. Баричев, С. Г. Основы современной криптографии / С.Г. Баричев, В.В. Гончаров, Р.Е. Серов. – Москва: СИНТЕГ, 2011. – 176 c.
5. Чижов, И.В. Пространство ключей криптосистемы Мак-Элиса – Сидельникова: автореферат / И.В. Чижов. – М.: МГУ, 2010. – 20 с.
6. Герман, О. Н. Теоретико-числовые методы в криптографии / О.Н. Герман, Ю.В. Нестеренко. – М.: Академия, 2012. – 272 c.
7. Горев, А И; Симаков А А Обеспечение Информационной Безопасности / А Горев А И; Симаков А. – Москва: Мир, 2005. – 844 c.

---

Количество просмотров публикации: Please wait

Все статьи автора «Гордов Никита Алексеевич»