elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.


 


Tema destacado: Introducción a la Factorización De Semiprimos (RSA)


+  Foro de elhacker.net
|-+  Seguridad Informática
| |-+  Seguridad
| | |-+  Criptografía (Moderador: kub0x)
| | | |-+  Sistema de cifrado por lote de texto plano
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: 1 2 [3] Ir Abajo Respuesta Imprimir
Autor Tema: Sistema de cifrado por lote de texto plano  (Leído 6,667 veces)
AlbertoBSD
Programador y
Colaborador
***
Desconectado Desconectado

Mensajes: 3.472


🏴 Libertad!!!!!


Ver Perfil WWW
Re: Sistema de cifrado por lote de texto plano
« Respuesta #20 en: 1 Abril 2016, 06:50 »

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
  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<string.h>
  4. #include<errno.h>
  5. #include<sys/stat.h>
  6.  
  7. off_t fsize(const char *filename);
  8. unsigned char max(unsigned char item,unsigned char mx);
  9. unsigned char min(unsigned char item,unsigned char mn);
  10.  
  11. int main() {
  12. int **sums;
  13. int **counts;
  14. float **diff;
  15. float **promedios;
  16. float **desviacion;
  17. float *sumdesviaciones;
  18. float *promedioDesviaciones;
  19. float *diffdesviaciones;
  20. float *desviacion2;
  21. FILE *file;
  22. char *buffer;
  23. float temp;
  24. int l,i,j,k;
  25. file = fopen("salida.txt","r");
  26. if(file) {
  27. l = fsize("salida.txt");
  28. buffer = calloc(l+1,sizeof(char));
  29. fread(buffer,sizeof(char),l,file);
  30. fclose(file);
  31. sums = calloc(l,sizeof(int*));
  32. counts = calloc(l,sizeof(int*));
  33. diff = calloc(l,sizeof(float*));
  34. promedios = calloc(l,sizeof(float*));
  35. desviacion = calloc(l,sizeof(float*));
  36. sumdesviaciones = calloc(l,sizeof(float));
  37. promedioDesviaciones = calloc(l,sizeof(float));
  38. diffdesviaciones = calloc(l,sizeof(float));
  39. desviacion2 = calloc(l,sizeof(float));
  40. i = 0;
  41.  
  42. while(i < l) {
  43. sums[i] = calloc(i+1,sizeof(int));
  44. counts[i] = calloc(i+1,sizeof(int));
  45. diff[i] = calloc(i+1,sizeof(float));
  46. promedios[i] = calloc(i+1,sizeof(float));
  47. desviacion[i] = calloc(l,sizeof(float));
  48. i++;
  49. }
  50.  
  51. //rellenar array de sumas
  52. j = 0;
  53. while(j < l) {
  54. k =0;
  55. while(k < l) {
  56. //printf("Procesando sums[%i][%i]\n",j,(k % (j+1)));
  57. sums[j][k % (j+1)] += buffer[k];
  58. counts[j][k % (j+1)] +=1;
  59. k++;
  60. }
  61. j++;
  62. }
  63. //mostramos las sumas y los contadores
  64. i=1;
  65. j=0;
  66. while(j < l) {
  67. k =0;
  68. while(k < i) {
  69. //printf("sums[%i][%i] = %i\n",j,k,sums[j][k]);
  70. //printf("counts[%i][%i] = %i\n",k,i,counts[j][k]);
  71. k++;
  72. }
  73. i++;
  74. j++;
  75. }
  76. //calcular promedios
  77. i=1;
  78. j=0;
  79.  
  80. while(j < l) {
  81. k =0;
  82. while(k < i) {
  83. promedios[j][k] = ((float)sums[j][k])/((float)counts[j][k]);
  84. //printf("promedios[%i][%i] = %f\n",j,k,promedios[j][k]);
  85. k++;
  86. }
  87. i++;
  88. j++;
  89. }
  90. //calcular Diferencias
  91. j = 0;
  92. while(j < l) {
  93. k =0;
  94. while(k < l) {
  95. temp = promedios[j][k % (j+1)] - buffer[k];
  96. if(temp < 0.0) {
  97. temp = -1.0 *temp;
  98. }
  99. diff[j][k % (j+1)] += temp;
  100. k++;
  101. }
  102. j++;
  103. }
  104. //calcular desviacion
  105. i=1;
  106. j=0;
  107. while(j < l) {
  108. k =0;
  109. while(k < i) {
  110. desviacion[j][k] = diff[j][k]/counts[j][k];
  111. //printf("desviacion[%i][%i] = %f\n",j,k,desviacion[j][k]);
  112. k++;
  113. }
  114. i++;
  115. j++;
  116. }
  117.  
  118. //calcular suma desviaciones
  119. i=1;
  120. j=0;
  121. while(j < l) {
  122. k =0;
  123. while(k < i) {
  124. sumdesviaciones[j]+= desviacion[j][k];
  125. k++;
  126. }
  127. promedioDesviaciones[j] =  sumdesviaciones[j]/i;
  128. printf("promedio desviacion[%i] = %f\n",j,promedioDesviaciones[j]);
  129. i++;
  130. j++;
  131. }
  132. //calcular differencia de desviaciones
  133. i=1;
  134. j=0;
  135. while(j < l) {
  136. k =0;
  137. while(k < i) {
  138. diffdesviaciones[j]+= promedioDesviaciones[j] - desviacion[j][k];
  139. k++;
  140. }
  141. desviacion2[j] = diffdesviaciones[j]/(float)k;
  142. printf("desviacion2[%i] = %f\n",j,desviacion2[j]);
  143. i++;
  144. j++;
  145. }
  146.  
  147. printf("l : %i\n",l);
  148. }
  149. return 0;
  150. }
  151.  
  152. unsigned char max(unsigned char item,unsigned char mx) {
  153. return (item >= mx)? item:mx;
  154. }
  155.  
  156. unsigned char min(unsigned char item,unsigned char mn) {
  157. return (item <= mn)? item:mn;
  158. }
  159.  
  160. off_t fsize(const char *filename) {
  161. struct stat st;
  162. if (stat(filename, &st) == 0)
  163. return st.st_size;
  164. fprintf(stderr, "Cannot determine size of %s: %s\n",filename, strerror(errno));
  165. return -1;
  166. }
  167.  
  168.  


En línea

kub0x
Enlightenment Seeker
Moderador
***
Desconectado Desconectado

Mensajes: 1.367


S3C M4NI4C


Ver Perfil
Re: Sistema de cifrado por lote de texto plano
« Respuesta #21 en: 1 Abril 2016, 09:32 »

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!


« Última modificación: 1 Abril 2016, 20:20 por kub0x » En línea

Viejos siempre viejos,
Ellos tienen el poder,
Y la juventud,
¡En el ataúd! Criaturas Al poder.

JoseluCross

Desconectado Desconectado

Mensajes: 33


Conoceréis la Verdad, y la Verdad os hará libres


Ver Perfil WWW
Re: Sistema de cifrado por lote de texto plano
« Respuesta #22 en: 1 Abril 2016, 15:54 »

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.
En línea

No hay problema sin solución, solo personas que no quieren resolverlo.
kub0x
Enlightenment Seeker
Moderador
***
Desconectado Desconectado

Mensajes: 1.367


S3C M4NI4C


Ver Perfil
Re: Sistema de cifrado por lote de texto plano
« Respuesta #23 en: 1 Abril 2016, 20:23 »

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!
En línea

Viejos siempre viejos,
Ellos tienen el poder,
Y la juventud,
¡En el ataúd! Criaturas Al poder.

Páginas: 1 2 [3] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Convertir HTML a Texto Plano
Java
Blitzkrieg' 2 7,288 Último mensaje 1 Abril 2010, 17:25
por Blitzkrieg'
Ayuda con cifrado conociendo Texto plano
Criptografía
adan-2994 5 4,109 Último mensaje 16 Octubre 2011, 18:11
por тαптяα
Codificacion de texto plano
Programación C/C++
ixak1 3 1,428 Último mensaje 21 Junio 2012, 20:19
por ixak1
Sophos lanza sistema sincronizado de cifrado de archivos “Always-On”
Noticias
wolfbcn 0 543 Último mensaje 20 Julio 2016, 22:27
por wolfbcn
No se cifrado de un texto
Criptografía
valbuja12 2 400 Último mensaje 10 Septiembre 2019, 11:14
por valbuja12
Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines