Шифрование

@mik-a-el · Регистрация: 10.04.2006

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

Шифрование методом Льюиса

Эта программа оставит символы, не присутствующие в строке Alpha_Hor без изменения. То же самое касается и заглавных букв (хотя заглавные буквы можно внести в эту самую строку).

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
const
  len = 26;
 
  {Это символы для выбора столбца таблицы}
  alpha_hor: string = 'abcdefghijklmnopqrstuvwxyz';
 
  {Здесь будут символы для выбора строки таблицы}
  alpha_ver: string = '';
 
var
  {Это собственно таблица кодирования}
  table: array[1 .. len, 1 .. len] of char;
 
{функция получает строку S и возвращает строку,
  полученную из исходной сдвигом на N позиций}
function shift(s: string; n: integer): string;
  begin
    s := copy(s, length(s) - pred(n), n) + s;
    delete(s, length(s) - pred(n), n); shift := s
  end;
 
var
  i, j, row, col: integer;
  s: string; ch: char;
 
  key: string;
  is_russian: boolean;
  f_in: file of char; f_out, f_key: text;
begin
  { Заполнение таблицы кодировки }
  for i := 1 to len do begin
    {получаем строку символов для текущей строки таблицы}
    s := shift(alpha_hor, pred(i));
    for j := 1 to len do
      table[i, j] := s[j];
    {
      не забываем первый символ заносить в "хранилище"
      для выбора строк по кодируемой букве
    }
    alpha_ver := alpha_ver + s[1]
  end;
 
  { связываем логические файлы программы с физическими файлами на диске }
 
  { файл с фразой для кодирования - открываем для чтения }
  assign(f_in, 'f_00in.txt');
  {$i-} reset(f_in); {$i+}
 
  { файл для сохранения результата - открываем для записи }
  assign(f_out, 'f_00out.txt');
  {$i-} rewrite(f_out); {$i+}
 
  {
    файл, содержащий ключевое слово - открываем для чтения,
    считываем слово в строковую переменную и закрываем файл
  }
  assign(f_key, 'f_00key.txt');
  {$i-} reset(f_key); {$i+}
  readln(f_key, key);
  close(f_key);
 
  { счетчик закодированных символов }
  i := 0;
  {до конца кодируемого файла делаем следующее:}
  while not eof(f_in) do begin
    { читаем очередной символ }
    read(f_in, ch);
    { находим по нему строку таблицы }
    row := pos(ch, alpha_ver);
    {
      эта переменная содержит значение успеха предыдущей операции
      (если True, то символ присутствует в таблице, иначе False)
    }
    is_russian := (row > 0);
    if is_russian then begin
      { Если символ присутствует в таблице, его надо кодировать }
 
      { увеличиваем счетчик закодированных символов }
      inc(i);
 
      {
        находим столбец по значению ключевого символа
        (операция mod используется, чтобы исключить выход
        за пределы ключа, т.к. длина ключа обычно меньше
        длины шифруемой последовательности)
      }
      col := pos(key[i mod (length(key))], alpha_hor);
      { и заменяем простой символ на зашифрованный (из таблицы) }
      ch := table[row, col];
    end;
    {
      если символ надо было шифровать, он уже зашифрован,
      если он не может быть зашифрован, он остался без изменений.
      Пишем его в выходной файл
    }
    write(f_out, ch)
  end;
 
  { И закрываем оба файла: исходный и зашифрованный }
  close(f_out);
  close(f_in)
end.

@mik-a-el · 08.05.2009, 12:32 **[ТС]**

Шифрование методом Атбаш

Некоторые фрагменты библейских текстов зашифрованы с помощью шифра, который назывался Атбаш. Правило зашифрования состояло в замене i-й буквы алфавита буквой с номером n - i + 1, где n - число букв в алфавите.

Происхождение слова Атбаш объясняется принципом замены букв. Это слово составлено из букв Алеф, Тав, Бет, Шин, то есть первой и последней, второй и предпоследней букв древнесемитского алфавита.

Функция, шифрующая строку методом Атбаш, имеет вид:

Pascal
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
function Atbash(toCode: string): string;
var i: integer;
begin
  for i := 1 to length(toCode) do
    toCode[ i ] := Chr(256 - Ord(toCode[ i ]));
  Atbash := toCode;
end;
 
{ Использование: }
var
  s: string;
 
begin
  s := Atbash('Just a test'); { зашифровать }
  writeln(s);
  writeln('s = ', Atbash(s)); { расшифровать }
end.

Для дешифрования сообщения нужно просто повторно применить к нему этот же алгоритм.

@mik-a-el · 08.05.2009, 12:33 **[ТС]**

Шифрование методом Цезаря

Шифр Цезаря реализует кодирование фразы путем «сдвига» всех букв фразы на определенное число n (в оригинальном шифре Цезаря число n равнялось 3). Если буква кодируемой фразы имеет в алфавите позицию j, то она в "шифровке" будет заменяться буквой, находящейся в алфавите на позиции j + n.

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

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
const
  n = 3;
 
function CaesarEncipher(toCode: string): string;
var i, T: integer;
begin
  for i := 1 to length(toCode) do begin
    T := (Ord(toCode[ i ]) + n);
    if T >= 256 then dec(T, 256);
    toCode[ i ] := Chr(T);
  end;
  CaesarEncipher := toCode;
end;
 
function CaesarDecipher(toDecode: string): string;
var i, T: integer;
begin
  for i := 1 to length(toDecode) do begin
    T := (Ord(toDecode[ i ]) - n);
    if T < 0 then Inc(T, 256);
    toDecode[ i ] := Chr(T);
  end;
  CaesarDecipher := toDecode;
end;
 
{ применение: }
var
  s: string;
 
begin
  s := CaesarEncipher('just a Caesar');
  writeln(s);
  writeln('s = ', CaesarDecipher(s));
end.

@mik-a-el · 08.05.2009, 12:34 **[ТС]**

Квадрат Полибия

В Древней Греции (II в. до н.э.) был известен шифр, называемый "квадрат Полибия". Шифровальная таблица представляла собой квадрат с пятью столбцами и пятью строками, которые нумеровались цифрами от 1 до 5. В каждую клетку такого квадрата записывалась одна буква. В результате каждой букве соответствовала пара чисел, и шифрование сводилось к замене буквы парой чисел.

Соответственно, шифрование/дешифрование текста производятся следующим образом:

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
const
  TPolibius: array['A' .. 'E', 'A' .. 'E'] of char = (
    ('A', 'B', 'C', 'D', 'E'),
    ('F', 'G', 'H', 'I', 'K'),
    ('L', 'M', 'N', 'O', 'P'),
    ('Q', 'R', 'S', 'T', 'U'),
    ('V', 'W', 'X', 'Y', 'Z')
  );
function PolibiusEncipher(toCode: string): string;
var
  i: integer;
  ix, jx: char;
  s: string;
begin
  s := '';
  for i := 1 to length(toCode) do begin
 
    for ix := 'A' to 'E' do
      for jx := 'A' to 'E' do
        if TPolibius[ix, jx] = toCode[ i ] then begin
          s := s + ix + jx; break;
        end;
 
  end;
  PolibiusEncipher := s
end;
 
function PolibiusDecipher(toDecode: string): string;
var
  i: integer;
  s: string;
begin
  s := '';
  i := 1;
  while i <= length(toDecode) do begin
    s := s + TPolibius[toDecode[ i ], toDecode[succ(i)]];
    inc(i, 2);
  end;
  PolibiusDecipher := s
end;
 
var
  s: string;
 
begin
  s := PolibiusEncipher('POLIBIUS');
  writeln(s);
  writeln('s = ', PolibiusDecipher(s));
end.

@mik-a-el · 08.05.2009, 12:34 **[ТС]**

Шифр Вижинера

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

Ниже приведены функции для работы с текстом по методу Вижинера (текст может состоять ТОЛЬКО из символов, присутствующих в алфавите):

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
const
  TViginer: string = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
 
function ViginerEncipher(toCode, K: string): string;
var
  i: integer;
  currK: byte;
  s: string;
begin
  s := '';
  for i := 1 to length(toCode) do begin
    currK := pred(pos(K[ (pred(i) mod length(K)) + 1 ], TViginer));
    s := s +
      TViginer[ ((pred(pos(toCode[ i ], TViginer)) + currK) mod length(TViginer)) + 1 ];
  end;
  ViginerEncipher := s;
end;
 
function ViginerDecipher(toDecode, K: string): string;
var
  i, T: integer;
  currK: byte;
  s: string;
begin
  s := '';
  for i := 1 to length(toDecode) do begin
    currK := pred(pos(K[ (pred(i) mod length(K)) + 1 ], TViginer));
    T := pred(pos(toDecode[ i ], TViginer)) - currK;
    if T < 0 then inc(T, length(TViginer));
    s := s + TViginer[T + 1];
  end;
  ViginerDecipher := s;
end;
 
var
  s: string;
 
begin
  s := ViginerEncipher('INFORMATION', 'BORED');
  writeln(s);
  writeln('s = ', ViginerDecipher(s, 'BORED'));
end.

@mik-a-el · 08.05.2009, 12:34 **[ТС]**

Шифр Гронсфельда

Алгоритм шифра Гронсфельда (созданный в 1734 году бельгийцем Хосе де Бронкхором, графом де Гронсфельд, военным и дипломатом), является модификацией шифра Цезаря, заключающейся в том, что величина сдвига не является постоянной, а задается ключом (гаммой).

Такой способ шифрования также называется короткопериодической гаммой.

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
function GronsfeldEncipher(toCode, K: string): string;
var i, T, _T: integer;
begin
  for i := 1 to length(toCode) do begin
    _T := ord(toCode[ i ]);
 
    T := (Ord(toCode[ i ])
 
      +
      (Ord(K[(pred(i) mod length(K)) + 1]) - Ord('0'))
 
         );
 
    if T >= 256 then dec(T, 256);
    toCode[ i ] := Chr(T);
  end;
  GronsfeldEncipher := toCode;
end;
 
function GronsfeldDecipher(toDecode, K: string): string;
var i, T: integer;
begin
  for i := 1 to length(toDecode) do begin
    T := (Ord(toDecode[i])
 
      -
      (Ord(K[(pred(i) mod length(K)) + 1]) - Ord('0'))
 
         );
    if T < 0 then Inc(T, 256);
    toDecode[ i ] := Chr(T);
  end;
  GronsfeldDecipher := toDecode;
end;
 
var
  s: string;
 
begin
  s := GronsfeldEncipher('INFORMATION', '2178');
  writeln(s);
  writeln('s = ', GronsfeldDecipher(s, '2178'));
end.

@mik-a-el · 08.05.2009, 12:35 **[ТС]**

Шифрование с помощью решетки

Неоднократно на форуме поднимался вопрос о шифровании текста с помощью решетки...

Ниже приводится программа, шифрующая заданный текст по этому алгоритму (процедура EncodeText, создается матрица, хранящая закодированный текст), и дешифрующая его же (функция DecodeText):

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
const
  n = 8;
type
  sType = string[n];
  matrix = array[1 .. n] of sType;
const
  mask: matrix = (
    'x...x...',
    '.x...x..',
    '..x...x.',
    '...x...x',
    '..x...x.',
    '...x....',
    'x...x..x',
    '..x..x..'
  );
 
  st: string =
    'сколькоцелыхчетырёхзначныхчиселможнополучитьизцифрнольодиндватри';
 
var
  encoded: matrix;
  masked: matrix;
 
{ Процедура поворота матрицы }
procedure T(var res: matrix);
var
  i, j: integer;
  mx: matrix;
begin
  mx := res;
  for i := 1 to n do
    for j := 1 to n do
      res[j, n - i + 1] := mx[i, j];
end;
 
{ Зашифровка текста }
procedure EncodeText(const s: string;
          const mask: matrix; var mx: matrix);
var
  i, j, count: integer;
  masked: matrix;
begin
  { Заполнение матрицы mx строками по N пробелов }
  for i := 1 to n do
    for j := 1 to n do mx[i] := mx[i] + #32;
 
  masked := mask;
  count := 1;
  while count <= length(s) do begin
 
    for i := 1 to n do
      for j := 1 to n do
        if masked[i, j] = 'x' then begin
          mx[i][j] := s[count];
          inc(count)
        end;
    T(masked);
 
  end;
end;
 
{ Расшифровка текста }
function DecodeText(const mask, encoded: matrix): string;
var
  s: string;
  i, j, count: integer;
  masked: matrix;
begin
 
  masked := mask;
  count := 0; s := '';
  while length(s) < n*n do begin
    for i := 1 to n do
      for j := 1 to n do
        if masked[i, j] = 'x' then s := s + encoded[i, j];
    T(masked);
  end;
  DecodeText := s;
 
end;
var
  i: integer;
begin
 
  EncodeText(st, mask, encoded);
 
  writeln('encoded text: ');
  for i := 1 to n do begin
    writeln(encoded[i]);
  end;
 
  writeln(DecodeText(mask, encoded));
 
end.

@mik-a-el · 08.05.2009, 12:36 **[ТС]**

Шифр Хилла (с длиной блока = 2)

Криптосистема, основанная Хиллом, базируется на линейной алгебре.

Пространства исходных сообщений и криптотекстов совпадают: латинский алфавит. Перенумеруем буквы в порядке их следования в алфавите: A получает номер 0, B - номер 1, ... и Z - номер 25.

Все арифметические операции выполняются по модулю 26 (длина алфавита), то есть 26 отождествляется с 0, 27 - с единицей и т.д.

Выберем целое число D <= 2. Оно указывает размерность используемых матриц. В процедуре шифрования наборы из D букв шифруются вместе. Возьмем D = 2. Пусть ключ M - квадратная матрица порядка D, элементами которой являются числа 0 .. 25. Эта матрица должна удовлетворять требованию невырожденности, т.е. для нее должна существовать матрица M-1, например:

Code
1
2
3
    | 3 3 |          |15 17 |
M = |     |, и M-1 = |      |
    | 2 5 |          |20  9 |

(вся арифметика ведется по модулю 26)

Шифрование осуществляется с помощью уравнения

Code
1
MP = C

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

Например:
исходное сообщение: HELP определяет 2 вектора (по 2 буквы в каждом):

Code
1
2
3
     |H|   |7|          |L|   |11|
P1 = | | = | |  и  P2 = | | = |  |
     |E|   |4|          |P|   |15|

Из уравнений

Code
1
2
3
       |7|                 | 0|
M*P1 = | | = C1  и  M*P2 = |  | = C2
       |8|                 |19|

получаем зашифрованный текст HIAT...

Для дешифровки сообщения используем матрицу M-1 [mod 26] и для шифротекста C вычисляем

Code
1
P = M-1 * C [mod 26]

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
type
  very_long = longint;
 
  { Тип матрицы - ключа }
  tkey    = array[1 .. 2, 1 .. 2] of integer;
  { Матрица - столбец }
  tcolumn = array[1 .. 2] of integer;
 
  pmatrix = ^matrix;
  matrix  = array [1 .. maxint div sizeof(tcolumn)] of tcolumn;
 
function _inc(var x: integer): integer;
begin
  inc(x);
  _inc := x;
end;
 
{
  Реализация расширенного алгоритма Евклида
  (используется для нахождения числа, обратного данному по модулю
   при вычислении определителя матрицы)
}
procedure extended_euclid(a, b: very_long;
          var x, y, d: very_long);
var q, r, x1, x2, y1, y2: very_long;
begin
 
  if b = 0 then begin
 
    d := a; x := 1; y := 0;
    exit
 
  end;
 
  x2 := 1; x1 := 0; y2 := 0; y1 := 1;
  while b > 0 do begin
 
    q := a div b; r := a - q * b;
    x := x2 - q * x1; y := y2 - q * y1;
    a := b; b := r;
    x2 := x1; x1 := x; y2 := y1; y1 := y;
 
  end;
 
  d := a; x := x2; y := y2;
 
end;
 
(* Вычисление числа, обратного A по модулю N *)
function inverse(a, n: very_long): very_long;
var d, x, y: very_long;
begin
 
  extended_euclid(a, n, x, y, d);
  if d = 1 then inverse := x
  else inverse := 0;
 
end;
 
{ Алфавит криптосистемы }
const
  alpha: string = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
 
{ Преобразование массива столбцов длины Count в строку символов }
function make_str(const arr: array of tcolumn;
         const count: integer): string;
var
  res: string;
  i, j: integer;
begin
  res := '';
 
  for i := 0 to pred(count) do
    for j := 1 to 2 do res := res + alpha[succ(arr[i][j])];
 
  make_str := res;
end;
{ Преобразование строки символов S в массив столбцов (возвращается длина массива) }
function make_columns(var arr: array of tcolumn;
         const s: string): integer;
var
  i, count: integer;
  col: tcolumn;
begin
  count := -1;
  for i := 1 to length(s) do begin
 
    col[2 - (i mod 2)] := pred(pos(s[i], alpha));
    if not odd(i) then
      arr[_inc(count)] := col;
 
  end;
  make_columns := count + 1;
end;
 
{ Функция шифрования сообщения S ключом K }
function EncodeHill(const k: Tkey; const s: string): string;
var
  i, j, count: integer;
  mx, Y: pmatrix;
  len: integer;
 
begin
  len := sizeof(tcolumn) * ( (length(s) div 2) + byte(odd(length(s))) );
  getmem(mx, len);
  getmem( Y, len);
 
  count := make_columns(mx^, s);
  for i := 1 to count do
    for j := 1 to 2 do
      Y^[i][j] := (K[j, 1] * mx^[i][1] + K[j, 2] * mx^[i][2]) mod length(alpha);
 
  EncodeHill := make_str(Y^, count);
 
  freemem( Y, len);
  freemem(mx, len);
end;
 
{ Функция расшифровки шифротекста S известным ключом K }
function DecodeHill(const k: Tkey; const s: string): string;
 
  function positive(X: integer): integer;
  begin
    repeat
      inc(X, length(alpha));
    until X >= 0;
    positive := X;
  end;
 
var
  inv_k: Tkey;
  det, i, j, count: integer;
  mx, Y: pmatrix;
  len: integer;
 
begin
  det := k[1, 1] * k[2, 2] - k[1, 2] * k[2, 1];
  if det < 0 then det := positive(det);
 
  det := inverse(det, length(alpha));
  for i := 1 to 2 do
    for j := 1 to 2 do begin
 
      if i = j then
        inv_k[i, j] := det * k[3 - i, 3 - j]
      else
        inv_k[i, j] := - det * k[i, j];
 
      if inv_k[i, j] < 0 then
        inv_k[i, j] := positive(inv_k[i, j])
      else inv_k[i, j] := inv_k[i, j] mod 26;
    end;
 
  len := sizeof(tcolumn) * ( (length(s) div 2) + byte(odd(length(s))) );
  getmem(mx, len);
  getmem( Y, len);
 
  count := make_columns(Y^, s);
 
  for i := 1 to count do
    for j := 1 to 2 do
      mx^[i][j] := (inv_k[j, 1] * Y^[i][1] + inv_k[j, 2] * Y^[i][2]) mod length(alpha);
 
  DecodeHill := make_str(mx^, count);
 
  freemem( Y, len);
  freemem(mx, len);
end;
 
{ Тестируем работу функций кодирования/декодирования }
const
  k_2: Tkey = ((1, 7), (3, 6));
 
begin
  writeln('encoding:');
  writeln(EncodeHill(k_2, 'AFINEAFTERNOON'));
  writeln('decoding:');
  { Декодируем результат работы предыдущей функции с тем же ключом }
  writeln(DecodeHill(k_2, 'JEVYEMIZTKHTBQ'));
end.

Новые блоги и статьи Все статьи Все блоги /
Использование SDL3-callbacks вместо функции main() на Android, Desktop и WebAssembly 8Observer8 24.01.2026 Если вы откроете примеры для начинающих на официальном репозитории SDL3 в папке: examples, то вы увидите, что все примеры используют следующие четыре обязательные функции, а привычная функция main(). . .	моя боль 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/