c_str());
ofstream outf(outFileName.c_str());
int y=power(g,x,p);
wcout<<"Открытый ключ (p,g,y)="<<"("<<p<<","<<g<<","<<y<<")"<<endl;
wcout<<"Закрытый ключ x="<<x<<endl;
wcout<<"\nШифруемый текст:"<<endl;
while(inf.good()){
int m=inf.get();
if(m>0){
wcout<<(char)m;
int k=rand()%(p-2)+1; // 1 < k < (p-1)
int a= power(g,k,p);
int b= mul(power(y,k,p),m,p);
outf<<a<<" "<<b<<" ";
}
}
wcout<<endl;
inf.close();
outf.close();
}
void decrypt(int p,int x,string inFileName,string outFileName){
ifstream inf(inFileName.c_str());
ofstream outf(outFileName.c_str());
wcout<<"\nДешифрованый текст:"<<endl;
while(inf.good()){
int a=0;
int b=0;
inf>>a;
inf>>b;
if(a!=0&&b!=0){
//wcout<<a<<" "<<b<<endl;
int deM=mul(b,power(a,p-1-x,p),p);// m=b*(a^x)^(-1)mod p =b*a^(p-1-x)mod p - трудно было найти нормальную формулу, в ней вся загвоздка
char m=static_cast<char>(deM);
outf<<m;
wcout<<m;
}
}
wcout<<endl;
inf.close();
outf.close();
}
int main(){
srand(time(NULL));
crypt(593,123,8, "in.txt","out_crypt.txt");
decrypt(593,8,"out_crypt.txt","out_decrypt.txt");
return 0;
}
Реализация алгоритма шифрования на базе стандарта RSA представлена ниже.
// RSA.cpp : RSA.
#include "stdafx.h"
#include <iostream>
#include <ctime>
#include <cstdlib>
#include <iomanip>
using namespace std;
/////////////////////////////////////////////////////////////////////
//Алгоритм "решето Сундарама". Выбирает все простые числа
//до заданного (случайно сгенерированного).
int sundaram(int n)
{
int *a = new int [n], i, j, k;
memset(a, 0, sizeof(int) * n);
for(i = 1; 3*i+1 < n; i++)
{
for(j = 1; (k = i+j+2*i*j) < n && j <= i; j++)
a[k] = 1;
}
//Выбирает из списка простых чисел ближайшее к заданному.
for(i = n-1; i >= 1; i--)
if(a[i] == 0)
{
return (2 * i + 1);
break;
}
delete [] a;
}
/////////////////////////////////////////////////////////////////////
//Алгоритм Евклида. Алгоритм для нахождения наибольшего
//общего делителя двух целых чисел. Используется для проверки
//чисел на взаимопростоту.
int gcd(int a, int b)
{
int c;
while (b)
{
c = a % b;
a = b;
b = c;
}
return abs(a);
}
/////////////////////////////////////////////////////////////////////
int main()
{
cout << "Please wait... Key generation procces." << endl << endl;
// Генерация двух чисел и выбор двух простых чисел.
srand( (unsigned)time( NULL ) );
int p = rand()%100;
int q = rand()%100;
int p_simple = sundaram(p);
int q_simple = sundaram(q);
//Находим число n.
unsigned int n = p_simple*q_simple;
//Генерация числа d и проверка его на взаимопростоту
//с числом ((p_simple-1)*(q_simple-1)).
int d, d_simple = 0;
while (d_simple !=1)
{
d = rand()%100;
d_simple = gcd (d, ((p_simple-1)*(q_simple-1)));
}
//Определение числа e, для которого является истинным
//соотношение (e*d)%((p_simple-1)*(q_simple-1))=1.
unsigned int e = 0, e_simple = 0;
while (e_simple !=1)
{
e += 1;
e_simple = (e*d)%((p_simple-1)*(q_simple-1));
}
//Сгенерированные ключи.
cout << '{' << setw(12) << e << ',' << setw(12) << n << '}' << " - Open key" << endl;
cout << '{' << setw(12) << d << ',' << setw(12) << n << '}' << " - Secret key" << endl << endl;
//Ввод шифруемых данных.
const int MAX = 20;
char *Text = new char [MAX];
cout << "Please enter the Text. Use <Enter> button when done." << endl;
cin.get(Text, MAX);
//Массив для хранения шифротекста.
unsigned int *CryptoText = new unsigned int [MAX];
unsigned int *Tdecrypt = new unsigned int [MAX];
//Получение из введённых данных десятичного кода ASCII и
//дальнейшее его преобразование по формуле ci = (mj^e)%n.
int b = 301;
int c;
cout << endl << setw(5) << "Text" << setw(6) << "ASCII"
<< setw(20) <<"CryptoText/Block#" << setw(14)
<< "ASCIIdecrypt" << setw(14) << "Text decrypt" << endl
<< "------------------------------------------------------------" << endl;
for (int j = 0; j < MAX; j++)
{
c = 1;
unsigned int i = 0;
int ASCIIcode = (static_cast<int>(Text[j]))+b;
while (i<e)
{
c = c*ASCIIcode;
c = c%n;
i++;
}
CryptoText[j] = c;
b+=1;
}
//Расшифровка полученного кода по формуле mi = (ci^d)%n
//и перевод его в десятичный код ASCII.
b = 301;
int m;
for (int j = 0; j < MAX; j++)
{
m = 1;
unsigned int i = 0;
while (i<d)
{
m = m*CryptoText[j];
m = m%n;
i++;
}
m = m-b;
Tdecrypt[j] = m;
b+=1;
}
for (int j = 0; j < MAX; j++)
{
cout << setw(5) << Text[j] << setw(6) << static_cast<int>(Text[j]) << setw(20)
<< CryptoText[j] << setw(14) << Tdecrypt[j] << setw(14) << static_cast<char>(Tdecrypt[j]) << endl;
}
delete [] Text;
delete [] CryptoText;
delete [] Tdecrypt;
return 0;
}
int _tmain(int argc, _TCHAR* argv[])
{
return 0;
}
Реализация алгоритма шифрования по схеме Рабина представлена ниже.
#include <iostream>
#include <algorithm>
#include <iterator>
#include <string>
#include <vector>
#include <cstring>
using namespace std;
int p = 167, q = 151;
int n = p * q;
int modulo (int a, int b)
{
return a >= 0 ? a % b : ( b - abs ( a%b ) ) % b;
}
void encode(string s)
{
vector<int>l;
for(int i = 0; i < strlen(s.c_str()); i++) {
l.push_back((int)s[i]);
}
copy(l.begin(), l.end(), ostream_iterator<int>(cout, ""));
}
void decode(vector<int> s)
{
vector<char>l;
for(int i = 0; i < s.size(); i++) {
l.push_back(char(s[i]));
}
copy(l.begin(), l.end(), ostream_iterator<char>(cout, ""));
}
int encrypt(int m, int p, int q)
{
int c = (m * m)%n;
return c;
}
int mod(int k, int b, int m)
{
int i=0;
int a=1;
vector<int> t;
while(k>0){
t.push_back(k%2);
k=(k-t[i])/2;
i++;
}
for(int j=0; j<i; j++){
if(t[j]==1){
a=(a*b)%m;
b=(b*b)%m;
} else{
b=(b*b)%m;
}
}
return a;
}
vector<int> eea(int a, int b)
{
if (b>a) {
int temp=a; a=b; b=temp;
}
int x=0;
int y=1;
int lastx=1;
int lasty=0;
while (b!=0) {
int q= a/b;
int temp1= a%b;
a=b;
b=temp1;
int temp2 = x;
x=lastx-q*x;
lastx = temp2;
int temp3 = y;
y = lasty-q*y;
lasty=temp3;
}
vector<int>arr(3);
arr[0] = lastx;
arr[1] = lasty;
arr[2] = 1;
return arr;
}
int decrypt(int c, int p, int q)
{
int mp = mod((p+1)/4, c, p);
int mq = mod((q+1)/4, c, q);
vector<int> arr = eea(p, q);
int pp = arr[0]*p*mq;
int qq = arr[1]*q*mp;
double r = modulo((pp+qq), n);
if( r < 128)
return r;
int negative_r = n - r;
if (negative_r < 128)
return negative_r;
int s = modulo((pp-qq), n);
if( s < 128)
return s;
int negative_s = n - s;
if( negative_s < 128)
return negative_s;
}
int main()
{
string test ="Rabin Cryptosystem";
cout << "Message: " << test << endl;
int len = strlen(test.c_str());
vector<int>l;
for(int i = 0; i <= len; i++)
{
l.push_back(encrypt(test[i], p, q));
}
cout << "Encryption: ";
copy(l.begin(), l.end(), ostream_iterator<int>(cout, ""));
vector<int>d;
for(int i = 0; i < len; i++)
{
d.push_back(decrypt(l[i], p, q));
}
cout << "\nDecoded message: ";
decode(d);
cout << endl;
return 0;
}
Разработка своего алгоритма на языке С++14 представлена ниже.
void txtencode(std::string Incode, std::string passCode)
{
//Так как сам результат может содержать нежелательные символы, эта переменная содержит символы с помощью которых мы будем выдавать закодированный результат, который вдальнейшем сможем отправить без особых хлопот
auto b52 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
//Эти переменные будут меняться в процессе кодировки и создавать мешанину каждого кодируемого символа в отдельности
auto maxPC = ifPC = 0;
//Уникализируем переменную maxPC. Ее значение будет происходить от суммы каждого юникодного значения символов пароля
for(auto i=0; i<passCode.length; i++) maxPC += passCode;
//Значение maxPCmod будет меняться на убывание, опять же в зависимости от юникодного значения символа пароля
//А вот значение maxPC сохраним, оно понадобиться вдальнейшем, чтобы присвоить переменной maxPCmod новое значение, когда то будет меньше 0.
maxPCmod = maxPC;
//Результат кодируемой строки. Изначально равно пустоте.
auto rexcode = "";
//Переменная содержит первый символ пароля:
passCode = numPC
//С ее помощью будем перебирать пароль и перемешивать его с символом строки
auto numPC = 0;
//Перебираем каждый символ строки
for(auto i=0; i<Incode.length; i++)
{
//Если все символы пароля перемешаны, начинаем перебор пароля с первого символа
if(numPC == passCode.length()) numPC = 0;
//Присвоиваем переменной maxPCmod новое значение, если оно меньше нуля.
if(maxPCmod < 1) maxPCmod = maxPC+ifPC;
//Эта переменная нужна для создания уникального значения maxPCmod, и как следствие уникального символа, с которым будет перемешиваться символ исходной строки.
// Получаем ее путем деления по модулю значений maxPCmod и текущего используемого юникодного значения символа пароля
//В целом постоянная мешанина переменных maxPCmod, maxPC и ifPC позволяет кодировать каждый отдельный символ исходной строки с уникальным значением, что подразумевает невозможность отследить какую-либо синхронизацию алгоритма
ifPC += maxPCmod % numPC;
//Создаем непосредственно символ, с которым и будем перемешивать текущий символ строки
auto iscode = maxPCmod % passCode.charCodeAt(numPC);
//Создаем мешанину, путем сложения предыдущей переменной с переменной текущего символа
auto nCode = (Incode iscode);
//Уменьшаем значение maxPCmod для ее дальнейшей уникализации
maxPCmod -= passCode;
//Переходим к следующему символу пароля
numPC++;
//Это будет уникальный номер текущего символа.
//При делении закодированного символа на 52 число означает неполное частно, а буква остаток.
//Например 22С означает 22*52+2, так как С второй по счету символ начиная с нуля.
rexcode += parseInt(nCode / 52) + b52.charAt(parseInt(nCode % 52));
}
//Возвращаем закодированную строку
return rexcode;
}
Функция декодировки представлена ниже.
void txtdecode(std::string Incode, std::string passCode)
{
auto b52 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
auto maxPC = 0;
for(auto i=0; i<passCode.length; i++) maxPC += passcode[i];
maxPCmod = maxPC;
ifPC = 0;
//Разбиваем строку на массив, который будет состоять из каждого закодированного символа
auto Incode = Incode.match(/\d+\w/g);
auto rexcode = "";
auto numPC = 0;
for(auto i=0; i<Incode.length(); i++)
{
if(numPC == passCode.length()) numPC = 0;
if(maxPCmod < 1) maxPCmod = maxPC+ifPC;
ifPC += maxPCmod % passcode[numPC];
auto iscode = maxPCmod % passcode[numPC];
//В отличии от фунции кодирования, тут дейтсвие происходит в обратную сторону
auto nCode = (parseInt(Incode[i])*52)+parseInt(b52.indexOf(Incode[i].substr(-1)));
maxPCmod -= passcode[numPC];
numPC++;
//И в результате соответственно уже не сложение, а вычитание
rexcode += (int)(nCode-iscode);
}
//Уже можно вернуть return rexcode.
//Но для корректного отображения в браузере, я преобразую некоторые символы во мнемоники, а урлы преобразую в ссылки.
return rexcode.replace(/&/g, "&").replace(/</g, "<").replace(/>/g, ">").replace(/ /g, " ").replace(/\r\n|\r|\n/g,"<br />").replace(/(https?\:\/\/|www\.)([а-яА-Я\d\w#!:.?+=&%@!\-\/]+)/gi, function(url)
{
return '<a target="_blank" href="'+ (( url.match('^https?:\/\/') )?url:'http://' + url) +'">'+ url +'</a>';
});
}
2