Implementación en lenguaje C del algoritmo de cifrado DES
/*-Nombre del archivo: des.h */
/ *- * /
/*-Función: Implementar la función de cifrado y descifrado del algoritmo de cifrado DES*/
/************** ********** **************************************** *********** /
typedef int INT32
typedef char INT8
typedef unsigned char ULONG8
typedef unsigned short int type ulong 16;
typedef unsigned long entero ULONG32
/*Si se utiliza un compilador de C++, se utiliza la siguiente definición de macro.
# definir dll exportar extern " C " _ _ declspec(dll exportar)
*/
# definir dll exportar _ _ declspec(dll exportar)
/*Función de interfaz de cifrado*/
DllExport int 32 DdesN(ulong 8 * data, ULONG8 **key, ULONG32 n_key, ulong 32 readlen);
DllExport INT32 desN(ULONG8 *datos, ULONG8 **clave, ULONG32 n_key, ulong 32 readlen);
DllExport INT32 des3(ULONG8 *datos, ULONG8 *clave, ULONG32 n, ulong 32 readlen);
p>
DllExport int 32 ddes 3(ulong 8 *data, ULONG8 *key, ULONG32 n, ulong 32 readlen);
DllExport INT32 des(ULONG8 *data, ULONG8 * clave, int 32 readlen);
DllExport INT32 Ddes(ULONG8 *datos, ULONG8 *clave, int 32 readlen);
************ ************ **************************************** ************ **/
/*-Nombre del archivo: des.c */
/*- */
/*-Función: Implementación del algoritmo de cifrado DES Funciones de cifrado y descifrado*/
//************************ ************** **********************************/
# incluir & ltstdlib.h & gt
# incluir & ltstdio.h & gt
# incluir & ltstring.h & gt
# include & ltmemory.h & gt
# include & ltmalloc.h & gt
#Include "des.h"
#Definición exitosa 0
#Definición fallida-1
#Definición READFILESIZE 512
#Definición WZ _recommended_number 4
#Definición WZUSEHELPNUM 19
#Definición DESONE 1
#Definición diseño 2
#Definición DESMULTI 3
int 8 * WZ _recommended_help[] =
{
"Herramienta de cifrado y descifrado basada en DES v1.0", /*0*/
"Buscar la excelencia y tener el coraje de innovar",
"——Wu Zhen",
" "
};
int 8 * WZ _Use_Help[]={
Ingrese 5 +n parámetros:,
" \t1. Nombre del archivo ejecutable*. exe",
" \t2. Tipo de operación 1: cifrado de una capa; 2: descifrado de una capa;",
" \t\t13: cifrado de una sola capa de N; 23: descifrado de una sola clave de N capas;" ,
" \t\t39: cifrado de múltiples claves de N capas; 49: descifrado de múltiples claves de N capas",
" \t3. Nombre del archivo del que leer datos*.
txt",
"\t4. Nombre del archivo* en el que se escriben los datos. txt",
"\t5. Clave (8 bytes, por ejemplo: wuzhen12)",
"\t[6]. El número de capas de claves simples de n capas o... clave de descifrado|cifrado de doble capa",
" \t[7]. Triple cifrado | clave de descifrado",
" \t[8]. ...",
" \t[N].
cifrado de n capas | clave de descifrado",
"\tEjemplo 1:DES 1 1. txt 2. txt 12345678",
"\t:des 2 2. txt 3 . txt 12345678 ",
" \tEjemplo 2: DES 13 1 .txt 2 .txt Ian 5 ",
" \t : des 23 2.txt 3.txttian Dulce 5 " ,
"\tEjemplo 3:des 39 1.txt 2.txt 12345678天高信马",
"\t:des 49 2.txt 3. txt 12345678天天高新马",
"******************************"
} ;
INT32 hextofile(ULONG8 *buf, FILE *writefile, ulong 32 length); /*Escribe archivo en 16 */
INT32 encodehex(ULONG8 * tobuf, ULONG8 *frombuf, ulong 32 len); /*16 decodificación binaria*/
INT32 file_enc(FILE *readfile, FILE *writefile,
ULONG8 *key, ULONG32 keynum,
ULONG8 **superclave, ULONG32 n_superclave,
bandera ULONG8);
INT32 file_dec(ARCHIVO *archivo de lectura, ARCHIVO *archivo de escritura,
ULONG8 *clave, ULONG32 keynum,
ULONG8 **superkey, ULONG32 n_superkey,
indicador ULONG8
void wz_print_help()
INT32 main( INT32 argc, INT8 *argv[])
{
INT8 *NOMBRE DE ARCHIVO1, *NOMBRE DE ARCHIVO2
ARCHIVO *fp , * fp2
ULONG8 *key;
ULONG8 * * superkey/*n clave de cifrado y descifrado de capa*/
ulong 8n_super key;
ULONG32 num
if(argc & gt;= 5 & amp& amp(atoi(argv[1])= = 39 | | atoi(argv[1])= = 49) )
{
n _ super clave = argc-4;
super clave = (int 8 * *) calloc (1, n _ super clave * sizeof(void *));
for(num = 0; num & ltn _ superkeynum++)
{
super clave[num]= argv[4 +num];
}
}
else if(argc = = 6 & amp;& amp(atoi(argv[1])= = 13 | | atoi(argv[1])= = 23) &&(atoi(argv[5])>0)
{
}
si no(argc = = 5 & amp; & amp (ato
i(argv[1])= = 1 | atoi(argv[1])= = 2))
{
}
Otros p>
{
wz _ print _ help();
Devolución fallida
}
nombre de archivo 1 = argv [2];
nombre de archivo 2 = argv[3];
if ((fp= fopen(FILENAME1," Rb"))= = NULL | |(fp2 = fopen( nombre de archivo 2, " WB)) = = NULL)
{
printf("No se puede abrir el archivo\n ");
La devolución falló;
}
clave = argv[4];
interruptor(atoi(argv[1])
{
Caso 1: /*Cifrado*/
file_enc(fp, fp2, clave, 0, NULL, 0, DESONE);
Printf("\n \tDES Layer); 1 cifrado, el texto cifrado se almacena en %s archivo \n ", nombre de archivo 2);
Roto;
Caso 2:
file_dec(fp, fp2 , clave, 0, NULL, 0, DESONE);
Printf("\n \tDES la capa 1 ha sido descifrada, el texto cifrado se almacena en %s archivo \n ", nombre de archivo 2);
Break;
Caso 13:
file_enc(fp, fp2, key, atoi(argv[5]), NULL, 0, destrie);
Printf("\n \tDES %u cifrado de clave única de capa se completa, el texto cifrado se almacena en el archivo %s\n ", atoi(argv[5]), nombre de archivo 2);
Break;
p>Caso 23:
file_dec(fp, fp2, key, atoi(argv[5]), NULL, 0, destrie);
Printf("\n \tDES %u clave única de capa ha sido descifrada, el texto cifrado se almacena en el archivo %s \n ",atoi(argv[5]), nombre de archivo 2);
Roto;
Caso 39:
file_enc(fp, fp2, NULL, 0, superkey, n_superkey, des multi);
Printf("\n \ Cifrado de claves múltiples tDES completado, texto cifrado almacenado en %s archivo \n ", nombre de archivo 2);
Gratis(superclave);
superclave = NULL
Roto;
Caso 49:
file_dec(fp, fp2, NULL, 0, superkey, n_superkey, des multi);
Printf("\n \ Cifrado de claves múltiples tDES completado. El texto cifrado se almacena en el archivo %s \n ", nombre de archivo 2);
Gratis (superclave);
superclave = NULL
Roto;
Valor predeterminado:
printf(" Elija cifrar | descifrar, elija cifrar | descifrar \ n ");
Romper;
}
fclose(FP);
fclose(fp2);
Regreso exitoso
}
nulo wz_
print_help()
{
int 32 I;
printf(" \ t ");
for(I = 0; i<22;i++)
{
printf("%c ", 5);
}
printf(" \ n " );
for(I = 0;i<WZ_Recommended_No.;i++)
{
printf("\t%c\ t%s %c\n ",5,WZ_recommended_help[i],5);
}
printf(" \ t ");
for(I = 0;i<22; i++)
{
printf("%c ", 5);
}
printf(" \ n ");
for(I = 0;i<WZUSEHELPNUMi++)
{
printf("\t %s\n ", WZ_Use_Help[I]);
}
Regresar;
}
INT32 file_enc (ARCHIVO *leer archivo, ARCHIVO *escribir archivo,
ULONG8 *clave , ULONG32 keynum,
ULONG8 **superclave, ULONG32 n_superkey,
bandera ULONG8)
{
INT32 filelen = 0, readlen = 0, escribir len = 0;
ulong 32 total filelen = 0 /*Calcular la longitud real del archivo*/
ulong 8 leer buf[leer tamaño de archivo]= { 0 } ;
filelen = fread( readbuf, sizeof( INT8), READFILESIZE, leer archivo
while( filelen == READFILESIZE)
{
archivo total+= tamaño de archivo leído;
Cambiar (bandera)
{
Caso DESONE:
des(readbuf, clave, leer tamaño de archivo);
Pausa;
Caso 3:
des3(readbuf,key,keynum,leer tamaño de archivo);
Break;
Diseño de caso:
desN(readbuf,superkey,n_superkey,read tamaño de archivo
Break
}
hextofile(readbuf, writefile, leer tamaño de archivo); /*Escribe el archivo en forma de 16*/
memset(readbuf, 0, leer tamaño de archivo
<); p>filelen = fread( readbuf, sizeof( INT8), READFILESIZE, leer archivo}
/*Este es el último lote de datos leídos del archivo, la longitud); puede ser igual a 0, así que juzgue*/
if(filelen & gt; 0)
{
/*Si la longitud leída del archivo es no es igual a 0, debe exceder los 8 bytes.
La longitud del archivo existe en los últimos 8 bytes*/
total filelen+= filelen;
memcpy(& readbuf[READFILESIZE-8], ( ulong 8 *) & totalfilelen, 4);
Switch(flag)
{
Caso DESONE:
des( readbuf, key, leer tamaño de archivo);
Romper;
Caso 3:
des3( readbuf, key, keynum, leer tamaño de archivo); ;
Diseño de caso:
desN(readbuf, superkey, n_superkey, leer tamaño de archivo);
Break;
}
hextofile(readbuf, writefile, leer tamaño de archivo); /*Escribe el archivo en formato 16*/
memset(readbuf, 0, leer tamaño de archivo);
}
else /*filelen == 0*/
{
memcpy(&readbuf[0],(ulong 8 *)& amp; totalfilelen , 4);
cambiar(bandera)
{
caso DESONE:
des(readbuf,key,8 );
Pausa;
Caso 3:
des3(readbuf, key, keynum, 8);
Pausa;
p>
Diseño de caso:
desN(readbuf, superkey, n_superkey, 8);
Break;
}
hextofile(readbuf,writefile,8);/*Escribe el archivo en forma de 16*/
}
Regreso exitoso;
}
INT32 file_dec(ARCHIVO *archivo de lectura, ARCHIVO *archivo de escritura,
ULONG8 *clave, ULONG32 keynum,
ULONG8 **superclave, ULONG32 n_superclave,
bandera ULONG8)
{
INT32 filelen = 0, readlen = 0, escribir len = 0
ulong 32 total filelen = 0; * Calcular la longitud real del archivo*/
int 32 num = 0;
ulong 8 read buf[read size]= { 0 };
ulong 8 enviar buf[leer tamaño de archivo] * 2]= { 0 };
fseek(readfile,-16,SEEK_END);/*Representa los últimos 16 bytes del espacio de longitud del archivo*/
filelen = fread(sendbuf,sizeof(INT8),16,readfile);
encodehex(readbuf,sendbuf,8);
Cambiar (bandera)
{
Caso DESONE:
Ddes(readbuf, key, 8);
Rotura;
Caso 3:
Ddes3(readbuf,k
ey,keynum,8);
Pausa;
Diseño de caso:
DdesN(readbuf,superkey,n_superkey,8);
romper;
}
/*decrypt*/
memcpy((ulong 8 *)&total filelen &readbuf[0], 4) ; /*Obtener la longitud total del archivo*/
memset(readbuf, 0, 8
memset(sendbuf, 0, 16); > num = archivo total/tamaño de archivo leído /*Hay múltiples grupos READFILESIZE*/
totalfilelen % = READFILESIZE
fseek(readfile, 0, SEEK _ SET); al comienzo del archivo*/
while(num -)
{
filelen = fread( sendbuf, sizeof( INT8), READFILESIZE*2, readfile);
encodehex(readbuf, sendbuf, leer tamaño de archivo);
Cambiar (bandera)
{
Caso DESONE:
Ddes(readbuf, clave, leer tamaño de archivo);
Pausa;
Caso 3:
Ddes3(readbuf, clave, keynum, leer tamaño de archivo) ;
Romper;
Diseño de caso:
DdesN(readbuf, superkey, n_superkey, leer tamaño de archivo);
Romper ;
p>}
writelen = fwrite(readbuf, sizeof(INT8), READFILESIZE, writefile);
memset(readbuf, 0, leer tamaño de archivo) ;
memset(sendbuf, 0, read tamaño de archivo * 2
}
if (total filelen > 0)/*El último bloque tiene extra); elementos*/
{
filelen = fread( sendbuf, sizeof( INT8), READFILESIZE*2, readfile);
encodehex( readbuf, sendbuf, read); tamaño de archivo);
Cambiar (bandera)
{
Caso DESONE:
Ddes(readbuf, clave, leer tamaño de archivo);
Pausa;
Caso 3:
Ddes3(readbuf, clave, keynum, leer tamaño de archivo);
Pausa;
Diseño de caso:
DdesN(readbuf, superkey, n_superkey, leer tamaño de archivo);
Break;
}
writelen = fwrite( readbuf, sizeof(INT8), totalfilelen, writefile);
memset(readbuf, 0, leer tamaño de archivo);
memset(sendbuf, 0, leer archivosi
ze * 2);
}
Regreso exitoso;
}
INT32 hextofile(ULONG8 *buf, FILE *writefile, ULONG32 longitud)
{
ulong 32 writelen = 0;
/*Escribe el archivo en forma de 16*/
mientras (writelen & lt; longitud)
{
if(buf[writelen] == 0)
{
fprintf( writefile ," %x ", 0);
fprintf( writefile, " %x ", 0
}
else if(buf[writelen]); & lt ; 0x10)
{
fprintf( escribirarchivo, " %x ", 0
fprintf( escribirarchivo, " %x ", buf[); writelen] );
}
Otros
{
fprintf(writefile, " %x ", buf[writelen]);
p>
}
writelen++;
}
Regreso exitoso
}
codificación INT32hex (ULONG8 *tobuf, ULONG8 *frombuf, ULONG32 len)
{
ULONG8 * readfirst = frombuf
ULONG8 * readend = & amp de buf[1];
int 8 * s;
ulong 8y[2]; for(I = 0; i & ltleni++)
{
y[0]= * leer primero
y[1]= * leer final; /p>
leer primero+= 2;
leer final+= 2;
tobuf[I]=(ulong 8)strtol((int 8 *)y, & amps, 16);
}
Regreso exitoso;
}