Maksim

README.md

@@ -2,13 +2,13 @@
 =========================
 
 *Комбинирующий генератор (G)* - криптографический объект, который генерирует некоторую псевдослучайную последовательность.
-Именено его мы и будем пытаться атаковать. Для начала нам следует реализовать сам генератор.
+Именно его мы и будем пытаться атаковать. Для начала нам следует реализовать сам генератор.
 
 Замечу, что я сделал несколько конкретизаций:
 1) Длина РСЛОС может быть любая, я же принял длину всех РСЛОС в 16 ячейки памяти;
 2) Функция f может иметь достаточно сложную структуру, я же предлагаю рассматривать функцию, определенную для генератора Геффе.
 
-Булева функция, для него имеет вид: `(x1 * x2) ^ ((x1 ^ 1) * x3)`
+Булева функция для него имеет вид: `(x1 * x2) ^ ((x1 ^ 1) * x3)`
 
 	                    Таблица истинности:	
 	x1	x2	x3		(x1 * x2) ^ ((x1 ^ 1) * x3)
@@ -21,22 +21,23 @@
 	1	1	0		            1
 	1	1	1		            0
 
-Следовательно, корреляция с гаммой будет наблюдаться только для последоваательней, возвращаемых вторым и третьим регистром 
+Из таблицы истинности легко увидеть, что вероятность совпадения значений `x1` и `(x1 * x2) ^ ((x1 ^ 1) * x3)` составляет 0.5.
+Для `x2` и `x3` эта вероятность составит 0.75. Следовательно, значимая корреляция с гаммой будет наблюдаться только для последовательностей, возвращаемых вторым и третьим регистром, так как корреляция с гаммой последовательности, возвращаемой первым регистром, будет не отличима от корреляции с гаммой любой случайной последовательнсти.
 
 
 Функция: createG() // создание G 
 --------------------------  
 
 *Вход:*  пустой 
 
-*Выход:* `G` // комбирирующий генератор
+*Выход:* `G` // комбинирующий генератор
 
 
 G представляет собой структуру / класс и состоит из:
 
     uint8_t N;     // количество РСЛОС в G	
 	uint16_t r[N]; // реверснутые полиномы обратной связи для РСЛОС
-	uint16_t a[N]; // начальные состония РСЛОС	
+	uint16_t a[N]; // начальные состояния РСЛОС	
 
 
     1. N <- 3;
@@ -49,7 +50,7 @@ G представляет собой структуру / класс и сос
 Функция: workG() // работа G
 --------------------------  
 
-*Вход:*  G, `uint32_t l` // G - комбирирующий генератор, l - длина выходной последовательности, которую мы хотим получить
+*Вход:*  G, `uint32_t l` // G - комбинирующий генератор, l - длина выходной последовательности, которую мы хотим получить
 
 *Выход:* `uint8_t z[l]`  // z[l] - выходная битовая последовательность
 
@@ -83,7 +84,7 @@ G представляет собой структуру / класс и сос
 
 
     uint16_t r;       // реверснутые полином обратной связи для РСЛОС
-    uint16_t a;       // начальное состоние РСЛОС
+    uint16_t a;       // начальное состояние РСЛОС
     uint8_t x[l];     // выходная битовая последовательность
 
 
@@ -120,36 +121,36 @@ G представляет собой структуру / класс и сос
     4. Вернуть x;
 
 
-Фукция: zigentalerAlg() // алгоритм Зигинталера
+Функция: zigentalerAlg() // алгоритм Зигинталера
 --------------------------  
 
-*Вход:* `G, uint32_t l, uint8_t z[l]` // G - комбирирующий генератор(Вместо генератора только N), l(size) - длина выходной последовательности, z[l] (sequence) - сгенерированная битовая последовательность
+*Вход:* `G, uint32_t l, uint8_t z[l]` // G - комбинирующий генератор(Вместо генератора только N), l(size) - длина выходной последовательности, z[l] (sequence) - сгенерированная битовая последовательность
 
-*Выход:* `uint16_t a[N]`              // полученные с помощью атаки начальные состония РСЛОС
+*Выход:* `uint16_t a[N]`              // полученные с помощью атаки начальные состояния РСЛОС
 
 
     double p[N];          // априорные вероятности (prior_probabilities)
     double c;             // кросс-корреляционная функция (cross_correlation_fun)
     uint8_t x[l];         // выходная битовая последовательность (test_sequence)
-    uint16_t a[N];        // полученные с помощью атаки начальные состония РСЛОС (result)
+    uint16_t a[N];        // полученные с помощью атаки начальные состояния РСЛОС (result)
 
 
     1. uint32_t n = l / 2;
     2. Для j = 1 .. N - 1:
-            2.1. Для d = 1 .. 65535:
-                    2.1.1. x <- createAndWorkTestR(d, n, j);
-                    2.1.2. Для i = 0 .. n - 1:
-                                2.1.2.1.  с <- c  + ((-1) ^ z[i] * (-1) ^ x[i]);
-                    2.1.3. c <- c / n;
-                    2.1.4. Если c < 0.5, то перейти на 2.1.1 для d <- d + 1;
-                    2.1.5. a[j] <- d, перейти на 2 для j <- j + 1;							
+        2.1. Для d = 1 .. 65535:
+		2.1.1. x <- createAndWorkTestR(d, n, j);
+		2.1.2. Для i = 0 .. n - 1:
+			2.1.2.1.  с <- c  + ((-1) ^ z[i] * (-1) ^ x[i]);
+		2.1.3. c <- c / n;
+		2.1.4. Если c < 0.4, то перейти на 2.1.1 для d <- d + 1;
+		2.1.5. a[j] <- d, перейти на 2 для j <- j + 1;							
     3. Для d = 1 .. 65535:
-            3.1. x <- createAndWorkTestG(d, l, a[N]);
-            3.2. Для i = 0 .. 1 - 1:
-                    3.2.1.  с <- c  + ((-1) ^ z[i] * (-1) ^ x[i]);
-            3.3. c <- c / l;
-            3.4. Если c < 0.95, то перейти на 3.1 для d <- d + 1;
-            3.5. a[0] <- d;			
+        3.1. x <- createAndWorkTestG(d, l, a[N]);
+		3.2. Для i = 0 .. 1 - 1:
+            3.2.1.  с <- c  + ((-1) ^ z[i] * (-1) ^ x[i]);
+        3.3. c <- c / l;
+        3.4. Если c < 0.95, то перейти на 3.1 для d <- d + 1;
+        3.5. a[0] <- d;			
     4. Вернуть a;
 
 
@@ -162,7 +163,7 @@ G представляет собой структуру / класс и сос
 
     uint32_t l = 1000; // выбранная на шару длина битовой последовательности
     uint32_t z[l];     // выходная битовая последовательность
-    uint16_t a[N];     // полученные с помощью атаки начальные состония РСЛОС
+    uint16_t a[N];     // полученные с помощью атаки начальные состояния РСЛОС
 
     1. G <- createG();
     2. z <- workG(G, l);