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

@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 · 24.12.2018, 17:34

Картинка в jpg:

яШяа JFIF яЫ C яЫ C яА є " яД яД r ! 1"AQ aq 2Ѓ‘#U”Ў±ТУ $BRS•Бр3brsІСбс %458C‚“ TceґФ'(EFdtuvѓ…’ўҐ &DVfЈ§іХ)GWXw„–¤µяД яД J !1 AQ "aqЃБр2‘Ў±С BRr #3б 5bs‚Вс$6CS’ІТ %&4УўяЪ ? чу "0`Б‚# "0`Б‚# "0`Б‚# "0`Б‚# "0`Б‚# "0`Б‚# "0`Б‚# "0`Б‚# "0`Б‚# "0`Б‚# "0`Б‚# "0`Б‚# "0`Б‚# "0`Б‚# "0`Б‚# "0`Б‚# "0`Б‚*wџљ…b * ў6_ЇU)sjnУ©qзQ+OУ¦4eФ#F= 1Ц‡XsK¤%m** мAЯ µ'6FдO€јiҐдКюoМфКU )ИЛЩ€њRМ™ЃKЁНr{*i‡еэ)9%ТЫCЈ —”ўЃҐҐ(њm? xKђё§"‡#>СЮћњ»Zj*KЊj2 ЏпЌ_¤гМ¶ґ·'¦ў „ј•Ґ % $ Ў* \EеkЃьU‘^џњтњҐММЊУЫ©Ф©ХщРe¤Б[«€дwвјЫ± iO8Rу mЛ«лl,E*U^zй|ИрK-U«Њс …х9•Jл •”¦И…Sn§Lq€їG3 ±Keй"Zж†›LЁqЭJК ”6°‡ !КЮТц™ҐpЧ$Йа]V>fв HҐП*Бќ\}шQ¦ИђмosЁUЅЩLЗТYёyВ]’ўRГ/, n џЙ7,y ©—k”N geJнBµ@ќV*MЁ= Ј9*Ф№}IO8§ q#u¬Ё‚Ґ(YJQ*дrЃЛ”ј¤юF—ГfЭҐЙЛ,еч#9R”ў 2ъд4Ъ

FFD8FFE000104A46494600010100000100010000 FFDB004300020101010101020101010202020202 0403020202020504040304060506060605060606 070908060709070606080B08090A0A0A0A0A0608 0B0C0B0A0C090A0A0AFFDB004301020202020202 050303050A0706070A0A0A0A0A0A0A0A0A0A0A0A 0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A 0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0A0AFFC0 00110802BA020D03012200021101031101FFC400 1E00000104020301000000000000000000000004 05060703080102090AFFC4007210000103020404 030404070A080806081701020304051100061221 070813312241510914617115328191235594A1B1 D2D30A16172442525395C1F033627273B2D1E1F1 182534353843829319546365B4D4272845466474 7576838592A2A51A26445666A3A7B3D529475758 778496A4B5FFC4001C0101000203010101000000 000000000000000203010405060708FFC4004A11 0001040103010407050504070705010001000203 110405122131061341511422617181C1F03291A1 B1D10715425272162333E10835627382C2F12436 435392B2D217252634D3A2FFDA000C0301000211 0311003F00F7F3060C18223060C18223060C1822 3060C18223060C18223060C18223060C18223060 C18223060C18223060C18223060C18223060C182 23060C18223060C18223060C18223060C1822306 0C18223060C18223060C18223060C18223060C18 223060C18223060C18223060C18223060C182230 60C18223060C18223060C18223060C18223060C1 8223060C18223060C18223060C18223060C1822A 779F9A85620F2A19A2365FAF5529736A6ED3A971 E7512B4FD3A63465D423463D0931D68758734BA4 256DAD2A04EC41DF14B5273646E44F88BC69A5E4 CAFE6FCCF4CA550F29C8CBD97F889C52CC99814B A8CD727B2A6987E5FD293925D2DB43A3199794A2 81A5A5289C6D3F10784B90B8A72287233ED1DE9E 9CBB5A6AAD4B8C6A321A8FEF8D5FA4E3CCB6B4B7 27A6A21684BC95A50E250E2405A12A0C5C45E56B 81FC55915E9F9CF29CA5CCCC8CD3DBA9D4A9D5F9 D065A4C15BAB88E477E2BCDBB11D694F3852F30A 6DCBABEB6C2C45AD555E7AE97CC8F04B2D55AB8C F10B85F539954AEB129594A6C885536EA74C7188 BF47331AB14B65E9225AE6869B4CA871DD4ACA16 9436B0871321CADED2F699A570D724C9E05D563E 66E21648A5CFA0C19D5C7DF851A6C890EC6F73A8 55BDD94CC7D259B879C25D92A252C32F2C106E0C 9FC9372C791AA9976B944E1A1767654AED42B540 9D56AD4DA83D16A339A0D4B97D494F38A71D7123 75ACA882A528594A512AE47281CB94BCA4FE4697 C366DDA5C9CB2CE5F723395294A22032FAE434DA

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

@NSIFS211 · 24.12.2018, 19:57 **[ТС]**

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

В общем случае нет нулей в начале.

Ну может в общем и нет. Просто мне много раз такое попадалось, когда в начале было сравнительно много нулей. Хрен с ними.

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

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

понял

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

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

Используйте https://ru.wikipedia.org/wiki/RC4
предельно простой в реализации и понимании.

В него не вникал, но когда-то читал такое:
https://ru.wikipedia.org/wiki/ГОСТ_28147-89

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

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

Довольно современный алгоритм для защиты от школьников.

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

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

КГБ/ФСБ/МВД/ГРУ/ЦРУ/АНБ/ТЕПЛОСЕТЬ/КУ-КЛУКС-КЛАН/ШТАЗИ/ГОРЛИФТ/МИ-6/ВОДОКАНАЛ/СС/ЖЭК

вдруг появятся незваные гости и приедут садить на бутылку, то помимо услуг адвоката, стоит заранее подумать о верочке:
https://www.veracrypt.fr/en/Downloads.html

Добавлено через 2 минуты
Ну а если очень хочется самому кодить, то в .NET - платформе есть System.Security.Cryptography

@NSIFS211 · 26.12.2018, 16:02 **[ТС]**

Вот вчера слепил такое:

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
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
{PascalABC.NET}
library lib13;
interface
  function CryptographySC13(data, key, iv:array of byte; mode:boolean):array of byte;
implementation
 
var arr1:array [,] of byte;
var arr2:array of byte;
 
procedure InitializeArray();
begin
  var arr3:array [,] of byte :=
  (
     (
        216,  23, 154, 115,  82,  85,  93, 122, 120, 190, 209, 188, 238,   9, 171, 142, 
        140,  40, 250, 102, 157, 139,  73,  44,  67, 101,  31,  72,  96,  30, 218, 165, 
         81, 119, 149, 163, 233, 110,  13,  92, 251, 159,  53, 104,  42, 203,  86,  32, 
        246,  56, 184, 247, 199,  66, 240,  84, 164, 144, 121,  78,  47, 155, 141, 197, 
         26, 252, 185, 236,  17, 255, 100, 158,  87,  95, 152, 103,  89, 241, 202, 248, 
         91,  59,   2,  39,  74,  27, 147, 254,  97, 239,  88,  33, 153, 111,  50, 194, 
         29, 112, 195, 150,  99,  71, 222, 129, 151, 221,   6, 172, 169,  46, 108,  94, 
        113, 117,  25, 143, 175,   7,  70,  75, 187, 253,  54,  69, 168, 148,  34, 173, 
        227, 196,  52, 201, 212, 156, 160, 228,  77,  15, 109,  28, 225,  14,   0,  79, 
        229, 183, 200, 189,  62, 127, 161,  37, 224, 178, 207, 213, 249, 125,  38,  63, 
        132, 145, 174, 243,  48, 177,   8, 244, 215, 131, 205, 232,  68,  10, 206,  64, 
        124, 219, 128, 126,  55,  80,   4, 192, 186,  76, 245, 116, 211, 118,  21, 234, 
         16, 198,  60, 182,  83, 107,  35,  45, 230, 134, 135, 237, 193,  57, 106,  20, 
          1, 181, 231,  36, 214, 226,   5, 204, 166, 167,  61,  19, 180,  24, 162, 179, 
         58, 123, 235,  22,  12, 170, 138,  41,  51,   3, 191,  49, 137, 210, 217, 133, 
        223, 130, 220, 208, 146, 242,  18, 136,  90,  11, 176,  43,  98, 114,  65, 105
     ),
     
     (
        198,  34,  38,  99, 143,  41, 100, 235, 121, 105, 116, 224,  32,  46, 228, 170, 
        172, 149, 199,  36, 169, 165,  25,  39, 175,  20, 191, 117, 234, 212, 101, 157, 
        180, 112, 122, 156,  49, 182, 163, 126, 207,   9, 138, 248,   5,  60,  23,  12, 
         42, 140,  51,  27,  22, 188, 127,  72, 139, 144,  37,  26, 211, 192, 187, 204, 
        222, 249,  21,  64, 108, 103, 179,  69, 147, 110,  82, 194, 250,  89, 184,  35, 
        241,  85, 160,  10, 123, 245, 167, 113, 216, 247,  70, 217,  62, 154, 190,  92, 
         48, 164,   6, 132, 223, 252, 134, 141,  11, 158, 230, 106, 166,   7, 176, 229, 
         19,  93, 146, 215, 239, 226, 152,  78,   2,  24, 142, 193, 221, 243, 104,  88, 
        195, 209, 218, 242,  56,  47,  45, 145,  57, 114,  63,  61,  81,  91,  74, 210, 
         18, 202,  66, 183, 237, 118, 255, 161, 130,  54,  67, 125,   3, 203, 109, 148, 
         97, 197,  43,  58,  87, 253, 254,  90,  59, 205, 120,  98,  55, 159, 133, 115, 
        155, 129, 200, 181, 185, 246,  13,  76, 206,  40, 136,   4, 102, 233, 236, 231, 
         30, 171,  14,  53, 213, 208, 177,  50, 244,  52,   1,  28, 124,  94, 186,  95, 
         73,  29, 238,   0, 151,  84, 227, 178, 174,  80,  79, 111,  68,  15, 251, 220, 
         33, 232, 189, 137, 131,  31,   8,  86,  83,  44,  17, 107, 240, 196, 225, 214, 
        173, 153,  65,  16, 135,  75, 219, 150, 162, 168, 119, 128,  77, 201,  71,  96
     ),
     
     (
          59,   2, 228,  68, 236, 229,  37, 151,  17,  86, 132, 135, 101, 113, 150,   8, 
         124, 247, 176, 195, 173, 252,  67,  78, 149,   3,  66, 186,  75, 183, 142,  62, 
         207, 107,  53, 254,  98, 106,  65, 148, 225, 154, 141,  39, 174, 203,  34,  15, 
         201, 152, 166, 118, 215,  14, 177, 198,   0, 120, 210,  49,  47, 178, 127,  29, 
         122, 206, 214, 231,  56,  12,   6,  73,  79, 179,  46, 119,  91, 189,  87,  30, 
          32,  61,  18,  36, 115,  89, 205, 168, 190, 133, 209,  55, 111,  51,  42, 187, 
         238, 196, 156, 202,  83, 167, 170, 232, 227, 185,  31, 123, 157,  21,   1,  97, 
          25, 102,  52, 250, 163, 105, 109,  71, 194,  54,  76,  33,  77,  44, 114,  90, 
          74, 218,  28, 160, 162, 129, 145,  26, 134,  92,  64, 226,  85, 139, 147, 242, 
          70, 235, 244, 137, 182, 144, 211, 161, 121, 100, 220, 126,  58,  35,  22,  43, 
         125,   7,  45, 237, 153,  38, 191, 200,  63,  23, 110, 104, 117, 128, 108, 246, 
          24,  40, 199,  93, 181, 184, 171, 224,  10, 253, 175, 219, 103, 213, 140, 251, 
          16, 158,  13,  84, 216, 130, 204,  80, 212, 233, 240,   9, 234,  57, 192, 138, 
         223, 146,  99,  72,  11,  94, 165,  48, 222,  50, 136, 159, 112, 172, 221, 248, 
         188, 131,  95,  27, 249, 197,   5,  60,  19, 255,  69,  88, 230, 180, 241, 169, 
         245, 193, 217, 239, 155, 164, 208, 116,  41,  82,  96,  20, 143,  81,   4, 243
     ),
     
     (
         72, 236, 140,  84,  12, 251, 188,  85, 206, 182, 197,  15,  96, 152, 143, 196, 
         27, 155, 109, 124,  38, 187,  67, 203, 102,  66, 167,  57, 218, 146, 164, 177, 
        230, 185, 229, 123, 212,  14, 119,   4,  10,  92, 213, 144, 112, 104,   2, 142, 
        120,  32,  16,  47, 115,  19,  62, 169, 162, 106, 228, 134,  89,  88,  40, 148, 
        173,  25,  59, 225, 113, 214,  56, 114, 248,  31, 198,  52, 121, 136,   6, 181, 
        246,  97,   5,  69,  73, 101, 241, 135,  34, 159, 153,  83,  78, 105, 216,  33, 
        217, 147,  68, 125,  50, 221,  99,  18,  82,  24,  30,  80, 250, 193,  36,  37, 
        252,  39, 222,  28,   9, 220, 170, 138, 253,  26,  70,  45, 168, 243, 192, 154, 
         11,  43, 171, 209, 175, 122, 186, 204,  65, 103,  61,  60, 223, 116, 242,  77, 
        210, 179, 211, 237, 108, 254,  41, 190, 141, 215, 156, 137,  23,  51,  44, 184, 
        219, 127, 132,  63, 110,  87, 189, 165,  35, 200, 231, 166,  90, 239, 111, 226, 
        163, 107,  29, 240, 235,   7,  13,  98, 126, 255, 201, 202, 194,  58,  48, 195, 
         21, 178, 128, 233, 238, 244, 117, 118,   0, 234, 145, 232, 158, 199, 130,  95, 
         49, 227,  53,  20, 161, 191, 207, 249,  75,  64, 247, 133, 150,  81,   3, 205, 
        160, 100, 183, 129,   1,  91,  79, 224,  93,  71, 176, 157,  22,  55, 172,  74, 
        149,  94, 151,  86, 174, 139, 245,  17, 131,  76,   8,  46, 208,  42, 180,  54
     )
  );
  
  var arr4:array of byte :=
  (
      24, 246, 207,  45,  40, 113,  81, 119, 186, 101,  65,  62,   2, 235,  79, 117, 
      52,  87, 182, 194,  33, 208,  50, 252, 214, 108, 156, 218, 250,  74, 103, 221, 
     232,   8, 206, 181, 226, 234,  21,  92, 219, 209, 164, 142,  27, 189, 162, 171, 
      55,  89, 225, 228,  44, 168, 120, 176, 126,  42,  34, 178, 203,   7, 118, 136, 
      16, 114,  59, 151, 251, 217,   9, 229,  43,  18, 175, 122, 220,  64,  95, 150, 
      67,   6, 195, 100, 124,  83,  13, 247, 187,   3,  56,  57,  17,  84,  31, 102, 
      19, 223,  48, 211,  38, 111,  60, 213, 244, 227, 115,  77, 152,  30, 249,  54, 
     177, 106, 204, 161, 130, 123, 241, 116, 240,  25, 212,  32, 202, 157, 127,   1, 
     135,  51,  88,  73, 255,  20, 143,  78, 239, 166, 112, 185, 132, 253,  28, 197, 
      86, 158, 196, 165, 110, 230,  12, 215, 144, 139, 169,  72,  94,  69, 145, 128, 
     179,  68, 183, 191,  71, 184, 200,   4, 147, 172, 224, 170, 190,  11, 173,  90, 
      10, 160,  35, 238, 167, 192, 149,  85, 243,  37,  93,  26, 153, 237,  80,  66, 
      82, 188, 233, 245,  53, 180,  99, 107,  47,  39, 205, 146,  63, 248, 199,  98, 
     193, 134, 109,  41, 222, 231,   0,  49, 154, 201, 163, 129, 105, 138, 236, 148, 
      75, 131,  46,  14, 159,  70, 198,  15, 216,  29,  23, 137,  91, 254, 121,  96, 
     104, 141, 125,  97, 133, 242, 210, 140, 155,  61,  58,  36,  76,  22,   5, 174
  );
  
  arr1 := new byte [4, 256];
  for var i:integer := 0 to 3 do
    for var ci:integer := 0 to 255 do
      arr1[i, ci] := arr3[i, ci];
      
  arr2 := new byte [256];
  for var i:integer := 0 to 255 do arr2[i] := arr4[i];
end;
 
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 Uint32ToByteArray(x:longword):array of byte;
begin
  var a:array of byte := new byte [4];
  for var i:integer := 0 to 3 do a[i] := 0;
  var b:longword := x;
  var c:integer := 0;
  while ((b div 256) <> 0) do
  begin
    a[c] := (b mod 256);
    b := (b div 256);
    c := (c + 1);
  end;
  a[c] := b;
  Result := a;
end;
 
procedure LFT(var a:array of byte);
begin
  var b:byte := a[0];
  for var i:integer := 0 to 2 do a[i] := a[i + 1];
  a[3] := b;
end;
 
function FFN(x, y:longword):longword;
begin
  var a:longword := ((x + y) mod 4294967296);
  var b:array of byte := Uint32ToByteArray(a);
  for var i:integer := 0 to 3 do b[i] := arr1[i, b[i]];
  LFT(b);
  Result := System.BitConverter.ToUInt32(b, 0);
end;
 
procedure FeistelNetwork(var x:array [,] of byte; RKey:array of longword; index:integer);
begin
  var a, b: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
    b := (FFN(a, RKey[i]) xor b);
    if (i <> 7) then Swap(a, b);
  end;
  var w:array of byte := Uint32ToByteArray(a);
  for var i:integer := 0 to 3 do x[i, index] := w[i];
  w := Uint32ToByteArray(b);
  for var i:integer := 4 to 7 do x[i, index] := w[i - 4];
end;
 
function RoundKey(var key:array of byte; y:array of byte; usingReverse:boolean):array of longword;
begin
  for var i:integer := 0 to 7 do key[i] := (key[i] xor y[i]);
  var b:array of longword := new longword [8];
  var c:array [,] of byte := new byte [2, 4];
  var d:array of byte := new byte [4];
  
  for var i:integer := 0 to 1 do
    for var ci:integer := 0 to 3 do
      c[i, ci] := key[i * 4 + ci];
  
  for var i:integer := 0 to 1 do
    for var ci:integer := 0 to 3 do
    begin
      for var xi:integer := 0 to 3 do
        d[xi] := arr2[((c[i, ci] + c[(i xor 1), xi]) mod 256) xor (i * 4 + ci)];
      b[i * 4 + ci] := System.BitConverter.ToUInt32(d, 0);
    end;
  
  if usingReverse then System.Array.Reverse(b);
  Result := b;
end;
 
procedure BlockTransform(var x:array [,] of byte; var a, s:array of byte; mode:boolean; i:integer);
begin
  var b:array of longword := RoundKey(a, s, (not mode));
  for var ci:integer := 0 to 7 do s[ci] := x[ci, i];
  FeistelNetwork(x, b, i);
  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, i)
    else for var i:integer := (x.GetLength(1) - 1) downto 0 do
      BlockTransform(x, a, s, mode, i);
end;
 
function CryptographySC13(data, key, iv:array of byte; mode:boolean):array of byte;
begin
  InitializeArray();
  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.

Работает быстрее, чем предыдущий, но насколько именно - не проверял. (для On18 - кроме сложения 32-битных чисел по разным модулям там ничего и нету

). На баги особо не проверял, но по крайней мере запустилось. Тест нулей прошел нормально. Кто что может сказать по этому коду?

Архив с исходниками:

@NSIFS211 · 26.12.2018, 16:04 **[ТС]**

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

@On18 · 27.12.2018, 18:36

Выглядит на много лучше.
Сойдет.

@NSIFS211 · 27.12.2018, 20:12 **[ТС]**

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

Выглядит на много лучше.
Сойдет.

УРААА!!!

@NSIFS211 · 29.12.2018, 17:19 **[ТС]**

хотя рано радоваться....

нашел потенциальную какашку:

Pascal
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
procedure LFT(var a:array of byte);
begin
  var b:byte := a[0];
  for var i:integer := 0 to 2 do a[i] := a[i + 1];
  a[3] := b;
end;
 
function FFN(x, y:longword):longword;
begin
  var a:longword := ((x + y) mod 4294967296);
  var b:array of byte := Uint32ToByteArray(a);
  for var i:integer := 0 to 3 do b[i] := arr1[i, b[i]];
  LFT(b);
  Result := System.BitConverter.ToUInt32(b, 0);
end;

здесь:

Pascal
1
2
3
  var b:array of byte := Uint32ToByteArray(a);
  for var i:integer := 0 to 3 do b[i] := arr1[i, b[i]];
  LFT(b);

хотя сдвиг на 1 байт влево и делается, он мало что дает. каждый байт отвечает фактически сам за себя и может как-то изменить остальные разве что в следующем раунде. для простоты выкинем нах сложение по модулю 2^32 в самом начале и заменим его перексориванием. если изменился первый байт открытого текста в левом блоке, он не повлияет ни на какие байты, кроме самого себя, но когда правый блок будет перексориваться с результатом функции, то этот измененный байт окажется последним, потом на следующем раунде предпоследним и т.д. а копия входящего блока, которая потом подается на перексоривание сети фейстеля, сдвига не претерпевает, и в конечном счете за 16 раундов какой-то лавинный эффект по тексту будет, но окажется ли он достаточным? может стоит добавить нечто в духе перексоривания первого байта со всеми остальными, а только потом производить подстановку? по крайней мере если оставить все как есть, и попробовать нарисовать схему, то на 4 раунде он зацикливается, получая возможность поменять только половину байтов, а если добавить перексоривание, то на 2 раунде может влиять на все.

Добавлено через 3 минуты
есть еще идея увеличить для ЧСВ размер ключа и блока до 128 бит. стоит?

@NSIFS211 · 01.01.2019, 21:24 **[ТС]**

С новым годом!

@NSIFS211 · 03.01.2019, 14:08 **[ТС]**

К стати, функцию расширения ключа

Pascal
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
function RoundKey(var key:array of byte; y:array of byte; usingReverse:boolean):array of longword;
begin
  for var i:integer := 0 to 7 do key[i] := (key[i] xor y[i]);
  var b:array of longword := new longword [8];
  var c:array [,] of byte := new byte [2, 4];
  var d:array of byte := new byte [4];
  
  for var i:integer := 0 to 1 do
    for var ci:integer := 0 to 3 do
      c[i, ci] := key[i * 4 + ci];
  
  for var i:integer := 0 to 1 do
    for var ci:integer := 0 to 3 do
    begin
      for var xi:integer := 0 to 3 do
        d[xi] := arr2[((c[i, ci] + c[(i xor 1), xi]) mod 256) xor (i * 4 + ci)];
      b[i * 4 + ci] := System.BitConverter.ToUInt32(d, 0);
    end;
  
  if usingReverse then System.Array.Reverse(b);
  Result := b;
end;

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

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

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

возможно ли это конкретно для этой функции на практике - неизвестно.

теперь известно. можно.

к случайному ключу

[67, 58, 109, 198, 22, 192, 208, 39]

у меня вручную получилось вычислить эквивалентный:

[73, 64, 115, 204, 16, 186, 202, 33]

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

Добавлено через 2 минуты
код для проверки чтоб другие не писали себе заново:

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
var arr2:array of byte;
 
procedure P1();
begin
    var arr4:array of byte :=
  (
      24, 246, 207,  45,  40, 113,  81, 119, 186, 101,  65,  62,   2, 235,  79, 117, 
      52,  87, 182, 194,  33, 208,  50, 252, 214, 108, 156, 218, 250,  74, 103, 221, 
     232,   8, 206, 181, 226, 234,  21,  92, 219, 209, 164, 142,  27, 189, 162, 171, 
      55,  89, 225, 228,  44, 168, 120, 176, 126,  42,  34, 178, 203,   7, 118, 136, 
      16, 114,  59, 151, 251, 217,   9, 229,  43,  18, 175, 122, 220,  64,  95, 150, 
      67,   6, 195, 100, 124,  83,  13, 247, 187,   3,  56,  57,  17,  84,  31, 102, 
      19, 223,  48, 211,  38, 111,  60, 213, 244, 227, 115,  77, 152,  30, 249,  54, 
     177, 106, 204, 161, 130, 123, 241, 116, 240,  25, 212,  32, 202, 157, 127,   1, 
     135,  51,  88,  73, 255,  20, 143,  78, 239, 166, 112, 185, 132, 253,  28, 197, 
      86, 158, 196, 165, 110, 230,  12, 215, 144, 139, 169,  72,  94,  69, 145, 128, 
     179,  68, 183, 191,  71, 184, 200,   4, 147, 172, 224, 170, 190,  11, 173,  90, 
      10, 160,  35, 238, 167, 192, 149,  85, 243,  37,  93,  26, 153, 237,  80,  66, 
      82, 188, 233, 245,  53, 180,  99, 107,  47,  39, 205, 146,  63, 248, 199,  98, 
     193, 134, 109,  41, 222, 231,   0,  49, 154, 201, 163, 129, 105, 138, 236, 148, 
      75, 131,  46,  14, 159,  70, 198,  15, 216,  29,  23, 137,  91, 254, 121,  96, 
     104, 141, 125,  97, 133, 242, 210, 140, 155,  61,  58,  36,  76,  22,   5, 174
  );
 
  arr2 := new byte [256];
  for var i:integer := 0 to 255 do arr2[i] := arr4[i];
end;
 
function RoundKey(var key:array of byte; y:array of byte; usingReverse:boolean):array of longword;
begin
  for var i:integer := 0 to 7 do key[i] := (key[i] xor y[i]);
  var b:array of longword := new longword [8];
  var c:array [,] of byte := new byte [2, 4];
  var d:array of byte := new byte [4];
  
  for var i:integer := 0 to 1 do
    for var ci:integer := 0 to 3 do
      c[i, ci] := key[i * 4 + ci];
  
  for var i:integer := 0 to 1 do
    for var ci:integer := 0 to 3 do
    begin
      for var xi:integer := 0 to 3 do
        d[xi] := arr2[((c[i, ci] + c[(i xor 1), xi]) mod 256) xor (i * 4 + ci)];
      b[i * 4 + ci] := System.BitConverter.ToUInt32(d, 0);
    end;
  
  if usingReverse then System.Array.Reverse(b);
  Result := b;
end;
 
begin
P1();
repeat
  var a:array of byte := new byte [8];
  var b:array of byte := (0, 0, 0, 0, 0, 0, 0, 0);
  for var i:integer := 0 to 7 do
  begin
    Write(i, ' = ');
    a[i] := 0;
    Readln(a[i]);
  end;
  
  var c:array of longword := RoundKey(a, b, false);
  for var i:integer := 0 to 7 do Writeln(c[i]);
  Writeln();
until (false);
end.

Добавлено через 33 минуты
вот собсно расчет:
берем случайный ключ:

[67, 58, 109, 198, 22, 192, 208, 39]

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

[67, 58, 109, 198]
[22, 192, 208, 39]

и для более общего вида нумеруем эти числа:

[A, B, C, D]
[E, F, G, H]

составляем таблицу подстановок:

[A + E] [A + F] [A + G] [A + H]
[B + E] [B + F] [B + G] [B + H]
[C + E] [C + F] [C + G] [C + H]
[D + E] [D + F] [D + G] [D + H]
[E + A] [E + B] [E + C] [E + D]
[F + A] [F + B] [F + C] [F + D]
[G + A] [G + B] [G + C] [G + D]
[H + A] [H + B] [H + C] [H + D]

теперь берем любое число из этого списка и присваиваем ему любое значение:

A = 73

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

(a + e) mod 256 = (67 + 22) mod 256 = 89
(e + 73) mod 256 = 89
e = (89 + 256 - 73) mod 256 = 16

это у нас число под номером e в эквивалентном ключе.
аналогично получаем:

(b + e) mod 256 = (22 + 58) mod 256 = 80
(b + 16) mod 256 = 80
b = (80 + 256 - 16) mod 256 = 64

(c + e) mod 256 = (22 + 109) mod 256 = 131
(c + 16) mod 256 = 131
c = (131 + 256 - 16) mod 256 = 115

(d + e) mod 256 = (22 + 198) mod 256 = 220
(d + 16) mod 256 = 220
d = (220 + 256 - 16) mod 256 = 204

(a + f) mod 256 = (67 + 192) mod 256 = 3
(f + 73) mod 256 = 3
f = (3 + 256 - 73) mod 256 = 186

(d + g) mod 256 = (198 + 208) mod 256 = 150
(g + 204) mod 256 = 150
g = (150 + 256 - 204) mod 256 = 202

(d + h) mod 256 = (198 + 39) mod 256 = 237
(d + 204) mod 256 = 237
h = (237 + 256 - 204) mod 256 = 33

вот и выходит эквивалентный ключ:

[73, 64, 115, 204, 16, 186, 202, 33]

@NSIFS211 · 06.01.2019, 16:45 **[ТС]**

вот немного помозговал и сделал так:

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
214
215
216
217
{PascalABC.NET}
library lib23;
interface
  function CryptographySC23(data, key, iv:array of byte; mode:boolean):array of byte;
implementation
 
var arr1, arr2:array [,] of byte;
 
procedure InitializeArray();
begin
  var arr3:array of byte := System.IO.File.ReadAllBytes('SC23.bin');
  
  arr1 := new byte [8, 256];
  arr2 := new byte [8, 256];
  
  for var i:integer := 0 to 7 do
    for var ci:integer := 0 to 255 do
    begin
      arr1[i, ci] := arr3[i * 256 + ci];
      arr2[i, ci] := arr3[i * 256 + ci + 2048];
    end;
 
end;
 
function OpenText1to2(x:array of byte):array [,] of byte;
begin
  var a:integer := x.Length;
  var b:array [,] of byte := new byte [16, ((a div 16) + 1)];
  var c:integer := 0;
  try
    for var i:integer := 0 to (a div 16) do
      for var ci:integer := 0 to 15 do
      begin
        b[ci, i] := x[c];
        c := (c + 1);
      end;
  except on System.IndexOutOfRangeException do
    begin
    end;
  end;
  b[15, (a div 16)] := (16 - (a mod 16));
  Result := b;
end;
 
function OpenText2to1(x:array [,] of byte):array of byte;
begin
  var a:integer := x[15, (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 15 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 15 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 16);
  var b:array [,] of byte := new byte [16, a];
  var c:integer := 0;
  for var i:integer := 0 to (a - 1) do
    for var ci:integer := 0 to 15 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 15 do
    x[i, 0] := (x[i, 0] xor iv[i]);
end;
 
function FFN(x:array of byte; y:array [,] of byte; index:integer):array of byte;
begin
  var a:array of byte := new byte [8];
  for var i:integer := 0 to 7 do
    a[i] := ((x[i] + y[i, index]) mod 256);
  
  for var i:integer := 1 to 7 do
    a[i] := (a[i] xor a[0]);
  
  var b:byte := a[0];
  for var i:integer := 0 to 6 do
    a[i] := a[i + 1];
  a[7] := b;
  
  for var i:integer := 0 to 7 do
    a[i] := arr1[i, a[i]];
  
  Result := a;
end;
 
procedure ByteXor(var x:array of byte; y:array of byte);
begin
  for var i:integer := 0 to 7 do
    x[i] := (x[i] xor y[i]);
end;
 
procedure FeistelNetwork(var x:array [,] of byte; RKey:array [,] of byte; index:integer);
begin
  var a, b:array of byte;
  a := new byte [8]; b := new byte [8];
  
  for var i:integer := 0 to 7 do
  begin
    a[i] := x[i, index];
    b[i] := x[(i + 8), index];
  end;
  
  for var i:integer := 0 to 15 do
  begin
    ByteXor(b, FFN(a, RKey, i));
    if (i <> 15) then Swap(a, b);
  end;
  
  for var i:integer := 0 to 7 do
  begin
    x[i, index] := a[i];
    x[(i + 8), index] := b[i];
  end;
end;
 
procedure REV1(var x:array [,] of byte; index:integer);
begin
  for var i:integer := 0 to 7 do
    Swap(x[i, index], x[i, (15 - index)]);
end;
 
function RoundKey(var key:array of byte; y:array of byte; usingReverse:boolean):array [,] of byte;
begin
  for var i:integer := 0 to 15 do
    key[i] := (key[i] xor y[i]);
  
  var a:array [,] of byte := new byte [8, 16];
  
  for var i:integer := 0 to 15 do
    for var ci:integer := 0 to 7 do
      a[ci, i] := arr2[ci, ((key[ci + (i mod 2) * 8] + i) mod 256)];
  
  if usingReverse then
    for var i:integer := 0 to 7 do REV1(a, i);
  
  Result := a;
end;
 
procedure BlockTransform(var x:array [,] of byte; var a, s:array of byte; mode:boolean; i:integer);
begin
  var b:array [,] of byte := RoundKey(a, s, (not mode));
  for var ci:integer := 0 to 15 do s[ci] := x[ci, i];
  FeistelNetwork(x, b, i);
  for var ci:integer := 0 to 15 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 [16]; s := new byte [16];
  for var i:integer := 0 to 15 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, i)
    else for var i:integer := (x.GetLength(1) - 1) downto 0 do
      BlockTransform(x, a, s, mode, i);
end;
 
function CryptographySC23(data, key, iv:array of byte; mode:boolean):array of byte;
begin
  InitializeArray();
  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.

чтобы 16 замечательных табличек по 256 байт не мозолили глаза, выписал их в отдельный бинарник, содержимое которого в hexadecimal выглядит так:

Code
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
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
0daf 799e ee22 f5e5 0327 ea68 6fc6 5909
14dc ec65 dfc1 10a3 d7b3 b8d5 d354 e308
6c70 23ac 7664 b54d cf0c 851c 82e0 2f88
ebef c2b6 febf 2c2a e8d8 363d 7d41 fb1b
7f3b d6e7 6398 dedd bdd2 2605 8a19 f683
58ae 9749 5bff b0cb a072 fc61 33bc 6aa5
4b31 37a4 351e 1ac5 6e60 4ab4 adab 5ec3
e2a1 7e25 f378 38fd 2104 d12b db17 537a
077c b251 cafa 5f32 c045 da62 7b84 e45c
8b29 3ced 509d 8ec4 a946 b116 ced0 8718
a830 896b 01aa 1d8c 9a3f 5a55 4081 4871
cc39 4244 e9f8 c812 56bb 95b7 9111 a794
b90f 9b2e f477 243a 570e 1f73 e100 998d
f702 280a 6913 3e52 f9ba 068f 74c9 cda6
9c75 5d20 479f 96f2 2d66 4c34 906d e6d9
1586 c74f a2f1 be80 d493 0b4e f092 4367
3279 2539 8460 bf1b 1990 2708 5d14 85bc
66d3 3cd5 a244 e134 c0da 933a 51b4 6d4b
ae04 330f 47a5 d995 e501 2da8 ea7e f670
ee3e c899 af96 d6ab f977 2391 a72c fb16
7505 c2e0 e8e3 1da9 7d09 d20a dc46 64c5
df73 83b1 586c 314d ccff accd c70e 3fd0
136e bb53 3b40 7b0d 45b7 97ec a13d c112
1f43 871a 5f0b 9b98 fa20 7176 48f2 ad9e
c34f db59 d7e7 728d eff1 f0b0 61b6 005a
414a 2ede 7a6f 67ca 5265 2acf edba 6b54
50e6 f4b2 fc11 cb69 8e35 d142 3049 88d8
c41c 9d7c fd9a a392 7f94 744c 8b2b f318
7802 0cdd 688f 0789 63b9 17a4 5728 155c
81bd b329 3738 beeb c921 f7fe 2fe9 6a06
869c 80aa 628c b8e2 82f5 5ec6 10a0 8a24
55f8 b51e d44e 2636 a603 e422 56ce 5b9f
fb93 9b6f afda e400 d8a1 b9a0 6cfa 3b47
426e 75c9 c71a d425 c612 3430 6274 16ea
4c60 3210 2ead 0edb cff6 8308 dcfe 9488
2aba 5576 ce89 d30a 3568 bc4e e736 4db1
b4f3 5d1f 4158 d007 5b7c a6f5 c38b 9513
3df7 5378 8c3a 9798 15d1 edd9 ef33 7746
8781 9fc2 5643 e91d a717 283c 5704 4a69
7239 2951 bbe2 fc40 a337 f80b 097f bd73
b50c 181e 8531 7b66 a205 9cf4 5f6a 23aa
2202 8a99 c55e c006 ddcb 27b7 26c8 8dc4
ecdf 54d6 6b8e 0db6 82a4 7a91 5211 ccca
fd45 6d80 b37d 5a19 4fe0 9a3f 2061 1c96
f2bf 7944 9286 67c1 ee01 2db0 b248 e863
a9de e65c f070 d538 8f9e f9a5 0f24 6449
6559 719d b8e3 8490 bed7 2b2f 4bae ff1b
f1e5 14ac 50eb cda8 0321 2cd2 7ee1 ab3e
d96b a485 695a d434 040b bef6 cc8c 2721
7447 fb4b 9b60 d694 2242 cdfa 9ddb e8a3
4c38 729c c5c3 de3c 451b bb37 0565 5e0a
dd08 1f61 c1c9 e48f 6dba af03 7d73 15b2
2563 4057 a546 8ab7 0e39 16e2 7666 674e
5c44 a1d3 99a6 291d ca6f 9e33 1c59 aa89
2bed b343 3298 f541 7c20 c4fd 56df 9383
0fa9 8107 9686 6ccf 0d23 2f4a 5dae 9592
b46e f014 ad5f 3ae3 78a0 3d02 f430 e7d7
3ec0 fc80 876a 8e54 49c6 849a 0611 77a2
f7c2 4fb8 fe18 e935 bfb6 682e eedc 7f36
2cf2 cb2a 887e 7aec 8d26 2462 1ad2 5364
b1bc ac0c 7be6 b9f1 b531 10e1 d152 efa7
e091 50ea 753b 7913 82bd 4dd5 2871 ce55
129f 01f3 9009 f958 3fb0 175b f88b ebda
ff70 abd0 d851 4897 2dc8 191e e500 a8c7
8843 03b2 93eb 414d 18ff d69a 73ae d012
89a1 2539 b656 a9de 7c3f 8bca 702b 093d
bb2e ad50 f222 c4f4 e6a8 b081 0b8f c526
429c 342d 0a27 92cd 522c 1906 20e3 3202
00b5 8d31 e8a6 2a14 d3ba e0cc f95b 6c65
84fe 973b b129 79e4 df4c 0c67 eac0 1bc3
7a59 bf77 e758 3caf d440 950e 10a7 76cb
effa b896 63e2 5ced 45d5 a501 d7ec f785
dae5 69f0 a3dd db98 30f5 4953 fdc7 1c7e
7b1d 91d1 75c8 b428 375f 35aa 8366 9f60
23d2 eedc 8c7f b36e 1355 abbe 3615 8ef3
94d9 1f1e b9cf 4e4b a286 e99e 5d9d 510d
8754 f86a b780 2182 5772 6848 7447 d899
a4f1 c633 786b 8aa0 ce1a 5efc 07bd 46fb
6f62 ac44 0511 c23e 9b2f c916 174f 7d61
6df6 9024 7104 e108 bc0f 4a38 3ac1 645a
9fdf 5a89 055f a5aa 0e25 684f 276a b484
a4b6 c31c f077 928a 3b3c 39ad 93cd e99e
a098 1fe6 5eb8 b223 e20a 4c24 3361 bf44
9179 4b01 64ee 1813 2cfb 4abb c566 5b3e
e07e 2634 9c71 b5f7 aee5 8bcc f9d8 0c67
8fd3 5438 feb1 f216 d130 6945 0472 2b35
7573 ef6c 8506 dc28 2da6 a856 d7db 948c
035c eaac 32de 3dc1 8dd2 ce7d d9c9 31c7
6e0d 53a1 fde1 996d b7f3 8019 4e59 7097
cf4d 1229 0fa3 d47f da08 d036 0bcb aff1
577b bdf6 7a83 caf8 c241 15fc 95ff 1a8e
2a82 493a 1dc0 4700 1437 9dec c617 e75d
5546 6222 b0bc 8652 65c8 5874 2178 fa96
09d6 0751 f51b 81be 639a c4ba e3a7 606f
766b 2eb3 50e4 3f7c 2feb 48a2 d5ab b9e8
8811 90f4 20ed 10a9 4387 4240 02dd 1e9b
6cc9 4120 9929 3e37 3a5f 1392 9556 2ad4
fdf8 0b9c f019 6b44 5891 f586 e35d b38b
bcf9 09fe 6ab9 4a03 0eab edcb 7831 9d3c
fa30 6e47 9fba 15f7 e802 b6ad c5cf f301
a467 51b4 1825 b714 b02d 2ce2 7011 7c97
16df 8de9 9b85 66a1 4d42 360f 75e7 71b1
8a28 8f00 5248 ff45 827d 345b 6239 a31a
89dc 94a2 4baa d827 d550 5edb ebda ea4e
0d74 0880 c422 e0a6 7af2 c62e 071f d1d7
d912 17fb 60fc a0e1 dd64 ccc2 b2f4 a8af
2fc7 efe5 e683 c83d bdbb 2687 6349 3be4
ec35 9a06 0cbf 5c76 1c53 9ed2 a9c0 ce2b
10ca 0a8c 7fb8 90ee 3304 aea7 d640 cd98
7e8e 9688 84ac c323 3f46 6f72 2469 d0c1
1e5a 6805 57f6 81be 651d 217b 7754 4c43
9355 5961 a5b5 7973 d31b de4f 32f1 6d38
598d e992 b47e a911 e4b0 9701 d1c6 945c
aa10 df4d 6b5e 3cbf 1424 ad99 2f0b c71e
331b c9d0 85a6 2b02 189b 1f38 05f8 7c2e
1687 668c 259f 41a7 ce57 4eff 84a8 dab5
58f7 c86a 3f19 b1ba fc37 312d f036 3d20
7479 a470 f148 76bc 1545 0e62 a044 8b77
7367 6017 ab9c aee1 727b 51cf 834b d353
86e7 8afd 6534 0cdd aff5 89a3 78fb ecb2
509d 4a6c 5b9e ea26 0dcc 49c3 000a d7d5
dbee 271c 287d 6346 0669 cad4 acc1 8efa
7fc4 61f9 dce0 0781 30a5 fe95 09b8 4c55
b6c5 0390 bede 1229 b9bb 5ad9 f40f cd75
223e 2171 5d9a 08ed 42bd cbe8 ef80 eb56
f23b 6fe2 d647 b36e 3ae3 4f43 232c 047a
f31d 9893 3282 8f5f e5d2 6891 52f6 39c2
40b7 886d 13e6 9664 35d8 a1c0 2aa2 541a
9b81 fd9a 6dde 7582 4fa9 833f 1164 f712
d19c e72f f868 60d8 8d2a ef7c 96cb 8b4b
6cc1 77b0 4617 cdf5 58b7 ce7f 19db 4a3e
9757 2024 c4ba 1643 e6c9 9d02 445d c8dc
42e3 2221 1f59 4c93 0fe0 a315 ca66 3861
513c c0b1 902c fff3 5565 3d7a e873 5f86
6f0d be7e 8c5b 36fe a7f9 ae5c bd03 6a28
e5d3 fb88 00e2 a174 71a8 3a01 9fad 25dd
d27b cf4e 6eab 5694 34bf 7605 9818 14c6
0992 2dd4 0ae1 79da cc30 afb3 54ec b629
84b2 1a8e 9e1d 627d a653 4750 6bbc 264d
7880 d6ac a504 f21c 9937 8552 b52b 0c27
aa49 95df 91e9 c5e4 f4fa 3bf0 b431 d7d5
8aee edd0 7008 c21e 07eb 0e48 a0f1 3389
720b 1b69 d939 b940 1045 3213 5e87 ea63
f6a4 67bb a223 06fc 352e 5ac7 b841 c38f
ab25 7ba2 758e 8566 899f 38f4 d653 bf10
dc3d cb2f 009b e513 decf 0f2b 23c5 02f5
463f 6073 4aa4 5c54 a01c d9a9 21d2 b939
3efe 70f2 d18f 275b 1736 12f6 5109 30cc
7682 d4ce 98e2 28eb 630c fab1 4e6a e7ff
0e1e c229 db6f c383 c994 ae6d 934d 33fd
0807 a148 b6ca 471f 6b86 5fa7 1dd5 068b
5a5e c71b 680b 8119 f9ef 4cbd 4b1a 5595
4941 8a90 a89a edbe 7d04 f384 d72e e13a
bad3 dd24 e643 daf1 b2ea 88fb 7cb0 f0b4
96e8 45bb 7eb5 ece3 208c ad69 747a a58d
6c16 a6b8 78aa 5d18 87d8 a391 0314 0d72
c6f7 c440 2cf8 fcd0 6434 3c11 3150 ee92
2280 9cbc c19e 6edf 3b7f e037 2635 b356
42ac 2de4 4fb7 0179 c815 2a32 6158 cd0a
7105 59af c077 6762 9d52 57e9 4499 6597
aafb 2d9b 5a79 3703 667f a596 0a63 b05f
f890 cb62 6fc0 5d16 24a4 ef3e 60ba 64e0
c7d2 3b46 f39a 6905 eaae a080 5713 29eb
3f3d bb7a f931 e1bd c655 f60d 586c f735
e287 d8e8 98b9 cf1f fee5 fd1d 8684 344e
8117 76d1 7472 5e18 0e8c d021 f067 0761
9710 088a 3919 b62c 4ddd e9e7 b8bc 8fc2
892a 049c 11ad c13c 596d f42f c3c9 fa7c
8d9d de78 4099 921a 2554 4193 9583 ec6a
a2e3 4b0f 4894 4a09 28af d977 ac14 9f45
0c06 ee8e b5a6 73be 6e42 cedb 00e6 5ba8
3056 4338 2327 6836 f185 534c abdf 478b
f565 3abf 2bc4 a9d3 325c 4fb7 029e 01ed
917d 50b4 d5dc c51e 2ecc 1b75 22f2 a1fc
88d4 710b ff12 6bb3 d6a3 2015 52da 44d7
70e4 a7b1 c87e ca7b 1c26 82b2 4951 cd33
db27 601c 0165 f678 5f4e 2442 45eb b9cb
ef22 91f3 c603 96a8 1751 6e92 4f38 9d08
2673 b1be 863c af9b a1e6 3739 a730 0a62
3ec5 7a35 47a0 2d18 0705 5cab 15ed c767
4182 cfb3 dc33 cdc0 d7ff ddee ca8d 32c4
6fa3 7657 e11f 53b0 ec34 b6f0 def1 9cd9
79d4 b4d1 7513 fe7d 6d1b 3b84 f91d d580
aea6 256b 23fa 99f7 ad4d 1a8f 46c3 0c83
8efd 025a c8b8 1940 043a bda9 7bd0 4843
066c 7cb2 202f 9061 bcba fb87 7e9a 0d54
10e5 e758 1e8a 88e8 d336 7431 77d2 70b5
e2bf 947f 2b98 97cc ce93 c25d 4ce9 6a66
72a2 1229 4a95 56ac 5564 f228 e4da 2e5b
f509 44b7 a414 e0e3 508b 9e16 ea2a 8568
df0e 8952 69c9 d600 a563 9fbb 2c81 aaf8
d84b 1121 c18c f4fc 5e71 3d0f 0b49 3f59
dc1b c7b2 76c4 e41e 7ff0 4c4d 96fd eb66
810b 4739 e1bf d328 4f0e bd86 135b 8477
c2ca ba11 a522 44ad ffb3 d5df 5e43 a393
fb42 e3b1 3b33 8cab 153c 9236 37d6 04cc
05db 56ce cdfc 59cb 7e12 8399 fa09 143e
5aae 7320 aad4 0a16 1825 0f64 1723 e0b0
c62c c953 63f2 6e68 a235 f9b4 55da 9e69
7c2e 9a72 249f b679 279d e71c 494a 1f9c
5207 8746 6ade f86b 1003 65cf 0d80 4e34
822b b561 e521 85ee 883a ac32 d789 af41
5c62 b86d 4506 c3a4 6f01 dd7d 1951 8b7b
8ff5 a729 8a3f 6c94 58e9 4bf4 d290 d830
c8b9 9b71 b7a8 2f97 e270 f3c5 eda0 f6e6
8dd0 5fea 0875 7438 4857 eff7 fef1 d931
be3d 9598 2a8e bc5d 9140 50ec d1a1 0226
c160 7ac0 a900 0c67 54a6 1de8 2d78 1abb
50ee 8379 f96b f58b cb38 36fa ac5e 7efe
60fd eb46 8af7 8132 d9e8 b188 cf8d 7bfc
de22 9c0d bf14 402e 707f 35ff f86c 1ae7
b061 00b2 723d 4205 d6ef 9078 02c0 0f89
da0b 2b84 24dd bddf d8e6 e495 85d1 94d5
5a86 5b7d ca3a 87c8 a228 6409 a0b7 b8ad
dc76 3720 68d7 ae82 624f 1d15 991e 4329
965f f63f aa4d 5357 a5b6 2547 04ce 2a3c
eca4 6769 6dc4 51bc c1f3 bac6 307a 9777
0c6f c366 1093 121b 411c b5e3 176a e09e
e2c9 65d3 ab8f 9bbb 56a3 f258 f406 a7a8
0116 5921 af1f 082c 3bd2 cd5c 3975 c2b9
8e73 5448 9fbe 1926 cce9 d04a e1a1 338c
71b3 5207 18c7 2f74 7c6e a663 2df0 0a0e
2798 03db 4b13 b4c5 3449 5d23 d43e f14c
119d 4592 a9ea fb44 9ae5 9131 4e80 ed55
a58d df05 2b0a fdff 5524 6bb8 3d6d e29f
93d6 59bc c743 8403 fb4f 6661 ac6a c373
91bf b96f fcd8 2a68 b035 0b64 3725 1e3e
3870 878a 412d 1007 a330 7ca9 a75f 3ccc
0133 f5f7 95e9 8cda 8f7a 9adb 1ce8 a80e
c06e ab54 c249 eb4a 3f71 d13a cb89 0844
659c e6de 7534 e747 c87e 2c46 b557 72aa
22c9 b342 fe79 d097 860f cda2 f15a ddf8
28ae 8027 855c 2eea f402 c5f3 7bc1 14d9
4b0c d316 a600 3b31 6006 7f4e bde5 81af
ef82 fa5d b2c4 7874 1713 7d20 2fe0 488e
e4d4 f05e cef6 519b dcb7 0d99 a1f2 ee09
129d 1fad b4e3 4cba 40d2 1a56 3958 92b6
cf45 8326 a429 188b d71b 1104 96d5 2150
7763 c698 6962 329e e167 534d 1d15 caa0
9476 8836 beb1 ed23 5b90 ecbb 1952 f96c
0746 cbc3 a1e2 b34a 0a84 62b0 e33c 8fab
da6a a06b 531a 4cad dfc8 8e91 49d6 ac44
f150 f7ae 65e8 e797 7deb 8988 8a37 7cc6
8506 a64b f46d 221b 56b8 cafd 5d57 0ef3
9447 d10f 547b c998 41fb 82a9 6c99 21b7
b29f e6c7 ccaa c52e 7a81 788b 2a75 401e
2593 8309 d942 c0cf 1d19 7fe0 61d0 03d2
de36 176e c243 5e4e fab9 5227 2b6f c4f5
5135 8d9b 1323 1615 385f 0d3d 7479 bdec
3bed 6655 9631 45b1 9e8c a55b 10d7 693a
1808 ba12 3ff2 ea05 67af 7e58 92fe 8760
b50c ff77 fc1f 959c f6f0 73f9 90ef 2920
59db 1c32 2d14 4ff8 bbc1 869d 2434 ee72
71e1 d4a2 e4bc 30bf 6863 3edc 282f ddd8
2c9a 485c 76a7 5aa8 d304 a302 d5b4 01ce
e539 0026 b64d 0bcd 11a4 8064 33be e970

а процедура непосредственно заполняющая массивы стала выглядеть приятнее:

Pascal
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
var arr1, arr2:array [,] of byte;
 
procedure InitializeArray();
begin
  var arr3:array of byte := System.IO.File.ReadAllBytes('SC23.bin');
  
  arr1 := new byte [8, 256];
  arr2 := new byte [8, 256];
  
  for var i:integer := 0 to 7 do
    for var ci:integer := 0 to 255 do
    begin
      arr1[i, ci] := arr3[i * 256 + ci];
      arr2[i, ci] := arr3[i * 256 + ci + 2048];
    end;
 
end;

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

Еще заметил, что раундовые ключи и результаты образующей функции нет смысла передавать в виде чисел - в самом деле, вот мы в образующей функции все делаем, делаем, делаем над массивом из байтов, переводим его в беззнаковое целое... НАХ?!! чтобы перексорить его с правым блоком и в следующем раунде обратно разложить на 8 байт? так проще сразу передать его массивом. ну а что до сложения по модулю 2^64 можно просто попарно складывать байты по модулю 256, один хер ничего не поменяется. результат вычислений конечно поменяется но суть - нисколько. с раундовыми ключами то же самое. для функции расширения ключа вроде получилось показать, что эквивалентных ключей у нее нет, и что для каждого ключа не существует такого второго, что при расширении этого второго получится тот же ключ, что и для первого, только в обратном порядке.

Кто что может сказать по этому коду? Какие перспективы его стойкости?

архив с исходниками:

@NSIFS211 · 06.01.2019, 16:52 **[ТС]**

байты для табличек брал отсюда:

https://www.random.org
опять же каждая табличка содержит 1 байт только 1 раз и значение каждого байта не совпадает с его индексом в таблице. больше никакие критерии к табличкам не предъявлялись

@NSIFS211 · 14.01.2019, 16:32 **[ТС]**

вот еще напоследок составил такой код (по ходу самый нормальный)

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
214
215
216
{PascalABC.NET}
 
library lib25;
interface
  function CryptoSC25(data, key, iv:array of byte; mode:boolean):array of byte;
implementation
  
  var arr1, arr2, RoundKey, arrX:array [,] of byte;
  
  procedure InitializeArray();
  begin
    var arr3:array of byte := System.IO.File.ReadAllBytes('SC25.bin');
    
    arr1 := new byte [8, 256];
    arr2 := new byte [16, 256];
    RoundKey := new byte [8, 16];
    
    for var i:integer := 0 to 7 do
      for var ci:integer := 0 to 255 do
        arr1[i, ci] := arr3[i * 256 + ci];
        
    for var i:integer := 0 to 15 do
      for var ci:integer := 0 to 255 do
        arr2[i, ci] := arr3[i * 256 + ci + 2048];
  end;
  
  procedure OpenText1to2(x:array of byte);
  begin
    var a:integer := x.Length;
    arrX := new byte [16, ((a div 16) + 1)];
    
    try
      for var i:integer := 0 to (a div 16) do
        for var ci:integer := 0 to 15 do
          arrX[ci, i] := x[i * 16 + ci];
    except on System.IndexOutOfRangeException do
      begin
      end;
    end;
    
    arrX[15, (a div 16)] := (16 - (a mod 16));
  end;
  
  function OpenText2to1():array of byte;
  begin
    var a:integer := arrX[15, (arrX.GetLength(1) - 1)];
    var b:array of byte := new byte [arrX.Length - a];
    
    try
      for var i:integer := 0 to (arrX.GetLength(1) - 1) do
        for var ci:integer := 0 to 15 do
          b[i * 16 + ci] := arrX[ci, i];
    except on System.IndexOutOfRangeException do
      begin
      end;
    end;
    
    Result := b;
  end;
  
  procedure CryptoText1to2(x:array of byte);
  begin
    arrX := new byte [16, (x.Length div 16)];
    
    for var i:integer := 0 to ((x.Length div 16) - 1) do
      for var ci:integer := 0 to 15 do
        arrX[ci, i] := x[i * 16 + ci];
  end;
  
  function CryptoText2to1():array of byte;
  begin
    var a:array of byte := new byte [arrX.Length];
    
    for var i:integer := 0 to (arrX.GetLength(1) - 1) do
      for var ci:integer := 0 to 15 do
        a[i * 16 + ci] := arrX[ci, i];
        
    Result := a;
  end;
  
  procedure IVT(iv:array of byte);
  begin
    for var i:integer := 0 to 15 do
      arrX[i, 0] := (arrX[i, 0] xor iv[i]);
  end;
  
  function FFN(block:array of byte; index:integer):array of byte;
  begin
    var a:array of byte := new byte [8];
    
    for var i:integer := 0 to 7 do
      a[i] := ((block[i] + RoundKey[i, index]) mod 256);
      
    for var i:integer := 1 to 7 do
      a[i] := (a[i] xor a[0]);
      
    var b:byte := a[0];
    for var i:integer := 0 to 6 do
      a[i] := a[i + 1];
    a[7] := b;
    
    for var i:integer := 0 to 7 do
      a[i] := arr1[i, a[i]];
      
    Result := a;
  end;
  
  procedure ByteXor(var x:array of byte; y:array of byte);
  begin
    for var i:integer := 0 to 7 do
      x[i] := (x[i] xor y[i]);
  end;
  
  procedure FeistelNetwork(index:integer);
  begin
    var block1, block2:array of byte;
    block1 := new byte [8];
    block2 := new byte [8];
    
    for var i:integer := 0 to 7 do
      begin
        block1[i] := arrX[i, index];
        block2[i] := arrX[(i + 8), index];
      end;
      
    for var i:integer := 0 to 15 do
      begin
        ByteXor(block2, FFN(block1, i));
        if (i <> 15) then Swap(block1, block2);
      end;
      
    for var i:integer := 0 to 7 do
      begin
        arrX[i, index] := block1[i];
        arrX[(i + 8), index] := block2[i];
      end;
  end;
  
  procedure GetRoundKey(var key:array of byte; y:array of byte; usingReverse:boolean);
  begin
    for var i:integer := 0 to 15 do
      key[i] := (key[i] xor y[i]);
      
    var a:integer;
      
    for var i:integer := 0 to 15 do
      for var ci:integer := 0 to 7 do
        begin
          a := (ci + (i mod 2) * 8);
          RoundKey[ci, i] := arr2[a, ((key[a] + (i div 2)) mod 256)];
        end;
          
    if usingReverse then
      for var i:integer := 0 to 7 do
        for var ci:integer := 0 to 7 do
          Swap(RoundKey[ci, i], RoundKey[ci, (15 - i)]);
  end;
  
  procedure BlockTransform(var key, y:array of byte; mode:boolean; index:integer);
  begin
    GetRoundKey(key, y, (not mode));
    
    for var i:integer := 0 to 15 do
      y[i] := arrX[i, index];
      
    FeistelNetwork(index);
    
    for var i:integer := 0 to 15 do
      y[i] := (y[i] xor arrX[i, index]);
  end;
  
  procedure CryptoTransform(key:array of byte; mode, first:boolean);
  begin
    var a, s:array of byte;
    a := new byte [16];
    s := new byte [16];
    
    for var i:integer := 0 to 15 do
      a[i] := key[i];
      
    System.Array.Clear(s, 0, 16);
    
    if first then
      for var i:integer := 0 to (arrX.GetLength(1) - 1) do
        BlockTransform(a, s, mode, i)
    else
      for var i:integer := (arrX.GetLength(1) - 1) downto 0 do
        BlockTransform(a, s, mode, i);
  end;
  
  function CryptoSC25(data, key, iv:array of byte; mode:boolean):array of byte;
  begin
    InitializeArray();
    var a:array of byte;
    
    if mode then
      begin
        OpenText1to2(data);
        IVT(iv);
        CryptoTransform(key, true, true);
        CryptoTransform(key, true, false);
        a := CryptoText2to1();
      end
    else
      begin
        CryptoText1to2(data);
        CryptoTransform(key, false, false);
        CryptoTransform(key, false, true);
        IVT(iv);
        a := OpenText2to1();
      end;
      
    Result := a;
  end;
  
end.

таблица подстановок для него:

Code
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
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
e555 7275 a10f 6622 10dd 8498 eb1c 07ec
8c92 4654 4485 570e 1faf 65ef 7414 e72e
5961 3ff4 6e18 8bcb 2401 08da d98a 39b6
d3b1 7ba4 c66c 4023 c935 67df 5080 c2a7
76b5 ab58 5d5c debf 25d7 831d 33f9 883c
7c2f 0332 bc5e f82d 79d8 e073 fba3 71a0
f1b9 a2f5 4382 6406 e94a 37f2 c587 0c34
e470 aa7a 8696 60a6 4c95 bd52 bb2a 424f
b3f3 d6c1 fc97 8e19 a541 02ac b8f7 0da9
1612 1e56 c36d 48cd c0e8 7f89 1b78 2817
050b ff49 9bae 9477 e3a8 312c 9ac4 219f
2745 b79d b0ea cf8f 7d38 3091 e2c8 9e47
3a5f fddb 1a53 d1ca 4ed5 c74b fef6 2613
fa0a 904d e68d f03e 9962 6fe1 04ba 00b2
7ead 9c2b 93ce ed36 d220 116b 63dc 3d69
ccb4 68be ee6a 295a 513b d05b 0981 15d4
43d0 cbe2 e806 d498 6130 142b 2085 d174
7d18 104e bb3d a193 abd2 909f ff16 36c6
6f75 7bf3 3881 176e cf79 9b41 346c 2cc2
25b7 4207 6bf5 cc5c f646 e148 4c40 8baa
58be 8a1d d9de f052 acdb dfa8 d689 1a0c
bdb4 39a2 bfd8 e004 1f3b 62ec da67 7724
ea95 b108 011e 546a 99e3 29fe b051 9dad
a705 3ced 7649 8ea6 e78d 7e2e 5f47 6578
6d4b c780 3700 3f1b 530a 71fc f132 0f22
eb1c 9a0e dc97 2a4a 2d19 84b9 f803 6892
56c3 26e9 0dee 3a2f 5045 4fc0 15f7 fd5b
94bc 8fe4 125d efc1 63f4 31d3 b57c 5a0b
7f86 a3fb cae5 8796 afb6 359e 7ab8 3eb3
e691 c557 598c d582 a4fa c960 83ae a966
55a5 72b2 c89c 2344 ddce 1302 33ba 0928
f288 11a0 6970 4d5e 2773 21cd d764 f9c4
ea3e c04c b8c1 6a78 e732 a720 42f9 12ca
3ff3 37fb 4085 2675 1113 6107 d63c 60e2
a024 4dac 2d41 5690 aed8 063a 81b5 3665
0e73 a2b7 a3ec 5091 2c79 6e0f 6f8d 8e8a
fe09 e976 d2d7 7733 c772 a6ba 441a 5b9c
f4f1 881e 84c6 9508 8371 639e 92a8 4e8b
66cf 1074 192a 039d e121 d0bd ddd1 2fc8
b946 d52b f559 98c9 f251 1855 3022 2386
dab3 faf7 a904 cc39 e462 549f bba1 ef67
291c f09b f85a c3c4 6b27 7c57 4980 9970
bcde ad1f 4b25 93fd dc94 d958 d45d ebee
a56c 389a 7fce 7bb1 1443 82c5 e5e8 9748
4500 be01 024a 7ecd b0ff 0a35 8f8c 2e05
db5e a4e0 e61d 87d3 6816 53b4 6d7a 1596
c2bf 2864 170c b6fc df34 4f47 0d3b 525c
ede3 aa7d 5fb2 1b3d 0bcb f631 6989 afab
3ae6 9d94 6aa6 c3dd fc56 7c43 5c00 f149
4664 68f2 dc7a 511c d684 374f 824e 1d6c
ca72 58b2 7f75 1f41 f84b 5917 e506 e393
0780 2b74 ad05 57b4 e0d5 08f7 4cc5 8e34
7918 2a69 7626 7bce ec6d 8116 42d7 f55f
61a7 4833 bdfd bb8b 2d44 f0e7 9227 fa66
b165 b99c aba2 87b0 2e95 cf5e 1a5d 7845
23f9 1032 eec9 6022 3fac 9ed2 9790 a124
54f3 cb89 67f6 0929 e270 85c2 1121 e9aa
b339 121b 88c6 6f0d a025 f42f 3d3e d3fb
2c28 6335 52cd c8be 5501 71df 4a38 3b47
98ff bcbf 0c7e 0b19 da36 5bb8 02a8 d050
d830 134d a9b7 9a7d 1e77 d99f ba8a 15cc
a5b6 ed0e b5a3 eb53 2003 5aa4 73e1 c7fe
31e8 e4c0 ea6b 620f 3c8c ae04 839b c191
c496 d18d afdb d46e 86ef 998f de0a 1440
8daa 91e6 62da ef17 b567 1c54 286d 2ec7
771b ab47 4d40 2165 468e f4dd 50ce d59f
ecee d76c c0e1 72f5 bf45 b3a4 7f02 07e3
de75 056f 8a23 7b0e 59d3 0f0b 2c34 a3c6
f033 cab4 9ee0 f29b 4b9a bb73 7efb c4fc
9218 4432 3690 bc2f 5f0a c835 c3f1 a98c
6ba5 3e43 8968 3125 faf9 2206 10a2 9d61
d98f 1397 15d8 b058 1e42 5a03 1a99 d151
ba94 277c 52ea 84cc 4f4a 3900 0d55 6095
e2b7 16f3 4182 bd53 5d96 114e afc9 d664
8593 c59c 2b04 37cf 7d48 3d24 1fb9 714c
bedc ae09 df5e f7eb acdb e95b 6608 8ba8
20b8 63cd 0188 74b1 3a5c a786 a6f8 b283
ad98 8129 6938 3c57 303f 56d2 d0e4 78a0
0cd4 1da1 12c1 79f6 196a 876e 1476 cb2a
b6fd 2de7 3bfe 80e8 ed7a c226 e570 ff49
79f0 f33d 952c 61bf f429 a117 c36d 8149
e762 8820 1219 1e7a d330 a6b8 c78c 7263
2b0b d9cc 2186 59b9 52b4 347f 92fa 3a55
716c 83d4 379b 8a89 3e9e b3e4 39a4 46f8
d5a0 5aca 1806 082e 26ae 57cd 00a7 98be
60c2 8ff2 1c4b 80fe ba1d 0cd1 015b 96d7
fc58 68ce 5eed e923 3202 22b6 bcc8 285f
7d13 2a0a 7856 1082 fffd d203 c975 66dd
eb6f 912f 36f1 b25c e0a9 ea3f 9cef ac4a
64d8 1bde 9adf 43e8 976b 9442 0f38 c16a
2dbd b750 09b5 8eee 704f e535 6587 cfe6
3311 25a5 736e 7748 e29f 4cc6 4067 c4f6
8db0 5153 d624 99ab 0e85 a8a3 1590 7604
0541 da7b 848b 694e 14a2 fb4d 07e3 7e1f
f53c 1aaf 5d9d 74db c5ad 7cf7 3b16 0daa
b1e1 27d0 47c0 5444 9345 ec31 dcbb cbf9
e20b 5978 41b2 4b7a ed0f b939 f1d4 d624
f601 5fde 9963 4218 c12e 0057 fffa 7e14
799c 97cb 4a92 68f5 e4cc e650 d030 0775
e053 239d 114c a97b 4920 893c 446b adf2
9173 1754 a131 d722 1d10 0693 7c35 81f3
0543 67e9 60fe 8208 aee5 84d3 9486 1a48
32e3 65cf b50c a272 f06f d2a6 3345 52fb
a3db 3dce b8df 5838 9a34 ec16 da6a a58d
eeb6 02c5 1b55 6651 7003 2f6e c2ba 80f8
28b3 04bd bb5b e1b4 4ebc 3f1e 4d8b 251f
5676 c8b1 40dd 1321 3a0a fcca 463e bedc
36f7 85e7 62f9 4f69 abaa 6c15 b0c6 c49f
d5a4 6d74 6409 a8bf 83e8 775c 47d9 0da0
3761 875e 5a7f 881c 8eaf 95c0 acc7 ead8
a7ef 2c26 129b 5d2a 7d71 eb96 8c27 2b3b
fdf4 9ec9 0e19 8ac3 8fd1 cd98 2d90 29b7
4638 db7a 271f 2926 c14c 43f7 253d 2b4e
2e08 fe8b 9da8 1ec7 f296 6792 441c b2e8
4f23 47a9 402c c4a4 b160 52b4 85e3 e66c
7641 fd9f 623b 01ce a6df 955d 8916 7753
5420 35b8 138a 6b9a 8c98 4507 3e4a 8f2d
5be1 34b3 d0b5 81cf 310a 68f9 301d cc93
a3ad 7ed5 80f1 f41a 64cb 17b9 488d d782
ea58 c669 eb2f eec8 8333 39dd 0224 ab61
1103 c5fa 2237 a0d8 dae5 9b91 d66a dca1
af3a 90b0 e236 5670 2a75 556d 971b 5174
94cd ed21 7b0c 9c79 3cbe ef6e c2ac deaa
84c3 c915 7da5 9e3f 0b32 06a7 728e f06f
d966 65e4 b6a2 737c 4219 14e0 1888 4b7f
fbbb 57d2 0d10 bd49 f899 864d 5fd1 5c87
04ba f500 d4b7 0f5e 59ca 71fc 7809 ff0e
63c0 05d3 e750 5aae f3bc f6e9 bf28 ec12
38b9 1b06 c05f 450e a86a 71c3 b33c 3376
be50 9e44 bfb8 7f18 67ce 9be9 13e0 95c5
1449 9ca7 209a d068 c1cd 08a3 fe0a 2188
0cb2 4f81 db9f fc0f ba85 2ae6 8453 934c
f6af d4f9 4292 9874 a57b a280 91d1 3b2c
c6b0 365c 5de7 f8fa 9d35 c8fb 12ab c4c9
863e cfdf def3 ec72 8964 5ee2 22e1 eb60
056b 522e a91e 038a ee01 57bd d2c2 d510
19f7 6ebb 8eea 9732 cc70 1c7a 7343 da2b
251f ff8c 5b30 4166 8256 4096 f461 aeb1
f534 5ae5 f151 6fbc 3194 b4b5 65d7 6328
8f27 0bef 3a7c dcac 4e37 073f 17f2 8df0
4890 a6ca 4add 7ee4 6926 d9e3 d34d 1acb
7811 0939 003d 58b7 79c7 237d a075 a10d
6c04 771d 1554 2f02 2447 ad16 5546 d6e8
6d83 2959 aafd 87a4 2db6 ed8b 99d8 4b62
b572 8c2d 798e ae04 1819 0be1 fec0 77a0
e793 70a7 99a2 7db4 ead7 0a92 cd28 969a
716a 63aa 276d 2530 ff6c e214 46d5 a3d1
bfd4 6ff5 ecdc 1541 76f9 9b31 8a10 f14c
3c16 ace8 b95c 8722 5938 897e f460 9873
7c35 d92c 6736 dd91 efc9 bd7b be52 c461
2e3f 2655 8362 6e69 8bc1 5ab7 a5d2 43c2
f334 3da8 4985 3a64 01af dbd6 080d 1358
e9a9 ad57 1d53 9c1b 90b3 2f7f 1f68 00f0
eefb 32e0 02fa fd12 78df 514f e4eb a69e
3b3e 50f6 0f39 4024 0523 0e65 ed37 80c6
094b 8294 4e2b d8e6 741c e345 f79f 03ab
8f47 b0bb 177a ba4d 7595 d0c8 84f2 a1da
b10c b2ce 56cc d388 f833 869d 4497 ca06
5d42 5fb6 5e20 de48 c7a4 cf07 2a66 5421
c5e5 5bc3 fc8d 1a81 29cb bc4a b86b 111e
3f57 38f6 2674 2886 dfeb bfa4 3710 78e7
32ea baa0 b5c4 e609 75f7 1f6f 3c83 db2b
fd80 24fe dae5 e00b 2518 5e03 605b de04
4951 62d4 20d8 a234 6b07 1a8c b79f 8ddc
93b3 bd73 e1cc 7077 725c 91cd 7f1d 2ca9
8e2f d1aa 33ed 923a 2d82 2747 94a7 96dd
7a55 2369 c9ef 5614 610f eca5 f53d 00f9
8717 29ad f82a 44b8 d046 40f3 ff67 02a3
13c3 fab2 b0fb 5da1 39f2 304e c63e 7968
be7e 897c bc06 0c22 6316 014d ca5a e2c5
99b9 f415 9859 5faf 0d50 769c cb05 1bc8
6ad5 b4b1 904a 0a6e 43ee c0d3 1ef0 ac3b
8f08 7b97 3511 9571 4b21 bbd7 8bc1 8453
9a52 6cc7 e4a6 4fb6 31a8 650e 9be9 e8d2
f1ce ae19 12ab d981 5485 cfe3 2efc 64d6
451c 5888 4241 489e 364c 7d8a 9d66 c26d
9679 e999 b233 7ee7 2f2c 4c01 4f4d 438d
c09e 076e 6144 c357 3637 7298 b9c9 55d4
8eee 56d0 b4a0 6c67 f7b6 34d8 927f c1c8
381f cc28 6d1e 1d0c e0ae 24bc 1bf9 0b82
93a8 5274 8860 2235 5c69 b318 2b03 66a9
4ab7 be13 32e8 237a 6558 f0a6 3164 7080
94fb ad09 849c f67d 0a46 d7ab cace 12d5
a1d3 766b 2d4b 3e3d de20 cd41 8aa4 8ba7
04da f8e3 97db 9554 6f00 f189 aa45 50e2
f214 c6c5 0fbf f416 1083 87d9 a3ef cfc4
ec8c f5fc e49f a573 6ab1 1590 1725 21ba
1c30 fd78 5147 481a 0e40 9a49 59d1 9be6
f35a 865d 05fe e54e 0ded 1162 b0ac 81a2
68cb e15e 7726 af3b 7bd6 bb63 9d5b 1902
b52a 063a 713c ea42 c22e 757c dfc7 8feb
91dd dc85 39ff bd29 08fa b827 3fd2 5f53
ef83 a3d5 a24a 8f6d 0dbc e7f8 41b8 3af6
f09e 4c9d ed8d b927 eb13 f732 8480 9371
3c3f b6fe 312b 79f3 010f d0c6 7894 0bd2
3600 42b3 1cca 4372 e686 62fc 2192 d7c9
2955 5f96 02d8 9fba 19cf ae26 07b7 3d0c
1fc3 8761 59ec a735 b105 fa73 46a8 115b
5851 5203 18fd 814f 8b08 2038 de1a f1d4
44e9 0e4b 10bf b557 6fac ad1d ea2a 632c
53bd a569 88e1 499b e854 c025 c465 7e9a
567f dfc2 c11b a0bb 67cb a6db 14ee 5ada
7b74 2324 33e3 4d1e 09f4 8239 e4ff 3b12
977a ab16 d1a4 6c99 fb45 c7e0 68be 7cd9
b247 f922 9c77 f289 8564 af37 cef5 e2a1
cdaa 958a 7617 8ee5 0a6a 6b6e 0490 2e5e
d315 7d34 06c8 2870 2fb0 662d 6098 40cc
50b4 48dc 5cc5 dd3e 5d8c 4e30 d675 91a9
fd90 8b34 9ecd a022 feb7 faa3 5597 e02d
b0f3 c5d8 6a53 1fea a9f4 2388 bbaa 2c4e
0954 3e86 081e a721 32ca 7f59 4a16 7c2a
8e4c 91f1 6062 ba4b 2f7d d0f5 cc26 b48d
ed5f 003f c298 c882 6c18 c789 d395 a8b5
2868 3bd5 43ef f242 0724 4d17 690d 9f33
bd74 751c 7631 e296 e941 df2e 400f c3a2
798f 0652 493c dd46 48d6 d115 b6d4 85bc
ad05 b2c0 0e5c 2b0a 6ee8 04a1 1020 1337
51a4 1aff c1ab 673a 6419 84f6 d9cb 12b1
9d87 c4f8 b350 bf29 da5a 56c6 578c e19c
fb66 d781 6bac 1beb 807a 6303 14de e701
5dbe 385b 0c11 471d cfe3 9a5e 27e4 7baf
8a65 7158 2577 ee3d f76f a57e 9361 4435
78e5 f9e6 9bb8 fcdb b930 ec4f 9972 9236
d270 c9ae ce83 73dc 6df0 3902 a645 940b
0d2c 039a 5d66 64a7 d048 ba42 1256 315c
c128 b722 1a51 b662 fb30 0fd8 08c9 fc44
04f9 14d3 f768 9c20 630c 1d09 4f23 d4f5
de60 3f8b a970 4c46 bd4d 539b 8a35 378e
ab6e f105 c058 527a 6507 ee97 6a0a f0d1
333a 7fe2 43ca 54ff ace9 dcec e1bc 6727
d98f 6fa5 9f39 add2 8d1e 837c cc4e e498
e055 84da 3b25 1775 065e 93fd 1b32 2ba8
bbce 4a49 0088 1f2f 7136 6cb2 18e7 10f3
210b 2ecd c5c7 69a6 a013 7e78 4102 2a81
fe34 2ddb 9582 9657 8611 b076 c3aa e573
e6ea 6d89 72c6 df40 16f2 743d 9ea2 26ef
b594 855f 918c d724 b4f6 b145 0eae 1c47
c83e 61cb 7b80 be87 fa5b 4b15 cfb9 a359
50e8 77c4 92d5 bfa4 d6b8 a17d 796b 90eb
c2f4 995a edb3 e33c 29af 9d01 38f8 dd19
f9fc f69a 40db 1b60 701a 7a08 4eca 2ede
8566 bce0 f867 6fc1 e71f 80cc 5f6c eed2
e49e 4b65 afba 7349 845a 1c6e d4ab 1ec2
533b 48a5 0034 d0e6 41c8 8e86 ef6d 6179
29d1 9f03 0725 9675 24ce 689b c48d f258
920b ebcd d8d9 8733 ece2 b811 8101 282f
7c3a b638 78d5 7db1 d756 0e12 4645 02ad
3ca8 5494 209c 5c8f 0474 052b a631 ed88
f08c 0f55 596b 6ab9 77b0 a1f5 4436 f789
bfa7 91a3 7fb4 7ea2 9dff 37a0 b5fe 2c23
b7c7 0c99 6471 15bd faf3 fb83 765d 5b2d
9721 57e9 2719 f4ea 5ec0 cb16 da52 cf09
4c82 2662 1732 a43e e130 7bc5 9093 068b
394f 47ac bebb 6935 e8c3 72fd 3d10 c951
b214 63b3 e5a9 98df 42d3 2a18 3f0d 2295
dc13 f1ae 8add d650 4d1d e3c6 0aaa 4a43
942c 0532 1f58 27e9 a308 64f2 21c9 314a
6d02 9396 7654 841a 0d97 40b3 e8c6 4f12
7dd0 b7bc 20b1 6e34 0063 929c efc1 985e
06cd ff62 dd44 8de1 6c67 07c2 5be6 d9f5
f459 0f78 81a8 3b66 41ec 8b90 b64c e40e
3dc0 65de ba68 136b b87b 181c 434e 5a24
e314 53b2 48d7 09b9 aed1 1947 4656 fd16
6945 33f6 91a7 108f 70ed 837c 35a9 c522
57f7 265d 7e0b d4a0 ebbe cac8 494d ccce
033a 602e 736a 0cfa 61aa ea37 8079 bfe2
8aa6 a51b ab77 3ed2 af01 4bd6 156f dc39
898c d30a 0438 1711 c482 d59f 1e9a 1d86
8836 fb85 99b0 3c9d 28cf cb25 7aa4 bb42
52ac a1e5 c3df 5f50 fe51 9b5c 7572 9e2d
b529 f0fc 7f74 c7f9 b42b adf1 f8f3 bd30
9571 3fdb dae7 8ee0 55a2 232f d82a 87ee
398a 1489 09dd 07a9 6af4 1f17 ffce 502a
51ac 27ad 713a 383d 377a 92b4 780d e748
ae67 9dc7 3228 4b0a a3ea 6029 99f1 3393
7200 755f 5a4d e18c 2fd5 11ec e030 f31d
c804 ab25 1521 8e91 87d3 7f64 52e2 dc02
fb74 c2a4 ed23 db56 f89c 6b62 2d3f bde8
b2b6 461c 5847 af79 247e 55cb f668 7b2b
2080 d2f5 dfe4 4ef2 45cc 49b1 c4b5 01c9
a5e5 6eef a861 7d5d a73e 668d b05b 12da
9f3b 1385 b344 9573 1a63 9ecd fa59 0510
319a c0d4 bb40 8642 c6e6 9769 b9e3 c3d0
5c4c 8865 2218 cf8b a083 7798 0634 906d
2c8f 70bc 4103 9b16 5e6c 1ebe f93c 84d6
eec1 a108 53f0 f781 350f 0e2e 7619 fe1b
e9ba a657 54d1 0bd7 ca4f c5aa 6f7c fc96
fd36 82bf a20c 94b8 d826 4ad9 de43 ebb7
cb64 6d0c b2c9 5886 c3b9 8e12 e4b7 cff9
6034 2a91 e9af 7e4d 0bd6 aa16 7ce3 094e
d830 8889 1c00 9e03 4ffd d176 7ff4 c096
9fdc cc61 59b1 6c80 1115 bbe7 0e3f 3c38
502b db9c 549b f2a3 defb bcd3 9735 d56b
99a8 cef1 6585 f62f 3a7b 4bbd b50a c57d
bfff c4e2 4641 529d 4a66 9548 5678 a782
d25b 43c7 a4f0 05df 7abe 3383 70ec 02fe
19f3 0147 3723 1fd7 3d08 22c8 75ac 9a20
d067 da10 d92d 5a74 8731 2742 b077 1828
5cb6 c2ea fa13 7906 3e53 a681 24e5 a593
395f a904 3b26 baab e08f b425 b8ed 49d4
ef17 40f7 dd8d 2eb3 94e1 63e8 fc14 1bee
32c1 55a1 6862 5e45 5771 2ca2 9251 f829
4421 adcd 6aca eb0f 8aa0 1a6e 5d1d c673
e690 f536 840d 72ae 1e8c 8b98 696f 4c07
b1f1 4ade fb09 5f0c 305d 3ef5 b399 8cbc
787b aa75 e51c 92d9 c0b7 a348 eac3 160f
2a44 c832 10cb f372 4553 d756 2b5c 08a6
6d85 0559 d4c9 e754 8657 f6ec 6c87 7c62
51dd ab80 9c7d b201 8370 b8ac 0b13 9ba5
288d edeb 31fe 40d8 3c46 bfbb 20e3 8ac1
47d0 7fe0 6fe8 e1c7 8bff 294c 9f64 0d17
dc4f ce37 2326 5821 a176 635a a4e4 0322
3f91 a224 e942 06fa 7e8e f049 0a1e cdf2
0466 7ab6 4ef7 523b af5e 65da 121f 1ba8
438f 7197 676a f8db 0033 9e36 f4d5 25ef
ad02 9455 ba15 5084 cafc 39c4 b068 f941
18b4 2efd c24d 1aa7 9514 6e9a 890e d161
88cc 982f b9be 7369 5b1d d607 35bd 27ee
d2d3 cfa9 a0e2 4b6b 193a 3d93 e677 11df
b5ae 6079 9d74 9038 822c 2d34 96c5 81c6
5a06 1fea 9c41 3a1e a63e 77ed a972 55e7
ee19 bcc1 2461 5886 5723 b8a4 8434 c563
b727 df65 c893 05c9 8f1a 3269 3930 4d62
9126 7ccf 5e75 fd88 a876 31dd 7308 83ca
de6c e449 a04e efa5 9022 6b6f ce40 2874
9ed2 fe04 cd9a f229 c70f 818b 4f1c 377b
8c38 18da 450d bebd 2e99 b950 4a56 b17e
518a abba 8971 4cfb 92d1 5954 0a11 d6a7
2a07 675b 00b6 4364 953d 42d0 10cc 9fd3
7002 87e3 468d e2d5 6ef3 9dd8 b009 1d6d
f603 8efc c42b 2ff9 f5dc 80aa 2d13 9bb2
b4cb 52af 5ddb ae3f 173b 48e6 0cf1 d94b
3c7d 97a2 c67a c2d7 bf14 a1ec 6021 fa94
33e8 f435 a368 47e5 0ee0 ebc3 152c 6a85
b5b3 01ac 5f36 e144 ad0b e9f0 7982 16ff
25d4 f766 f81b 12c0 9653 7820 5c98 7fbb
76e3 c4a6 31e8 3c6e 1d97 fb41 caaf 869f
147b 92f0 a0ce 8e5f b4d2 3adc c1df d003
b972 5878 2547 7140 0a4f ee98 edc7 07cb
8d19 8a4a 7c37 1f4c 8c0c ef66 1870 962b
8487 33b2 1b68 0e17 1ce7 a15a 5c30 a361
2dff 8b56 34ad e423 08ea e689 00cd 0b63
52b5 286b f1a5 6205 e16a 4338 9c55 7f75
830d 95f6 7739 f812 16ec bb81 46f4 696c
5394 4479 c3d3 e93f 06d9 fc90 cc82 bc64
1ed1 fd4b 11c8 a7f5 36f9 51f7 42cf 2e32
809d 241a b0bd 27c2 c9a8 452c de22 35ae
579a d7d4 f220 67ac be3b d815 7e6d b6ab
91e0 4801 044e 6feb 7dd6 26ba 4de5 7a8f
faa2 2910 49da b3dd e259 b874 73c0 5d9b
5e85 3d9e fea4 6513 5bb1 dbd5 f3b7 aaa9
992f 0993 212a 540f c53e bfc6 5060 0288
33ca 87e8 0025 809e 22da 364b 3cd9 ed94
e9be 8c1b 5651 036d 5f75 fdb3 721c 0be6
3159 4074 68cb 90df f950 f782 e27d 4218
b941 1d69 3fcc 5cb5 c884 7b7a 2657 ab2a
f3bd 1932 ad64 3d7f 5430 efde d3ba 66ae
c42e 1eee 6e65 c760 fe77 6fbb a112 fb05
d62d 4e86 3ec6 95c0 069c 992c 493b 6a07
fa9f a75a 0248 9d79 43ac d115 dd9a 7163
14a9 2bb7 f18b ff28 20fc f08f 45dc c5f2
2f1a 16b0 a5db cec1 8de5 5be3 b40d 53bc
9b92 4738 910a f837 6b08 d483 c996 b8c2
9701 6cbf aaaf 52a2 f478 0429 8881 d20c
67eb 761f 27d7 b2e1 2355 e462 f511 10ec
cd85 ead0 a88e 8ad5 7c73 46e0 cf0e 3aa3
c344 b1a4 09f6 4d7e 984a 4c89 5e70 e70f
d85d 61a6 13a0 1758 3439 214f 2493 35b6
453a aff0 74c0 54cb 6348 09ae 3da1 b975
d9dd 38e8 96c3 f49f d1eb 40f2 e73e 5a43
1f26 8fd4 6d88 9915 13c2 ccdb 304b 16ad
6a77 079a 3bcf f680 3220 93f3 7223 7eec
c135 bffb fea8 81d7 b168 78e0 2a95 84cd
4749 8942 0851 2e4f 7b1c c7f1 6e31 bd6f
ed36 2891 1d17 d59c ffab 657f 5b33 7114
943f 9e0c 5979 f762 a02b dcaa fa82 572d
0ba2 5300 c85f 4a5c fda4 3741 640e 5e6b
dea9 85a5 e9a3 247d b0f8 4e7c 5521 44ef
730f cab8 d292 1a04 be76 b4e2 97b3 832c
b2bc d890 2f61 f912 60ee d0c9 ea01 5d86
1b67 27a6 8e8a 103c a719 39fc e4d3 df22
52e5 7ae3 c4f5 6c03 29ba 4d8c c650 1825
56ac 70b7 9d1e bb06 4c98 0569 8b0d 5802
da0a ce11 8766 9bd6 b546 c5e6 8db6 e134

релиз как всегда тривиален:

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
{PascalABC.NET}
 
{$reference lib25.dll}
 
procedure ReadArr(var x:array of byte);
begin
  for var i:integer := 0 to 15 do
    begin
      Write(i.ToString());
      if (Length(i.ToString()) = 1) then Write(' ');
      Write(' > ');
      x[i] := 0;
      Readln(x[i]);
    end;
  Writeln();
end;
 
begin
  var key, iv:array of byte;
  key := new byte [16];
  iv := new byte [16];
  
  var s1, s2:string;
  s1 := '';
  s2 := '';
  
  var b:boolean := false;
  
  Write('file > ');
  Readln(s1);
  Write('save result > ');
  Readln(s2);
  
  Write('mode > ');
  Readln(b);
  
  Writeln('iv:');
  ReadArr(iv);
  Writeln('key:');
  ReadArr(key);
  
  System.Console.Clear();
  
  var a1:array of byte := System.IO.File.ReadAllBytes(s1);
  var a2:array of byte := lib25.lib25.CryptoSC25(a1, key, iv, b);
  System.IO.File.WriteAllBytes(s2, a2);
end.

Какие мысли?

архив:

@NSIFS211 · 15.01.2019, 17:16 **[ТС]**

вы что, уснули все?

@NSIFS211 · 21.01.2019, 17:01 **[ТС]**

@NSIFS211 · 26.01.2019, 16:10 **[ТС]**

@NSIFS211 · 29.01.2019, 19:02 **[ТС]**

интересно, сколько здесь будет смайликов?

@NSIFS211 · 09.02.2019, 17:56 **[ТС]**

@NSIFS211 · 19.02.2019, 17:19 **[ТС]**

@NSIFS211 · 11.04.2019, 21:11 **[ТС]**

Новые блоги и статьи Все статьи Все блоги /
Когда логика программы не спасает от человеческих ошибок Maks 18.08.2026 В последнее время всё чаще и чаще сталкиваюсь с таким явлением, как абсолютная невнимательность (или глупость) пользователей. Проявляется это чаще всего на работе в коллективе. Допустим, человек с. . .	Лето уходит kumehtar 17.08.2026	Мысли в слух kumehtar 17.08.2026 Забавно, насколько сейчас стала доступна информация. Например о магии, духовном развитии, медитациях, и других подобных направлениях, ранее зачастую тайных, передаваемых от учителя к ученику. Хотя. . .	Перемещение строк из ТЧ в другой документ с учетом текущего пробега Maks 17.08.2026 Реализация из решения ниже выполнена на примере нетипового документа "Автозапчасти", с ТЧ "Шины". За основу взят алгоритм отсюда: https:/ / www. cyberforum. ru/ blogs/ 359708/ 10838. html Задача: . . .
Саморегулирующийся социальный контракт для сервера cross-section. Hrethgir 14.08.2026 С кодом конечно таких глубоких размышлений пока не было, впрочем я уже привык к алгоритмизации. Суть предмета записи: снова в диалоге с нейросетью (я взял пока себе ник для учётки админа - Rector). . . .	Часы электронные Uhbif79 12.08.2026 Выкладываю программу часов. Программа позволяет: 1. Использовать системное время и дату, 2. Есть возможность вводить время и дату вручную. 3. Реализованы 2 будильника: начало и конец рабочего дня. . . .	Часы с будильником на основе класса QLCDNumber Uhbif79 12.08.2026 Всем добрый день, выкладываю программу часов с будильником на основе класса QLCDNumber. Здесь я пробовал самостоятельно создавал классы, впервые столкнулся с видимостью переменной одного класса из. . .	Установка MinGW GCC 16.2 и CMake 8Observer8 10.08.2026 VK Видео: https:/ / vkvideo. ru/ video-240781534_456239017 YouTube: eY5-5PyI9NM Текстовая версия

@NSIFS211 23 / 20 / 4 Регистрация: 15.12.2018 Сообщений: 152
	26.12.2018, 16:04 [ТС]
	И еще блоки брались случайные, так чтобы 1 байт встречался ровно 1 раз, и чтобы значение каждого байта не совпадало с его индексом в таблице. 0

@On18 461 / 201 / 80 Регистрация: 14.12.2017 Сообщений: 433
	27.12.2018, 18:36
	Выглядит на много лучше. Сойдет. 0

@NSIFS211 23 / 20 / 4 Регистрация: 15.12.2018 Сообщений: 152
	01.01.2019, 21:24 [ТС]
	С новым годом! 0

@NSIFS211 23 / 20 / 4 Регистрация: 15.12.2018 Сообщений: 152
	06.01.2019, 16:52 [ТС]
	байты для табличек брал отсюда: https://www.random.org опять же каждая табличка содержит 1 байт только 1 раз и значение каждого байта не совпадает с его индексом в таблице. больше никакие критерии к табличкам не предъявлялись 0

@NSIFS211 23 / 20 / 4 Регистрация: 15.12.2018 Сообщений: 152
	15.01.2019, 17:16 [ТС]
	вы что, уснули все? 0

@NSIFS211 23 / 20 / 4 Регистрация: 15.12.2018 Сообщений: 152
	21.01.2019, 17:01 [ТС]
	0

@NSIFS211 23 / 20 / 4 Регистрация: 15.12.2018 Сообщений: 152
	26.01.2019, 16:10 [ТС]
	0

@NSIFS211 23 / 20 / 4 Регистрация: 15.12.2018 Сообщений: 152
	29.01.2019, 19:02 [ТС]
	интересно, сколько здесь будет смайликов? 0

@NSIFS211 23 / 20 / 4 Регистрация: 15.12.2018 Сообщений: 152
	09.02.2019, 17:56 [ТС]
	0

@NSIFS211 23 / 20 / 4 Регистрация: 15.12.2018 Сообщений: 152
	19.02.2019, 17:19 [ТС]
	0

@NSIFS211 23 / 20 / 4 Регистрация: 15.12.2018 Сообщений: 152
	11.04.2019, 21:11 [ТС]
	0