Red de conocimiento informático - Material del sitio web - Hermano, estoy buscando un pequeño programa de cifrado C++ DES que pueda ejecutarse.

Hermano, estoy buscando un pequeño programa de cifrado C++ DES que pueda ejecutarse.

Este es el algoritmo DES proporcionado por nuestro maestro. Definitivamente no hay problema. Ahora la función main() está vacía. Simplemente complete la función main() según sus propias necesidades y podrá ejecutarla. y textos Tal vez Dado que el cuadro de texto de Baidu para responder preguntas es un poco pequeño, algunos códigos que originalmente estaban en la misma línea pueden dividirse en dos líneas. Si tiene ese problema, ¡ajústelo usted mismo!

#include

#include "stdio.h"

#include "memoria.h"

# incluir "time.h"

#include "stdlib.h"<

#define PLAIN_FILE_OPEN_ERROR -1

#define KEY_FILE_OPEN_ERROR -2

#define CIPHER_FILE_OPEN_ERROR -3

#define OK 1

typedef char ElemType;

/*IP de tabla de reemplazo inicial*/

int IP_Table[64] = { 57,49,41,33,25,17,9,1,

59,51,43,35,27,19,11,3,

61,53.45,37,29,21,13,5,

63,55,47,39,31,23,15,7,

56, 48,40,32,24,16,8,0,

58,50,42,34,26,18,10,2,

60,52,44, 36,28,20,12,4,

62,54,46,38,30,22,14,6};

/* Tabla de reemplazo anti-inicial IP^ - 1*

int IP_1_Table[64] = {39,7,47,15,55,23,63,31,

38,6,46,14,54.22, 62 ,30,

37,5,45,13,53,21,61,29,

36,4,44,12,52,20,60,28,

35,3,43,11,51,19,59,27,

34,2,42,10,50,18,58,26,<

33,1,41,9,49,17,57,25,

32,0,40,8,48,16,56,24};

/* Tabla de reemplazo extendida E**

int E_Table[48] = {31, 0, 1, 2, 3, 4,

3, 4, 5, 6, 7 , 8, <

7, 8,9,10,11,12,

11,12,13,14,15,16,

15 ,16,17,18,19,20,

19,20,21,22,23,24,

23,24,25,26,27,28,

27,28,29,30,31, 0};

/* Establecer función P*/

int P_Table[32] = {15, 6,19,20,28,11,27,16,

0,14,22,25,4,17,30,9,

1,7,23, 13,31,26,2,8,

18,12,29,5,21,10,3,24};

/*S caja*/

int S[8][4][16] =

/*S1*/

{{14,4,13,1,2

,15,11,8,3,10,6,12,5,9,0,7},

{0,15,7,4,14,2,13,1,10, 6,12,11,9,5,3,8},

{4,1,14,8,13,6,2,11,15,12,9,7,3,10 ,5,0},

{15,12,8,2,4,9,1,7,5,11,3.14,10,0,6,13}},

/*S2*/

{{15,1,8,14,6,11,3,4,9,7,2,13,12,0,5,10},

{3,13,4,7,15,2,8,14,12,0,1,10,6,9,11,5},

{0 ,14,7,11,10,4,13,1,5,8,12,6,9,3,2,15},

{13,8,10,1,3, 15,4,2,11,6,7,12,0,5,14,9}},

/*S3*/

{{10,0,9 ,14,6,3,15,5,1 ,13,12,7,11,4,2,8},

{13,7,0,9,3,4,6, 10,2,8,5,14,12,11,15,1},

{13,6,4,9,8,15,3,0,11,1,2,12 ,5,10,14,7},

{1,10,13,0 ,6,9,8,7,4,15,14,3,11,5,2,12} },

/*S4*/

{{7,13,14,3,0,6,9,10,1,2,8,5,11,12 ,4,15},

{13,8,11,5,6,15,0,3,4,7,2,12,1.10,14,9},

{10,6,9,0,12,11,7,13,15,1,3,14,5,2,8,4},

{3,15,0, 6,10,1,13,8,9,4,5,11,12,7,2,14}},

/*S5*/

{{2 ,12 4,1,7,10,11,6,8,5,3,15,13,0,14,9},

{14,11,2,12,4,7 ,13,1,5,0,15,10,3,9,8,6},

{4,2,1,11,10,13,7,8,15,9, 12,5,6,3,0,14},

{4,2,1,11,10,13,7,8,15,9,12,5,6,3,0 ,14},

{11,2,1,11,6,3,0,14},<

{11,8,12,7,1,14, 2,13,6,15,0,9,10,4,5,3}},

/*S6*/

{{12,1,10,15 ,9,2,6,8,0,13,3,4,14,7,5,11},

{10,15,4,2,7,12 S7*/

{10,15,4,2,7,12,1,13,14,0,11,3,8},

{9,14,15,5,2 ,8,12,3,7,0,4,10,1,13,11,6},

{4,3,2,12,9,5,15,10,11, 14,1,7,6,0,8,13}},

/* S7*/

{{4,11,2,14,15,0,8 ,13,3,12,9,7,5,10,6,1},

{13,0,11,7,4,9,1,10,14,3,5, 12,2,15,8,6},

{1,4,11,13,12,3,7,14,10.15,6,8,0,5,9,2},

{6,11,13,8,1,4,

10,7,9,5,0,15,14,2,3,12}},

/*S8*/

{{13,2,8,4 ,6,15,11,1,10,9,3,14,5,0,12,7},

{1,15,13,8,10,3,7,4,12,5, 6,11,0,14,9,2},

{7,11,4,1,9,12,14,2,0,6,10,13,15,3,5 ,8},

{2,1,14,7,4,10,8,13,15,12,9,0,3,5.6,11}};

/* Opción de desplazamiento 1**

int PC_1[56] = {56,48,40,32,24,16,8,

0,57,49,41 ,33,25,17,

9,1,58,50,42,34,26,

18,10.2,59,51,43,35,

62,54,46,38,30,22,14,

6,61,53,45,37,29,21,

13,5, 60,52,44,36,28,

20,12,4,27,19,11,3};

/* Opción de desplazamiento 2****

int PC_2[48] = {13,16,10,23,0,4,2,27,

14,5,20,9,22,18,11,3 ,

25, 7,15,6,26,19,12,1,

40,51,30,36,46,54 ,29,39,

50,44,32,46,43,48,38,55,

33,52,45,41,49,35,28,31};

//* Especifique el número de veces que se moverá hacia la izquierda*/

int MOVE_TIMES[16] = {1,1,2,2,2,2,2,2,2,2, 2,2, 2,1,2,2,2,2,2,2,2,1};

int ByteToBit(ElemType ch,ElemType bit[8]);

int BitToByte (ElemType bit[8],ElemType *ch);

int Char8ToBit64(ElemType ch[8],ElemType bit[64]);

int Bit64ToChar8(ElemType bit[64], ElemType ch[8]);

int DES_MakeSubKeys( clave ElemType[64], subclaves ElemType[16][48]);

int DES_PC1_Transform(clave ElemType [64], tempbts ElemType[56]);

int DES_PC2_ Transform(clave ElemType[56],tempbts ElemType[48]);

int DES_ROL(datos ElemType[56] , int tiempo) ;

int DES_IP_Transform(datos ElemType[64]);

int DES_IP_1_Transform(datos ElemType[64]);

int DES_E_Transform(ElemType datos[48]

int DES_P_Transform( ElemType datos[32]);

int DES_SBOX(ElemType dat);

a[48]);

int DES_XOR(ElemType R[48], ElemType L[48],int count);

int DES_Swap( ElemType izquierda[32],ElemType derecha); [32]);

int DES_EncryptBlock(ElemType PlainBlock[8], ElemType subKeys[16][48], ElemType cipherBlock[8 ]);

int DES_DecryptBlock(ElemType cipherBlock[ 8], subclaves ElemType[16][48], ElemType PlainBlock[8]);

int DES_Encrypt(char * PlainFile, char *keyStr,char *cipherFile);

int DES_Decrypt(char *cipherFile, char *keyStr,char *plainFile);

/*ByteToBit**

int ByteToBit(ElemType ch, ElemType bit[8]){

int cnt;

for(cnt = 0;cnt < 8; cnt++){

*(bit+cnt) = (ch>>cnt)&1;

}

Devuelve 0

}

/*Binario a Byte**

int BitToByte(ElemType bit[8],ElemType *ch){

int cnt;

for(cnt = 0;cnt < 8; cnt++){

*ch | = *(bit + cnt)<<cnt;

}

return 0;

}

//* Cambiar el length Convierte una cadena de 8 en una cadena de bits binarios**

int Char8ToBit64( ElemType ch[8],ElemType bit[64]){

int cnt;

for(cnt = 0; cnt < 8; cnt++){

ByteToBit(*(ch+cnt),bit+(cnt<<3));

}

Devuelve 0;

}

/* Convierte la cadena de bits binarios en una cadena de longitud 8

int Bit64ToChar8(ElemType bit[64],ElemType ch[8]){

int cnt;

memset(ch,0,8);

for(cnt = 0; cnt < 8 ; cnt++ ){

BitToByte(bit+(cnt<<3),ch+cnt);

}

Devuelve 0;

}

/* Generar subclaves***

int DES_MakeSubKeys(ElemType key[64],ElemType subKeys[16][48]){

ElemType temp[ 56];

int cnt;

DES_PC1_ Tran

sform(key,temp);/*Reemplazo de PC1**

for(cnt = 0; cnt < 16; cnt++){/*16 rondas de generación de descarte, generando 16 subclaves**

DES_ROL(temp,MOVE_TIMES[cnt]);/* Girar a la izquierda**

DES_PC2_Transform(temp,subKeys[cnt]);/* Reemplazo de PC2, generar subclaves*/

}

Devuelve 0;

}

/* Disposición de claves 1 */

int DES_PC1_Transform( ElemType key[ 64], ElemType tempbts[56]){

int cnt;

for(cnt = 0; cnt < 56; cnt++){

tempbts[cnt ] = clave[PC_1[cnt]];

}

devuelve 0;

}

/*Sustitución de clave 2**

int DES_PC2_Transform(ElemType key[56], ElemType tempbts[48]){

int cnt;

for(cnt = 0; cnt < 48; cnt++){

tempbts[cnt] = clave[PC_2[cnt]];

}

}

Devuelve 0;

}

//* Girar a la izquierda***

int DES_ROL(ElemType data[56], int time){

ElemType temp[56];

/*Guarda los bits que se desplazarán directamente en el bucle***

memcpy(temp,data,time);

memcpy(temp+time,data+28,time);

/*Cambiar los primeros 28 bits*/

memcpy(data,data+time,28-time );

memcpy(data+28-time,temp,time);

/* Segundo cambio de 28 bits*/

memcpy( data+ 28,data+28 +tiempo,28-tiempo);

memcpy(datos+56-tiempo,temp+tiempo,tiempo

Devuelve 0;

}

/*Reemplazo de IP**

int DES_IP_ Transform(ElemType data[64]){

int cnt;

ElemType temp[64 ];

for(cnt = 0; cnt < 64; cnt++){

temp[cnt] = datos[IP_Table [cnt]];

}

memcpy(data,temp,64);

return 0;

}

//*IP Transformación inversa**

int DES_IP_1_Transform(ElemType data[64]){

int cnt;

ElemType temp[64];

p>

para(cnt = 0; cnt < 64;

cnt++){

temp[cnt] = datos[IP_1_Table[cnt]];

}

memcpy(data,temp,64);

devuelve 0;

}

/*Desplazamiento extendido**

int DES_E_Transform(ElemType data[48]){

int cnt;

ElemType temp[48];

for(cnt = 0; cnt < 48; cnt++){

temp[cnt] = datos[E_Table[cnt]];

}

memcpy(data,temp,48);

devuelve 0;

}

/*Reemplazo de P**

int DES_P_Transform(ElemType data[32]){

int cnt;

ElemType temp[ 32];

for(cnt = 0.cnt < 32; cnt++){

temp[cnt] = datos[P_Table[cnt]];

}

memcpy(data,temp,32);

devuelve 0;

}

/*Disimilar o/*

int DES_XOR(ElemType R[48], ElemType L[48] ,int count){

int cnt;

for(cnt = 0; cnt < count; cnt++){

R[cnt] ^= L[cnt];

}

devuelve 0;

}

/*Reemplazo de SBOX**

int DES_SBOX(ElemType data[48]){

int cnt;

int línea,fila,salida; p>

int cur1,cur2;

for(cnt = 0; cnt < 8; cnt++){

cur1 = cnt*6;

cur2 = cnt<<2;

/* Calcula las filas y columnas del cuadro S*

línea = (data[cur1] <<1) + data[cur1 +5] ;

fila = (datos[cur1+1]<<3) + (datos[cur1+2]<<2)

+ (datos[cur1+ 3]< <1) + datos[cur1+4];

salida = S[cnt][línea][fila];

/*Restaurar a binario**

datos[cur2] = (salida&0X08)>>3;

datos[cur2+1] = (salida&0X04)>>2;

datos[cur2 +2] = (salida&0X02)>>1;

datos[cur2+3] = salida&0x01;

}

retorno 0;

<

p>}

/* Intercambio*/

int DES_Swap(ElemType izquierda[32], ElemType derecha[32]){

ElemType temp[32] ;

memcpy(temp,izquierda,32);

memcpy(izquierda, derecha,32);

memcpy(derecha,temp,32);

Devuelve 0;

}

/* Cifrar un solo bloque*/

int DES_EncryptBlock(ElemType PlainBlock[8], ElemType subKeys [ 16][48], ElemType cipherBlock[8]){

ElemType PlainBits[64];

ElemType copyRight[48]

int cnt;

Char8ToBit64(plainBlock,plainBits);

/*Disposición inicial (disposición IP)*/

DES_IP_Transform(plainBits)

/ *Iterar 16 rondas**

for(cnt = 0; cnt < ; 16; cnt++){

memcpy(copyRight,plainBits+32,32);

/*Extiende la mitad derecha de 32 bits a 48 bits usando el reemplazo extendido*/

DES_E_Transform(copyRight);

/*Extiende la mitad derecha de la subclave. la operación OR exclusiva*/

DES_XOR(copyRight,subKeys[cnt],48);

/* El resultado de la operación OR exclusiva ingresa al S-box y genera el 32 -bit resultado*/

DES_SBOX(copyRight);

/* P reemplazo*/

DES_P_Transform(copyRight);

/ * Cambiar el lado izquierdo del texto plano XOR de la mitad de la parte y la mitad derecha*/

DES_XOR(plainBits,copyRight,32);

if(cnt != 15){

/* Finalmente complete el intercambio de las partes izquierda y derecha**

DES_Swap(plainBits,plainBits+32);

}

}

/* Transformación inicial inversa (transformación IP^1)*/

DES_IP_1_ Transform(plainBits);

Bit64ToChar8(plainBits,cipherBlock);

Devuelve 0;

p>

}

/* Descifrar un solo paquete*/

int DES_DecryptBlock (ElemType cipherBlock[ 8], subclaves ElemType[16][48],ElemType PlainBlock[8 ]){

ElemType cipherBits[64];

ElemType copyRight[48];

int cnt;

Char8ToBit64(cipherBlock, cipherBits);

/*Transformación inicial (transformación de IP)*

DES_IP_Transform(cipherBits);

<

p> /*Iterar durante 16 rondas*

/*Iterar durante 16 rondas.

for(cnt = 15; cnt >= 0; cnt--){

memcpy(copyRight,cipherBits+32,32);

/* Utilice el reemplazo extendido para ampliar la mitad derecha de 32 bits a 48 bits*/

DES_E_ Transform(copyRight);

/*Utilice subclaves para diferenciar la mitad derecha*/

DES_XOR(copyRight,subKeys[cnt],48);

/*Diferencia el resultado en S-box y genera el resultado de 32 bits*/

DES_ SBOX (copyRight);

/*P Transform**

DES_P_Transform(copyRight);

/*Diferencia la mitad izquierda y la mitad derecha del texto sin formato*

DES_XOR(cipherBits,copyRight,32);

if(cnt != 0){

//* Completa el intercambio de las partes izquierda y derecha. **

DES_Swap(cipherBits,cipherBits+32);

}

}

/* Transposición inicial inversa (IP^1 transponer )*/

DES_IP_1_ Transform(cipherBits);

Bit64ToChar8(cipherBits,plainBlock);

Devuelve 0;

}< / p>

/*Matriz de caracteres de texto cifrado*/

int DES_Encrypt( char *plainText, int datalen,char *keyStr,char *cipherText){

int count = datalen ;

int icount = contar;

if ((cuenta % 8) != 0)

icount = contar+(8-(cuenta % 8) ) ;

ElemType PlainBlock[8],cipherBlock[8],keyBlock[8];

ElemType bKey[64];

ElemType subKeys[16] [ 48];

/*Establecer la clave**

memcpy(keyBlock,keyStr,8);

/*Convertir la clave a una secuencia binaria * *

Char8ToBit64(keyBlock,bKey);

/*Generar subclaves**

DES_MakeSubKeys(bKey,subKeys);

char *pdata = PlainText;

while(count>=8){

/* Lee 8 bytes a la vez y devuelve los bytes leídos correctamente*/

memcpy(plainBlock,pdata,8);

DES_EncryptBlock(plainBlock,subKeys,cipherBlock);

memcpy(cipherText, cipherBlock,8);

cipherText += 8;

pdata += 8;

contar -= 8;

}

si( contar){

/*rellenar*/

memcpy(p

lainBlock,pdata,count);

memset(plainBlock + count,'\0',7 - count);

/* Se guarda el último carácter, incluido el último carácter Número de caracteres de relleno*

PlainBlock[7] = 8 - recuento

DES_EncryptBlock(plainBlock,subKeys,cipherBlock);

memcpy(cipherText,cipherBlock, 8) ;

}

devolver icount;

}

/*Cifrar archivo**

int DES_Encrypt_File( char *plainFile, char *keyStr,char *cipherFile){

ARCHIVO *plain,*cipher;

int count

ElemType PlainBlock[8], cipherBlock[8],keyBlock[8];

ElemType bKey[64];

ElemType subKeys[16][48];

if( (simple = fopen( PlainFile, "rb")) == NULL){

Devuelve PLAIN_FILE_OPEN_ERROR;

}

if((cipher = fopen(cipherFile , " wb")) == NULL){

Devuelve CIPHER_FILE_OPEN_ERROR;

}

/*Establece la clave**

memcpy( keyBlock,keyStr,8);

/*Convierte la clave a una secuencia binaria**

Char8ToBit64(keyBlock, bKey);

/* Genera subclaves **

DES_MakeSubKeys(bKey,subKeys);

while(!feof(plain)){

/*Lee 8 bytes cada vez y devuelve el número de bytes leídos correctamente*

if (( count = fread(plainBlock,sizeof(char),8,plain)) == 8){

DES_EncryptBlock(plainBlock,subKeys,cipherBlock );

fwrite( cipherBlock,sizeof(char),8,cipher);

}

}

if(count) {

/*fill****

memset(plainBlock + count,'\0',7 - count

/* El último carácter); guarda el número de caracteres rellenados, incluido el último carácter**

PlainBlock[7] = 8 - recuento;

DES_EncryptBlock(plainBlock ,subKeys,cipherBlock);

fwrite(cipherBlock,sizeof(char),8,cipher);

}

fclose(plain);

fclose(cipher);

devolver Aceptar;

}

/* Descifrar matriz de caracteres de texto*/

int DES_Decrypt(char *cipherText, int &cipherlen,char *keyStr,char **plainText){

int recuento = 0;

int tiempos = 0;

ElemType PlainBlock[8],cipherBlock[8],keyBlock[8];

ElemType bKey[64];

ElemType subKeys[16][48];

/*Establezca la clave**

memcpy(keyBlock,keyStr ,8);

/*Convertir clave a flujo binario*/

Char8ToBit64(keyBlock,bKey);

/*Generar subclave*/ /

DES_MakeSubKeys(bKey, subKeys);

*plainText = new char[cipherlen+1];

memset(*plainText,0,cipherlen+1 );

char *pdata = *plainText;

while( 1){

/*El número de bytes de texto cifrado debe ser un múltiplo entero de 8

memcpy(cipherBlock,cipherText,8);

DES_DecryptBlock(cipherBlock,subKeys,plainBlock);

veces += 8;

if( veces < cipherlen){

memcpy(pdata,plainBlock,8);

pdata = pdata + 8;

cipherText += 8;

p>

}

else{

descanso;

}

}

/*Juicio sobre si se rellena el final

if(plainBlock[7] < 8){

for(count = 8 - PlainBlock[7]; count < 7; count++) {

for(count = 8 - PlainBlock[7]; count < 7; count++){

for(count = 8 - PlainBlock[7]; count < 7; count++) contar++){

if(plainBlock[recuento] ! = '\0'){

descanso;

}

}

}

}

if(count == 7){/*con relleno**

cipherlen -= PlainBlock[7];

memcpy(pdata, PlainBlock,8 - PlainBlock [7]);

}

}

else{/*Sin relleno****

memcpy(pdata,plainBlock ,8);

}

return OK;

}

/* decrypt_file*/

int

DES_Decrypt_File(char *cipherFile, char *keyStr,char *plainFile){

ARCHIVO *plain, *cipher;

int recuento, tiempos = 0;

long fileLen;

ElemType PlainBlock[8],cipherBlock[8],keyBlock[8];

ElemType bKey[64];

ElemType subKeys[16 ][48];

if((cipher = fopen(cipherFile, "rb")) == NULL){

Devuelve CIPHER_FILE_OPEN_ERROR;

}

if((plain = fopen(plainFile, "wb")) == NULL){

Devuelve CIPHER_FILE_OPEN_ERROR

}

if((plain = fopen(plainFile, "wb")) = = NULL){

Devuelve PLAIN_FILE_OPEN_ERROR;

}

/*Establece la clave* *

memcpy(keyBlock,keyStr,8);

/*Convierte la clave en una secuencia binaria**

Char8ToBit64(keyBlock,bKey);

/*Generar subclaves**

DES_MakeSubKeys(bKey,subKeys);

/*Obtener la longitud del archivo*/

fseek ( cifrado,0,SEEK_END);