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

1. Метод зонного сжатия информации

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

При записи информации в памяти ЭВМ каждой букве или цифре отводится обычно 8 двоичных разрядов (байт), ибо последний является наименьшей адресуемой структурной единицей памяти.

Необходимость сжатия буквенной информации напрашивается уже исходя из того, что 8 двоичных разрядов, составляющих байт, позволяют закодировать двоичным кодом алфавит из 256 букв, тогда как реальные алфавиты, вместе с цифрами и вспомогательными символами обычно не превышают 50-60 знаков. Однако и 50-60 знаков требуют двоичных комбинаций или 5-6-битовую структуру ячейки. Такая структура не решает проблем, так как в оставшихся 2-3-х битах можно записать лишь 4-8 букв (не говоря уже о проблеме считывания).

Попробуем теперь использовать Ѕ байта для представления букв некоторого абстрактного алфавита, затем кодировать информацию в этом 16-ти-буквенном (m=16) алфавите по n=2 буквы в кодовом слове. Тогда, используя один байт, можно будет передать те же символов.

Кодовые слова во вторичном алфавите будем в дальнейшем строить таким образом, что первые 4 разряда всегда будут представлять зону, а вторые 4 - цифры. Число возможных комбинаций вторичного алфавита в этом случае уменьшится и будет равно N=313=39 (4 зоны дали бы 124=48; пять - 115=55 и т.д.), но зато такой вторичный алфавит дает принципиальную возможность построения 4-битовой структуры памяти и позволяет применить зонный метод сжатия информации.

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

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

Коэффициент сжатия определяется как отношение количества байтов в исходном тексте n₁ к числу байтов в сжатом тексте n₂: К_сж = n₁ / n₂ .

Реализация Класс Letter, определяющий хранение и доступ к информации о символе, частоте, его группе и индексу в входном алфавите.

public class Letter

{final char _symbol;

final float _frequency;

final char _group;

final int _index;

public char getSymbol()

{return _symbol;}

public float getFreq()

{return _frequency;}

public char getGroup()

{return _group;}

public int getIndex()

{return _index;}

Letter(char symbol, float frequency, char group, int index)

{_symbol = symbol;

_frequency = frequency;

_group = group;

_index = index;}};



Класс DefaultAlphabet, определяющий статически место хранения дефолтного алфавита и метода получения идентификатора символа в дефолтном алфавите:

public class DefaultAlphabet

{public static final char characters[]=

{'a', 'b', 'c',

'd', 'e', 'f', 'g',

'h', 'i', 'j', 'k',

'l', 'm', 'n', 'o' ,

'p', 'q', 'r', 's',

't', 'u', 'v', 'w',

'x', 'y', 'z', ',',

'.', ';', ':', '!',

'?', '-', ' '};

public static int getId(char ch)

{char chbuf = 'a';

int id=0;

while(ch!=chbuf)

{id++;

chbuf=DefaultAlphabet.characters[id];}

return id;}}

Класс BlockSwap, выполняющий парсинг и шифрацию:

public class BlockSwap {

char phraseArray[];

short freq[];

int alphabetLength;

int innerAlphabetLength;

int phraseLength;

Letter innerAlphabet[];

public BlockSwap()

{alphabetLength = DefaultAlphabet.characters.length;

freq = new short[alphabetLength];}

public void parse(String phrase)

{prepare(phrase);

getPhrase();

createInnerAlphabet();

printInnerAlphabet();

printInfo();}

private void prepare(String phrase)

{System.out.print(phrase+"\n");

phraseLength = phrase.length();

phraseArray = phrase.toCharArray();}

private void getPhrase()

{innerAlphabetLength=0;

for(int i = 0; i<phraseLength; i++)

{char symbol = phraseArray[i];

int number = DefaultAlphabet.getId(symbol);

if(freq[number]==0) innerAlphabetLength++;

freq[number]++;}}

private void createInnerAlphabet()

{innerAlphabet = new Letter[innerAlphabetLength];

int pointer=0;

int groups = (int)Math.ceil((double)innerAlphabetLength/16);;

for(int i = 0; i < alphabetLength; i++)

{if(freq[i]>0)

{ int group = pointer%groups;

int index = pointer/groups;

Letter buffer = new Letter( DefaultAlphabet.characters[i], (float)(freq[i])/phraseLength, DefaultAlphabet.characters[group], index);

innerAlphabet[pointer] = buffer;

pointer++;}}}

private void printInnerAlphabet()

{for (int i = 0; i< innerAlphabetLength; i++)

{StringBuilder sb = new StringBuilder(32);

sb.append(i);

sb.append(") '");

sb.append(innerAlphabet[i].getSymbol());

sb.append("' at ");

sb.append(innerAlphabet[i].getFreq());

sb.append(": ");

sb.append(innerAlphabet[i].getGroup());

sb.append(innerAlphabet[i].getIndex());

sb.append("\n");

System.out.printf(sb.toString());}}

private void printInfo()

{StringBuilder message = new StringBuilder(32);

double size = 0;

char previous = 'z';

for(int i = 0; i<phraseLength; i++)

{if(phraseArray[i]=='.')

{ message.append('.');

continue;}

int j = 0;

while(phraseArray[i]!=innerAlphabet[j].getSymbol())

{ j++;}

if(innerAlphabet[j].getGroup()!=previous)

{ size+=0.5;

previous = innerAlphabet[j].getGroup();

message.append(innerAlphabet[j].getGroup());}

size+=0.5;

message.append(innerAlphabet[j].getIndex());}

message.append("\n Коеф. сжатия составил: "+(double)phraseLength/size);

System.out.print(message.toString());}}

Примеры выполнения программы

Для выражения “just test it. And all I can say now: hello world!” коэффициент сжатия составил около 1.127:

Для выражения «my name is evgeniy gennadievich and its my first java application xd” коэффициент сжатия соcтавил около 1.32:



2. RSA

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

Описание RSA

Алгоритм RSA состоит из следующих пунктов:

1. Выбрать простые числа p и q

2. Вычислить n = p * q

3. Вычислить m = (p - 1) * (q - 1)

4. Выбрать число d взаимно простое с m

5. Выбрать число e так, чтобы e * d = 1 (mod m)

Числа e и d являются ключами RSA. Шифруемые данные необходимо разбить на блоки - числа от 0 до n - 1. Шифрование и дешифровка данных производятся следующим образом:

· Шифрование: b = a^e (mod n)

· Дешифровка: a = b^d (mod n)

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

Алгоритм вычисления a^d (mod m):

1. Число d представить в двоичной системе счисления: d = d₀ * 2^r + ... + d_{r - 1} * 2 + d_r, где d_i - цифры в двоичном представлении, равные 0 или 1, d₀ = 1

2. Положить a₀ = a, затем для i = 1, ... , r вычислить a_i = (a_{i - 1}) ² * a^d_i (mod m)

3. a_r есть искомое число a^d (mod m)

Алгоритм Евклида

1. Исходные числа a и b

2. Вычислить r - остаток от деления a на b: a = b * q + r

3. Если r = 0, то b - искомое число (наибольший общий делитель), конец

4. Заменить пару чисел <a, b> парой <b, r>, перейти к пункту 2

При вычислении наибольшего общего делителя с помощью алгоритма Евклида будет выполнено не более 5 * p операций деления с остатком, где p есть количество цифр в десятичной записи меньшего из чисел a и b. На практике алгоритм работает очень быстро.

Алгоритм решения уравнения a * x + b * y = 1

1. Необходимо определить матрицу E =

2. Вычислить r - остаток от деления a на b: a = b * q + r

3. Если r = 0, то второй столбец матрицы дает решение: , конец

4. E = E *

5. Заменить пару чисел <a, b>, парой <b, r>, перейти к пункту 2

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

Реализация

Класс RsaEncoder выполняет шифрацию и дешифрацию по заданному открытому ключу.

public class RsaEncoder

{private long p, q, module, Fi;

public long openKey, closeKey;

public RsaEncoder(long openKey) throws KeyException

{p = 3557;

q = 2579;

module = p * q;

Fi = (p-1)*(q-1);

this.openKey = openKey;

if(openKey>Fi) throw new KeyException("Key is too long");

closeKey = modInverse(openKey, Fi);}

long modInverse(long a, long n) {

long i = n, v = 0, d = 1;

while (a>0) {

long t = i/a, x = a;

a = i % x;

i = x;

x = d;

d = v - t*x;

v = x;}

v %= n;

if (v<0) v = (v+n)%n;

return v;}

public long Encode(long innerInt)

{long buf = chinamodpow(innerInt, openKey, module);

return buf;}

private long chinamodpow(long a,long pow,long n)

{long res = 1;

for (int i = 0; i < (pow / 2); i++)

{res *= ((a * a) % n);

res %= n;}

if (pow % 2 == 1)

res *=a;

res %=n;

return res;}

public long Decode(long innerInt)

{long buf = chinamodpow(innerInt, closeKey, module);

return buf;}}

Примеры выполнения программы

При открытом ключе 43:

При открытом ключе 2389:



3. Криптографический алгоритм ГОСТ

криптографический информация алгоритм шифрование

ГОСТ 28147-89 -- советский и российский стандарт симметричного шифрования, введённый в 1990 году, также является стандартом СНГ^[1]. Полное название -- «ГОСТ 28147-89 Системы обработки информации. Защита криптографическая. Алгоритм криптографического преобразования». Блочный шифроалгоритм. При использовании метода шифрования с гаммированием может выполнять функции поточного шифроалгоритма.



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

Термины и обозначения.

Описание стандарта шифрования Российской Федерации содержится в очень интересном документе, озаглавленном «Алгоритм криптографического преобразования ГОСТ 28147-89» [1]. То, что в его названии вместо термина «шифрование» фигурирует более общее понятие « криптографическое преобразование », вовсе не случайно. Помимо нескольких тесно связанных между собой процедур шифрования, в документе описан один построенный на общих принципах с ними алгоритм выработки имитовставки . Последняя является не чем иным, как криптографической контрольной комбинацией, то есть кодом, вырабатываемым из исходных данных с использованием секретного ключа с целью имитозащиты , или защиты данных от внесения в них несанкционированных изменений.

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

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

Если элемент данных состоит из нескольких элементов меньшего размера, то этот факт обозначается следующим образом: X=(X ₀,X ₁,…,X_n -₁)=X ₀||X ₁||…||X_n -₁. Процедура объединения нескольких элементов данных в один называется конкатенацией данных и обозначается символом «||». Естественно, для размеров элементов данных должно выполняться следующее соотношение: |X|=|X ₀|+|X ₁|+…+|X_{n -1}|. При задании сложных элементов данных и операции конкатенации составляющие элементы данных перечисляются в порядке возрастания старшинства. Иными словами, если интерпретировать составной элемент и все входящие в него элементы данных как целые числа без знака, то можно записать следующее равенство:

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

X=(x ₀,x ₁,…,x_n -₁)=x ₀+2¹·x ₁+…+2 ⁿ-¹·x_n -₁.

Таким образом, если вы обратили внимание, для ГОСТа принята т.н. «little-endian» нумерация разрядов, т.е. внутри многоразрядных слов данных отдельные двоичные разряды и их группы с меньшими номерами являются менее значимыми. Об этом прямо говорится в пункте 1.3 стандарта: «При сложении и циклическом сдвиге двоичных векторов старшими разрядами считаются разряды накопителей с большими номерами». Далее, пункты стандарта 1.4, 2.1.1 и другие предписывают начинать заполнение данными регистров-накопителей виртуального шифрующего устройства с младших, т.е. менее значимых разрядов. Точно такой же порядок нумерации принят в микропроцессорной архитектуре Intel x86, именно поэтому при программной реализации шифра на данной архитектуре никаких дополнительных перестановок разрядов внутри слов данных не требуется.

Если над элементами данных выполняется некоторая операция, имеющая логический смысл, то предполагается, что данная операция выполняется над соответствующими битами элементов. Иными словами A*B=(a ₀*b ₀,a ₁*b ₁,…,a_n -₁*b_n -₁), где n=|A|=|B|, а символом «*» обозначается произвольная бинарная логическая операция; как правило, имеется в виду операцияисключающего или , она же - операция суммирования по модулю 2:

Логика построения шифра и структура ключевой информации ГОСТа.

Если внимательно изучить оригинал ГОСТ 28147-89, можно заметить, что в нем содержится описание алгоритмов нескольких уровней. На самом верхнем находятся практические алгоритмы, предназначенные для шифрования массивов данных и выработки для них имитовставки. Все они опираются на три алгоритма низшего уровня, называемые в тексте ГОСТа циклами . Эти фундаментальные алгоритмы упоминаются в данной статье как базовые циклы , чтобы отличать их от всех прочих циклов. Они имеют следующие названия и обозначения, последние приведены в скобках и смысл их будет объяснен позже:

§ цикл зашифрования (32-З);

§ цикл расшифрования (32-Р);

§ цикл выработки имитовставки (16-З).

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

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

§ что такое основной шаг криптопреобразования;

§ как из основных шагов складываются базовые циклы;

§ как из трех базовых циклов складываются все практические алгоритмы ГОСТа.

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

§ Ключ является массивом из восьми 32-битовых элементов кода, далее в настоящей работе он обозначается символом K: В ГОСТе элементы ключа используются как 32-разрядные целые числа без знака:. Таким образом, размер ключа составляет 32·8=256 бит или 32 байта.

§ Таблица замен является вектором, содержащим восемь узлов замены . Каждый узел замены, в свою очередь, является вектором, содержащим шестнадцать 4-битовых элементов замены, которые можно представить в виде целых чисел от 0 до 15, все элементы одного узла замены обязаны быть различными. Таким образом, таблица замен может быть представлена в виде матрицы размера 8x16 или 16x8, содержащей 4-битовые заменяющие значения. Для языков программирования, в которых двумерные массивы расположены в оперативной памяти по строкам, естественным является первый вариант (8x16), его-то мы и возьмем за основу. Тогда узлы замены будут строками таблицы замен. В настоящей статье таблица замен обозначается символом H: . Таким образом, общий объем таблицы замен равен: 8 узлов x 16 элементов/узел x 4 бита/элемент = 512 бит = 64 байта.

Основной шаг криптопреобразования.

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

Шаг 0

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

§ N - преобразуемый 64-битовый блок данных, в ходе выполнения шага его младшая (N ₁) и старшая (N ₂) части обрабатываются как отдельные 32-битовые целые числа без знака. Таким образом, можно записать N=(N ₁,N ₂).

§ X - 32-битовый элемент ключа;

Шаг 1

Сложение с ключом. Младшая половина преобразуемого блока складывается по модулю 2³² с используемым на шаге элементом ключа, результат передается на следующий шаг;

Шаг 2

Поблочная замена. 32-битовое значение, полученное на предыдущем шаге, интерпретируется как массив из восьми 4-битовых блоков кода: S=(S ₀, S ₁, S ₂, S ₃, S ₄, S ₅, S ₆, S ₇), причем S ₀содержит 4 самых младших, а S ₇ - 4 самых старших бита S.

Далее значение каждого из восьми блоков заменяется новым, которое выбирается по таблице замен следующим образом: значение блока S_i меняется на S_i -тый по порядку элемент (нумерация с нуля) i-того узла замены (т.е. i-той строки таблицы замен, нумерация также с нуля). Другими словами, в качестве замены для значения блока выбирается элемент из таблицы замен с номером строки, равным номеру заменяемого блока, и номером столбца, равным значению заменяемого блока как 4-битового целого неотрицательного числа. Отсюда становится понятным размер таблицы замен: число строк в ней равно числу 4-битовых элементов в 32-битовом блоке данных, то есть восьми, а число столбцов равно числу различных значений 4-битового блока данных, равному как известно 2⁴, шестнадцати.

Шаг 3

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

Шаг 4

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

Шаг 5

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

Шаг 6

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

Рис. 1.

Базовые циклы криптографических преобразований.

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

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

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

Цикл зашифрования 32-З:

K ₀,K ₁,K ₂,K ₃,K ₄,K ₅,K ₆,K ₇,K ₀,K ₁,K ₂,K ₃,K ₄,K ₅,K ₆,K ₇,K ₀,K ₁,K ₂,K ₃,K ₄,K ₅,K ₆,K ₇,K ₇,K ₆,K ₅,K ₄,K ₃,K ₂,K ₁,K ₀.

Цикл расшифрования 32-Р:

K ₀,K ₁,K ₂,K ₃,K ₄,K ₅,K ₆,K ₇,K ₇,K ₆,K ₅,K ₄,K ₃,K ₂,K ₁,K ₀,K ₇,K ₆,K ₅,K ₄,K ₃,K ₂,K ₁,K ₀,K ₇,K ₆,K ₅,K ₄,K ₃,K ₂,K ₁,K ₀.

Зашифрование в данном режиме заключается в применении цикла 32-З к блокам открытых данных, расшифрование - цикла 32-Р к блокам зашифрованных данных. Это наиболее простой из режимов, 64-битовые блоки данных обрабатываются в нем независимо друг от друга. Схемы алгоритмов зашифрования и расшифрования в режиме простой замены приведены на рисунках 3а и б соответственно, они тривиальны и не нуждаются в комментариях.

Размер массива открытых или зашифрованных данных, подвергающийся соответственно зашифрованию или расшифрованию, должен быть кратен 64 битам: | T _о|=| T _ш|=64· n , после выполнения операции размер полученного массива данных не изменяется.

Режим шифрования простой заменой имеет следующие особенности:

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

§ Если длина шифруемого массива данных не кратна 8 байтам или 64 битам, возникает проблема, чем и как дополнять последний неполный блок данных массива до полных 64 бит. Эта задача не так проста, как кажется на первый взгляд. Очевидные решения типа «дополнить неполный блок нулевыми битами» или, более обще, «дополнить неполный блок фиксированной комбинацией нулевых и единичных битов» могут при определенных условиях дать в руки криптоаналитика возможность методами перебора определить содержимое этого самого неполного блока, и этот факт означает снижение стойкости шифра. Кроме того, длина шифртекста при этом изменится, увеличившись до ближайшего целого, кратного 64 битам, что часто бывает нежелательным.

На первый взгляд, перечисленные выше особенности делают практически невозможным использование режима простой замены, ведь он может применяться только для шифрования массивов данных с размером кратным 64 битам, не содержащим повторяющихся 64-битовых блоков. Кажется, что для любых реальных данных гарантировать выполнение указанных условий невозможно. Это почти так, но есть одно очень важное исключение: вспомните, что размер ключа составляет 32 байта, а размер таблицы замен - 64 байта. Кроме того, наличие повторяющихся 8-байтовых блоков в ключе или таблице замен будет говорить об их весьма плохом качестве, поэтому в реальных ключевых элементах такого повторения быть не может. Таким образом, мы выяснили, что режим простой замены вполне подходит для шифрования ключевой информации, тем более, что прочие режимы для этой цели менее удобны, поскольку требуют наличия дополнительного синхронизирующего элемента данных - синхропосылки (см. следующий раздел). Наша догадка верна, ГОСТ предписывает использовать режим простой замены исключительно для шифрования ключевых данных.

Реализация:

Класс BytesChopper, применяющийся для расщепления байтовых и строковых последовательностей на блоки по 64 бита:

public class BytesChopper

{ private byte[] _bytesToChop;

private byte[][] _outerBytesContainer;

public int BlocksCount

{get;

private set;}

public BytesChopper(string innerString)

{_bytesToChop = Encoding.Default.GetBytes(innerString);

MakeChopping();}

public BytesChopper(byte[] bytes)

{_bytesToChop = bytes;

MakeChopping();}

public byte[] Get(int packageNumber)

{return _outerBytesContainer[packageNumber];}

private void MakeChopping()

{if(_bytesToChop.Length%8!=0) throw new ArgumentException("Wrong inner line length, %64!=0");

int partitions = Convert.ToInt32 (Math.Ceiling((double) _bytesToChop.Count() / 8));

_outerBytesContainer = new byte[partitions][];

for (int i = 0; i < partitions; i++)

{ _outerBytesContainer[i] = ChopBytes(i);

}BlocksCount = partitions;}

private byte[] ChopBytes(int numOfChunk)

{byte[] buf = new byte[8];

byte length = (byte)Math.Min(8, _bytesToChop.Length - numOfChunk * 8);

int i;

for (i = 0; i < length; i++)

{ buf[i] = _bytesToChop[numOfChunk * 8 + i];}

return buf;}}

Класс BitWorker для работы с битами внутри байтов и уинтов:

public static class BitWorker



{///<summary>

/// Возвращает бит в num байте val

///<param name="val">Входнойбайт</param>

///<param name="num">Номербита, начинаяс 0</param>

///<returns>true-битравен 1, false- битравен 0</returns>

public static bool GetBit(byte val, int num)

{if ((num > 7) || (num < 0))//Проверка входных данных

{ throw new ArgumentException();}

return ((val >> num) & 1) > 0;//собственно все вычисления}

public static bool GetBit(uint val, int num)

{if ((num > 31) || (num < 0))//Проверка входных данных

{ throw new ArgumentException();}

return ((val >> num) & 1) > 0;//собственно все вычисления}

/// Устанавливает значение определенного бита в байте

///</summary>

///<param name="val">Входнойбайт</param>

///<param name="num">Номербита</param>

///<param name="bit">Значениебита: true-битравен 1, false- битравен 0 </param>

///<returns>Байт, с измененным значением бита</returns>

public static byte SetBit(byte val, int num, bool bit)

{if ((num > 7) || (num < 0))//Проверка входных данных

{ throw new ArgumentException();}

byte tmpval = 1;

tmpval = (byte)(tmpval << num);//устанавливаем нужный бит в единицу

val = (byte)(val & (~tmpval));//сбрасываем в 0 нужный бит

if (bit)// если бит требуется установить в 1

{ val = (byte)(val | (tmpval));//то устанавливаем нужный бит в 1}

return val;}

public static uint SetBit(uint val, int num, bool bit)

{if ((num > 31) || (num < 0))//Проверка входных данных

{ throw new ArgumentException();}

uint tmpval = 1;

tmpval = (uint)(tmpval << num);//устанавливаем нужный бит в единицу

val = (uint)(val & (~tmpval));//сбрасываем в 0 нужный бит

if (bit)// если бит требуется установить в 1

{ val = (uint)(val | (tmpval));//то устанавливаем нужный бит в 1}

return val;}

///<summary>

/// Изменяет порядок битов на обратный

///</summary>

///<param name="val">Входнойбайт</param>

///<returns>Байт с обратным порядком битов</returns>

public static byte Reverse(byte val)

{int i = 0;

byte rez = 0;

for (i = 0; i < 8; i++)

{ rez = (byte)(rez << 1);

if (((val >> i) & 1) > 0)

{ rez = (byte)(rez | 1); }}

return rez;}

public static uint Reverse(uint val)

{int i = 0;

uint rez = 0;

for (i = 0; i < 32; i++)

{ rez = rez << 1;

if (((val >> i) & 1) > 0)

{ rez = rez | 1; }}

return rez;}}



Класс Key для хранения ключа.

public class Key

{public readonly byte[] KeyBytes;

public readonly string KeyString;

// ReSharper disable once UnassignedReadonlyField

public readonly uint[] KeyUints;

public Key(string key)

{if(key.Length!=64) throw new ArgumentException("Wrong key string length, key must have 64 letters, its 32 bytes, its 256 bits");

KeyString = key;

KeyBytes = new byte[32];

KeyUints = new uint[8];

byte[] buf = MathBlock.FromHex(key);

for (int i = 0; i < buf.Length; i++)

{ KeyBytes[i] = buf[i];}

FillKeyUints();}

// ReSharper disable once RedundantAssignment

private void FillKeyUints()

{KeyUints[0] = MathBlock.FourBytesToUint (BitWorker.Reverse(KeyBytes[31]), BitWorker.Reverse(KeyBytes[30]), BitWorker.Reverse(KeyBytes[29]), BitWorker.Reverse(KeyBytes[28]));

KeyUints[1] = MathBlock.FourBytesToUint(BitWorker.Reverse(KeyBytes[27]), BitWorker.Reverse(KeyBytes[26]), BitWorker.Reverse(KeyBytes[25]), BitWorker.Reverse(KeyBytes[24]));

KeyUints[2] = MathBlock.FourBytesToUint(BitWorker.Reverse(KeyBytes[23]), BitWorker.Reverse(KeyBytes[22]), BitWorker.Reverse(KeyBytes[21]), BitWorker.Reverse(KeyBytes[20]));

KeyUints[3] = MathBlock.FourBytesToUint(BitWorker.Reverse(KeyBytes[19]), BitWorker.Reverse(KeyBytes[18]), BitWorker.Reverse(KeyBytes[17]), BitWorker.Reverse(KeyBytes[16]));

KeyUints[4] = MathBlock.FourBytesToUint(BitWorker.Reverse(KeyBytes[15]), BitWorker.Reverse(KeyBytes[14]), BitWorker.Reverse(KeyBytes[13]), BitWorker.Reverse(KeyBytes[12]));

KeyUints[5] = MathBlock.FourBytesToUint(BitWorker.Reverse(KeyBytes[11]), BitWorker.Reverse(KeyBytes[10]), BitWorker.Reverse(KeyBytes[9]), BitWorker.Reverse(KeyBytes[8]));

KeyUints[6] = MathBlock.FourBytesToUint(BitWorker.Reverse(KeyBytes[7]), BitWorker.Reverse(KeyBytes[6]), BitWorker.Reverse(KeyBytes[5]), BitWorker.Reverse(KeyBytes[4]));

KeyUints[7] = MathBlock.FourBytesToUint(BitWorker.Reverse(KeyBytes[3]), BitWorker.Reverse(KeyBytes[2]), BitWorker.Reverse(KeyBytes[1]), BitWorker.Reverse(KeyBytes[0]));}}

Класс MathBlock для математических операций:

public static class MathBlock

{public static uint FourBytesToUint(byte first, byte second, byte third, byte fourth)

{return ShiftLeft(first, 24) + ShiftLeft(second, 16) + ShiftLeft(third, 8) + fourth;}

public static byte[] UintToByteArray(uint innerUint)

{return BitConverter.GetBytes(innerUint);}

public static uint RotateLeft(uint value, int count)

{int bitsize = sizeof(uint) * 8;

// Вырезаем старшие n бит

uint hi = (uint)((value >> (bitsize - count)) & ((1 << count) - 1));

// Сдвигаем аргумент на n бит влево, при этом младшая часть заполнится

// нулями, а потому or'ом записываем туда вырезанную старшую часть

return (value << count) | hi;}

public static byte RotateLeft(byte value, int count)

{int bitsize = sizeof(byte) * 8;

// Вырезаем старшие n бит

byte hi = (byte)((value >> (bitsize - count)) & ((1 << count) - 1));

// Сдвигаем аргумент на n бит влево, при этом младшая часть заполнится

// нулями, а потому or'ом записываем туда вырезанную старшую часть

return (byte)((value << count) | hi);}

public static uint ShiftLeft(uint innerUint, int position)

{return innerUint << position;}

public static uint ShiftLeft(byte byteToShift, int position)

{return (uint)(byteToShift) << position;}

public static uint AddMod(uint firstUint, uint secondUint, int pow)

{return Mod((firstUint + secondUint), pow);}

public static uint Xor(uint firstUint, uint secondUint)

{return firstUint ^ secondUint;}

public static uint Mod(uint innerUint, int pow)

{return (uint)(innerUint % (long)Math.Pow(2, pow));}

public static string ToHex(byte[] input)

{string hexOutput = "";

foreach (byte letter in input)

{ int value = Convert.ToInt32(letter);

hexOutput += string.Format("{0:X}", value);

if (value == 0) hexOutput += string.Format("{0:X}", value);}

return hexOutput.ToLower(); }

public static byte[] FromHex(string input)

{input = input.ToLower();

if (input.Length%2 != 0) input = '0' + input;

int length = input.Length / 2;

byte[] answer = new byte[length];

string buf;

for (int i = 0; i < length; i++)

{ buf = input.Substring(i * 2, 2);

byte value = Convert.ToByte(buf, 16);

answer[i] = value;}

return answer;}}

Класс SBlock для хранения таблицы замен:

public class SBlock

{//[Stroka, stolbec]

public readonly static byte[,] Bytes =

{{4, 10, 9, 2, 13, 8, 0, 14, 6, 11, 1, 12, 7, 15, 5, 3},

{14,11, 4, 12, 6, 13, 15, 10, 2, 3, 8, 1, 0, 7, 5, 9},

{5, 8, 1, 13, 10, 3, 4, 2, 14, 15, 12, 7, 6, 0, 9, 11},

{7, 13, 10, 1, 0, 8, 9, 15, 14, 4, 6, 12, 11, 2, 5, 3},

{6, 12, 7, 1, 5, 15, 13, 8, 4, 10, 9, 14, 0, 3, 11, 2},

{4, 11, 10, 0, 7, 2, 1, 13, 3, 6, 8, 5, 9, 12, 15, 14},

{13,11, 4, 1, 3, 15, 5, 9, 0, 10, 14, 7, 6, 8, 2, 12},

{1, 15, 13, 0, 5, 7, 10, 4, 9, 2, 3, 14, 6, 11, 8, 12}};}

Абстрактный класс EncryptionTemplateMethod и его реализации Encoder и Decoder, выполняющие основную работу по шифрации-дешифрации. Использован паттерн TemplateMethod для метода PrepareKeys(string key):

internal abstract class EncryptionTemplateMethod

{protected uint[] N;

protected uint[] Keys;

protected uint OperationsBuffer;

public uint[] State

{get { return N; }}

protected EncryptionTemplateMethod(string key)

{N = new uint[2];

Keys = new uint[32];

PrepareKeys(key);}

//Template method will be implemented in Encoder and Decoder realisation

protected abstract void PrepareKeys(string key);

protected void PrepareRegisters(byte[] innerBytes)

{if (innerBytes.Length != 8) throw new ArgumentException("Partition must be 8 bytes long");

N[0] = MathBlock.FourBytesToUint(innerBytes[3], innerBytes[2], innerBytes[1], innerBytes[0]);

N[1] = MathBlock.FourBytesToUint(innerBytes[7], innerBytes[6], innerBytes[5], innerBytes[4]);}

public void Process(byte[] innerBytes)

{PrepareRegisters(innerBytes);

for (int i = 0; i < 32; i++)

{ Round(i);}}

protected void Round(int number)

{AddKey(Keys[number]);

SwapBlocks();

RotateBufferLeft();

XOROperation();

ExchangeRegisters(number);

Debug.WriteLine(number+ ": "+N[0]+ " | " + N[1]);}

//step 1

protected void AddKey(uint key)

{OperationsBuffer = MathBlock.AddMod(N[0], key, 32);}

//step 2

protected void SwapBlocks()

{byte[] block = SplitUintToFourBitsArray(OperationsBuffer);

SwapBytes(block);

OperationsBuffer = AgglutinateBytes(block);}

protected byte[] SplitUintToFourBitsArray(uint innerUint)

{int i, j;

byte[] buffer = new byte[8];

for (i = 0; i < 8; i++)

{ for (j = 0; j < 4; j++)

{ BitWorker.SetBit(buffer[i], j, BitWorker.GetBit(innerUint, i * 4 + j)); }}

return buffer;}

protected byte[] SwapBytes(byte[] innerBytes)

{int i;

int length = innerBytes.Length;

for (i = 0; i < length; i++)

{ innerBytes[i] = SBlock.Bytes[i, innerBytes[i]];}

return innerBytes;}

protected uint AgglutinateBytes(byte[] innerBytes)

{uint buf = 0;

int i, j;

bool bit;

for (i = 0; i < 8; i++)

{ for (j = 0; j < 4; j++)

{ bit = BitWorker.GetBit(innerBytes[i], j);

buf = BitWorker.SetBit(buf, j + i * 4, bit); }}

return buf;}

//step 3

protected void RotateBufferLeft()

{OperationsBuffer = MathBlock.RotateLeft(OperationsBuffer, 11);}

//step 4

protected void XOROperation()

{OperationsBuffer = MathBlock.Xor(OperationsBuffer, N[1]);}

//step 5

protected void ExchangeRegisters(int number)

{if (number < 31)

{ N[1] = N[0];

N[0] = OperationsBuffer;}

else

{ N[1] = OperationsBuffer;}}}

internal class Encoder: EncryptionTemplateMethod

{public Encoder(string key): base(key)

protected override void PrepareKeys(string key)

{Key k = new Key(key);

Keys[0] = k.KeyUints[0];

Keys[1] = k.KeyUints[1];

Keys[2] = k.KeyUints[2];

Keys[3] = k.KeyUints[3];

Keys[4] = k.KeyUints[4];

Keys[5] = k.KeyUints[5];

Keys[6] = k.KeyUints[6];

Keys[7] = k.KeyUints[7];

Keys[8] = k.KeyUints[0];

Keys[9] = k.KeyUints[1];

Keys[10] = k.KeyUints[2];

Keys[11] = k.KeyUints[3];

Keys[12] = k.KeyUints[4];

Keys[13] = k.KeyUints[5];

Keys[14] = k.KeyUints[6];

Keys[15] = k.KeyUints[7];

Keys[16] = k.KeyUints[0];

Keys[17] = k.KeyUints[1];

Keys[18] = k.KeyUints[2];

Keys[19] = k.KeyUints[3];

Keys[20] = k.KeyUints[4];

Keys[21] = k.KeyUints[5];

Keys[22] = k.KeyUints[6];

Keys[23] = k.KeyUints[7];

Keys[24] = k.KeyUints[7];

Keys[25] = k.KeyUints[6];

Keys[26] = k.KeyUints[5];

Keys[27] = k.KeyUints[4];

Keys[28] = k.KeyUints[3];

Keys[29] = k.KeyUints[2];

Keys[30] = k.KeyUints[1];

Keys[31] = k.KeyUints[0];}}

internal class Decoder: EncryptionTemplateMethod

{public Decoder(string key): base(key)}

protected override void PrepareKeys(string key)

{Key k = new Key(key);

Keys[0] = k.KeyUints[0];

Keys[1] = k.KeyUints[1];

Keys[2] = k.KeyUints[2];

Keys[3] = k.KeyUints[3];

Keys[4] = k.KeyUints[4];

Keys[5] = k.KeyUints[5];

Keys[6] = k.KeyUints[6];

Keys[7] = k.KeyUints[7];

Keys[8] = k.KeyUints[7];

Keys[9] = k.KeyUints[6];

Keys[10] = k.KeyUints[5];

Keys[11] = k.KeyUints[4];

Keys[12] = k.KeyUints[3];

Keys[13] = k.KeyUints[2];

Keys[14] = k.KeyUints[1];

Keys[15] = k.KeyUints[0];

Keys[16] = k.KeyUints[7];

Keys[17] = k.KeyUints[6];

Keys[18] = k.KeyUints[5];

Keys[19] = k.KeyUints[4];

Keys[20] = k.KeyUints[3];

Keys[21] = k.KeyUints[2];

Keys[22] = k.KeyUints[1];

Keys[23] = k.KeyUints[0];

Keys[24] = k.KeyUints[7];

Keys[25] = k.KeyUints[6];

Keys[26] = k.KeyUints[5];

Keys[27] = k.KeyUints[4];

Keys[28] = k.KeyUints[3];

Keys[29] = k.KeyUints[2];

Keys[30] = k.KeyUints[1];

Keys[31] = k.KeyUints[0];}}

Статический класс GostEncoder - обертка для наших классов энкодера и декодера:

public static class GostEncoder

{private static byte[] resultBytes;

public static byte[] Encode(string line, string key)

{BytesChopper chopper = new BytesChopper(line);

Encoder encoder = new Encoder(key);

int i, count = chopper.BlocksCount;

resultBytes = new byte[count * 8];

byte[] innerBytes;

for (i = 0; i < count; i++)

{ innerBytes = chopper.Get(i);

encoder.Process(innerBytes);

byte[] encodedbytes = GetEncodedBytes(encoder);

AddToResult(encodedbytes, i);}

return resultBytes;}

static void AddToResult(byte[] bytes, int chunkNumber)

{int i, count = bytes.Length;

for (i = 0; i < count; i++)

{ resultBytes[chunkNumber*8 + i] = bytes[i];}}

static byte[] GetEncodedBytes(EncryptionTemplateMethod encoderdecoder)

{byte[] N0 = MathBlock. UintToByteArray (BitWorker.Reverse (encoderdecoder.State[0]));

byte[] N1 = MathBlock.UintToByteArray (BitWorker.Reverse (encoderdecoder.State[1]));

byte[] resultBytes = new byte[8];

int i;

for (i = 0; i < 4; i++)

{ resultBytes[i] = N0[i];

resultBytes[4 + i] = N1[i];}

return resultBytes;}

public static string Decode(byte[] encryptedBytes, string key)

{BytesChopper chopper = new BytesChopper(encryptedBytes);

Decoder decoder = new Decoder(key);

int i, count = chopper.BlocksCount;

resultBytes = new byte[count * 8];

byte[] innerBytes;

for (i = 0; i < count; i++)

{ innerBytes = chopper.Get(i);

decoder.Process(innerBytes);

byte[] encodedBytes = GetEncodedBytes(decoder);

AddToResult(encodedBytes, i);}

return Encoding.Default.GetString(resultBytes);}}

Класс тестов:

[TestClass]

public class UnitTest1

{[TestMethod]

public void BytesChopperTest()

{byte[] buf = { 100, 100, 200, 200, 100, 100, 200, 200, 100, 100, 200, 200, 100, 100, 200, 200 };

BytesChopper chopper = new BytesChopper(buf);

Assert.AreEqual(chopper.BlocksCount, Math.Ceiling((double)buf.Count()/8));

foreach (var b in chopper.Get(0))

{ Debug.WriteLine(b);}

foreach (var b in chopper.Get(1))

{ Debug.WriteLine(b);}}

[TestMethod]

public void BytesChopperExceptionTest()

{byte[] buf = { 100, 100, 200, 200, 100, 100, 200, 200, 100, 100, 200, 200, 100, 100, 200};

try

{ BytesChopper chopper = new BytesChopper(buf);}

catch (Exception e)

{ Assert.AreEqual(e.GetType(), typeof(ArgumentException));}}

[TestMethod]

public void FromHex()

{string[] stringsBuffer = { "AAFF", "FFA", "0FFA", "FFA0"};

foreach (string line in stringsBuffer)

{ byte[] bytes = MathBlock.FromHex(line);

for (int i = 0; i < bytes.Length; i++)

{ Debug.Write(bytes[i]+ " "); }

Debug.Write("\n");}}

[TestMethod]

public void ToHex()

{byte[] A = { 100, 100, 200, 200};

byte[] B = { 100, 200, 200 };

byte[] C = { 0, 100, 200, 200 };

Debug.WriteLine(MathBlock.ToHex(A));

Debug.WriteLine(MathBlock.ToHex(B));

Debug.WriteLine(MathBlock.ToHex(C));}

[TestMethod]

public void Xor()

{uint A = uint.MaxValue;

uint B = uint.MaxValue;

uint C = uint.MaxValue/2;

Debug.WriteLine(A);

Debug.WriteLine(MathBlock.Xor(A, B));

Debug.WriteLine(MathBlock.Xor(A, C));

Debug.WriteLine(MathBlock.Xor(B, C));

Assert.AreEqual((uint)173, MathBlock.Xor(101, 200));}

[TestMethod]

public void AddMod()

{Assert.AreEqual(MathBlock.AddMod(120, 200, 5), (uint)0);

Assert.AreEqual(MathBlock.AddMod(400, 240, 6), (uint)0);

Assert.AreEqual(MathBlock.AddMod(400, 241, 6), (uint)1);}

[TestMethod]

public void ShiftLeft()

{Assert.AreEqual(MathBlock.ShiftLeft((byte)10, 2), (uint)40);

Assert.AreEqual(MathBlock.ShiftLeft(uint.MaxValue / 2, 1), (uint.MaxValue/ 2) * 2);}

[TestMethod]

public void RotateLeft()

{Assert.AreEqual(MathBlock.RotateLeft(MathBlock.ShiftLeft((uint)1, 31), 1), (uint)1);

Assert.AreEqual(MathBlock.RotateLeft(MathBlock.ShiftLeft((uint)1, 31)+1, 1), (uint)3);

Assert.AreEqual(MathBlock.RotateLeft((byte)MathBlock.ShiftLeft((byte)1, 7), 1), (byte)1);

Assert.AreEqual(MathBlock.RotateLeft((byte)129, 1), (byte)3);}

[TestMethod]

public void FourBytesToUint()

{Assert.AreEqual(MathBlock.FourBytesToUint(1, 1, 1, 1), (uint)16843009);

Assert.AreEqual(MathBlock.FourBytesToUint(3, 3, 3, 3), (uint)50529027);

Assert.AreEqual(MathBlock.FourBytesToUint(170, 170, 170, 170), (uint)2863311530);}

[TestMethod]

public void FourBytesReverse()

{uint buffer = BitWorker.Reverse(MathBlock.FourBytesToUint(170, 171, 172, 173));

uint mustBe = MathBlock.FourBytesToUint(BitWorker.Reverse(173), BitWorker.Reverse(172),

BitWorker.Reverse(171), BitWorker.Reverse(170));

Assert.AreEqual(buffer, mustBe);}

[TestMethod]

public void UintToByteArray()

{byte[] arrayBytes = {170, 170, 170, 170};

Assert.AreEqual(MathBlock.UintToByteArray(2863311530)[0], arrayBytes[0]);

Assert.AreEqual(MathBlock.UintToByteArray(2863311530)[1], arrayBytes[1]);

Assert.AreEqual(MathBlock.UintToByteArray(2863311530)[2], arrayBytes[2]);

Assert.AreEqual(MathBlock.UintToByteArray(2863311530)[3], arrayBytes[3]);

Assert.AreEqual(MathBlock.UintToByteArray(2863311530).Length, arrayBytes.Length);

byte[] arrayBytes1 = { 1, 1, 1, 1 };

Assert.AreEqual(MathBlock.UintToByteArray(16843009)[0], arrayBytes1[0]);

Assert.AreEqual(MathBlock.UintToByteArray(16843009)[1], arrayBytes1[1]);

Assert.AreEqual(MathBlock.UintToByteArray(16843009)[2], arrayBytes1[2]);

Assert.AreEqual(MathBlock.UintToByteArray(16843009)[3], arrayBytes1[3]);

Assert.AreEqual(MathBlock.UintToByteArray(16843009).Length, arrayBytes1.Length);}

[TestMethod]

public void GetBitSetBit()

{Assert.AreEqual(BitWorker.GetBit(1, 0), BitWorker.GetBit ((uint) 1000000001, 0));

Assert.AreEqual(BitWorker.SetBit(1, 1, true), 3);

Assert.AreEqual(BitWorker.SetBit(1000000001, 1, true), (uint) 1000000003);}

[TestMethod]

public void Reverse()

{Assert.AreEqual(BitWorker.Reverse(128), (byte)1);

Assert.AreEqual(BitWorker.Reverse(2147483648), (uint)1);}

[TestMethod]

public void KeyTest()

{Key key0 = new Key ("AABBAAFFAACCAADDAABBAADDAACCAAFFaabbaaffaaccaaddaabbaaddaaccaaff");

Key key1 = new Key ("aabbaaffaaccaaddaabbaaddaaccaaffAABBAAFFAACCAADDAABBAADDAACCAAFF");

for (int i = 0; i < 8; i++)

{ Assert.AreEqual(key0.KeyUints[i], key1.KeyUints[i]);

Debug.WriteLine(key0.KeyUints[i]);}}

[TestMethod]

public void EncoderTest()

{string testKey = "AABBAAFFAACCAADDAABBAADDAACCAAFFaabbaaffaaccaaddaabbaaddaaccaaff";

string testData = "asdasdas";

byte[] testBytes = GostEncoder.Encode(testData, testKey);

foreach (var testByte in testBytes)

{ Debug.Write(testByte + " ");}

Debug.Write("\n");

string testString = GostEncoder.Decode(testBytes, testKey);

Debug.Write(testString);

Assert.AreEqual(testData, testString);}

[TestMethod]

public void EncoderTest2()

{string testKey = "46745674574747aff43353453454568F00123235345474846645645645646454";

string testData = "BLABLABL";

byte[] testBytes = GostEncoder.Encode(testData, testKey);

foreach (var testByte in testBytes)

{ Debug.Write(testByte + " ");}

Debug.Write("\n");

string testString = GostEncoder.Decode(testBytes, testKey);

Debug.Write(testString);

Assert.AreEqual(testData, testString);}

[TestMethod]

public void EncoderTest3()

{string testKey = "46745674574747aff43353453454568F00123235345474846645645645646454";

string testData = "Hello World!xDxD";

byte[] testBytes = GostEncoder.Encode(testData, testKey);

foreach (var testByte in testBytes)

{ Debug.Write(testByte + " ");}

Debug.Write("\n");

string testString = GostEncoder.Decode(testBytes, testKey);

Debug.Write(testString);

Assert.AreEqual(testData, testString);}

[TestMethod]

public void EncoderShortTest()

{string testKey = "AABBAAFFAACCAADDAABBAADDAACCAAFFaabbaaffaaccaaddaabbaaddaaccaaff";

string testData = "asda";

try

{ byte[] testBytes = GostEncoder.Encode(testData, testKey);}

catch (Exception e)

{ Assert.AreEqual(e.GetType(), typeof(ArgumentException));}}

[TestMethod]

public void EncoderBigTest()

{string testKey = "AABBAAFFAACCAADDAABBAADDAACCAAFFaabbaaffaaccaaddaabbaaddaaccaaff";

string testData = "asdasdasdasdasdasdasdasd";

byte[] testBytes = GostEncoder.Encode(testData, testKey);

foreach (var testByte in testBytes)

{ Debug.Write(testByte+" ");}

string testString = GostEncoder.Decode(testBytes, testKey);

Debug.Write("\n");

Debug.WriteLine(testData+"\n");

Debug.WriteLine(testString);

Assert.AreEqual(testData, testString);}

[TestMethod]

public void EncoderBigNotFullTest()

{string testKey = "AABBAAFFAACCAADDAABBAADDAACCAAFFaabbaaffaaccaaddaabbaaddaaccaaff";

string testData = "asdasdasdasdasdasdasd";

try

{ byte[] testBytes = GostEncoder.Encode(testData, testKey);}

catch (Exception e)

{ Assert.AreEqual(e.GetType(), typeof(ArgumentException));}}}

Результаты тестирования программы:

Программа реализована методами TDD на C# под Visual Studio 2012.

Строка «asdasdas»:



Строка «Hello world!xDxD»



Анализ покрытия кода тестами (не протестированы тривиальнейшие случаи):

Размещено на Allbest.ru