private string RSA_Dedoce_Symbol(string input, long d, long n)
{
string result = "";
List <string> helpList = new List <string>(input.Split(' '));
WriteResult?.Invoke("Количество шифрованных символов " + helpList.Count);
WriteResult?.Invoke("Для каждого числа считаем:");
foreach (string item in helpList)
{
try
{
BigInteger bi = BigInteger.Pow(ulong.Parse(item), (int)d);
BigInteger n_ = new BigInteger((int)n);
WriteResult?.Invoke("\nВозводим число " + item + " в степень d " + d);
bi = bi % n_;
WriteResult?.Invoke("Считаем остаток от деления полученного числа на N " + n_ + " = " + bi);
int index1 = (int)(bi / _characters.Length);
WriteResult?.Invoke("Делим " + bi + " на размер алфавита " + _characters.Length + " получаем индекс алфавита символа " + index1 + " переводим в алфавит " + _characters[index1].ToString());
result += _characters[index1].ToString();
WriteResult?.Invoke("Полученный символ записываем в результат " + result);
}
catch (Exception e)
{
return("Неверно задан ключ");
}
}
return(result);
}
private string RSA_Endoce_Symbol(string text, long e, long n)
{
string result = "";
BigInteger bi;
WriteResult?.Invoke("Длина текста " + text.Length);
WriteResult?.Invoke("Для каждого символа считаем:");
for (int i = 0; i < text.Length; ++i)
{
int index1 = _characters.IndexOf(text[i]);
WriteResult?.Invoke("\nИндекс символа в алфавите " + index1);
bi = BigInteger.Pow(index1 * _characters.Length, (int)e);
WriteResult?.Invoke("Возводим индекс " + index1 + " умноженный на длину алфавита " + _characters.Length + " в степень e " + e + " = " + bi);
BigInteger n_ = new BigInteger((int)n);
bi = bi % n_;
WriteResult?.Invoke("Находим остаток от деления полученного числа на N " + n_ + " = " + bi);
result += bi.ToString();
if (i != text.Length)
{
result += ' ';
}
WriteResult?.Invoke("Полученное число - зашифрованный символ записываем в результат: " + result);
}
return(result);
}
public override string DeCrypt(string text, Dictionary <string, string> parameters)
{//N d - Закрытый ключ
WriteResult?.Invoke("\n\nЗапустили дешифрование:");
if (parameters == null)
{
return("Не заданы параметры");
}
if (text.Length == 0)
{
return("Нет текста!");
}
string pattern = @"\s+";
string target = " ";
Regex regex = new Regex(pattern);
text = regex.Replace(text, target);
pattern = @"^\s";
target = "";
regex = new Regex(pattern);
text = regex.Replace(text, target);
pattern = @"\s$";
target = "";
regex = new Regex(pattern);
text = regex.Replace(text, target);
pattern = @"^(\d+ {1})+(\d)";
regex = new Regex(pattern);
if (!regex.IsMatch(text))
{
return("Текст не соответствует формату");
}
if (parameters["num"] == "1")
{
if (_N != 0)
{
string result = RSA_Dedoce_Symbol(text, _d, _N);
return(result);
}
return("N = 0");
}
if (parameters["num"] == "2")
{
if (_N != 0)
{
string result = RSA_Dedoce_Bigram(text, _d, _N);
return(result);
}
return("N = 0");
}
return("Неправильно выбраны параметры");
}
public override void Do()
{
Factorization(_N, out _p, out _q);
_d = GenEuclidAlgorithm(EulerFunction(_p, _q), _e);
var msg = "Закрытая экспонента равна: " + _d;
WriteResult?.Invoke(msg);
}
private long EulerFunction(long p, long q)
{
var result = (p - 1) * (q - 1);
var msg = "Функция Эйлера от N равна: ( " + p + " - 1 ) * ( " + q + " - 1 ) = " + result;
WriteResult?.Invoke(msg);
return(result);
}
public override void Do()
{
WriteResult?.Invoke("x=" + _x);
WriteResult?.Invoke("y=" + _y);
int rez = _x + _y;
WriteResult?.Invoke("x+y=" + rez);
}
public void DoDecrypt(string algName, string text, Dictionary <string, string> parameters) //Функция выбирает нужный алгоритм и запускает его
{
if (_algorythm?.Name != algName)
{
WriteResult?.Invoke("Сначала необходимо выполнить алгоритм.");
return;
}
WriteText?.Invoke(_algorythm?.DeCrypt(text, parameters));
}
// ReSharper disable once InconsistentNaming
private void Factorization(long N, out long rez1, out long rez2)
{
long p, q = 0;
for (p = 2; p <= (long)Math.Pow(N, 0.5); p++)
{
if (IsSimple(p) && N % p == 0 && IsSimple(N / p))
{
q = N / p;
break;
}
}
rez1 = p;
rez2 = q;
var msg = "После факторизации число N = " + p + " * " + q + ". ";
WriteResult?.Invoke(msg);
}
public override void Do()
{
var msg = "g=" + _g;
WriteResult?.Invoke(msg);
msg = "p=" + _p;
WriteResult?.Invoke(msg);
msg = "a=" + _a;
WriteResult?.Invoke(msg);
msg = "b=" + _b;
WriteResult?.Invoke(msg);
UInt64 A = MyPow(_g, _a, _p);
msg = "1)\n(1)A=g^a modp=" + A;
WriteResult?.Invoke(msg);
UInt64 B = MyPow(_g, _b, _p);
msg = "(2)B=g^b modp=" + B;
WriteResult?.Invoke(msg);
UInt64 B2 = MyPow(B, _a, _p);
msg = "2)\n(3)B^a modp=g^ab modp=" + B2;
WriteResult?.Invoke(msg);
UInt64 A2 = MyPow(A, _b, _p);
msg = "(4)A^b modp=g^ab modp=" + A2;
WriteResult?.Invoke(msg);
if (A2 != B2)
{
return;
}
ulong K = A2;
msg = "3)\n(5)K=g^ab modp=" + K;
WriteResult?.Invoke(msg);
}
private string RSA_Endoce_Bigramm(string text, long e, long n)
{
string result = "";
BigInteger bi;
WriteResult?.Invoke("Длина текста " + text.Length);
WriteResult?.Invoke("Для каждой пары символов считаем:");
for (int i = 0; i < text.Length; i += 2)
{
int index1 = _characters.IndexOf(text[i]);
if (i == text.Length - 1)
{
WriteResult?.Invoke("\nШифруем один символ с индексом " + index1);
bi = BigInteger.Pow(index1, (int)e);
WriteResult?.Invoke("Возводим индекс " + index1 + " умноженный на длину алфавита " + _characters.Length + " в степень e " + e + " = " + bi);
}
else
{
int index2 = _characters.IndexOf(text[i + 1]);
WriteResult?.Invoke("\nШифруем два символа: с индексами " + index1 + " " + index2);
bi = BigInteger.Pow(index2 + index1 * _characters.Length, (int)e);
WriteResult?.Invoke("Умножаем индекс первого символа на длину алфавита " + index1 * _characters.Length + " складываем с индексом второго символа " + index2 + " = " + (index1 * _characters.Length + index2));
WriteResult?.Invoke("Возводим сумму " + (index1 * _characters.Length + index2) + " в степень e " + e + " = " + bi);
}
BigInteger n_ = new BigInteger((int)n);
bi = bi % n_;
WriteResult?.Invoke("Находим остаток от деления полученного числа на N " + n_ + " = " + bi);
result += bi.ToString();
if (i != text.Length - 1)
{
result += ' ';
}
WriteResult?.Invoke("Полученное число - зашифрованный биграмм записываем в результат: " + result);
}
return(result);
}
public override string Crypt(string text, Dictionary <string, string> parameters)
{//N e - открытый ключ
WriteResult?.Invoke("\n\nЗапустили шифрование:");
if (parameters == null)
{
return("Не заданы параметры");
}
if (text.Length == 0)
{
return("Нет текста!");
}
text = text.ToUpper();
string pattern = @"^[A-Z]+$";
Regex reg = new Regex(pattern);
if (!reg.IsMatch(text))
{
return("Текст не соответствует алфавиту A-Z!");
}
if (parameters["num"] == "1")
{
if (_N != 0)
{
//var upper = text.ToUpper();
string result = "";
string help = RSA_Endoce_Symbol(text, _e, _N);
int num = help.Length;
for (int i = 0; i < num - 1; i++)
{
result += help[i];
}
return(result);
}
}
if (parameters["num"] == "2")
{
if (text.Length % 2 > 0)
{
WriteResult?.Invoke("Так как символов нечетное количество допишем в конец строки Z.");
text += "Z";
}
if (_N != 0)
{
//var upper = text.ToUpper();
string result = "";
string help = RSA_Endoce_Bigramm(text, _e, _N);
int num = help.Length;
for (int i = 0; i < num - 1; i++)
{
result += help[i];
}
return(result);
}
return("N = 0");
}
return("Неправильно выбраны параметры");
}
public override void Do()
{
WriteResult?.Invoke("p=" + _p);
WriteResult?.Invoke("a=" + _a);
WriteResult?.Invoke("b=" + _b);
WriteResult?.Invoke("m=" + _m);
WriteResult?.Invoke("k=" + _k);
int I = 0;
// ReSharper disable once InconsistentNaming
int J = 1;
var mult = _k * _m;
WriteResult?.Invoke("Произведение m и k равно " + mult);
if (mult < _p)
{
return;
}
Dictionary <int, double> numer1 = new Dictionary <int, double>();
Dictionary <int, double> numer2 = new Dictionary <int, double>();
for (int i = 0; i < _m; i++)
{
var rez = ((int)MyPow(_a, i, _p) * _b) % _p;//(Math.Pow(_a, i) * _b) % _p;
numer1.Add(i, rez);
}
for (int i = 1; i < _k + 1; i++)
{
var rez = MyPow(_a, i * _m, _p);
numer2.Add(i, rez);
}
bool flag = false;
for (int j = 1; j < _k + 1; j++)
{
for (int i = 1; i < _m; i++)
{
// ReSharper disable once CompareOfFloatsByEqualityOperator
if (numer1[i] == numer2[j])
{
J = i;
I = j;
flag = true;
break;
}
if (flag)
{
break;
}
}
}
var x = I * _m - J;
if (x == -1)
{
WriteResult?.Invoke("Уравнение не имеет решений!");
return;
}
WriteResult?.Invoke("Первый ряд:");
var numerable1 = string.Empty;
for (int i = 0; i < _m; i++)
{
if (i == J)
{
numerable1 += "[" + numer1[i] + "] ";
continue;
}
numerable1 += numer1[i] + " ";
}
WriteResult?.Invoke(numerable1);
WriteResult?.Invoke("Второй ряд:");
var numerable2 = string.Empty;
for (int i = 1; i < _k + 1; i++)
{
if (i == I)
{
numerable2 += "[" + numer2[i] + "] ";
continue;
}
numerable2 += numer2[i] + " ";
}
WriteResult?.Invoke(numerable2);
WriteResult?.Invoke("i=" + I);
WriteResult?.Invoke("j=" + J);
WriteResult?.Invoke("x=i*m-j=" + x);
UInt64 test = MyPow(_a, x, _p);
if (test == (UInt64)_b)
{
WriteResult?.Invoke("true");
}
}
