Programa de descifrado de código fuente
# include & ltiostream.h & gt
# include & ltmath.h & gt
# include & ltstdio.h & gt
typedef int Elemtype
Tipo de elemento p, q, e;
Elemtype fn
Tipo de elemento m, c;
int bandera = 0;
typedef void(* Msghandler)(void);
estructura MsgMap {
char ch
controlador Msghandler;
};
/*Clave pública*/
Estructura PU {
elem tipo e;
Tipo de elemento n;
} pu
/*Clave privada*/
Estructura PR {
Tipo de elemento d;
p>Tipo de elemento n;
} pr
/*Determinar si un número es primo*/
bool test_prime(tipo de elemento m) {
si (m & lt= 1) {
Devuelve falso
}
si no (m == 2) {
Devuelve verdadero
}
En caso contrario {
for(int I = 2;i<= sqrt(m);i++) {
if((m % i) == 0) {
Devuelve falso
Descanso;
}
}
Devuelve verdadero
}
}
/*Convierte datos decimales a una matriz binaria*/
void switch_to_bit(tipo de elemento b, tipo de elemento bin[32]) {
int n = 0;
while(b & gt; 0) {
bin[n]= b % 2;
n++;
b/=
}
}
p>/*Menú candidato, interfaz principal*/
void Init() {
cout & lt& lt"* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * <& ltendl
cout & lt& lt" *** Bienvenido a RSA Encoder* * *"& lt;& ltendl
cout & lt& lt"* * * a acerca de * * *"& lt;& ltendl
cout & lt&. lt"* * * e. cifrar * * *"& lt;& ltendl
cout & lt& lt"* * * * d. descifrar * * *"& lt;& ltendl
cout & lt& lt"* * * s. setkey * * *"& lt;& ltendl
cout & lt& lt"* * * q. quit * * *"& lt ;& ltendl
cout & lt& lt"* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *por *Terry*
* *"& lt;& ltendl
cout & lt& lt"Presiona una tecla:" & lt& ltendl
}
/* Ordenar dos números, grandes one first*/
Orden no válida (Elemtype & ampin1, Elemtype & ampin2) {
elem type a =(in 1 & gt; in2? in 1:in2);
elem tipo b =(en 1 & lt;en2?en 1:in2);
en 1 = a;
en2 = b;
}
/*Encontrar el máximo común divisor*/
Tipo de componente mcd (tipo de componente a, tipo de componente b) {
Orden (a , b);
int r;
if(b == 0) {
Devolver a
}< /p; >
De lo contrario {
mientras(verdadero) {
r = a % b;
a = b
b; = r;
if (b == 0) {
Devolver a;
Descanso;
}
}
}
}
/*Usa el algoritmo euclidiano extendido para encontrar la operación inversa de la multiplicación*/
elem escriba extender _ Euclid(elem tipo m, Elemtype bin) {
Orden (m, bin);
Elemtype a[3], b[3], t[ 3];
a[0] = 1, a[1] = 0, a[2] = m;
b[0] = 0, b[1] = 1, b [2] = bin;
if (b[2] == 0) {
devuelve a[2] = mcd(m, bin);
}
if (b[2] ==1) {
return b[2] = mcd(m, bin);
}
mientras(verdadero) {
if (b[2] ==1) {
return b[1];
romper;
}
int q = a[2]/b[2];
for(int I = 0;i<3;i++ ) {
t[I]= a[I]-q * b[I];
a[I]= b[I]
b[I]= t[I];
}
}
}
/*Algoritmo rápido de exponenciación modular*/
Multiplicación modular de tipo de elemento (tipo de elemento a, tipo de elemento b, tipo de elemento n) {
tipo de elemento f = 1;
Correo electrónico [32]
cambiar_a_bit(b,bin);
for(int I = 31;i>=0;i-) {
f =(f * f)% n;
if(bin[i] == 1) {
f =(f * a)% n;
}
}
Devolver f;
}
/*Generar clave*/
void produce_key() {
cout & lt& lt"Ingrese dos números primos p y q:"
CIN & gt; & gtp & gt& gtq; (test_prime(p)&test_prime(q))){
co
ut & lt& lt"Error de entrada, ¡confirme que ambos números son números primos!"& lt& ltendl
cout & lt& lt"Ingrese dos números primos p y q:";
CIN & gt;& gtp & gt& gtq;
};
pr .n = p * q
pu . /p>
fn =(p-1)*(q-1);
cout & lt& lt" fn = " & lt& ltfn & lt& ltendl
cout & lt<"Ingrese e:";
CIN & gt;& gte;
while((gcd(fn, e)!=1)) {
cout<<"e es un error, inténtelo de nuevo!";
cout<<"Ingrese e:";
CIN>>e;
>}
pr.d = (extend_euclid(fn, e)+fn)% fn;
pu.e = e
bandera = 1;
cout & lt& lt" pr . d:" & lt;& ltpr.d & lt& lt" pr . n:" & lt;& ltPR& lt& ltendl
cout & lt& lt" pu . e:" & lt;& ltpu.e & lt& lt" pu . n:" & lt;& ltpu.n & lt& ltendl
}
/*Cifrado*/
void encrypt() {
if(flag == 0) {
cout & lt& lt" setkey first:" & lt;& ltendl
produce_key();
}
cout & lt& lt"Ingrese m:";
CIN>>m;
c= modulo_multiplication(m,pu.e,pu.n);
cout<<"c es:"<<c & lt& ltendl
}
/*descifrado*/
void decryption(){
if(flag == 0) {
cout & lt& lt" setkey first:" & lt;& ltendl
produce _ key();
}
cout <<"Ingrese c:";
CIN>>c;
m = multiplicación modular (c, pr.d, pr.n);
cout & lt& lt"m es: "& lt& ltm & lt& ltendl
}
/*Información de derechos de autor*/
void about() {
cout & lt& lt"* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * & lt;& ltendl
cout & lt& lt"* * * por Terry * * *"& lt;& ltendl
cout & lt& lt"* **Copyright 2010, todos los derechos reservados* * *"& lt;& ltendl
cout & lt& lt "*** Terry, ¡Desarrollado por Zoe! *
* * "& lt& ltendl
cout & lt& lt"***Si tiene alguna pregunta, envíe un correo electrónico* * *"& lt;& ltendl
cout & lt& lt" *** ¡Vaya a 18679376@qq.com! * * * " & lt& ltendl
cout & lt& lt"***Ciencias e ingeniería informática * * *"& lt; Universidad de Ciencia y Tecnología Electrónica de Xi'an 2010-4-29 * * * "& lt;& ltendl
cout & lt& lt"* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * & lt;& ltendl
cout & lt& ltendl & lt& ltendl
init ();
}
/*Mapa de mensajes*/
MsgMap Messagemap[] = {
{'a ', aprox. s ', clave de producción},
{'d ', descifrado},
{'e ', cifrado},
{'q ', NULL }
};
/*Función principal, que proporciona bucle*/
void main() {
init(); /p>
char d;
mientras((d = getchar())!='q') {
int I = 0;
while(Mapa de mensajes[i].ch) {
if(Mapa de mensajes[i].ch == d) {
Mapa de mensajes[i]. handler();
Romper;
}
i++;
}
}
}
//Bienvenido a compartir, robar es vergonzoso.