Sistema de cifrado por lote de texto plano

[AlbertoBSD]

Buen dia pues hice un pequeño programa para tu algoritmo.

La idea que tenia no a funcionado.

El enfoque era estadístico, lo que hice fue generar N arreglos de Enteros donde N es igual al numero de caracteres del mensaje.

El primer arreglo[0] es de longitud 1
El segundo arrega[1] es de longitud 2
y asi sucesivamente.

Guarde las sumas de los valores ascii de cada caracter en los arreglos. Ademas de contar cuantas veces se sumaba en cada caracter en cada casilla.

Saque los promedios y las desviaciones estandar ademas. saque el promedio de cada arreglo y las desviaciones estandar de las desviaciones estandar valga la redundancia...

Mi idea era ver como cambiaban las desviaciones estandar y me imaginaba que en los puntos de inflexion estaría la pista.

Curiosamente en algunos ejemplos el primer punto de inflexion coincidencia con la longitud de la contraseña, pero en otros no lo hacia.

Codigo:

Código (c) [Seleccionar] Expandir


#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
#include<sys/stat.h>

off_t fsize(const char *filename);
unsigned char max(unsigned char item,unsigned char mx);
unsigned char min(unsigned char item,unsigned char mn);

int main() {
int **sums;
int **counts;
float **diff;
float **promedios;
float **desviacion;
float *sumdesviaciones;
float *promedioDesviaciones;
float *diffdesviaciones;
float *desviacion2;
FILE *file;
char *buffer;
float temp;
int l,i,j,k;
file = fopen("salida.txt","r");
if(file) {
l = fsize("salida.txt");
buffer = calloc(l+1,sizeof(char));
fread(buffer,sizeof(char),l,file);
fclose(file);
sums = calloc(l,sizeof(int*));
counts = calloc(l,sizeof(int*));
diff = calloc(l,sizeof(float*));
promedios = calloc(l,sizeof(float*));
desviacion = calloc(l,sizeof(float*));
sumdesviaciones = calloc(l,sizeof(float));
promedioDesviaciones = calloc(l,sizeof(float));
diffdesviaciones = calloc(l,sizeof(float));
desviacion2 = calloc(l,sizeof(float));
i = 0;

while(i < l) {
sums[i] = calloc(i+1,sizeof(int));
counts[i] = calloc(i+1,sizeof(int));
diff[i] = calloc(i+1,sizeof(float));
promedios[i] = calloc(i+1,sizeof(float));
desviacion[i] = calloc(l,sizeof(float));
i++;
}

//rellenar array de sumas
j = 0;
while(j < l) {
k =0;
while(k < l) {
//printf("Procesando sums[%i][%i]\n",j,(k % (j+1)));
sums[j][k % (j+1)] += buffer[k];
counts[j][k % (j+1)] +=1;
k++;
}
j++;
}
//mostramos las sumas y los contadores
i=1;
j=0;
while(j < l) {
k =0;
while(k < i) {
//printf("sums[%i][%i] = %i\n",j,k,sums[j][k]);
//printf("counts[%i][%i] = %i\n",k,i,counts[j][k]);
k++;
}
i++;
j++;
}
//calcular promedios
i=1;
j=0;

while(j < l) {
k =0;
while(k < i) {
promedios[j][k] = ((float)sums[j][k])/((float)counts[j][k]);
//printf("promedios[%i][%i] = %f\n",j,k,promedios[j][k]);
k++;
}
i++;
j++;
}
//calcular Diferencias
j = 0;
while(j < l) {
k =0;
while(k < l) {
temp = promedios[j][k % (j+1)] - buffer[k];
if(temp < 0.0) {
temp = -1.0 *temp;
}
diff[j][k % (j+1)] += temp;
k++;
}
j++;
}
//calcular desviacion
i=1;
j=0;
while(j < l) {
k =0;
while(k < i) {
desviacion[j][k] = diff[j][k]/counts[j][k];
//printf("desviacion[%i][%i] = %f\n",j,k,desviacion[j][k]);
k++;
}
i++;
j++;
}

//calcular suma desviaciones
i=1;
j=0;
while(j < l) {
k =0;
while(k < i) {
sumdesviaciones[j]+= desviacion[j][k];
k++;
}
promedioDesviaciones[j] =  sumdesviaciones[j]/i;
printf("promedio desviacion[%i] = %f\n",j,promedioDesviaciones[j]);
i++;
j++;
}
//calcular differencia de desviaciones
i=1;
j=0;
while(j < l) {
k =0;
while(k < i) {
diffdesviaciones[j]+= promedioDesviaciones[j] - desviacion[j][k];
k++;
}
desviacion2[j] = diffdesviaciones[j]/(float)k;
printf("desviacion2[%i] = %f\n",j,desviacion2[j]);
i++;
j++;
}

printf("l : %i\n",l);
}
return 0;
}

unsigned char max(unsigned char item,unsigned char mx) {
return (item >= mx)? item:mx;
}

unsigned char min(unsigned char item,unsigned char mn) {
return (item <= mn)? item:mn;
}

off_t fsize(const char *filename) {
struct stat st;
if (stat(filename, &st) == 0)
return st.st_size;
fprintf(stderr, "Cannot determine size of %s: %s\n",filename, strerror(errno));
return -1;
}



[kub0x]

Muy buenas JoseluCross,

he probado tus dos vertientes del algoritmo de cifrado, la primera dónde simplemente reiniciabas el contador de la clave para cifrar de N en N bloques (donde N es el tamaño de clave) y la segunda la cual incrementas el valor de cada carácter de la clave por cada bloque de tamaño N.

Supongo que en la segunda vertiente intentabas arreglar el tema de los espacios.

Problemas en primera versión: Los espacios al ser sumados en la clave pueden exceder el tamaño 126, por lo que reducirías en 94 su peso. Cuando eso no sucede, simplemente basta con restar a todo el ciphertext el número 32 para obtener los caracteres de la clave.

Problemas en segunda versión: Aquí cuando el bloque a cifrar se acaba, a parte de reiniciar el contador "passPosition", incrementas en uno el peso de cada carácter de la clave. Por lo que si el cracker conoce el tamaño de clave, puede dividir el texto en bloques relacionados con la clave, y contar los incrementos, todo ello en zero index. Un ejemplo sería:

HOLA (pass) este es un mensaje super secreto y nadie nunca lo va a descifrar (plaintext). 64 length el plaintext, 4 length la pass -> 16 bloques, en zero index 15, por lo tanto 15 incrementos por caracter en la clave.

Notése que en ambos casos, aún restando 94, sería fácil obtener el password.

Te dejo dos capturas, la primera corresponde a la V 1.0 y la segunda a la V 2.0 (el code del github):





Fíjate como en la segunda hasta se aprecia "HOLA" de seguida. Fíjate que los caracteres alfábeticos en su mayoría son H, O, L y A (no sería muy díficil deducir incluso a ojo la clave) alguno que otro alfabético hay, y el resto son númericos/símbolos.
Simplemente habría que restar a cada carácter del ciphertext (texto cifrado) 32 y 15 para obtener la clave en cuestión.

No he querido meterme en análisis estadístico, pero bueno no creo que me tomara mucho montarme un escenario en el lenguaje R.

Saludos!

[JoseluCross]

Veo por donde vas, me a costado pillarlo pero bueno. Yo cuando hice el arreglo para cambiar la contraseña lo hice pensando en reducir la probabilidad de reconocer patrones y poder deducir el tamaño de la contraseña, claro que pierde toda fuerza una vez conocido el tamaño.
Una cosa que no entiendo ¿por qué 96? son 94 los caracteres del rango ascii que uso.

Buen dia pues hice un pequeño programa para tu algoritmo.

La idea que tenia no a funcionado.

El enfoque era estadístico, lo que hice fue generar N arreglos de Enteros donde N es igual al numero de caracteres del mensaje.

El primer arreglo[0] es de longitud 1
El segundo arrega[1] es de longitud 2
y asi sucesivamente.

Guarde las sumas de los valores ascii de cada caracter en los arreglos. Ademas de contar cuantas veces se sumaba en cada caracter en cada casilla.

Saque los promedios y las desviaciones estandar ademas. saque el promedio de cada arreglo y las desviaciones estandar de las desviaciones estandar valga la redundancia...

Mi idea era ver como cambiaban las desviaciones estandar y me imaginaba que en los puntos de inflexion estaría la pista.

Curiosamente en algunos ejemplos el primer punto de inflexion coincidencia con la longitud de la contraseña, pero en otros no lo hacia.

Muy interesante, lo probaré, muchas gracias.

[kub0x]

Corregido, eran 94, tienes razón. Era tarde y me equivoqué jajaja pero bueno el tema queda ahí. Haz pruebas sobre los casos que he presentado e intenta añadir alguna protección extra para que podamos ayudarte a securizarlo un poco más.

Te recomiendo leer sobre cifrados por bloque y álgebra modular, pues son principios en los que se basan algunos de los cifrados estándar modernos.

Saludos!