Взломать детский шифр

@NSIFS211 · Регистрация: 15.12.2018

Студворк — интернет-сервис помощи студентам

Всем доброго времени суток, товарищи программеры. Перед тем, как приступить непосредственно к делу, мне хотелось бы поведать небольшую предысторию. Учусь в общеобразовательной школе в 11-м классе (физмат). Со мной есть еще несколько типов, с которыми мы по фанчику постепенно учим криптографию и называем друг друга нумерологами

Мы решили составить свой шифр (на программной основе), который имел бы достаточную стойкость (на уровне 11 класса). (ДЛЯ ЕДКИХ - Я ПРЕКРАСНО ПОНИМАЮ, ЧТО НЕ НАДО ПРИДУМЫВАТЬ НИЧЕГО ИЗ ОБЛАСТИ КРИПТОГРАФИИ, ПОКА У ТЕБЯ НЕТ ХОТЯ БЫ ДОКТОРСКОЙ СТЕПЕНИ ПО МАТЕМАТИКЕ) Но суть в том, чтобы придумать самим, а не использовать уже готовые решения (что-то вроде развития мозгов). Это задание решили отдать мне, т.к. я представляю, как работает сеть Фейстеля. Что касается ключа, было решено, что он должен обладать небольшой длиной, но все же достаточной для того, чтобы малолетки его не перебрали. В качестве идеального варианта взяли 64 бита. Дальше я уже додумывал сам. Это должна быть функция, желательно вызываемая из dll-библиотеки. Шифровать она должна линейный массив байтов, т.к. любой тип данных можно представить массивом байтов. Выдавать для удобства тоже желательно массив байтов. Ключ, как ни странно

тоже проще задавать массивом байтов. И для приличия ввел нечто напоминающее iv - массив байтов

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

Pascal
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
{PascalABC.NET}
library lib9;
interface
  function CryptographySC9(data, key, iv:array of byte; mode:boolean):array of byte;
implementation
function OpenText1to2(x:array of byte):array [,] of byte;
begin
  var a:integer := x.Length;
  var b:array [,] of byte := new byte [8, ((a div 8) + 1)];
  var c:integer := 0;
  try
    for var i:integer := 0 to (a div 8) do
      for var ci:integer := 0 to 7 do
      begin
        b[ci, i] := x[c];
        c := (c + 1);
      end;
  except on System.IndexOutOfRangeException do
    begin
    end;
  end;
  b[7, (a div 8)] := (8 - (a mod 8));
  Result := b;
end;
 
function OpenText2to1(x:array [,] of byte):array of byte;
begin
  var a:integer := x[7, (x.GetLength(1) - 1)];
  var b:array of byte := new byte [x.Length - a];
  a := 0;
  try
    for var i:integer := 0 to (x.GetLength(1) - 1) do
      for var ci:integer := 0 to 7 do
      begin
        b[a] := x[ci, i];
        a := (a + 1);
      end;
  except on System.IndexOutOfRangeException do
    begin
    end;
  end;
  Result := b;
end;
 
function Transform2to1(x:array [,] of byte):array of byte;
begin
  var a:array of byte := new byte [x.Length];
  var b:integer := 0;
  for var i:integer := 0 to (x.GetLength(1) - 1) do
    for var ci:integer := 0 to 7 do
    begin
      a[b] := x[ci, i];
      b := (b + 1);
    end;
  Result := a;
end;
 
function Transform1to2(x:array of byte):array [,] of byte;
begin
  var a:integer := (x.Length div 8);
  var b:array [,] of byte := new byte [8, a];
  var c:integer := 0;
  for var i:integer := 0 to (a - 1) do
    for var ci:integer := 0 to 7 do
    begin
      b[ci, i] := x[c];
      c := (c + 1);
    end;
  Result := b;
end;
 
procedure IVT(var x:array [,] of byte; iv:array of byte);
begin
  for var i:integer := 0 to 7 do x[i, 0] := (x[i, 0] xor iv[i]);
end;
 
function BigIntToByteArr(x:System.Numerics.BigInteger):array of byte;
begin
  var a:array of byte := x.ToByteArray();
  var b:array of byte := new byte [4];
  for var i:integer := 0 to 3 do b[i] := 0;
  try
    for var i:integer := 0 to 3 do b[i] := a[i];
  except on System.IndexOutOfRangeException do
    begin
    end;
  end;
  Result := b;
end;
 
function BigIntToUint32(x:System.Numerics.BigInteger):longword;
begin
  Result := System.BitConverter.ToUInt32(BigIntToByteArr(x), 0);
end;
 
function ToByteArr(x:longword):array of byte;
begin
  var a:System.Numerics.BigInteger := x;
  Result := BigIntToByteArr(a);
end;
 
function FFN1(x, y:longword):longword;
begin
  var a:System.Numerics.BigInteger := (x + 2 * y + 79813);
  Result := BigIntToUint32((a * a * a + a + 21379) mod 168248124743);
end;
 
function FFN2(x, y:longword):longword;
begin
  var a:System.Numerics.BigInteger := (x + 3 * y + 4159);
  Result := BigIntToUint32((a * a * a * a * a + a * a + 161233) mod 2939384514263);
end;
 
procedure FeistelNetwork(var x:array [,] of byte; RKey:array of longword; index:integer; first:boolean);
begin
  var a, b, g:longword;
  var s:array of byte := new byte [8];
  for var i:integer := 0 to 7 do s[i] := x[i, index];
  a := System.BitConverter.ToUInt32(s, 0);
  b := System.BitConverter.ToUInt32(s, 4);
  for var i:integer := 0 to 7 do
  begin
    if first then g := FFN1(a, RKey[i])
       else g := FFN2(a, RKey[i]);
    b := (g xor b);
    if (i <> 7) then Swap(a, b);
  end;
  var w:array of byte := ToByteArr(a);
  for var i:integer := 0 to 3 do x[i, index] := w[i];
  w := ToByteArr(b);
  for var i:integer := 4 to 7 do x[i, index] := w[i - 4];
end;
 
function FLW(x, y:longword):longword;
begin
  var a, b:System.Numerics.BigInteger;
  a := x;
  b := y;
  Result := BigIntToUint32(((a + 723319) * (b + 56311477) + 5119) mod 527845764689);
end;
 
function FLW2(x, y:longword):longword;
begin
  var a, b:System.Numerics.BigInteger;
  a := x;
  b := y;
  Result := BigIntToUint32(((a + 97522913) * (b + 26635429) + 426073) mod 3894575586631);
end;
 
function RoundKey(var key:array of byte; y:array of byte; usingReverse, first:boolean):array of longword;
begin
  var a:array of longword := new longword [2];
  for var i:integer := 0 to 7 do key[i] := (key[i] xor y[i]);
  a[0] := System.BitConverter.ToUInt32(key, 0);
  a[1] := System.BitConverter.ToUInt32(key, 4);
  var b:array of longword := new longword [8];
  for var i:integer := 0 to 3 do
    for var ci:integer := 0 to 1 do b[i * 2 + ci] := a[ci];
    
  for var i:integer := 0 to 7 do
    for var ci:integer := 0 to 7 do
      if first then b[ci] := FLW(b[ci], b[i])
          else b[ci] := FLW2(b[ci], b[i]);
  if usingReverse then System.Array.Reverse(b);
  Result := b;
end;
 
procedure BlockTransform(var x:array [,] of byte; var a, s:array of byte; mode1, mode2:boolean; i:integer);
begin
  var b:array of longword := RoundKey(a, s, (not mode1), mode2);
  for var ci:integer := 0 to 7 do s[ci] := x[ci, i];
  FeistelNetwork(x, b, i, mode2);
  for var ci:integer := 0 to 7 do s[ci] := (s[ci] xor x[ci, i]);
end;
 
procedure TransformCryptography(var x:array [,] of byte; Key:array of byte; mode, first:boolean);
begin
  var a, s:array of byte;
  a := new byte [8]; s := new byte [8];
  for var i:integer := 0 to 7 do
  begin
    a[i] := Key[i];
    s[i] := 0;
  end;
  if first then for var i:integer := 0 to (x.GetLength(1) - 1) do
      BlockTransform(x, a, s, mode, true, i)
    else for var i:integer := (x.GetLength(1) - 1) downto 0 do
      BlockTransform(x, a, s, mode, false, i);
end;
 
function CryptographySC9(data, key, iv:array of byte; mode:boolean):array of byte;
begin
  var b:array of byte;
  if mode then
   begin
     var a:array [,] of byte := OpenText1to2(data);
     IVT(a, iv);
     TransformCryptography(a, key, true, true);
     TransformCryptography(a, key, true, false);
     b := Transform2to1(a);
   end
  else
   begin
     var a:array [,] of byte := Transform1to2(data);
     TransformCryptography(a, key, false, false);
     TransformCryptography(a, key, false, true);
     IVT(a, iv);
     b := OpenText2to1(a);
   end;
   Result := b;
end;
 
end.

Обладает следующими характеристиками:
- скорость на моем пентиуме порядка 18 Кб/с в обе стороны, что позволяет шифровать текст адекватного размера, но и фотку сожрать тоже может, однако придется подождать
- время обработки данных как функция от длины массива возрастает +- линейно, как и должно быть

Для самой непосредственной реализации шифрования начеркал такой код (особо не заморачивался):

Pascal
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
{$reference lib9.dll}
 
begin
  var a:string := '';
  Write('file > ');
  Readln(a);
  var b:array of byte := System.IO.File.ReadAllBytes(a);
  Writeln('iv:');
  var c:array of byte := new byte [8];
  for var i:integer := 0 to 7 do
  begin
    Write(i.ToString() + ' > ');
    c[i] := 0;
    Readln(c[i]);
  end;
  Writeln();
  var d:array of byte := new byte [8];
  Writeln('key:');
  for var i:integer := 0 to 7 do
  begin
    Write(i.ToString() + ' > ');
    d[i] := 0;
    Readln(d[i]);
  end;
  var g:boolean := false;
  Write('mode > ');
  Readln(g);
  a := '';
  Write('save result > ');
  Readln(a);
  System.IO.File.WriteAllBytes(a, lib9.lib9.CryptographySC9(b, d, c, g));
end.

Моих знаний не хватит ни на один нормальный вид криптоанализа, поэтому смог выполнить лишь ряд элементарных проверок, называемых "тест нулей" - массив, состоящий из одних нулей зашифровал одними нулями, и у полученного шифротекста имелись следующие свойства:

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

тоже сказывается плачевно

Этот шифр приняли. Исходник служит одновременно релизом и описанием. Если релиз написан нерационально, прошу не пинать, т.к. писал с нуля и не исключаю, что что-то сделал криво (багов там вроде нет). Пока никто из наших его не взломал. Лично я тоже не представляю, как это можно сделать на практике, и пишу это все для того, чтобы узнать, что по этому поводу скажут прошаренные бородатые дядьки-программеры. Для того, чтобы не вызывать каких-то абстрактных рассуждений, предлагаю дешифровать конкретный файл (зашифрованная фотография .jpg - файл binarnik.bin - прикрепляю в архиве вместе со всеми исходниками). Если кому-то надо, там и SHA256 для расшифрованного файла. iv тоже прилагается. И на всякий случай, фотки в интернете нету - она отснята моим фотоаппаратом и после дешифровки, разумеется, становится общественным достоянием.

На адекватные вопросы обязательно отвечу. Всем заранее спасибо.

@On18 · 17.12.2018, 21:24

Для начала, на будущее:

1. если хотите чтобы ваш алгоритм смотрели, рисуйте понятные диаграммы/рисунки/схемы.

К примеру
http://upload.wikimedia.org/wi... iagram.png

2. Далее описывайте что и зачем вы использовали.

А просто разбирать программу - не будет никто.

Когда мы росли, был еще Союз, информации было 0. Буквально 0. Даже шифра Виженера не знали.
Все что видели в фильмах - Штирлица)))

Вот если бы тогда кто нибудь создавал подобный шифр - я бы понял и оценил.

А сейчас 21й век на дворе. У вас же под рукой интернет. Практически неограниченные возможности читать описания алгоритмов в сети, столько книг, что читай зачитаешся.
И что вы сделали? Вместо того что бы учиться, прочитали о сети Фейстеля и все.
А ну да, еще прочитали https://ru.wikipedia.org/wiki/... тный_метод
и соорудили формулы:

Pascal
1
Result := BigIntToUint32(((a + 723319) * (b + 56311477) + 5119) mod 527845764689);

Читайте. Читайте. Задавайте себе впорос - зачем то, зачем это. Что не понятно - спрашивайте.

А вот ЭТО что выше никуда не годится в принципе.

Добавлено через 6 минут
Хотя, кого я обманываю? Современная молодежь и читать)))) Это не совместимые понятия.

Ладно, может хоть абзац осилите:

Возможность использования в криптографии
Хотя линейный конгруэнтный метод порождает статистически хорошую псевдослучайную последовательность чисел, он не является криптографически стойким. Генераторы на основе линейного конгруэнтного метода являются предсказуемыми, поэтому их нельзя использовать в криптографии. Впервые генераторы на основе линейного конгруэнтного метода были взломаны Джимом Ридсом (Jim Reeds), а затем Джоан Бояр (Joan Boyar). Ей удалось также вскрыть квадратические и кубические генераторы. Другие исследователи расширили идеи Бояр, разработав способы вскрытия любого полиномиального генератора. Таким образом, была доказана бесполезность генераторов на основе конгруэнтных методов для криптографии. Однако генераторы на основе линейного конгруэнтного метода сохраняют свою полезность для некриптографических приложений, например, для моделирования. Они эффективны и в большинстве используемых эмпирических тестах демонстрируют хорошие статистические характеристики.

@NSIFS211 · 18.12.2018, 14:47 **[ТС]**

Сообщение от On18

Вместо того что бы учиться, прочитали о сети Фейстеля

То есть

Сообщение от On18

прочитали о сети Фейстеля

к понятию

Сообщение от On18

учиться

не относится? Ну в общем ваш намек ясен, проехали.

Описание и схему постараюсь составить, не факт, что очень понятно, но попробую.

Сообщение от On18

А вот ЭТО что выше никуда не годится в принципе.

А вот с этим не согласен. Там 2 функции такого рода:

Pascal
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
function FLW(x, y:longword):longword;
begin
  var a, b:System.Numerics.BigInteger;
  a := x;
  b := y;
  Result := BigIntToUint32(((a + 723319) * (b + 56311477) + 5119) mod 527845764689);
end;
 
function FLW2(x, y:longword):longword;
begin
  var a, b:System.Numerics.BigInteger;
  a := x;
  b := y;
  Result := BigIntToUint32(((a + 97522913) * (b + 26635429) + 426073) mod 3894575586631);
end;

Они обе фигурируют исключительно в следующем участке:

Pascal
1
2
3
4
for var i:integer := 0 to 7 do
    for var ci:integer := 0 to 7 do
      if first then b[ci] := FLW(b[ci], b[i])
          else b[ci] := FLW2(b[ci], b[i]);

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

Pascal
1
2
3
var b:array of longword := new longword [8];
  for var i:integer := 0 to 3 do
    for var ci:integer := 0 to 1 do b[i * 2 + ci] := a[ci];

заполняет массив b. Лично мне кажется, что для этой цели они вполне подходят.

Добавлено через 5 часов 3 минуты
Мной уже писалось выше:

Сообщение от NSIFS211

Я ПРЕКРАСНО ПОНИМАЮ, ЧТО НЕ НАДО ПРИДУМЫВАТЬ НИЧЕГО ИЗ ОБЛАСТИ КРИПТОГРАФИИ, ПОКА У ТЕБЯ НЕТ ХОТЯ БЫ ДОКТОРСКОЙ СТЕПЕНИ ПО МАТЕМАТИКЕ

Я прекрасно понимаю, что до AES ему далеко. Я НЕ ПРЕТЕНДУЮ, ЧТОБЫ В БЛИЖАЙШЕЕ ВРЕМЯ НА КОРОБКАХ ОТ ПРОЦЕССОРОВ ПОЯВИЛИСЬ НАДПИСИ "АППАРАТНОЕ УСКОРЕНИЕ SC9-ШИФРОВАНИЯ"

Пояснения к коду буду выкладывать по кусочкам.

@On18 · 18.12.2018, 20:40

Бегло посмотрел этот код. Обозначения взяты наобум, а,б,х переприсваиваются по нескольку раз непонятно зачем.

a:array of byte - так понял входящий открытый текст

IVT(a, iv);
procedure IVT(var x:array [,] of byte; iv:array of byte); - добавления ВИ, простой ксор
x[i, 0] := (x[i, 0] xor iv[i]);

for var i:integer := 0 to 7 do
begin
a[i] := Key[i];
s[i] := 0; - запомните это
end;

RoundKey(a, s);
function RoundKey(var key:array of byte; y:array of byte; usingReverse, first:boolean):array of longword;
a->key s->y
key[i] := (key[i] xor y[i]); - ключ ксор s/y тоесть с 0, зачем? Ну да ладно, поехали дальше
b[i * 2 + ci] := a[ci]
FLW(b[ci], b[i])
Result := BigIntToUint32(((a + 723319) * (b + 56311477) + 5119) mod 527845764689);
По сути из ключа 8 байт делают псведослучайную последовательность, с помощью ГПСЧ, который описан выше
в б теперь ключ. По сути этот ГПСЧ и обеспечивает "случайное" распределение, которые проходит тесты.

FeistelNetwork(x, b, i); - судя по названию и есть собственно сеть Фейстеля
procedure FeistelNetwork(var x:array [,] of byte; RKey:array of longword; index:integer; first:boolean);

g := FFN1(a, RKey[i]) - собственно функция
b := (g xor b); - ксор одного блока со вторым, обозначения конечно ужас. Ну да ладно

Смотрим саму функцию, по сути главный секрет алгоритма:
function FFN1(x, y:longword):longword;
begin
var a:System.Numerics.BigInteger := (x + 2 * y + 79813);
Result := BigIntToUint32((a * a * a + a + 21379) mod 168248124743);
end;

function FFN2(x, y:longword):longword;
begin
var a:System.Numerics.BigInteger := (x + 3 * y + 4159);
Result := BigIntToUint32((a * a * a * a * a + a * a + 161233) mod 2939384514263);
end;

Тут опять обозначения от балды:
a -> x Rkey -> y

обозначим

x = P
y = K

перепишем 2-ю функцию, там больше умножений, она же круче

z := (P + 3 * K + 4159);
Result := (z * z * z * z * z + z * z + 161233) mod 2939384514263;

Тоесть Z^5

Cчитаем:
P K Z Result
0 1 4162 2810603926299 (целых 13! цифр, ух как круто

)
1 1 4163 1806928162546
2 1 4164 2246195615177
3 1 4165 1190061854153
4 1 4166 1578951977161
5 1 4167 474522553842 !!!
6 1 4168 817199681051 !!!
7 1 4169 2608025442884 !!!
8 1 4170 2908657908118 !!!
9 1 4171 1720140160785 !!!

0 2 4165 1190061854153
1 2 4166 1578951977161
2 2 4167 474522553842 !!!
3 2 4168 817199681051 !!!
4 2 4169 2608025442884 !!!
5 2 4170 2908657908118 !!!
6 2 4171 1720140160785 !!!
7 2 4172 1982900299660
8 2 4173 758597894704
9 2 4174 987662045908

упс

смотрим почему же так:

отбрасываем лишнее:
z := (P + 3 * K + 4159);

z := (P1 + 3 * K1 + 4159);
z := (P2 + 3 * K2 + 4159);

P1 + 3 * K1 + 4159 = P2 + 3 * K2 + 4159

P1 + 3 * K1 = P2 + 3 * K2

P1 - P2 = 3 * K2 - 3 * K1

P1 - P2 = 3 * ( K2 - K1 )

Что позволяет составить таблицы:

P1 P2 K2 K1
4 1 10 9
5 2 11 10
6 3 12 11
7 4 13 12
8 5 14 13
9 6 15 14
10 7 16 15
11 8 17 16
12 9 18 17
....

проверяем

P K Z Result
4 9 4190 347332625697
1 10 4190 347332625697

Следовательно фукнция порождает кучу повторений.

А, и первая функция не лучше:
var a:System.Numerics.BigInteger := (x + 2 * y + 79813);
Result := BigIntToUint32((a * a * a + a + 21379) mod 168248124743);

P K Z Result
0 1 79815 10374936077
1 1 79816 29486478199
2 1 79817 48598499217 !!! ---
3 1 79818 67710999137 !!!
4 1 79819 86823977965 !!!
5 1 79820 105937435707 !!!
6 1 79821 125051372369 !!!
7 1 79822 144165787957 !!!
8 1 79823 163280682477 !!!
9 1 79824 14147931192 !!!

0 2 79817 48598499217 !!! ---
1 2 79818 67710999137 !!!
2 2 79819 86823977965 !!!
3 2 79820 105937435707 !!!
4 2 79821 125051372369 !!!
5 2 79822 144165787957 !!!
6 2 79823 163280682477 !!!
7 2 79824 14147931192 !!!
8 2 79825 33263783594
9 2 79826 52380114946

Тоесть что ключ 1 что ключ 2 - результат будет практически тот же.

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

@NSIFS211 · 19.12.2018, 18:06 **[ТС]**

ОПИСАНИЕ АЛГОРИТМА.

Приступим:

================ ПУНКТ 1 ================

Pascal
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
function OpenText1to2(x:array of byte):array [,] of byte;
begin
  var a:integer := x.Length;
  var b:array [,] of byte := new byte [8, ((a div 8) + 1)];
  var c:integer := 0;
  try
    for var i:integer := 0 to (a div 8) do
      for var ci:integer := 0 to 7 do
      begin
        b[ci, i] := x[c];
        c := (c + 1);
      end;
  except on System.IndexOutOfRangeException do
    begin
    end;
  end;
  b[7, (a div 8)] := (8 - (a mod 8));
  Result := b;
end;

ЧТО ДЕЛАЕТ:

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

Pascal
1
b[7, (a div 8)]

показывает, сколько байтов с конца надо выбросить при расшифровке.

ЗАЧЕМ ВВЕДЕНА:

Представляет произвольный массив незашифрованных данных к виду 8 X N, который подходит для дальнейших преобразований.

================ ПУНКТ 2 ================

Pascal
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
function OpenText2to1(x:array [,] of byte):array of byte;
begin
  var a:integer := x[7, (x.GetLength(1) - 1)];
  var b:array of byte := new byte [x.Length - a];
  a := 0;
  try
    for var i:integer := 0 to (x.GetLength(1) - 1) do
      for var ci:integer := 0 to 7 do
      begin
        b[a] := x[ci, i];
        a := (a + 1);
      end;
  except on System.IndexOutOfRangeException do
    begin
    end;
  end;
  Result := b;
end;

ЧТО ДЕЛАЕТ:

Выпоняет действия, обратные функции

Pascal
1
function OpenText1to2(x:array of byte):array [,] of byte;

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

ЗАЧЕМ ВВЕДЕНА:

Позволяет преобразовать двумерный массив 8 X N, полученный при расшифровке, к линейному виду, учтя разметку.

================ ПУНКТ 3 ================

Pascal
1
2
3
4
5
6
7
8
9
10
11
12
function Transform2to1(x:array [,] of byte):array of byte;
begin
  var a:array of byte := new byte [x.Length];
  var b:integer := 0;
  for var i:integer := 0 to (x.GetLength(1) - 1) do
    for var ci:integer := 0 to 7 do
    begin
      a[b] := x[ci, i];
      b := (b + 1);
    end;
  Result := a;
end;

ЧТО ДЕЛАЕТ:

Выполняет действия, аналогичные функции

Pascal
1
function OpenText2to1(x:array [,] of byte):array of byte;

с тем отличием, что тут не производится разметки, т.к. заранее известно, что количество байтов на входе кратно 8. В принципе эти 2 функции

Pascal
1
function OpenText2to1(x:array [,] of byte):array of byte;

и

Pascal
1
function Transform2to1(x:array [,] of byte):array of byte;

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

ЗАЧЕМ ВВЕДЕНА:

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

================ ПУНКТ 4 ================

Pascal
1
2
3
4
5
6
7
8
9
10
11
12
13
function Transform1to2(x:array of byte):array [,] of byte;
begin
  var a:integer := (x.Length div 8);
  var b:array [,] of byte := new byte [8, a];
  var c:integer := 0;
  for var i:integer := 0 to (a - 1) do
    for var ci:integer := 0 to 7 do
    begin
      b[ci, i] := x[c];
      c := (c + 1);
    end;
  Result := b;
end;

ЧТО ДЕЛАЕТ:

Как и в предыдущем случае работа аналогична уже существующей функции

Pascal
1
function OpenText1to2(x:array of byte):array [,] of byte;

снова вся разница состоит в том, что опять же заранее известно, что количество байтов на входе кратно 8.

ЗАЧЕМ ВВЕДЕНА:

Преобразует линейный массив шифротекста к виду 8 X N, такой массив пригоден для дальнейшей расшифровки.

================ ПУНКТ 5 ================

Pascal
1
2
3
4
procedure IVT(var x:array [,] of byte; iv:array of byte);
begin
  for var i:integer := 0 to 7 do x[i, 0] := (x[i, 0] xor iv[i]);
end;

ЧТО ДЕЛАЕТ:

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

ЗАЧЕМ ВВЕДЕНА:

По фанчику.

================ ПУНКТ 6 ================

Pascal
1
2
3
4
5
6
7
8
9
10
11
12
13
function BigIntToByteArr(x:System.Numerics.BigInteger):array of byte;
begin
  var a:array of byte := x.ToByteArray();
  var b:array of byte := new byte [4];
  for var i:integer := 0 to 3 do b[i] := 0;
  try
    for var i:integer := 0 to 3 do b[i] := a[i];
  except on System.IndexOutOfRangeException do
    begin
    end;
  end;
  Result := b;
end;

ЧТО ДЕЛАЕТ:

Если чисто с математической точки зрения - делит поступившее длинное целое по модулю на 2^32, а полученный результат раскладывает в массив из 4 байтов (log256(2^32) = 4), т.е. фактически переводит в 256-разрядную систему исчисления. Проще кода придумать не смог, т.к. результат деления по модулю System.Numerics.BigInteger на любое число, пусть даже на 2, все равно является типом System.Numerics.BigInteger .

ЗАЧЕМ ВВЕДЕНА:

Позволяет запихнуть System.Numerics.BigInteger в массив из 4 байтов.

================ ПУНКТ 7 ================

Pascal
1
2
3
4
function BigIntToUint32(x:System.Numerics.BigInteger):longword;
begin
  Result := System.BitConverter.ToUInt32(BigIntToByteArr(x), 0);
end;

ЧТО ДЕЛАЕТ:

С точки зрения математики тут все еще проще - делит поступившее длинное целое по модулю на 2^32.

ЗАЧЕМ ВВЕДЕНА:

аналогично функции

Pascal
1
function BigIntToByteArr(x:System.Numerics.BigInteger):array of byte;

снова позволяет запихнуть System.Numerics.BigInteger в 32-битное беззнаковое целое.

================ ПУНКТ 8 ================

Pascal
1
2
3
4
5
function ToByteArr(x:longword):array of byte;
begin
  var a:System.Numerics.BigInteger := x;
  Result := BigIntToByteArr(a);
end;

ЧТО ДЕЛАЕТ:

Раскладывает 32-битное беззнаковое число в 256-разрядную систему исчисления.

ЗАЧЕМ ВВЕДЕНА:

Обеспечивает работу сети Фейстеля - процедуры

Pascal
1
procedure FeistelNetwork(var x:array [,] of byte; RKey:array of longword; index:integer; first:boolean);

================ ПУНКТ 9 ================
2 функции:

Pascal
1
2
3
4
5
6
7
8
9
10
11
function FFN1(x, y:longword):longword;
begin
  var a:System.Numerics.BigInteger := (x + 2 * y + 79813);
  Result := BigIntToUint32((a * a * a + a + 21379) mod 168248124743);
end;
 
function FFN2(x, y:longword):longword;
begin
  var a:System.Numerics.BigInteger := (x + 3 * y + 4159);
  Result := BigIntToUint32((a * a * a * a * a + a * a + 161233) mod 2939384514263);
end;

ЧТО ДЕЛАЮТ:

Из 2 32-битных чисел получают 1 по несложной, однако все же нелинейной зависимости.

ЗАЧЕМ ВВЕДЕНЫ:

Обеспечивают работу сети Фейстеля - процедуры

Pascal
1
procedure FeistelNetwork(var x:array [,] of byte; RKey:array of longword; index:integer; first:boolean);

================ ПУНКТ 10 ================

Pascal
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
procedure FeistelNetwork(var x:array [,] of byte; RKey:array of longword; index:integer; first:boolean);
begin
  var a, b, g:longword;
  var s:array of byte := new byte [8];
  for var i:integer := 0 to 7 do s[i] := x[i, index];
  a := System.BitConverter.ToUInt32(s, 0);
  b := System.BitConverter.ToUInt32(s, 4);
  for var i:integer := 0 to 7 do
  begin
    if first then g := FFN1(a, RKey[i])
       else g := FFN2(a, RKey[i]);
    b := (g xor b);
    if (i <> 7) then Swap(a, b);
  end;
  var w:array of byte := ToByteArr(a);
  for var i:integer := 0 to 3 do x[i, index] := w[i];
  w := ToByteArr(b);
  for var i:integer := 4 to 7 do x[i, index] := w[i - 4];
end;

ЧТО ДЕЛАЕТ:

Простая сеть Фейстеля. Параметру first отдают true, когда массив обходится в одну сторону, и false, когда в обратную.

ЗАЧЕМ ВВЕДЕНА:
Основная процедура, обеспечивающая работу алгоритма.

================ ПУНКТ 11 ================
2 функции:

Pascal
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
function FLW(x, y:longword):longword;
begin
  var a, b:System.Numerics.BigInteger;
  a := x;
  b := y;
  Result := BigIntToUint32(((a + 723319) * (b + 56311477) + 5119) mod 527845764689);
end;
 
function FLW2(x, y:longword):longword;
begin
  var a, b:System.Numerics.BigInteger;
  a := x;
  b := y;
  Result := BigIntToUint32(((a + 97522913) * (b + 26635429) + 426073) mod 3894575586631);
end;

ЗАЧЕМ ВВЕДЕНЫ:

Обеспечивают работу функции

Pascal
1
function RoundKey(var key:array of byte; y:array of byte; usingReverse, first:boolean):array of longword;

================ ПУНКТ 12 ================

Pascal
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
function RoundKey(var key:array of byte; y:array of byte; usingReverse, first:boolean):array of longword;
begin
  var a:array of longword := new longword [2];
  for var i:integer := 0 to 7 do key[i] := (key[i] xor y[i]);
  a[0] := System.BitConverter.ToUInt32(key, 0);
  a[1] := System.BitConverter.ToUInt32(key, 4);
  var b:array of longword := new longword [8];
  for var i:integer := 0 to 3 do
    for var ci:integer := 0 to 1 do b[i * 2 + ci] := a[ci];
    
  for var i:integer := 0 to 7 do
    for var ci:integer := 0 to 7 do
      if first then b[ci] := FLW(b[ci], b[i])
          else b[ci] := FLW2(b[ci], b[i]);
  if usingReverse then System.Array.Reverse(b);
  Result := b;
end;

ЧТО ДЕЛАЕТ:

Позволяет из 8 байт на входе создать массив из 8 32-битных беззнаковых чисел.
При этом меняется сам параметр key, т.к. он ксорится с заданным массивом y. В НАЧАЛЕ МАССИВ y ЗАПОЛНЕН ОДНИМИ НУЛЯМИ, но потом заполняется совершенно разными значениями. Еще введен параметр usingReverse, т.к. при расшифровке ключ в сеть Фейстеля надо подставлять в обратном порядке.

ЗАЧЕМ ВВЕДЕНА:

Позволяет увеличить размер ключа.

================ ПУНКТ 13 ================

Pascal
1
2
3
4
5
6
7
procedure BlockTransform(var x:array [,] of byte; var a, s:array of byte; mode1, mode2:boolean; i:integer);
begin
  var b:array of longword := RoundKey(a, s, (not mode1), mode2);
  for var ci:integer := 0 to 7 do s[ci] := x[ci, i];
  FeistelNetwork(x, b, i, mode2);
  for var ci:integer := 0 to 7 do s[ci] := (s[ci] xor x[ci, i]);
end;

ЧТО ДЕЛАЕТ:

Преобразует 1 блок данных под номером i в массиве x. Параметр a - ключ, параметр s - с чем его ксорить, mode1 - шифрование/расшифровка, mode2 - первый/второй обход.

ЗАЧЕМ ВВЕДЕНА:
Непосредственно обрабатывает блоки данных.

================ ПУНКТ 14 ================

Pascal
1
2
3
4
5
6
7
8
9
10
11
12
13
14
procedure TransformCryptography(var x:array [,] of byte; Key:array of byte; mode, first:boolean);
begin
  var a, s:array of byte;
  a := new byte [8]; s := new byte [8];
  for var i:integer := 0 to 7 do
  begin
    a[i] := Key[i];
    s[i] := 0;
  end;
  if first then for var i:integer := 0 to (x.GetLength(1) - 1) do
      BlockTransform(x, a, s, mode, true, i)
    else for var i:integer := (x.GetLength(1) - 1) downto 0 do
      BlockTransform(x, a, s, mode, false, i);
end;

ЧТО ДЕЛАЕТ:

Применяет функцию

Pascal
1
procedure BlockTransform(var x:array [,] of byte; var a, s:array of byte; mode1, mode2:boolean; i:integer);

ко всему массиву данных x, используя заданные параметры.

ЗАЧЕМ ВВЕДЕНА:

Фактически отвечает непосредственно за шифрование.

================ ПУНКТ 15 ================

Pascal
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
function CryptographySC9(data, key, iv:array of byte; mode:boolean):array of byte;
begin
  var b:array of byte;
  if mode then
   begin
     var a:array [,] of byte := OpenText1to2(data);
     IVT(a, iv);
     TransformCryptography(a, key, true, true);
     TransformCryptography(a, key, true, false);
     b := Transform2to1(a);
   end
  else
   begin
     var a:array [,] of byte := Transform1to2(data);
     TransformCryptography(a, key, false, false);
     TransformCryptography(a, key, false, true);
     IVT(a, iv);
     b := OpenText2to1(a);
   end;
   Result := b;
end;

ЧТО ДЕЛАЕТ:

Заключающая функция, объединяющая все предыдущие в работоспособный алгоритм.

ЗАЧЕМ ВВЕДЕНА:

Представляет непосредственную реализацию алгоритма шифрования.

Добавлено через 20 минут

Сообщение от On18

Следовательно фукнция порождает кучу повторений.

Мне кажется, это можно понять еще проще:
тупо взглянуть на объявления этих 4 замечательных функций:

Pascal
1
2
3
4
5
6
7
function FFN1(x, y:longword):longword;
 
function FFN2(x, y:longword):longword;
 
function FLW(x, y:longword):longword;
 
function FLW2(x, y:longword):longword;

Так же тупо посчитать энтропию:
(2^32) / (2^32 * 2^32) = 1/ (2^32) = 1 / 4294967296

и блестяще заключить, что В ЛУЧШЕМ СЛУЧАЕ повторений не будет иметь только 1 ключ из..... 4 МИЛЛИАРДОВ

Сообщение от On18

key[i] := (key[i] xor y[i]); - ключ ксор s/y тоесть с 0, зачем?

Об этом написано в пункте 12

Сообщение от On18

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

Я НЕ ПРОШУ ЕГО УЛУЧШИТЬ, Я ПРОШУ ПЕРЕБРАТЬ БИНАРНИК ИЗ АРХИВА

Кстати, об этом уже писалось мною в самом первом посте:

Сообщение от NSIFS211

предлагаю дешифровать конкретный файл (зашифрованная фотография .jpg - файл binarnik.bin - прикрепляю в архиве вместе со всеми исходниками)

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

@On18 · 19.12.2018, 20:20

Сообщение от NSIFS211

Мне кажется, это можно понять еще проще:
тупо взглянуть на объявления этих 4 замечательных функций:
PascalВыделить код
1
2
3
4
5
6
7
function FFN1(x, y:longword):longword;
function FFN2(x, y:longword):longword;
function FLW(x, y:longword):longword;
function FLW2(x, y:longword):longword;
Так же тупо посчитать энтропию:
(2^32) / (2^32 * 2^32) = 1/ (2^32) = 1 / 4294967296
и блестяще заключить, что В ЛУЧШЕМ СЛУЧАЕ повторений не будет иметь только 1 ключ из..... 4 МИЛЛИАРДОВ

FLW, FLW2 - я так понял используются для расширения ключа, и действительно, похоже что отвечают требованиям ГПСЧ, который правда не криптостойкий.

А вот FFN1, FFN2 отвечают, я так понял, за шифрование.

Так вот, как уже показал выше:

P K Z Result
0 1 79815 10374936077
1 1 79816 29486478199
2 1 79817 48598499217 !!! ---
3 1 79818 67710999137 !!!
4 1 79819 86823977965 !!!
5 1 79820 105937435707 !!!
6 1 79821 125051372369 !!!
7 1 79822 144165787957 !!!
8 1 79823 163280682477 !!!
9 1 79824 14147931192 !!!

0 2 79817 48598499217 !!! ---
1 2 79818 67710999137 !!!
2 2 79819 86823977965 !!!
3 2 79820 105937435707 !!!
4 2 79821 125051372369 !!!
5 2 79822 144165787957 !!!
6 2 79823 163280682477 !!!
7 2 79824 14147931192 !!!
8 2 79825 33263783594
9 2 79826 52380114946

Тоесть,
для ключа К=1 и текста P=2 Result = 48598499217 !!! ---
для ключа К=2 и текста P=0 Result = 48598499217 !!! ---

Упс, чуть не дотянули до

Сообщение от NSIFS211

1 / 4294967296

Сообщение от NSIFS211

лично я буду считать алгоритм не взломанным.

Считайте все что угодно.

Добавлено через 1 час 31 минуту
Еще раз:

Упростим немного :

Допустим есть ограничение, можно использовать только числа от 0 до 9.

Тогда допустим из ключа с помощью ГПСЧ
1 7 => 5
2 1 => 7
3 2 => 6
4 7 => 3
5 7 => 1
6 2 => 6
7 5 => 2
8 4 => 5
получаем последовательность ключей К

Далее используем их для шифрования:

Используем предложенную супер надежную формулу
z := (P + 3 * K + 4159);
Result := (z * z * z * z * z + z * z + 161233) mod 2939384514263;*

№ 0 P= 0 K= 0 z= 4159 Result= 2711359113530
№ 1 P= 1 K= 0 z= 4160 Result= 324473722856
№ 2 P= 2 K= 0 z= 4161 Result= 2316798808173

Кликните здесь для просмотра всего текста

№ 3 P= 3 K= 0 z= 4162 Result= 2810603926299
№ 4 P= 4 K= 0 z= 4163 Result= 1806928162546
№ 5 P= 5 K= 0 z= 4164 Result= 2246195615177
№ 6 P= 6 K= 0 z= 4165 Result= 1190061854153
№ 7 P= 7 K= 0 z= 4166 Result= 1578951977161
№ 8 P= 8 K= 0 z= 4167 Result= 474522553842
№ 9 P= 9 K= 0 z= 4168 Result= 817199681051
№ 10 P= 0 K= 1 z= 4162 Result= 2810603926299
№ 11 P= 1 K= 1 z= 4163 Result= 1806928162546
№ 12 P= 2 K= 1 z= 4164 Result= 2246195615177
№ 13 P= 3 K= 1 z= 4165 Result= 1190061854153
№ 14 P= 4 K= 1 z= 4166 Result= 1578951977161
№ 15 P= 5 K= 1 z= 4167 Result= 474522553842
№ 16 P= 6 K= 1 z= 4168 Result= 817199681051
№ 17 P= 7 K= 1 z= 4169 Result= 2608025442884
№ 18 P= 8 K= 1 z= 4170 Result= 2908657908118
№ 19 P= 9 K= 1 z= 4171 Result= 1720140160785
№ 20 P= 0 K= 2 z= 4165 Result= 1190061854153
№ 21 P= 1 K= 2 z= 4166 Result= 1578951977161
№ 22 P= 2 K= 2 z= 4167 Result= 474522553842
№ 23 P= 3 K= 2 z= 4168 Result= 817199681051
№ 24 P= 4 K= 2 z= 4169 Result= 2608025442884
№ 25 P= 5 K= 2 z= 4170 Result= 2908657908118
№ 26 P= 6 K= 2 z= 4171 Result= 1720140160785
№ 27 P= 7 K= 2 z= 4172 Result= 1982900299660
№ 28 P= 8 K= 2 z= 4173 Result= 758597894704
№ 29 P= 9 K= 2 z= 4174 Result= 987662045908
№ 30 P= 0 K= 3 z= 4168 Result= 817199681051
№ 31 P= 1 K= 3 z= 4169 Result= 2608025442884
№ 32 P= 2 K= 3 z= 4170 Result= 2908657908118
№ 33 P= 3 K= 3 z= 4171 Result= 1720140160785
№ 34 P= 4 K= 3 z= 4172 Result= 1982900299660
№ 35 P= 5 K= 3 z= 4173 Result= 758597894704
№ 36 P= 6 K= 3 z= 4174 Result= 987662045908
№ 37 P= 7 K= 3 z= 4175 Result= 2671137839224
№ 38 P= 8 K= 3 z= 4176 Result= 2870686347589
№ 39 P= 9 K= 3 z= 4177 Result= 1587353659195
№ 40 P= 0 K= 4 z= 4171 Result= 1720140160785
№ 41 P= 1 K= 4 z= 4172 Result= 1982900299660
№ 42 P= 2 K= 4 z= 4173 Result= 758597894704
№ 43 P= 3 K= 4 z= 4174 Result= 987662045908
№ 44 P= 4 K= 4 z= 4175 Result= 2671137839224
№ 45 P= 5 K= 4 z= 4176 Result= 2870686347589
№ 46 P= 6 K= 4 z= 4177 Result= 1587353659195
№ 47 P= 7 K= 4 z= 4178 Result= 1761570876721
№ 48 P= 8 K= 4 z= 4179 Result= 455000577360
№ 49 P= 9 K= 4 z= 4180 Result= 608074866287
№ 50 P= 0 K= 5 z= 4174 Result= 987662045908
№ 51 P= 1 K= 5 z= 4175 Result= 2671137839224
№ 52 P= 2 K= 5 z= 4176 Result= 2870686347589
№ 53 P= 3 K= 5 z= 4177 Result= 1587353659195
№ 54 P= 4 K= 5 z= 4178 Result= 1761570876721
№ 55 P= 5 K= 5 z= 4179 Result= 455000577360
№ 56 P= 6 K= 5 z= 4180 Result= 608074866287
№ 57 P= 7 K= 5 z= 4181 Result= 2221841836942
№ 58 P= 8 K= 5 z= 4182 Result= 2357965570006
№ 59 P= 9 K= 5 z= 4183 Result= 1017495162183
№ 60 P= 0 K= 6 z= 4177 Result= 1587353659195
№ 61 P= 1 K= 6 z= 4178 Result= 1761570876721
№ 62 P= 2 K= 6 z= 4179 Result= 455000577360
№ 63 P= 3 K= 6 z= 4180 Result= 608074866287
№ 64 P= 4 K= 6 z= 4181 Result= 2221841836942
№ 65 P= 5 K= 6 z= 4182 Result= 2357965570006
№ 66 P= 6 K= 6 z= 4183 Result= 1017495162183
№ 67 P= 7 K= 6 z= 4184 Result= 1140864725688
№ 68 P= 8 K= 6 z= 4185 Result= 2729124361257
№ 69 P= 9 K= 6 z= 4186 Result= 2843940157123
№ 70 P= 0 K= 7 z= 4180 Result= 608074866287
№ 71 P= 1 K= 7 z= 4181 Result= 2221841836942
№ 72 P= 2 K= 7 z= 4182 Result= 2357965570006
№ 73 P= 3 K= 7 z= 4183 Result= 1017495162183
№ 74 P= 4 K= 7 z= 4184 Result= 1140864725688
№ 75 P= 5 K= 7 z= 4185 Result= 2729124361257
№ 76 P= 6 K= 7 z= 4186 Result= 2843940157123
№ 77 P= 7 K= 7 z= 4187 Result= 1486363217286
№ 78 P= 8 K= 7 z= 4188 Result= 1596829663561
№ 79 P= 9 K= 7 z= 4189 Result= 237007090997
№ 80 P= 0 K= 8 z= 4183 Result= 1017495162183
№ 81 P= 1 K= 8 z= 4184 Result= 1140864725688
№ 82 P= 2 K= 8 z= 4185 Result= 2729124361257
№ 83 P= 3 K= 8 z= 4186 Result= 2843940157123
№ 84 P= 4 K= 8 z= 4187 Result= 1486363217286
№ 85 P= 5 K= 8 z= 4188 Result= 1596829663561
№ 86 P= 6 K= 8 z= 4189 Result= 237007090997
№ 87 P= 7 K= 8 z= 4190 Result= 347332625697
№ 88 P= 8 K= 8 z= 4191 Result= 1928859382029
№ 89 P= 9 K= 8 z= 4192 Result= 2043256463650
№ 90 P= 0 K= 9 z= 4186 Result= 2843940157123
№ 91 P= 1 K= 9 z= 4187 Result= 1486363217286
№ 92 P= 2 K= 9 z= 4188 Result= 1596829663561
№ 93 P= 3 K= 9 z= 4189 Result= 237007090997
№ 94 P= 4 K= 9 z= 4190 Result= 347332625697
№ 95 P= 5 K= 9 z= 4191 Result= 1928859382029
№ 96 P= 6 K= 9 z= 4192 Result= 2043256463650
№ 97 P= 7 K= 9 z= 4193 Result= 691577990752
№ 98 P= 8 K= 9 z= 4194 Result= 814263100830
№ 99 P= 9 K= 9 z= 4195 Result= 2412366920412

Тоесть мы перебрали все позможные комбинации К=0..9 и текста 0..9.

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

У нас же супер функция, на которая на выдает нам случайные данные и вероятность совпадения как утверждает автор
1 / 4294967296

Тоесть для 100 значений вероятность совпадения 2-х - 0,000002328%

Ну что ж, проверим:

№ 79 P= 9 K= 7 z= 4189 Result= 237007090997
№ 86 P= 6 K= 8 z= 4189 Result= 237007090997
№ 93 P= 3 K= 9 z= 4189 Result= 237007090997

Кликните здесь для просмотра всего текста

№ 1 P= 1 K= 0 z= 4160 Result= 324473722856
№ 87 P= 7 K= 8 z= 4190 Result= 347332625697
№ 94 P= 4 K= 9 z= 4190 Result= 347332625697
№ 48 P= 8 K= 4 z= 4179 Result= 455000577360
№ 55 P= 5 K= 5 z= 4179 Result= 455000577360
№ 62 P= 2 K= 6 z= 4179 Result= 455000577360
№ 8 P= 8 K= 0 z= 4167 Result= 474522553842
№ 15 P= 5 K= 1 z= 4167 Result= 474522553842
№ 22 P= 2 K= 2 z= 4167 Result= 474522553842
№ 49 P= 9 K= 4 z= 4180 Result= 608074866287
№ 56 P= 6 K= 5 z= 4180 Result= 608074866287
№ 63 P= 3 K= 6 z= 4180 Result= 608074866287
№ 70 P= 0 K= 7 z= 4180 Result= 608074866287
№ 97 P= 7 K= 9 z= 4193 Result= 691577990752
№ 28 P= 8 K= 2 z= 4173 Result= 758597894704
№ 35 P= 5 K= 3 z= 4173 Result= 758597894704
№ 42 P= 2 K= 4 z= 4173 Result= 758597894704
№ 98 P= 8 K= 9 z= 4194 Result= 814263100830
№ 9 P= 9 K= 0 z= 4168 Result= 817199681051
№ 16 P= 6 K= 1 z= 4168 Result= 817199681051
№ 23 P= 3 K= 2 z= 4168 Result= 817199681051
№ 30 P= 0 K= 3 z= 4168 Result= 817199681051
№ 29 P= 9 K= 2 z= 4174 Result= 987662045908
№ 36 P= 6 K= 3 z= 4174 Result= 987662045908
№ 43 P= 3 K= 4 z= 4174 Result= 987662045908
№ 50 P= 0 K= 5 z= 4174 Result= 987662045908
№ 59 P= 9 K= 5 z= 4183 Result= 1017495162183
№ 66 P= 6 K= 6 z= 4183 Result= 1017495162183
№ 73 P= 3 K= 7 z= 4183 Result= 1017495162183
№ 80 P= 0 K= 8 z= 4183 Result= 1017495162183
№ 67 P= 7 K= 6 z= 4184 Result= 1140864725688
№ 74 P= 4 K= 7 z= 4184 Result= 1140864725688
№ 81 P= 1 K= 8 z= 4184 Result= 1140864725688
№ 6 P= 6 K= 0 z= 4165 Result= 1190061854153
№ 13 P= 3 K= 1 z= 4165 Result= 1190061854153
№ 20 P= 0 K= 2 z= 4165 Result= 1190061854153
№ 77 P= 7 K= 7 z= 4187 Result= 1486363217286
№ 84 P= 4 K= 8 z= 4187 Result= 1486363217286
№ 91 P= 1 K= 9 z= 4187 Result= 1486363217286
№ 7 P= 7 K= 0 z= 4166 Result= 1578951977161
№ 14 P= 4 K= 1 z= 4166 Result= 1578951977161
№ 21 P= 1 K= 2 z= 4166 Result= 1578951977161
№ 39 P= 9 K= 3 z= 4177 Result= 1587353659195
№ 46 P= 6 K= 4 z= 4177 Result= 1587353659195
№ 53 P= 3 K= 5 z= 4177 Result= 1587353659195
№ 60 P= 0 K= 6 z= 4177 Result= 1587353659195
№ 78 P= 8 K= 7 z= 4188 Result= 1596829663561
№ 85 P= 5 K= 8 z= 4188 Result= 1596829663561
№ 92 P= 2 K= 9 z= 4188 Result= 1596829663561
№ 19 P= 9 K= 1 z= 4171 Result= 1720140160785
№ 26 P= 6 K= 2 z= 4171 Result= 1720140160785
№ 33 P= 3 K= 3 z= 4171 Result= 1720140160785
№ 40 P= 0 K= 4 z= 4171 Result= 1720140160785
№ 47 P= 7 K= 4 z= 4178 Result= 1761570876721
№ 54 P= 4 K= 5 z= 4178 Result= 1761570876721
№ 61 P= 1 K= 6 z= 4178 Result= 1761570876721
№ 4 P= 4 K= 0 z= 4163 Result= 1806928162546
№ 11 P= 1 K= 1 z= 4163 Result= 1806928162546
№ 88 P= 8 K= 8 z= 4191 Result= 1928859382029
№ 95 P= 5 K= 9 z= 4191 Result= 1928859382029
№ 27 P= 7 K= 2 z= 4172 Result= 1982900299660
№ 34 P= 4 K= 3 z= 4172 Result= 1982900299660
№ 41 P= 1 K= 4 z= 4172 Result= 1982900299660
№ 89 P= 9 K= 8 z= 4192 Result= 2043256463650
№ 96 P= 6 K= 9 z= 4192 Result= 2043256463650
№ 57 P= 7 K= 5 z= 4181 Result= 2221841836942
№ 64 P= 4 K= 6 z= 4181 Result= 2221841836942
№ 71 P= 1 K= 7 z= 4181 Result= 2221841836942
№ 5 P= 5 K= 0 z= 4164 Result= 2246195615177
№ 12 P= 2 K= 1 z= 4164 Result= 2246195615177
№ 2 P= 2 K= 0 z= 4161 Result= 2316798808173
№ 58 P= 8 K= 5 z= 4182 Result= 2357965570006
№ 65 P= 5 K= 6 z= 4182 Result= 2357965570006
№ 72 P= 2 K= 7 z= 4182 Result= 2357965570006
№ 99 P= 9 K= 9 z= 4195 Result= 2412366920412
№ 17 P= 7 K= 1 z= 4169 Result= 2608025442884
№ 24 P= 4 K= 2 z= 4169 Result= 2608025442884
№ 31 P= 1 K= 3 z= 4169 Result= 2608025442884
№ 37 P= 7 K= 3 z= 4175 Result= 2671137839224
№ 44 P= 4 K= 4 z= 4175 Result= 2671137839224
№ 51 P= 1 K= 5 z= 4175 Result= 2671137839224
№ 0 P= 0 K= 0 z= 4159 Result= 2711359113530
№ 68 P= 8 K= 6 z= 4185 Result= 2729124361257
№ 75 P= 5 K= 7 z= 4185 Result= 2729124361257
№ 82 P= 2 K= 8 z= 4185 Result= 2729124361257
№ 3 P= 3 K= 0 z= 4162 Result= 2810603926299
№ 10 P= 0 K= 1 z= 4162 Result= 2810603926299
№ 69 P= 9 K= 6 z= 4186 Result= 2843940157123
№ 76 P= 6 K= 7 z= 4186 Result= 2843940157123
№ 83 P= 3 K= 8 z= 4186 Result= 2843940157123
№ 90 P= 0 K= 9 z= 4186 Result= 2843940157123
№ 38 P= 8 K= 3 z= 4176 Result= 2870686347589
№ 45 P= 5 K= 4 z= 4176 Result= 2870686347589
№ 52 P= 2 K= 5 z= 4176 Result= 2870686347589
№ 18 P= 8 K= 1 z= 4170 Result= 2908657908118
№ 25 P= 5 K= 2 z= 4170 Result= 2908657908118
№ 32 P= 2 K= 3 z= 4170 Result= 2908657908118

Упс.

Без повторений только
№ 0 P= 0 K= 0 z= 4159 Result= 2711359113530
№ 1 P= 1 K= 0 z= 4160 Result= 324473722856
№ 2 P= 2 K= 0 z= 4161 Result= 2316798808173
№ 97 P= 7 K= 9 z= 4193 Result= 691577990752
№ 98 P= 8 K= 9 z= 4194 Result= 814263100830
№ 99 P= 9 K= 9 z= 4195 Result= 2412366920412

6 из 100, тоесть не 0,000002328% а 94%.

@Ethereal · 19.12.2018, 23:35

Сообщение от NSIFS211

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

Анекдот про неуловимого Джо слышал ? Так вот твой алгоритм не взломан ровно в той степени в какой Джо неуловим.

@NSIFS211 · 20.12.2018, 13:19 **[ТС]**

Сообщение от On18

У нас же супер функция, на которая на выдает нам случайные данные и вероятность совпадения как утверждает автор
1 / 4294967296

Сообщение от On18

Используем предложенную супер надежную формулу
z := (P + 3 * K + 4159);
Result := (z * z * z * z * z + z * z + 161233) mod 2939384514263

Я не утверждаю, что она выдает случайные данные или является супер надежной. Про повторения было отмечено, что это

Сообщение от NSIFS211

В ЛУЧШЕМ СЛУЧАЕ

А в данном конкретном случае повторений будет целая куча, т.к. для уравнения (P + 3 * K = const) можно подобрать огромное количество P и K.

Сообщение от Ethereal

Анекдот про неуловимого Джо слышал ? Так вот твой алгоритм не взломан ровно в той степени в какой Джо неуловим.

Т.е. дешифровать этот бинарник никто не собирается ?

Исходя из анекдота про Джо следует именно это.

@NSIFS211 · 21.12.2018, 16:38 **[ТС]**

Сообщение от On18

Считайте все что угодно.

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

"Шифр - дерьмо! Вот есть шифротекст. Мы делает это, потом это, потом это, затем часок-другой помучаем процессор Core i7 вычислениями.... и вуаля! У нас открытый текст."

А когда исходят речи в духе:

"Шифр - дерьмо! Я разработал гениальный метод взлома, который позволяет получить открытый текст, перебрав не 2^256 , а всего лишь 2^255 вариантов..... "

на взлом это не очень тянет.

И хотя не могу поверить, что вы не поняли, что мне нужно, все равно пишу еще раз:

ДЛЯ ТЕХ, КТО В ТАНКЕ:

Мною был задан конкретный вопрос:

Сообщение от NSIFS211

предлагаю дешифровать конкретный файл (зашифрованная фотография .jpg - файл binarnik.bin - прикрепляю в архиве вместе со всеми исходниками)

Потом еще писалось:

Сообщение от NSIFS211

Я НЕ ПРОШУ ЕГО УЛУЧШИТЬ, Я ПРОШУ ПЕРЕБРАТЬ БИНАРНИК ИЗ АРХИВА

И мне очень хочется получить на него конкретный ответ, в духе:

"Вот, смотри, если сделать это, это, и это, то выходит, что твой ключ [0, 1, 2, 3, 4, 5, 6, 7] "

ВОТ НА ЭТОМ ДИСКУССИЮ МОЖНО БУДЕТ СМЕЛО СЧИТАТЬ ОКОНЧЕННОЙ

Сообщение от On18

Тоесть мы перебрали все позможные комбинации К=0..9 и текста 0..9.
Если мы сделали функцию правильно, не будет ни одного повторения.

Честно, НЕ ПРОВЕРЯЛ, но что-то мне подсказывает, что если вместо множителя 3 взять 4294967296 , то предложенная функция описанный тест пройдет блестяще, и даже если это будет действительно так, то один хрен ничего не поменяется.

@Ethereal · 21.12.2018, 16:38

Сообщение от NSIFS211

Т.е. дешифровать этот бинарник никто не собирается ?

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

@NSIFS211 · 21.12.2018, 16:42 **[ТС]**

Сообщение от Ethereal

Априори никто ничего делать не будет.

Ясно.

@Ethereal · 21.12.2018, 16:43

Хотя возможно, возможно что ты просто не понимаешь, что такое взлом криптоалгоритма. И поэтому обставляешь просьбу о взломе дополнительным условием, которое по сути взлом исключает.

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

Сообщение от NSIFS211

Я ПРОШУ ПЕРЕБРАТЬ БИНАРНИК ИЗ АРХИВА

которым исключаешь этот самый взлом.

@NSIFS211 · 21.12.2018, 16:44 **[ТС]**

В любом случае, спасибо хоть на том, что потратили на меня свое время.

@Ethereal · 21.12.2018, 16:46

Сообщение от NSIFS211

Ясно.

Что тебе ясно ? Ты представляешь что перебрать грубой силой 2 в 64-й степени вариантов не реально без построения специализированного компа для такого перебора ? Ты посчитал сколько на это надо времени вычислительными мощностями планеты Земля ? А еcли понимаешь, чего просишь ?

@NSIFS211 · 21.12.2018, 16:54 **[ТС]**

Сообщение от Ethereal

Алгоритм считается взломанным, если ключ можно вычислить быстрее чем перебором глубой силой. А ты ставишь дополнительнойй условие
Сообщение от NSIFS211
Я ПРОШУ ПЕРЕБРАТЬ БИНАРНИК ИЗ АРХИВА
которым исключаешь этот самый взлом.

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

Сообщение от NSIFS211

Я ПРОШУ ПЕРЕБРАТЬ БИНАРНИК ИЗ АРХИВА

то понимал не брутфорс 2^64 вариантов, а вскытие любыми методами вообще.

Добавлено через 3 минуты
Я представлял, что найдется кто-то, кто сможет математикой уменьшить 2^64 вариантов, до скажем, 2^32, а потом элементарно вскроет ключ.

Добавлено через 3 минуты

Сообщение от Ethereal

Что тебе ясно ? Ты представляешь что перебрать грубой силой 2 в 64-й степени вариантов не реально без построения специализированного компа для такого перебора ? Ты посчитал сколько на это надо времени вычислительными мощностями планеты Земля ? А еcли понимаешь, чего просишь ?

Я прекрасно понимаю, чего прошу.

@Ethereal · 21.12.2018, 16:57

Если любыми методами вообще, то причем тогда бинарник из архива ? Любыми методами вообще криптоаналитик показывает, что при наличии такого вот объема шифротекста (не того объема, что ты дал, а того, что указал криптоаналитик) ключ вскрывается быстрее, чем полным перебором, а значит криптоалгоритм в топку. Объем шифротекста выбирается криптоаналитиком при построении атаки на алгоритм, а не задается заранее кем-то другим.

@NSIFS211 · 21.12.2018, 17:09 **[ТС]**

Сообщение от Ethereal

Если любыми методами вообще, то причем тогда бинарник из архива ?

Для непосредственной демонстрации успехов в криптоанализе данного алгоритма.

Добавлено через 10 минут

Сообщение от Ethereal

Хотя возможно, возможно что ты просто не понимаешь, что такое взлом криптоалгоритма.

Не скрою, задело.

@On18 · 21.12.2018, 18:29

Я уже показал что:

1. алгоритм использует не криптостойкий ГПСЧ.
2. алгоритм имеет плохую основную функцию.

Что еще нужно?

Этого уже достаточно что бы считать алгоритм никуда не годным.

@NSIFS211 · 21.12.2018, 18:46 **[ТС]**

Сообщение от On18

Что еще нужно?

ДЕШИФРОВАТЬ БИНАРНИК ИЗ АРХИВА!!!!!!

@On18 · 21.12.2018, 18:48

Даже если захотеть анализирвоать расчеты, то получается следующее:

Автор "работает" с числами в 32 бит. Ок.
Возьмем половину от 2147483648
1073741824

Вичислим "расширение" ключа
Result := BigIntToUint32(((a + 723319) * (b + 56311477) + 5119) mod 527845764689);
3,24834E+11

далее подставим полученный ключ и допустистим что текст такой же
var a:System.Numerics.BigInteger := (x + 3 * y + 4159);
1,29934E+12

теперь все это попытаемся вычислить:
Result := BigIntToUint32((a * a * a * a * a + a * a + 161233) mod 2939384514263);

a * a * a * a * a = 3,70346E+60
a * a = 1,68827E+24
a * a * a * a * a + a * a + 161233 = 3,70346E+60
(a * a * a * a * a + a * a + 161233) mod 2939384514263 = ???

числа порядка 10^24 - 10^60

Вы в своем уме?

AES 128 - все ключи 10^37 и он стойкий.

Зачем умножать целые(!) цисла порядка 10^60?

Добавлено через 34 секунды

Сообщение от NSIFS211

ДЕШИФРОВАТЬ БИНАРНИК ИЗ АРХИВА!!!!!!

Это глупость.

Новые блоги и статьи Все статьи Все блоги /
моя боль iceja 24.01.2026 Выложила интерполяцию кубическими сплайнами www. iceja. net REST сервисы временно не работают, только через Web. Написала за 56 рабочих часов этот сайт с нуля. При помощи perplexity. ai PRO , при. . .	Модель сукцессии микоризы anaschu 24.01.2026 Решили писать научную статью с неким РОманом	http://iceja.net/ математические сервисы iceja 20.01.2026 Обновила свой сайт http:/ / iceja. net/ , приделала Fast Fourier Transform экстраполяцию сигналов. Однако предсказывает далеко не каждый сигнал (см ограничения http:/ / iceja. net/ fourier/ docs ). Также. . .	http://iceja.net/ сервер решения полиномов iceja 18.01.2026 Выкатила http:/ / iceja. net/ сервер решения полиномов (находит действительные корни полиномов методом Штурма). На сайте документация по API, но скажу прямо VPS слабенький и 200 000 полиномов. . .
Расчёт переходных процессов в цепи постоянного тока igorrr37 16.01.2026 / * Дана цепь(не выше 3-го порядка) постоянного тока с элементами R, L, C, k(ключ), U, E, J. Программа находит переходные токи и напряжения на элементах схемы классическим методом(1 и 2 з-ны. . .	Восстановить юзерскрипты Greasemonkey из бэкапа браузера damix 15.01.2026 Если восстановить из бэкапа профиль Firefox после переустановки винды, то список юзерскриптов в Greasemonkey будет пустым. Но восстановить их можно так. Для этого понадобится консольная утилита. . .	Сукцессия микоризы: основная теория в виде двух уравнений. anaschu 11.01.2026 https:/ / rutube. ru/ video/ 7a537f578d808e67a3c6fd818a44a5c4/	WordPad для Windows 11 Jel 10.01.2026 WordPad для Windows 11 — это приложение, которое восстанавливает классический текстовый редактор WordPad в операционной системе Windows 11. После того как Microsoft исключила WordPad из. . .

@On18 461 / 201 / 80 Регистрация: 14.12.2017 Сообщений: 433
	18.12.2018, 20:40
	Бегло посмотрел этот код. Обозначения взяты наобум, а,б,х переприсваиваются по нескольку раз непонятно зачем. a:array of byte - так понял входящий открытый текст IVT(a, iv); procedure IVT(var x:array [,] of byte; iv:array of byte); - добавления ВИ, простой ксор x[i, 0] := (x[i, 0] xor iv[i]); for var i:integer := 0 to 7 do begin a[i] := Key[i]; s[i] := 0; - запомните это end; RoundKey(a, s); function RoundKey(var key:array of byte; y:array of byte; usingReverse, first:boolean):array of longword; a->key s->y key[i] := (key[i] xor y[i]); - ключ ксор s/y тоесть с 0, зачем? Ну да ладно, поехали дальше b[i * 2 + ci] := a[ci] FLW(b[ci], b[i]) Result := BigIntToUint32(((a + 723319) * (b + 56311477) + 5119) mod 527845764689); По сути из ключа 8 байт делают псведослучайную последовательность, с помощью ГПСЧ, который описан выше в б теперь ключ. По сути этот ГПСЧ и обеспечивает "случайное" распределение, которые проходит тесты. FeistelNetwork(x, b, i); - судя по названию и есть собственно сеть Фейстеля procedure FeistelNetwork(var x:array [,] of byte; RKey:array of longword; index:integer; first:boolean); g := FFN1(a, RKey[i]) - собственно функция b := (g xor b); - ксор одного блока со вторым, обозначения конечно ужас. Ну да ладно Смотрим саму функцию, по сути главный секрет алгоритма: function FFN1(x, y:longword):longword; begin var a:System.Numerics.BigInteger := (x + 2 * y + 79813); Result := BigIntToUint32((a * a * a + a + 21379) mod 168248124743); end; function FFN2(x, y:longword):longword; begin var a:System.Numerics.BigInteger := (x + 3 * y + 4159); Result := BigIntToUint32((a * a * a * a * a + a * a + 161233) mod 2939384514263); end; Тут опять обозначения от балды: a -> x Rkey -> y обозначим x = P y = K перепишем 2-ю функцию, там больше умножений, она же круче z := (P + 3 * K + 4159); Result := (z * z * z * z * z + z * z + 161233) mod 2939384514263; Тоесть Z^5 Cчитаем: P K Z Result 0 1 4162 2810603926299 (целых 13! цифр, ух как круто ) 1 1 4163 1806928162546 2 1 4164 2246195615177 3 1 4165 1190061854153 4 1 4166 1578951977161 5 1 4167 474522553842 !!! 6 1 4168 817199681051 !!! 7 1 4169 2608025442884 !!! 8 1 4170 2908657908118 !!! 9 1 4171 1720140160785 !!! 0 2 4165 1190061854153 1 2 4166 1578951977161 2 2 4167 474522553842 !!! 3 2 4168 817199681051 !!! 4 2 4169 2608025442884 !!! 5 2 4170 2908657908118 !!! 6 2 4171 1720140160785 !!! 7 2 4172 1982900299660 8 2 4173 758597894704 9 2 4174 987662045908 упс смотрим почему же так: отбрасываем лишнее: z := (P + 3 * K + 4159); z := (P1 + 3 * K1 + 4159); z := (P2 + 3 * K2 + 4159); P1 + 3 * K1 + 4159 = P2 + 3 * K2 + 4159 P1 + 3 * K1 = P2 + 3 * K2 P1 - P2 = 3 * K2 - 3 * K1 P1 - P2 = 3 * ( K2 - K1 ) Что позволяет составить таблицы: P1 P2 K2 K1 4 1 10 9 5 2 11 10 6 3 12 11 7 4 13 12 8 5 14 13 9 6 15 14 10 7 16 15 11 8 17 16 12 9 18 17 .... проверяем P K Z Result 4 9 4190 347332625697 1 10 4190 347332625697 Следовательно фукнция порождает кучу повторений. А, и первая функция не лучше: var a:System.Numerics.BigInteger := (x + 2 * y + 79813); Result := BigIntToUint32((a * a * a + a + 21379) mod 168248124743); P K Z Result 0 1 79815 10374936077 1 1 79816 29486478199 2 1 79817 48598499217 !!! --- 3 1 79818 67710999137 !!! 4 1 79819 86823977965 !!! 5 1 79820 105937435707 !!! 6 1 79821 125051372369 !!! 7 1 79822 144165787957 !!! 8 1 79823 163280682477 !!! 9 1 79824 14147931192 !!! 0 2 79817 48598499217 !!! --- 1 2 79818 67710999137 !!! 2 2 79819 86823977965 !!! 3 2 79820 105937435707 !!! 4 2 79821 125051372369 !!! 5 2 79822 144165787957 !!! 6 2 79823 163280682477 !!! 7 2 79824 14147931192 !!! 8 2 79825 33263783594 9 2 79826 52380114946 Тоесть что ключ 1 что ключ 2 - результат будет практически тот же. А учитывая что в предложенном алгоритме нету и зачатка полезных идей, шифр улучшению не подлежит в принципе. 1

@NSIFS211 23 / 20 / 4 Регистрация: 15.12.2018 Сообщений: 152
	21.12.2018, 16:44 [ТС]
	В любом случае, спасибо хоть на том, что потратили на меня свое время. 0

@Ethereal 6773 / 2741 / 385 Регистрация: 17.02.2013 Сообщений: 4,048
	21.12.2018, 16:57
	Если любыми методами вообще, то причем тогда бинарник из архива ? Любыми методами вообще криптоаналитик показывает, что при наличии такого вот объема шифротекста (не того объема, что ты дал, а того, что указал криптоаналитик) ключ вскрывается быстрее, чем полным перебором, а значит криптоалгоритм в топку. Объем шифротекста выбирается криптоаналитиком при построении атаки на алгоритм, а не задается заранее кем-то другим. 2

@On18 461 / 201 / 80 Регистрация: 14.12.2017 Сообщений: 433
	21.12.2018, 18:29
	Я уже показал что: 1. алгоритм использует не криптостойкий ГПСЧ. 2. алгоритм имеет плохую основную функцию. Что еще нужно? Этого уже достаточно что бы считать алгоритм никуда не годным. 0