Все технические форумы на одном сайте Удобный поиск информации с популярных форумов в одном месте
Вопрос: Шифрование Elliptic Curve DSA

RSA алгоритм (класс RSACryptoServiceProvider в Net) позволяет шифровать массивы байт , а вот ECDsaCng вроде работает на алгоритме Elliptic Curve DSA, но при этом класс служит для подписывания данных().Так вот , можно ли посредством этого или иного класса (но того же алгоритма) шифровать массивы байт?Если да , можно пример. Ну и если вы получали эту информацию с какого-либо сайта , то желательно ссылку на источник.
Ответ:
Сообщение от jr_
обычно не шифруют, хотя бы потому что медленно.
Да мне всего-то передать симметричный ключ через асимметричное шифрование.
Вопрос: С++ программа шифрования и дешифрования текстового сообщения

Помогите написать программу
Написать программу шифрования и дешифрования сообщений. Шифрование выполнить следующим образом: расположить сначала все символы, расположенные на нечетных позициях, а затем в обратном порядке все символы, расположенные на четных позициях.
Реализовать меню для выбора режима работы программы: шифрование, дешифрование и выход. Предусмотреть возможность шифрования и дешифрования программно заданной строки, если пользователем задано пустая строка.
Ответ:
C++
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
///////////////////////////////////////////////////////////////////////////////
//2.
///////////////////////////////////////////////////////////////////////////////
//Написать программу шифрования и дешифрования сообщений.
//Шифрование выполнить следующим образом: расположить
//сначала все символы, расположенные на нечетных позициях,
//а затем в обратном порядке все символы, расположенные
//на четных позициях.
//Реализовать меню для выбора режима работы программы:
//шифрование, дешифрование и выход. Предусмотреть возможность
//шифрования и дешифрования программно заданной строки,
//если пользователем задано пустая строка.
///////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <iostream>
#include <map>
#include <string>
#include <vector>
///////////////////////////////////////////////////////////////////////////////
typedef std::string                     T_str;
typedef T_str::size_type                T_pos;
typedef std::vector         < T_pos >   T_indexes;
///////////////////////////////////////////////////////////////////////////////
enum    T_menu_item
{
    FRONT_ITEM          =   1,
    ENCRYPTION_ITEM     =   FRONT_ITEM,
    DECRYPTION_ITEM,
    EXIT_ITEM,
    BACK_ITEM           =   EXIT_ITEM
};
///////////////////////////////////////////////////////////////////////////////
typedef std::map    < T_menu_item,  T_str   >   T_name_of_action;
///////////////////////////////////////////////////////////////////////////////
T_name_of_action    name_of_action
    {
        { ENCRYPTION_ITEM,  "encryption"    },
        { DECRYPTION_ITEM,  "decryption"    },
        { EXIT_ITEM,        "exit"          }
    };
///////////////////////////////////////////////////////////////////////////////
bool    ind_is_odd( T_pos   ind )
{
    return  ind % 2     ==  0;//Считаем позицию начального символа строки нечетной.
}
///////////////////////////////////////////////////////////////////////////////
T_indexes   get_encr_str_indexes( T_pos     str_size )
{
    T_indexes   res( str_size );
 
    for( T_pos  p{}; p < str_size; ++p  )
    {
        res[p]  =   p;
    }
 
    std::reverse
        (
            std::stable_partition
                (
                    res.begin   (),
                    res.end     (),
 
                    []          ( auto  ind )
                    {
                        return  ind_is_odd( ind );
                    }
                ),
 
            res.end()
        );
 
    return  res;
}
///////////////////////////////////////////////////////////////////////////////
T_str   get_encrypted_string( T_str     const   &   s )
{
    auto    encr_str_indexes    =   get_encr_str_indexes    (
                                                                s.size()
                                                            );
 
    T_str   res(s);
 
    for( T_pos  p{}; p < res.size(); ++p )
    {
        res[p]  =   s   [
                            encr_str_indexes[p]
                        ];
    }
 
    return  res;
}
///////////////////////////////////////////////////////////////////////////////
T_str   get_decrypted_string( T_str     const   &   s )
{
    auto    encr_str_indexes    =   get_encr_str_indexes    (
                                                                s.size()
                                                            );
 
    T_str   res(s);
 
    for( T_pos  p{}; p < res.size(); ++p )
    {
        res [
                encr_str_indexes[p]
            ]
            =   s[p];
    }
 
    return  res;
}
///////////////////////////////////////////////////////////////////////////////
T_str   with_prompt_input_and_get_str
    (
        T_str    const   &   prompt,
        T_str    const   &   default_str
    )
{
    std::cout   <<  std::endl
                <<  prompt
                <<  std::endl
                <<  "-> ";
 
    T_str   res;
    std::cin.get();
    getline( std::cin,  res );
 
    if  (
            res.empty()
        )
    {
        res     =   default_str;
 
        std::cout   <<  res
                    <<  std::endl;
    }
 
    return  res;
}
///////////////////////////////////////////////////////////////////////////////
void    with_title_print_str
    (
        T_str   const   &   title,
        T_str   const   &   s
    )
{
    std::cout   <<  title
                <<  s
                <<  std::endl;
}
///////////////////////////////////////////////////////////////////////////////
void    encryption( T_str   const   &   default_str )
{
    auto    s   =   with_prompt_input_and_get_str
                        (
                            "enter string to encrypt: ",
                            default_str
                        );
 
    with_title_print_str
        (
            "encrypted string: ",
            get_encrypted_string(s)
        );
}
///////////////////////////////////////////////////////////////////////////////
void    decryption( T_str   const   &   default_str )
{
    auto    s   =   with_prompt_input_and_get_str
                        (
                            "enter string to decrypt: ",
                            default_str
                        );
 
    with_title_print_str
        (
            "decrypted string: ",
            get_decrypted_string(s)
        );
}
///////////////////////////////////////////////////////////////////////////////
void    print_menu_prompt()
{
    std::cout   <<  "\n\n\n\n\n\nSelect action:"
                <<  std::endl;
 
    for( T_menu_item  i{ FRONT_ITEM }; i <= BACK_ITEM; i = T_menu_item(i + 1) )
    {
        std::cout   <<  i
                    <<  " - "
                    <<  name_of_action[i]
                    <<  std::endl;
    }//for
 
    std::cout   <<  std::endl;
}
///////////////////////////////////////////////////////////////////////////////
bool    successfully_input_and_set_menu_item( T_menu_item   &   menu_item )
{
    int     int_menu_item{};
 
    std::cout   <<  "-> ";
 
    std::cin    >>  int_menu_item;
    menu_item   =   T_menu_item( int_menu_item );
 
    return      menu_item   >=  FRONT_ITEM
            &&  menu_item   <=  BACK_ITEM;
}
///////////////////////////////////////////////////////////////////////////////
void    menu()
{
    const   T_str   default_str
                        (
                            "There are more things in heaven and earth, Horatio,"
                            " Than are dreamt of in your philosophy."
                        );
 
    const   T_str   default_encr_s  =   get_encrypted_string( default_str );
 
    for(;;)
    {
        print_menu_prompt();
        T_menu_item     menu_item{};
 
        do
        {}
        while   (
                    !successfully_input_and_set_menu_item( menu_item )
                );
 
        switch( menu_item )
        {
        case    ENCRYPTION_ITEM :   encryption  ( default_str       );      break;
        case    DECRYPTION_ITEM :   decryption  ( default_encr_s    );      break;
        default                 :   exit        (0);                        break;
        }
    };
}
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    menu();
}
Вопрос: Простое обратное шифрование

Здравствуйте. Может кто-то знает простые конструкции шифрования/хэширования, которые имеют обратный эффект? Или надо писать собственную функцию?
Ответ: M1lleniuM. Нашел реализации алгоритмов 3DES и Blowfish на языке PHP. Эти алгоритмы реализованы PHP классами. Собраны вроде качественно (в 3DES сказано что Pure-PHP implementation).

Первая реализация работает с стандартной библиотекой php_mcrypt.dll. Если она не установлена на сервере в действие вступает программная реализация этого алгоритма в PHP классе. То есть по любому это должно работать. Использование библиотеки php_mcrypt.dll имеет больший приоритет чем внутренняя реализация алгоритма.





/**
* Проверенная-PHP реализация 3DES.
*
* Используется стандартная dll библиотека mcrypt и внутренняя реализация алгоритма 3DES если данная библиотека не установлена. Работает в режиме EDE3 (шифрование-дешифрование-шифрование)
*
* Версия PHP 5
*
* Короткий пример использования этой библиотеки:
* <code>
* <?php
* include 'vendor/autoload.php';
*
* $des = new \phpseclib\Crypt\TripleDES();
*
* $des->setKey('abcdefghijklmnopqrstuvwx');
*
* $size = 10 * 1024;
* $plaintext = '';
* for ($i = 0; $i < $size; $i++) {
* $plaintext.= 'a';
* }
*
* echo $des->decrypt($des->encrypt($plaintext));
* ?>
* </code>
*
* @category Crypt
* @package TripleDES
* @author Jim Wigginton <terrafrost@php.net>
* @copyright 2007 Jim Wigginton
* @license MIT License
* @link
*/


PHP_Blowfish

PHP класс который предоставляет CBC и ECB Blowfish шифрование без использования стандартной библиотеки. Тестировано с использованием Eric Young's тестовых векторов.

Требования

PHP 5 (4 должен работать но не тестирован)

Использование

Смотрите вложенный файл example.php в тестовом каталоге.
Вроде в наличии методы шифрования и расшифровывания с использованием секретного ключа. Если не ошибаюсь.
Вопрос: Шифрование

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

Эта программа оставит символы, не присутствующие в строке 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.
Ответ: Шифр Хилла (с длиной блока = 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.
Вопрос: Шифрование и передача данных

Всем доброго.
Изучаю сокеты, tcp/ip. Написал простенький клиент авторизации к серверу, данные хранятся на сервере в xml таблице. Встает вопрос: а когда, собственно, шифровать данные? Первый вариант: передавать сухие данные в потоке, шифровать (своим методом) на сервере и записывать шифрованные данные в xml таблицу. Для авторизации придется постоянно принимать чистые данные в потоке, их шифровать на сервере и сравнивать с таблицей. Так себе затея, привет любому снифферу. Второй вариант: шифровать данные в клиенте, передавать шифрованные данные в потоке и записывать их в таблицу. Для авторизации: клиент вводит данные, они шифруются, передаются серверу, тот сравнивает их в таблице и отдает ответ. Вроде нормально, но ведь клиент можно декомпилировать (тем более С#) и получить метод шифрования целиком. Третий вариант: в клиенте использовать шифрование типа MD5 с солью, а полученные данные на сервере дополнительно шифровать своим способом и записывать в таблицу.

Что я хотел бы услышать: какие-нибудь ссылки на ресурсы, книги, либо хоть какой краткий курс наиболее безопасной передачи данных в сети.
Ответ:
Цитата Сообщение от dok221 Посмотреть сообщение
Для авторизации: клиент вводит данные, они шифруются, передаются серверу, тот сравнивает их в таблице и отдает ответ. Вроде нормально, но ведь клиент можно декомпилировать (тем более С#) и получить метод шифрования целиком.
И что кому-то даст ваш метод шифрования? тем более зачастую в таких случаях используются односторонние функции
Вопрос: Подскажите как быть с шифрованием RSA

Уважаемые пользователи форума, помогите с кодом на delphi для шифрования по алгоритму RSA. Отыскал примеры в инете, но половина не рабочих. Искал и на этом форуме, встречаются обсуждения, но то что нужно, нет
Что нужно:
Код Code
1
есть паблик ключ и пароль, который надо этим ключом зашифровать. Собственно одна функция зашифровать пароль, но ничерта не получается.
Вот например статья -
Пробую точно как автор говорит, но вместо шифрования первые буквы ключа заменяются паролем и все.

Качал компонент LockBox, но там вообще никаких примеров, один код.

Может у кого-то есть готовая функция шифрования по RSA ?

Создавал дубликат темы на соседнем форуме, но там только ткнули в msdn. Но не получается нифига реализовать. Может есть у кого функция готовая, буду очень благодарен
Ответ:
Сообщение от c_y_b_e_r
Пробую точно как автор говорит, но вместо шифрования первые буквы ключа заменяются паролем и все.
Ну так показал бы как именно пробуешь (сам твой код), глядишь и нашлись бы желающие найти ошибки в твоём коде.
Вопрос: Шифрование и дешифрование данных (Кодек Speex)

Уважаемые форумчане нужна помощь с работой кодека Speex, есть реализация на java , там кодируются данные получаемые с микрофона и декодируются данные получаемые из сети, есть шифрование и дешифровка данных, что в мне нужно, а повторить только кодирование и декодирование у меня не получается вот код оригинала который кодирует:
Код Java(TM) 2 Platform Standard Edition 5.0
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
    public void run()
    {
        byte buf_speech[] = new byte[320];
        byte buf_bits[] = new byte [1600];
        byte temp_buf_bits[] = new byte [60];
        while(true)
        {    
            int index = 0;
            buf_bits[index++] = ProxyBuffer.SPEECH_PACKET;
            int ii;
            for(ii = 0; ii < 8; ++ii)
            {
                audio_.getTargetLine().read(buf_speech, 0, buf_speech.length);
                if(!speechDetector.speechDetecting(buf_speech, buf_speech.length))
                {
                    for(int i = 0; i < buf_speech.length; ++i)
                        buf_speech[i] = 0;                    
                }
                int sizeBytes = CodecOfSpeech.encode(buf_speech, temp_buf_bits);
                buf_bits[index++] = (byte)sizeBytes;
                for(int i = 0; i < sizeBytes; ++i)
                {
                    buf_bits[index++] = temp_buf_bits[i];
                }
            }
            buf_bits[index++] = (byte)0xff;
 
//шифрование
            if(ProxyBuffer.desKey != null)
            {
                byte bufCrypt[] = null;
                try
                {
                    bufCrypt = 
                            ProxyBuffer.desOut.doFinal(buf_bits, 1, index - 1);
                }
                catch(javax.crypto.IllegalBlockSizeException e)
                {
                    System.out.println(e.getMessage());
                    System.exit(-1);
                }
                catch(javax.crypto.BadPaddingException e)
                {
                    System.out.println(e.getMessage());
                    System.exit(-1);
                }                
                for(int i0 = 0; i0 < bufCrypt.length; ++i0)
                {
                    buf_bits[i0 + 1] = bufCrypt[i0];
                }
                index = bufCrypt.length + 1;
            }
 
            int crc = 0;
            for(int iii = 0; iii < index; ++iii)
            {
                crc += buf_bits[iii];
            }
            buf_bits[index++] = (byte)crc;
            ++countForAlive;
            if((index <= 6 * ii + 2 + 10 + 8) && (countForAlive < 120/ii))
                continue;            
            countForAlive = 0;
            DatagramPacket packet =
                    new DatagramPacket(buf_bits, index, address_, port_);
            outComingTraffic += packet.getLength() + 8 + 24;        
            try
            {
                socket_.send(packet);                       
            }
            catch(IOException exc)
            {
                System.out.println("ReadThread" + exc.getMessage());
                continue;
            }
            //<editor-fold defaultstate="collapsed" desc="test">
 
             //*/
            /* //Zeroing for test purpose only
            audio_.getTargetLine().read(buf_speech, 0, buf_speech.length);
            int sizeBytes = CodecOfSpeech.encode(buf_speech, temp_buf_bits);
            CodecOfSpeech.decode(temp_buf_bits, sizeBytes, buf_speech);
            for(int ii = 0; ii < buf_speech.length; ++ii)
            {                
                ProxyBuffer.proxyArray[ProxyBuffer.proxyHead++] = buf_speech[ii];
                if(ProxyBuffer.proxyHead >= ProxyBuffer.proxyArray.length)
                    ProxyBuffer.proxyHead = 0;
            }
            //*/
        }
    }
вот моя попытка:

Код Java(TM) 2 Platform Standard Edition 5.0
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
 public void run()
    {
        mWindow.stopCapture = false;
        
        mWindow.audioLine.start();
        
        byte buf_speech[] = new byte[320];
        byte temp_buf_bits[] = new byte[60];
        int index = 0;
        
        jCodec = new JSpeexCodec();
        
        try
        {
            mWindow.inBuf[index++] = 1;
            
            while(!mWindow.stopCapture)
            {    
                int ii;
                for(ii = 0; ii < 8; ++ii)
                {
                    mWindow.audioLine.read(buf_speech, 0, buf_speech.length);
                    if(!speechDetector.speechDetecting(buf_speech, buf_speech.length))
                    {
                        for(int i = 0; i < buf_speech.length; ++i)
                            buf_speech[i] = 0;                    
                    } 
                      
                    int sizeBytes = jCodec.encode(buf_speech, temp_buf_bits);
                    mWindow.inBuf[index++] = (byte)sizeBytes;
                    for(int i = 0; i < sizeBytes; ++i)
                    {
                        mWindow.inBuf[index++] = temp_buf_bits[i];
                    }
                }
            }
            
            mWindow.inBuf[index++] = (byte)0xff;    
            
            java.awt.EventQueue.invokeLater(() ->
            {
                mWindow.speakBtn.setEnabled(true);
                mWindow.mcBtn.setEnabled(true);
                mWindow.ftm.addFiles(mWindow.mFile);
            });
            
            if(audioLine != null)
            {
                audioLine.close();
            }
        }
        catch(Exception e)
        {
            System.out.println(e.getMessage());
        }
    }
параметры аудио для записи AudioFormat.Encoding.PCM_SIGNED, 8000, 16, 1, 2, 8000, false

реализация оригинала для декодирования:
Код Java(TM) 2 Platform Standard Edition 5.0
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
 public void run()
    {
        byte buf[] = new byte[1600];
        byte speech[] = new byte[320];     
        while(true)
        {
            DatagramPacket packet = new DatagramPacket(buf, buf.length);
            try
            {
                socket_.receive(packet);
            }
            catch(Exception exc)
            {
                continue;
            }
            incominTraffic += packet.getLength() + 8 + 24;
            int index = 0;
            int crc = 0;
            for(int ii = 0; ii < packet.getLength() - 1; ++ii)
                crc += buf[ii];
            if(buf[packet.getLength() - 1] != (byte)crc)
                continue;
            
            if(buf[0] == ProxyBuffer.CALL_PACKET)
            {
                if(packet.getLength() != 5)
                    continue;
                if((buf[1] != 0x77) || (buf[2] != 0x77) || (buf[3] != 0x77))
                    continue;                
                if(ProxyBuffer.peerAddress == null)
                    ProxyBuffer.peerAddress = packet.getAddress();
                ProxyBuffer.recvCallPacket = true;
                ProxyBuffer.liveConnect = true;
                
                buf[0] = ProxyBuffer.ACCEPT_CALL;                     
                buf[1] = 0x55;                                              
                buf[2] = 0x55;
                buf[3] = 0x55;
                crc = 0;
                for(int ii = 0; ii < 4; ++ii)
                {
                    crc += buf[ii];                                         
                }
                buf[4] = (byte)crc;
                packet.setData(buf, 0, 5);
                for(int ii = 0; ii < 4; ++ii)
                {
                    try
                    {
                        socket_.send(packet);
                    }
                    catch(IOException exc)
                    {
                        System.out.println("sendException " + exc.getMessage());
                        continue;
                    }                    
               
                    try
                    {
                        sleep(100);
                    }
                    catch(InterruptedException exc)
                    {
 
                    }
                }
                MainStream.peerPortIP = packet.getPort();
                ProxyBuffer.acceptCall = true;
                continue;
            }
            
            if(buf[0] == ProxyBuffer.ACCEPT_CALL)
            {
                if(packet.getLength() != 5)
                    continue;
                if((buf[1] != 0x55) || (buf[2] != 0x55) || (buf[3] != 0x55))
                    continue;
                MainStream.peerPortIP = packet.getPort();
                ProxyBuffer.liveConnect = true;
                ProxyBuffer.recvCallPacket = true;
                ProxyBuffer.acceptCall = true;
                continue;
            } 
            
            if(buf[0] == ProxyBuffer.SPEECH_PACKET)
            {
                ++index;                
                ProxyBuffer.liveConnect = true;
                
//шифрование
                if(ProxyBuffer.desKey != null)
                {
                    byte tempDeCryptoBuf[] = null;
                    if((packet.getLength() - 2) % 8 != 0)
                        continue;
                    try
                    {
                        tempDeCryptoBuf = ProxyBuffer.desIn.doFinal(buf, 1, packet.getLength() - 2);
                    }
                    catch(javax.crypto.IllegalBlockSizeException e)
                    {
                        System.out.println("IllegalBlockSizeException" + e.getMessage());
                        continue;
                    }
                    catch(javax.crypto.BadPaddingException e)
                    {
                        System.out.println("BadPaddingException" + e.getMessage());
                        continue;
                    }
                    if(tempDeCryptoBuf != null)
                        for(int i0 = 0; i0 < tempDeCryptoBuf.length; i0++)
                        {
                            buf[i0 + 1] = tempDeCryptoBuf[i0];
                        }
                    else
                        continue;
                }
 
                byte temp_buf[];
                while(true){
                    try {                        
                        if(buf[index] != 0xff){
                            if((buf[index] > 60) || (buf[index] < 0))
                                break;                                                            
                            temp_buf = new byte[buf[index++]];
                            
                            for(int ii = 0; ii < temp_buf.length; ++ii)
                                temp_buf[ii] = buf[index++];                            
                            
                            CodecOfSpeech.decode(temp_buf, temp_buf.length, speech);
                            for(int ii = 0; ii < speech.length; ++ii){
                                ProxyBuffer.proxyArray[ProxyBuffer.proxyHead++] = speech[ii];
                                if(ProxyBuffer.proxyHead >= ProxyBuffer.proxyArray.length)
                                   ProxyBuffer.proxyHead = 0; 
                            } 
                        }
                        else break;
                    }
                    catch(IndexOutOfBoundsException exc){
                        System.out.println("IndexOutOfBoundsException " + exc.getMessage());
                        break;
                    }
                    catch(Exception exc){
                        System.out.println("Exception " + exc.getMessage());
                        break;
                    }                            
                }
            }           
        }
    }    
}
а вот моя реализация:
Код Java(TM) 2 Platform Standard Edition 5.0
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
 public void run()
    {
        byte temp_buf[];
        byte speech[] = new byte[320];
        int index = 0;
        int indArr = 0;
        mWindow.outBuf = new byte[1024000];
        byte[] bufferAudio = new byte[source_line.getBufferSize()];
        
        source_line.write(mWindow.outBuf, 0, source_line.getBufferSize());
        
        if(mWindow.inBuf[0] == 1)
        {
            index++;
            while(true){
                try {                        
                    if(mWindow.inBuf[index] != 0xff){
                        if((mWindow.inBuf[index] > 60) ||
                                (mWindow.inBuf[index] < 0))
                            break;                                                            
                        temp_buf = new byte[mWindow.inBuf[index++]];
 
                        for(int ii = 0; ii < temp_buf.length; ++ii)
                            temp_buf[ii] = mWindow.inBuf[index++];                            
 
                        jDecode.decode(temp_buf, temp_buf.length, speech);
                        for(int ii = 0; ii < speech.length; ++ii){
                            mWindow.outBuf[indArr++] = speech[ii];
                        }//конец for                           
                    }//конец if
                    else break;
                }//конец try
                catch(IndexOutOfBoundsException exc){
                    System.out.println("IndexOutOfBoundsException " 
                            + exc.getMessage());
                    break;
                }
                catch(Exception exc){
                    System.out.println("Exception " + exc.getMessage());
                    break;
                }                            
            }//конец while
        }
                
        if(mWindow.outBuf.length >= 0)
        {
            source_line.write(mWindow.outBuf, 0, mWindow.outBuf.length);
        }
        int ind = 0;
        while(true)
        {
            for(int i = 0; i < 320; i++)
            {
                if(index != ind)
                {
                    bufferAudio[i] = mWindow.outBuf[ind++];
                    if(ind >= mWindow.outBuf.length)
                        ind = 0;
                }
                else
                {
                    bufferAudio[i++] = 0;
                    bufferAudio[i] = 0;
                }
            }
            
            source_line.write(bufferAudio, 0, 320);
        }
        
        source_line.drain();
        source_line.close();
 
        java.awt.EventQueue.invokeLater(() ->
        {
            mWindow.mcBtn.setEnabled(true);
            mWindow.speakBtn.setEnabled(true);
            mWindow.PlayBtn.setEnabled(true);
        });
    
мой вариант реализации кодирует и декодирует, но что-то не так потому что не воспроизводит в нормальном режиме декодированные данные, вот проект полностью, большая просьба помогите разобраться в чем ошибка.
Ответ: прошу прощения не правильно написал, мне нужно не шифрование, а именно сжатие и расжатие данных получаемых с микрофона, кодеком Speex.
Вопрос: Алгоритм шифрования. Деление по модулю

Читаю как работает аглоритм шифрования с открытым ключем
Алгоритм Диффи-Хеллмана работает следующим образом.
Предположим, что двум абонентам ( P1 и P2 ) требуется установить между собой безопасное соединение, для которого необходимо согласовать ключ шифрования.
1. P1 и P2 принимают к использованию два больших целых числа a и b, причем 1 < a < b.
2. P1 выбирает случайное число i и вычисляет  I = a^i mod b. P1 передает I абоненту P2.
3. P2 выбирает случайное число j и вычисляет J = a^j mod b. P2 передает J абоненту P1.
4. P1 вычисляет k1 = J^i mod b.
5. P2 вычисляет k2 = I^j mod b.
6. Имеем k1 = k2 = a^ (i*j) mod b, следовательно, k1 и k2 являются секретными ключами, предназначенными для использования при передаче других данных.
Вроде все понятно, но на шаге 4 вычисляется k1: k1 = J^i mod b, где J = a^j mod b
следовательно есть какое-то по которому (a^j mod b)^i mod b = a^ (i*j) mod b?
Ответ:
Читаю как работает аглоритм шифрования с открытым ключем
Алгоритм Диффи-Хеллмана работает следующим образом.
Предположим, что двум абонентам ( P1 и P2 ) требуется установить между собой безопасное соединение, для которого необходимо согласовать ключ шифрования.
1. P1 и P2 принимают к использованию два больших целых числа a и b, причем 1 < a < b.
2. P1 выбирает случайное число i и вычисляет  I = a^i mod b. P1 передает I абоненту P2.
3. P2 выбирает случайное число j и вычисляет J = a^j mod b. P2 передает J абоненту P1.
4. P1 вычисляет k1 = J^i mod b.
5. P2 вычисляет k2 = I^j mod b.
6. Имеем k1 = k2 = a^ (i*j) mod b, следовательно, k1 и k2 являются секретными ключами, предназначенными для использования при передаче других данных.
Вроде все понятно, но на шаге 4 вычисляется k1: k1 = J^i mod b, где J = a^j mod b
следовательно есть какое-то по которому (a^j mod b)^i mod b = a^ (i*j) mod b?
Вопрос: Шифрование по алгоритму RSA

Криптосистема шифрования данных RSA

Не получается дешифрование. Что не так?
Пара чисел (e,n) публикуется в качестве открытого ключа.
Пара чисел (d,n) является секретным ключом.
Все числа известны кроме n.
Шифрование сообщения с использованием открытого ключа:
Если m – сообщение (сообщениями являются целые числа в интервале от 0 до n-1), то зашифровать это сообщение можно как c=(m в степени е) mod(n).
Дешифрование сообщения с использованием секретного ключа:
Получатель расшифровывает, полученное сообщение с: m=(c в степени d) mod (n).
C#
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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace RSA
{
    class Program
    {
        static void Main(string[] args)
        {
 
            int p = 13, q = 7, e = 5, d = 29;
            int n, c=0, m,r=0;
            string s;
            n = p * q;
            Console.Write("Сообщение: ");
            s = Console.ReadLine();
            m = Convert.ToInt32(s);
            Console.WriteLine("Открытый ключ: ({0},{1})", e,n);
            Console.WriteLine("Секретный ключ: ({0},{1})", d, n);
            if (m >= 0 && m < (n - 1))
            {
                c = (int)Math.Pow(m, e)%n;
            }
            Console.WriteLine("Шифрование: {0} ", c);
            r = (int)Math.Pow(c, d) % n;
            Console.WriteLine("Дешифрование: {0} ", r);
            Console.ReadLine(); 
        }
 
 
    }
}
Ответ:
Сообщение от KatyKova
r = (int)Math.Pow(c, d) % n;
В этой строке вычислется c^29, которое не помещается в int уже при c=7. Тебе нужно реализовать функцию степени которая сразу по модулю ее считает, самый простой вариант (вычисляет модуль на каждом умножении):
C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
static int ModPow(int x, int y, int z) 
    => y == 0 ? 1 : (x * ModPow(x, y - 1, z)) % z;
    
static void Main()
{
    int p = 13, q = 7, e = 5, d = 29;
    int n, c = 0, m, r = 0;
    string s;
    n = p * q;
    Console.Write("Сообщение: ");
    s = Console.ReadLine();
    m = Convert.ToInt32(s);
    Console.WriteLine("Открытый ключ: ({0},{1})", e, n);
    Console.WriteLine("Секретный ключ: ({0},{1})", d, n);
    if (m >= 0 && m < (n - 1))
    {
        c = ModPow(m, e, n);
        Console.WriteLine("Шифрование: {0} ", c);
        r = ModPow(c, d, n);
        Console.WriteLine("Дешифрование: {0} ", r);
    }
    else Console.WriteLine("Слишком большое число");
    Console.ReadLine();
}
Вопрос: Реализовать шифрование текста с помощью программы openssl

коллеги, помагите


Нужно реализовать шифрование текста , для того чтобы подписать там передачу параметров
В инструкции по шифрованию описано как это сделать с помощью программы openssl
openssl dgst -sha1 -sign privat.key -hex tes.txt

С помощью openssl у меня все получилось , но мой проект на C# и надо внутри него подписать аналогично текст

Уже несколько дней ищу аналогию RSA-SHA-1 , ничего не нахожу.. мой ключь никда не подходит

private.key

-----BEGIN RSA PRIVATE KEY-----
MIICXgIBAAKBgQDjeFoeg3fDCJXr6uRJ+NSyBAKOFamsc45pA/QUzE1wVcSjomVq
.....
QGNnsBLvHGsAZREb3pScNQ8aeUNzyzQaDSh03jAi7L/LIw==
-----END RSA PRIVATE KEY-----


Нашел на студию 2013 можно поставить openssl.net но нинайду никаких аналогов

Подскажить код , который зашифрует по аналоги с тем что делает openssl

Подробная инстуркия которую надо реализовать




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