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


 


Tema destacado:


  Mostrar Temas
Páginas: [1] 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 ... 21
1  Seguridad Informática / Criptografía / vector contra rijndael (AES) con algunos datos conocidos? en: 21 Septiembre 2017, 05:01
Conozco el tipo de datos que se están cifrando, y el método de cifrado, tengo acceso a la salida cifrada.

El dato que se esta cifrando es un numero secuencial de 128 bits.

Esto es primero es 1, luego es 2 y asi... aunque no conoco el estado actual de este numero podria ser 1000, 100000  o 8439948 o cualquier otro numero.

La llave es aleatoria y aun que no conozco cual es esta llave, se o creo que esta misma llave es usada para cifrar el siguiente numero. Comento que creo por que no estoy seguro si internamente el algoritmo la cambie.

El Cifrado es rijndael (AES) a 128 bits en modo ECB.

Tengo acceso a una muestra de 65536 Bloques de 128 bits cifrados y los mismos corresponden a los numeros en secuencia de uno en uno.

Alguna idea de conseguir la llave?

Saludos!



2  Seguridad Informática / Criptografía / Crackear GELI [Infeasible] en: 14 Septiembre 2017, 19:07
Antes de empezar tengo que comentar que este método es infeasible.

El método podría tardar toda la vida, incluso podría terminarse el universo y no tener la llave para descifrar la Llave maestra para descifrar el disco duro.

Hace unos días publique un post sobre Extraer la información[2]
 de cifrado (Metadata Usada por Geli[1]). El post sirve solo para extraer información de metadata para su posterior análisis, de hecho el comando

Código:
#geli dump ada0p2

Realiza la misma salida, sin embargo con el programa podemos tener en memoria una copia de la clave cifrada para tratar de crackearla.

Ahora Comento que el programa es infeasible por lo mismo que tardaríamos una eternidad en crackear la clave, posiblemente cuando la clave sea encontrada por mera suerte el disco duro a descifrar ya no exista.

Sin embargo como no he visto ninguna herramienta publica he decidido programar mi propio crack para Discos Duros cifrados con geli.

Métodos de crackeo:

  • Fuerza Bruta a la passphrase mediante diccionario
  • Fuerza Bruta a la clave cifrada


Fuerza Bruta a la passphrase mediante diccionario

La primera opción es incluso mas tardada, pero puede ser que tengamos mas suerte si es que la passphrase escogida por el Sysadmin esta en nuestro diccionario, sin embargo si la palabra no esta en el diccionario es imposible.

En este caso la única limitante es:

Código:
Iterations: 218830

En ese caso tarda como 2 segundos en mi equipo realizar el key derivation con esa cantidad de iteraciones. Sin embargo la ultima instalación de FreeBSD que hice, incremente ese numero de iteraciones a 10485760 y tarda aproximadamente u 41 veces mas en realizar el key derivation.

Entonces en un ataque por diccionario tendriamos que pasar nuestra passphrare y derivarla X cantidad de veces, lo cual seria rapido para un X pequeño pero muy tardado para un X muy grande como el mencionado.

Recomendación  para los sysadmin que utilizen este método de cifrado o un cifrado similar, no elegir una clave que se encuentre en algun diccionario, y si pueden configurar el numero de iteracciones, configuren uno muy alto para que sea desalentador tratar de crackear por este medio.

Fuerza Bruta a la clave cifrada

Este metodo tiene como ventaja que se salta la parte de las iteraciones y como desventaja es que prueba todas las combinaciones posibles.

Sin embargo la probabilidad de que encuentre la clave en los primeros años de ejecución son NULAS, sin embargo a largooooo plazo va a terminar encontrado la llave para descifrar la clave maestra para descifrar el disco duro.

El metodo utiliza un archivo para salvar el progreso actual y poder reanudarlo en cualquier otro momento.

En cada iteracion del programa se realizan 2 pruebas para descifrar la clave.


  • Una clave de 64 Bytes que incrementa de uno en uno en cada ciclo
  • Una clave de 64 bytes de un buffer aleatorio

Una clave de 64 Bytes que incrementa de uno en uno.

Esta es la parte que nos da la certeza de que en algun momento podremos encontrar nuestra clave para descifrar ya que probamos todas las combinaciones posibles.

Una clave de 64 bytes de un buffer aleatorio

Posiblemente una perdidad de tiempo, pero si tenemos la suerte de que el buffer aleatorio coincida con la clave para descifrar la clave maestra. entonces podriamos tener la clave antes de tiempo.

Esta ultima parte se puede omitir y incrementariamos nuestro tiempo de finalizacion a un poco menos de la mitad del actual.

Infeasibilidad del metodo

La llave para descifrar la llave maestra es de 64 bytes de longitud, NO 64 Bits, 64 BYTES de longitud (64*8 bits)

Imaginemos el siguiente numero:
Código:
13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084095

Un numero decimal de 155 digitos

Entonces por cada prueba que realize nuestro programa tenemos la posibilidad de 1 en Ese numero de que sea nuestra clave de decifrado.

Para los curiosos esta seria la forma de leer el numero de posibilidades
Código:
13407   quintovigecillones
,807929 cuatorvigecillones
,942597 trivigecillones
,099574 duovigecillones
,024998 unvigecillones
,205846 vigecillones
,127479 nonidecillones
,365820 octidecillones
,592393 septodecillones
,377723 sextodecillones
,561443 quintodecillones
,721764 cuatordecillones
,030073 tridecillones
,546976 Duodecillones
,801874 Undecillones
,298166 Decillones
,903427 Nonillones
,690031 Octillones
,858186 Septillones
,486050 Sextillones
,853753 Quintillones
,882811 Cuatrillones
,946569 Trillones
,946433 Billones
,649006 Millones
,084095

Aunque tengo dudas de la pronunciacion apartir de los decillones.

El codigo para crackear por fuerza bruta esta en:

https://github.com/albertobsd/geli_metadata/blob/master/crackgeli.c


Si alguien quiere probrar tengo en mi firma un Reto para crackear

Crackeame si puedes Wallet.dat

Saludos!



[1] Extraer informacion de Cifrado
https://foro.elhacker.net/criptografia/extraer_informacion_de_cifrado_en_discoduro_de_freebsd-t474262.0.html

[2] Man page of Eli: https://www.freebsd.org/cgi/man.cgi?query=geli&apropos=0&sektion=8&manpath=FreeBSD+11.1-RELEASE&arch=default&format=html
3  Sistemas Operativos / Unix/Unix-Like / Recomendacion para Disco Duro Cifrado en FreeBSD en: 9 Septiembre 2017, 00:44
Si estamos usando FreeBSD y queremos cifrar todo nuestro disco duro no duden en preguntar sus dudas.

El comando geli para inicializar la criptografia en nuestro disco duro es el siguiente:

Código:
geli init -a hmac/sha256 -b -e AES-XTS -l 256 -s 4096 -i 524288 -B /tmp/USBTEMP/backup_metadata.eli -K /tmp/USBTEMP/da1p1.key da1p1

Obviamente hablamos de una instalacion nueva. No se puede en una instalacion preexistente, a no ser que vallamos a mover toda nuestra informaacion  de un disco duro sin cifrar a algun disco duro cifrado.

Previamente necesitamos crear un archivo "llave" de manera aleatoria con DD

Código:
dd if=/dev/random of=/tmp/USBTEMP/da1p1.key bs=4096 iseek=128 count=32

Esto nos genera un archivo de 128 Kilobytes (bs=4096 * count=32) de informacion aleatoria, pasandole este archivo a geli, necesitaremos este archivo cada vez que iniciemos nuestro ordenador, y mas nos vale tener al menos otras 3 copias de seguridad de dicho archivo.

Sumado al archivo en la memoria USB para poder cargar nuestro sistema tendremos:

  • Disco Duro cirado con  AES-XTS y una clave de 256 bits
  • Autenticacion de sectores del disco usando hmac/sha256
  • La Autenticacion con hmac/sha256 Envita que nos ataquen usando Replay
  • Peticion de passphrase Antes de montar el Disco Duro principal
  • El passphare es juntado con el salt y nuestro archivo de 128 Kilobytes y derivado 524288 veces para poder descifrar la clave maestra previamente cifrada y guardada en la metadata

La unica desventaja que le veo a esta implementacion es:

  • Disminucion del Performance al momento de Leer/Escribir informacion en el disco ya que todo es cifrado.
  • Lo anterior pordria ser mitigado Teniendo algun Hardware acelarador para operaciones criptograficas y un Disco Duro de Estado solido.
  • Disminucion de Capacidad de almacenamiento, Dado que estamos usando un sistema de Autenticacion, este necesita guardar los checksum de cada sector de disco para determinar que no han sido modificados por terceros
  • Ejemplo de lo Anterior un Disco Duro de 22 Gigabytes termina con capacidad de 19 GB. Pierde al rededor de 14% de Almacenamiento dedicado para la Autenticacion de la información

Saludos!


Source: https://albertobsd.blogspot.mx/2017/09/recomendacion-para-disco-duro-cifrado.html
4  Seguridad Informática / Criptografía / Extraer informacion de Cifrado en DiscoDuro de FreeBSD en: 8 Septiembre 2017, 06:45
Extraer informacion de Cifrado en DiscoDuro de FreeBSD

FreeBSD ofrece la opcion de cifrar completamente el disco duro. La principal herramienta es Geli[2].

Para ver la información sobre el cifrado del disco, OJO no la información cifrada, sino la información relacionada con el tipo y modo de cifrado usado para el disco duro en cuestion, es necesario primero obtener acceso fisco al disco, una en otra instalación con FreeBSD podemos extraer el sector que tiene la meta-data a analizar, este sector del disco duro (512 Bytes) se encuentra en el ultimo sector de la particion cifrada.

Si no sabemos cual particion es la particion cifrada podemos extraer el ultimo sector de todas la particiones de el disco duro.

Ejemplo:

Discoduro a analizar /dev/da1

Si listamos /dev/da1* podremos ver que tiene 2 particiones para este caso en particular

Código:
# ls /dev/da1*
/dev/da1p1
/dev/da1p2
Para extraer la informacion tenemos que usar el comando dd.

Tambien necesitamos saber cuanto espacio tiene el disco duro

# geom disk list
o
# gpart list

Ejemplo de salida:

Código:
Providers:
1. Name: da1p1
   Mediasize: 20401094656 (19G)
   Sectorsize: 512
   Stripesize: 0
   Stripeoffset: 32768
   Mode: r1w1e1
   rawtype: 7
   length: 20401094656
   offset: 0
   type: freebsd-ufs
   index: 1
   end: 39845887
   start: 0
2. Name: da1p2
   Mediasize: 1073708032 (1.0G)
   Sectorsize: 512
   Stripesize: 0
   Stripeoffset: 3221258240
   Mode: r1w1e0
   rawtype: 1
   length: 1073708032
   offset: 20401094656
   type: freebsd-swap
   index: 2
   end: 41942973
   start: 39845888

Para este ejemplo la particion tiene 20401094656 con lo cual si dividimos entre 512 nos da un total 39845888 Sectores con lo cual el ultimo sector valido es 39845887 que el que tenemos que leer, entonces el comando para extraer dicho sector es:

# dd if=/dev/da1p1 of=./sector.backup bs=512 iseek=39845887 count=1

Si nuestros calculos fueron acertados tendremos un archivo llamado sector.backup de 512 bytes.

El contenido de ese archivo puede variar mucho dependiendo del estado previo del disco duro.

Si el disco duro esta cifrado con mediante geli el archivo empezara con la siguiente leyenda:

GEOM::ELI, lo restante es informacion en binario con el siguiente orden

Código:
struct g_eli_metadata {
 char  md_magic[16]; /* Magic value. */
 uint32_t md_version;  /* Version number. */
 uint32_t md_flags;  /* Additional flags. */
 uint16_t md_ealgo;  /* Encryption algorithm. */
 uint16_t md_keylen;  /* Key length. */
 uint16_t md_aalgo;  /* Authentication algorithm. */
 uint64_t md_provsize; /* Provider's size. */
 uint32_t md_sectorsize; /* Sector size. */
 uint8_t  md_keys; /* Available keys. */
 int32_t  md_iterations; /* Number of iterations for PKCS#5v2. */
 uint8_t  md_salt[G_ELI_SALTLEN]; /* Salt. */
   /* Encrypted master key (IV-key, Data-key, HMAC). */
 uint8_t  md_mkeys[G_ELI_MAXMKEYS * G_ELI_MKEYLEN];
 u_char  md_hash[16]; /* MD5 hash. */

} __packed;
Me tome la molestia de Generar una herramienta en C que lee la informacion y le pasa las funciones existentes en el codigo fuente de geli para organizar el buffer acorde al formato de la estructura.

El programa puede ser visto en mi cuenta de github[3] si lo compilamos y ejecutamos pasandole como parametro el archivo de 512 bytes tendremos una salida similar a la siguiente [Algunos datos fuero cambiados]:

Código:
albertobsd@XHGC-VMBox:~ % ./eli_metadata sector.backup
Magic: GEOM::ELI
Version: 7
Flags: 2
E ALGO: 22
Key Length: 128
A Algo: 0
P Size: 23622320128
Sector Size: 4096
Avaible Keys: 1
Iterations: 218830
Salt: E8CF4BB53DA62DC60B8CAD36119D62B806D95524828286533728C4045E319DBBA1486522EA0454887E1094AD3FAFA0295E9350F1259AAC4B791D42A02F3A6BF2
Master Key: 3F4E170DAFF6539E9301EEF2840ED233BA3B84D02EB96
3AEBB0CA1EED891034A85A3BB325F7B09398706944DFE84CE4748D2C4F0E1FEA4FD601CC18A922ADE51C9D7DC740292A979153B744FC49F47956E24E23D64BFF854F04E3AD41C39215D834DF5E317FF9C1661D9B3300E40D85CE4C270BF57DD1AA82489A97F6741A119AF25D1987ED584E1585FD7ADAE7406D9119AC7AEE654DA2B9C28D2D39599593E1B751BAE614C921E814660E240D18B7650477E935941299F7D34C91350BD289902B7F7DF23D7523C1B6FC0AB33CAB3AF07E5EA0E97835EF13F31B1F56004A552F074951D8B490FEA605D449E2AEA774574BDFEE9153392E4084DF934FCA40638B676A868E3BAB8CA0E0A1912B348C645F74BCA3AB7D697053DD25107981086284F687D1D5EF1DA16280EE7CD0920A92CDAFAF7970D084C4C344FAB3117D0993A591AA43B1D09BE6D5AFB12C82C375BD980AC60F7E0A65C146F8E54E1D84FA0D73933EC26341E5B1D11BA14AF8FA3990F834C4FA39BEF17EECCE206670E5E854B

MD5: BD5DA8BAE0C0C6AAC7503769A3CE9110

Datos interesantes de la salida:

E ALGO: 22

Podemos ver en
/usr/src/sys/opencrypto/cryptodev.h

#define CRYPTO_AES_XTS  22

Que esta cifrado usando AES_XTS que segun [4] es el estandar recomenado para el cifrado de disco.


Key Length: 128

El cifrado usa una Llave de 128 bits, se podria configurar a 256 para un mejor cifrado.

A Algo: 0

El sistema no tiene Autenticacion, esto quiere decir que no se tiene forma de saber si la informacion que leemos del disco a sido modificada o sobreescirta por terceros, esto tambien da lugar a un ataque tipo replay para poder calcular la clave maestra

Avaible Keys: 1

El sistema solo tiene una llave maestra lo cual si se nos olvida nuestra "passphrase" o se nos pierden nuestras llaves tendremos muy pocas (NULAS) posibilidades de recuperar nuestra informacion

Iterations: 218830

Nuestra "passphrase" junto con el Salt y nuestros Keyfiles si existen es derivada 218830 veces mediante pkcs5v2_genkey en g_eli.c y el resultado de esta operacion se usa para descifrar la llave encripada en.

Master Key: 3F4E170DAFF6539E9301EEF2840ED233BA3B84D02EB96
3AEBB0CA1EED891034A85A3BB325F7B09398706944DFE84CE4748D2C4F0E1FEA4FD601CC18A922ADE51C9D7DC740292A979153B744FC49F47956E24E23D64BFF854F04E3AD41C39215D834DF5E317FF9C1661D9B3300E40D85CE4C270BF57DD1AA82489A97F6741A119AF25D1987ED584E1585FD7ADAE7406D9119AC7AEE654DA2B9C28D2D39599593E1B751BAE614C921E814660E240D18B7650477E935941299F7D34C91350BD289902B7F7DF23D7523C1B6FC0AB33CAB3AF07E5EA0E97835EF13F31B1F56004A552F074951D8B490FEA605D449E2AEA774574BDFEE9153392E4084DF934FCA40638B676A868E3BAB8CA0E0A1912B348C645F74BCA3AB7D697053DD25107981086284F687D1D5EF1DA16280EE7CD0920A92CDAFAF7970D084C4C344FAB3117D0993A591AA43B1D09BE6D5AFB12C82C375BD980AC60F7E0A65C146F8E54E1D84FA0D73933EC26341E5B1D11BA14AF8FA3990F834C4FA39BEF17EECCE206670E5E854B

El archivo termina con un MD5 Checksum de los valores en binario previamente mostrados, solo para validar que la información sea correcta.

Si es posible usar la información contenida en el archivo para Atacar por fuerza bruta y obtener la Clave Maestra decifrada pero en computacionalmente casi imposible de realizar.

[1] Original Post: https://albertobsd.blogspot.mx/2017/09/extraer-informacion-de-cifrado-en.html
[2] Man page of Eli: https://www.freebsd.org/cgi/man.cgi?query=geli&apropos=0&sektion=8&manpath=FreeBSD+11.1-RELEASE&arch=default&format=html
[3] Herramienta Utilizada: https://github.com/albertobsd/geli_metadata
[4] https://en.wikipedia.org/wiki/Disk_encryption_theory
5  Programación / Programación C/C++ / Dejen de usar rand() en C/C++ o los van a Hackear en: 27 Agosto 2017, 15:37
Dejen de usar rand() en C/C++ o los van a HACKEAR  :silbar:

Obviamente nadie usa la funcion rand() en programas del mundo real, ¿o si?

No se si colocar esto aqui o en criptografia o hacking. El tema trata de atacar una implementacion DEBIL de numeros random.

El ataque no es complejo, para el ejemplo mostrado pero muestra el peligro de las aplicaciones que usan numeros aleatorios debiles o predecibles.

Hace mas de una año en el foro publique un pequeño codigo del Juego Piedra Papel y Tijera: [Aporte] Piedra Pape y Tijera - Mini-Autómata + Ejercicio [1]

En ese ejemplo como originalmente lo hice para un video tutorial use por comodidad la funcion rand() que viene por defecto en las librerias estandar de muchas implementaciones y para no meter a los que se estan iniciando en temas de seguridad complejos, decidi usar esa funcion sabiendo que no es tan segura. Sin embargo no me habia dado cuenta de la gravedad de los numeros arrojados por rand aun inicializando con la semilla del tiempo. En cualquier caso lo numeros que arroja se pueden calcular usando la misma funcion rand()  :xD

En un entorno donde no se tiene acceso al codigo fuente de un programa, es posible (dependiendo de lo que el programa realize) tratar de adivinar que procesos internos realiza el programa en especial cuando involucra numeros aleatorios.

Veamos el ejemplo del piedra papel y tijera:

Código
  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<stdbool.h>
  4. #include<time.h>
  5.  
  6. char *cadenas[] = {"Piedra","Papel","Tijera"};
  7.  
  8. //0 empate
  9. //1 Pierde Usuario
  10. //2 Gana Usuario
  11. //Filas Computadora
  12. //Columas Usuario
  13.  
  14. char tabla_resultados[3][3] =
  15. {
  16. {0,2,1},
  17. {1,0,2},
  18. {2,1,0}
  19. };
  20.  
  21. char *resultado[] = {"Empate","Gana la COMPUTADORA","Gana el USUARIO"};
  22.  
  23. int main() {
  24. char buffer[10];
  25. char *error = NULL;
  26. bool entrar = true;
  27. bool jugado = false;
  28. int usuario = 0;
  29. int computadora = 0;
  30. srand(time(NULL));
  31. do {
  32. computadora = rand() % 3;
  33. do { //Entramos en este ciclo hasta que el usuario juege o decida salir para no afectar el valor rand del ejemplo
  34. printf("1) Piedra\n");
  35. printf("2) Papel\n");
  36. printf("3) Tijera\n\n");
  37. printf("S) Salir\n\n");
  38. printf("Seleccione una opcion:");
  39. fgets(buffer,5,stdin);
  40. usuario = (int) strtol(buffer,&error,10);
  41. if(error[0] == 's' || error[0] == 'S') {
  42. entrar = false;
  43. jugado = true;
  44. }
  45. else{
  46. if(usuario <=3 && usuario >= 1){
  47. usuario--; //Le restamos uno al input para poder usarlo en una tabla de estados con index 0
  48. jugado = true;
  49. printf("Usuario %s vs Computadora %s\n",cadenas[usuario],cadenas[computadora]);
  50. printf("Resultado: %s\n",resultado[tabla_resultados[computadora][usuario]]);
  51. }
  52. else {
  53. printf("Seleccione una opcion correcta\n");
  54. jugado = false;
  55. }
  56. }
  57. }while(!jugado);
  58. }while(entrar);
  59. }
  60.  


Veamos las partes importantes:

Código
  1. srand(time(NULL));

Se inicializa el random con la semilla del tiempo como lo haria cual quier persona que esta aprendiendo a programar con numeros aleatorios.
El codigo mostrado lo escribi para compilarlo con GCC pero deberia de funcionar en otros compiladores de C sin muchos cambios.

Código
  1. computadora = rand() % 3;

La computadora usa funcion rand() y le aplica modulo al resultado para obtener valores validos del 0 al 2.

Pues bien para ejemplo es todo lo que necesitamos saber. Bajo la premisa de que el/los programas usan la semilla del tiempo actual en Segundos desde el primero de enero de 1970 [2]

Entonces en otro programa de C podemos buscar todas las semillas de tiempo en un rango determinado y obtener primeras salida de cada una de ellas.

Ejemplo tomemos la fecha de hoy en el formato devuelto por la funcion time(), desde [3] lo podemos obtener para hoy es:

1503838078

Código
  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<stdbool.h>
  4. #include<time.h>
  5.  
  6. int main() {
  7. int i = 0;
  8. int resultado = 0;
  9. srand(1503838078);
  10. while(i < 10) {
  11. resultado = rand() % 3;
  12. printf("Resultado: %i\n",resultado);
  13. i++;
  14. }
  15. }


Salida

Código:
% ./testrand
Resultado: 2
Resultado: 0
Resultado: 0
Resultado: 1
Resultado: 1
Resultado: 1
Resultado: 2
Resultado: 0
Resultado: 0
Resultado: 1

% ./testrand
Resultado: 2
Resultado: 0
Resultado: 0
Resultado: 1
Resultado: 1
Resultado: 1
Resultado: 2
Resultado: 0
Resultado: 0
Resultado: 1

Como vemos la salida del programa es la misma en ambas ocasiones aunque se ejecuta con segundos de diferencia, posiblemente esto le paso a alguien que uso rand sin inicializar el srand, pero no le dio importancia.

¿Ahora que?

El hecho es que podemos reinicializar srand en cualqueir momento del codigo y la salida de rand va a ser la correspondiente a cada semilla ejemplo:

Código
  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<stdbool.h>
  4. #include<time.h>
  5.  
  6. int main() {
  7. int i = 0;
  8. int resultado = 0;
  9. srand(1503838078);
  10. while(i < 5) {
  11. resultado = rand() % 3;
  12. printf("Resultado: %i\n",resultado);
  13. i++;
  14. }
  15. srand(1503838079);
  16. i = 0;
  17. while(i < 5) {
  18. resultado = rand() % 3;
  19. printf("Resultado: %i\n",resultado);
  20. i++;
  21. }
  22. srand(1503838078);
  23. i = 0;
  24. while(i < 5) {
  25. resultado = rand() % 3;
  26. printf("Resultado: %i\n",resultado);
  27. i++;
  28. }
  29. }


Noten el cambio de srand de 1503838078 -> 1503838079 -> 1503838078 por lo cual la primeras 5 salidas van a ser iguales a las 15 ultimas


Salida

Código:
% ./hackrand
Resultado: 2
Resultado: 0
Resultado: 0
Resultado: 1
Resultado: 1
Resultado: 0
Resultado: 2
Resultado: 0
Resultado: 2
Resultado: 1
Resultado: 2
Resultado: 0
Resultado: 0
Resultado: 1
Resultado: 1

Ya con esta salida sabemos que podemos calcular cualquier salida de rand() en cualquier momento conociendo o calculando la semilla inicial

Pues bien es momento de ganarle al Piedra papel y tijera perdiendo  solo los primeros 2 o 3 juegos y en base a estos tratar de calcular cual fue la semilla utilizada.

Hice un programa que que te muestra las salidas de rand ya con X modulo de las semillas +/- 10 al tiempo actual y apartir de ahi elijes cual semilla continuar viendo Y asi sabremos que jugada va a hacer la computadora  antes de tiempo y poderle ganar:

Código
  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<stdbool.h>
  4. #include<time.h>
  5.  
  6.  
  7. int main(int argc, char **argv) {
  8. bool entrar,continuar,seleccione;
  9. char buffer[10];
  10. char *error = NULL;
  11. unsigned int tiempo = 0;
  12. unsigned int base = 0;
  13. int numero = 0;
  14. int resultado = 0,i = 0,j = 0;
  15. int divisor = 0;
  16. if(argc == 2) {
  17. divisor = (int )strtol(argv[1],&error,10);
  18. if(error[0] == 0) {
  19. tiempo = time(NULL);
  20. printf("Valor actual del tiempo %u\n",tiempo);
  21. printf("Calculando modulos en +/- 10\n");
  22. base = tiempo -10;
  23. j = 0;
  24. while( ( base + j) < (tiempo +10)) {
  25. srand(base + j);
  26. printf("Opcion %i:",j+1);
  27. i = 0;
  28. while(i < 10) {
  29. resultado = rand() % divisor;
  30. printf(" %i,",resultado);
  31. i++;
  32. }
  33. printf("\n");
  34. j++;
  35. }
  36. printf("Opcion S: Salir\n");
  37. do {
  38. seleccione = false;
  39. printf("Seleccione una opcion:");
  40. fgets(buffer,5,stdin);
  41. numero = (int)strtol(buffer,&error,10);
  42. if(error[0] == 's' || error[0] == 'S') {
  43. entrar = false;
  44. }
  45. else {
  46. if(numero >= 1 && numero <= 20) {
  47. continuar = true;
  48. numero--; //Restamos para compensar el +1 en el menu
  49. srand(base + numero);
  50. i = 0;
  51. while(i < 10) {
  52. resultado = rand();
  53. i++;
  54. }
  55. printf("Numeros siguientes en la secuencia seleccionada\n");
  56. do {
  57. i = 0;
  58. while(i < 5) {
  59. resultado = rand() % divisor;
  60. printf("%i, ",resultado);
  61. i++;
  62. }
  63. printf("\n");
  64. printf("+) Imprimir mas numeros\n");
  65. printf("S) Salir\n\n");
  66. printf("Seleccione: ");
  67. fgets(buffer,5,stdin);
  68. switch(buffer[0]) {
  69. case 's':
  70. case 'S':
  71. continuar = false;
  72. break;
  73. case '+':
  74. continuar = true;
  75. break;
  76. }
  77. }while(continuar);
  78. }
  79. else {
  80. seleccione = true;
  81. }
  82. }
  83. }while(seleccione);
  84. }
  85. }
  86. else {
  87. printf("Usar: %s <divisor>\n",argv[0]);
  88. }
  89. }
  90.  

Ejecitamos el programa para forcebrutear el srand con el parametro del modulo que estan aplicando:

Código:
% ./crack_rand.exe 3
Valor actual del tiempo 1503839464
Calculando modulos en +/- 10
Opcion 1: 2, 0, 0, 0, 0, 1, 2, 1, 0, 1,
Opcion 2: 2, 0, 0, 1, 1, 1, 0, 2, 1, 0,
Opcion 3: 2, 0, 1, 2, 2, 0, 2, 0, 0, 2,
Opcion 4: 0, 2, 0, 0, 0, 0, 1, 1, 1, 1,
Opcion 5: 0, 2, 0, 1, 1, 0, 0, 1, 1, 2,
Opcion 6: 0, 2, 2, 2, 2, 0, 1, 2, 1, 1,
Opcion 7: 0, 2, 2, 0, 0, 2, 2, 0, 1, 0,
Opcion 8: 1, 1, 1, 1, 0, 2, 1, 1, 1, 2,
Opcion 9: 1, 1, 2, 2, 2, 0, 2, 0, 2, 1,
Opcion 10: 1, 1, 1, 0, 2, 0, 1, 1, 2, 2,
Opcion 11: 1, 0, 1, 1, 0, 2, 2, 2, 2, 1,
Opcion 12: 2, 1, 0, 0, 1, 2, 1, 2, 2, 0,
Opcion 13: 2, 0, 0, 0, 2, 2, 2, 0, 2, 2,
Opcion 14: 2, 2, 0, 1, 0, 1, 1, 1, 2, 0,
Opcion 15: 2, 0, 0, 0, 0, 1, 0, 2, 0, 1,
Opcion 16: 0, 2, 0, 1, 2, 1, 2, 2, 2, 0,
Opcion 17: 0, 2, 2, 1, 2, 2, 0, 0, 0, 2,
Opcion 18: 0, 2, 2, 0, 0, 1, 1, 1, 2, 1,
Opcion 19: 1, 1, 1, 1, 2, 1, 0, 2, 0, 0,
Opcion 20: 1, 1, 2, 1, 2, 1, 1, 1, 2, 2,
Opcion S: Salir
Seleccione una opcion:

Ejecutamos el progrma de priedra papel o tijera y si bien muchas veces no tenemos acceso al codigo fuente, hay cosas que se pueden determinar  con un poco de imaginacion y conocimientos de programacion.

Código:
% ./ppt
1) Piedra
2) Papel
3) Tijera

S) Salir

Seleccione una opcion:1
Usuario Piedra vs Computadora Piedra
Resultado: Empate
1) Piedra
2) Papel
3) Tijera

S) Salir

Seleccione una opcion:1
Usuario Piedra vs Computadora Tijera
Resultado: Gana el USUARIO
1) Piedra
2) Papel
3) Tijera

S) Salir

Seleccione una opcion:1
Usuario Piedra vs Computadora Tijera
Resultado: Gana el USUARIO
1) Piedra
2) Papel
3) Tijera

S) Salir

Seleccione una opcion:1
Usuario Piedra vs Computadora Piedra
Resultado: Empate
1) Piedra
2) Papel
3) Tijera

S) Salir

Seleccione una opcion:2
Usuario Papel vs Computadora Piedra
Resultado: Gana el USUARIO
1) Piedra
2) Papel
3) Tijera

S) Salir

Seleccione una opcion:3
Usuario Tijera vs Computadora Papel
Resultado: Gana el USUARIO
1) Piedra
2) Papel
3) Tijera

S) Salir

Seleccione una opcion:3
Usuario Tijera vs Computadora Papel
Resultado: Gana el USUARIO
1) Piedra
2) Papel
3) Tijera

S) Salir

Seleccione una opcion:3
Usuario Tijera vs Computadora Papel
Resultado: Gana el USUARIO
1) Piedra
2) Papel
3) Tijera

S) Salir

Seleccione una opcion:1
Usuario Piedra vs Computadora Tijera
Resultado: Gana el USUARIO
1) Piedra
2) Papel
3) Tijera

S) Salir

Seleccione una opcion:3
Usuario Tijera vs Computadora Papel
Resultado: Gana el USUARIO
1) Piedra
2) Papel
3) Tijera

S) Salir

Seleccione una opcion:


Despues de los primeros intentos del programa: podemos darnos cuenta que la secuencia que se esta jugando es la 7 o la 18 del ejemplo

Código:
Opcion 7: 0, 2, 2, 0, 0, 2, 2, 0, 1, 0,
Opcion 18: 0, 2, 2, 0, 0, 1, 1, 1, 2, 1,

Y vemos que en los ultimos juegos Gane todos los piedra papel tijera que jugue.

Si bien es cierto que sin el codigo fuente o binario decompilado no es podible saber la cantidad de veces que se llama a la funcion rand antes de que realmente inicie el programa, si es posible calcular  incluso darnos cuenta de que podemos tener una base de datos o programa que calcule los modulos adecuados y tarde o temprano sabremos que semilla se utilizo para el caso de srand

Espero que dejen de usar srand y rand, buscando alguna funcion mas segura, si estan en Linux o un sistema libre, tendran siempre un /dev/random con bastantes numeros aleatorios muy dificiles de predecir.


¿Que alcance tiene esto?

Existen maquinas de juego electronico (bingo,loteria, balckjack) que utilizan funciones aleatorias y podria ser posible que alguna utilize rand() % X para algunos de sus calculos. Digo estas maquinas por que es probable que sus programadores se preocupen menos por la calidad de numeros generado, en maquinas de azar solo importa que los numeros sean uniformes (Todos con la misma probabilidad de salir) esto con el objetivo de calcular tablas de pagos adecuadas para la probabilidad de cada maquina.

Y pues temas se seguridad informatica como la generacion de passwords y otros usos de los numeros PseudoAlearorios, es recomendable buscar fuentes no predecibles de estos.

[1] https://foro.elhacker.net/programacion_cc/aporte_piedra_pape_y_tijera_miniautomata_ejercicio-t454850.0.html
[2] https://www.freebsd.org/cgi/man.cgi?query=time&sektion=3
[3] https://www.epochconverter.com/
6  Seguridad Informática / Criptografía / Intel Secure Key RNG ¿Seguro? en: 26 Agosto 2017, 16:42
Un poco de Background antes de empezar.

¿Que es un RNG?

Segun Wikipedia[1]: Random Number Generation, es el proceso de crear una secuencia de numeros o simbolos que no deben de ser predecibles.

Importancia de numeros Aleatorios

Para entender la importancia de los numeros aleatorios tenemos que preguntarnos ¿Donde utilizamos numeros Aleatorios?

Segun Schneier B. (2000)  Yarrow-160: Notes on the Design and Analysis of the Yarrow Cryptographic Pseudorandom Number Generator recuperado de [2]

Los numeros Aleatorios en Criptografia son usados por

  • Sesiones y llaves de mensajes para algoritmos de cifrado simetrico como tripe-Des Blowsh
  • Como semillas para rutinas que generan valores matematicos como numeros primos muy grandes para RSA
  • Saltos de password para frustrar ataques por fuerza bruta fuera de linea
  • Vectores de Inicializacion (IV) para bloques de algoritmos de cidrado (AES CBC, ECB etc)
  • Valores Aleatorios para Firmas Digitales de Cifrado como  DSA
  • Desafios Aleatorios en protocolos de Autenticacion como Kerberos
  • "Nonces" para protocolos y garantizar que cada ejecucion es unicia SSL

Me tome la molestia de traducir y agregar toda la lista para ejemplificar que el uso de numeros aleatorios es muy basto y mas comun de lo que piensan, cada que entran a una pagina web con SSL activado se generan numeros aleatorios.

Ahora ya con este Background sobre los RNG y el uso de numeros aleatorios en cryptogradia es posible  entrar en el Tema del Post

¿Que es el "Intel Secure Key RNG"?

Si bien por el nombre podriamos pensar que alguna especie de Llave USB o alguna pienza sofisticada de Hardware, pues estamos en un error!!
El mencionado Intel Secure Key RNG no es nada mas que una Instruccion nueva para procesadores modernos de Intel la cual nos devuelve valores aleatorios Generados directamente por el procesador [3]

Esto es Genial ya que en teoria le quita la Carga al Sistema Operativo de Generar Numeros Aleatorios utilizando algoritmos pesados
¿O no?

Pues bien dada la desconfianza que existe hacia cualquier implentacion del tipo privado, debido a debilidades y/o backdoors documentados. Los sistemas operativos modernos no toman estos "sources" de numeros aleatorios para servirlos directamente a las aplicaciones que soliciten numeros aleatorios, sino que los pasan atraves de algun algoritmo adicional y finalmente sirven sus propios numeros generados.

Esto lo hacen con el objetivo de elimiar cualquier rastro de backdoor que pueda existir.

La instruccion rdrand es usada por sistemas como Linux[4] y FreeBSD[5]  entre otros para  sus plataformas de Intel. Y como se menciono no la usan como valor directo, si no como uno de tantos origenes de Entropia para sus algoritmos de /dev/random

Personalmente he trabajado con el Kernel de FreeBSD y he visto en el codigo[6] el uso de la instruccion rdrand.

Entonces que formas tenemos para analizar si la salida directa de rdrand es segura.

Repasemos las caracteristicas que debe tener un RNG, segun [3]
  • Cada valor nuevo debe de ser estadisticamente independiente del anterior
  • La distribucion de todos los numeros generados debe de ser Uniforme
  • La secuencia debe de ser impredecible

Entonces para la comparacion usare varias muestras de 1MB del Disposivo random estandar del sistema, Para este ejemplo /dev/random de FreeBSD 11.1 RELEASE contra varias muestras de 1MB de la salida devuelta directamente por rdrand.

Para hacer esto lo mas amigable posible desarrolle un modulo para el kernel de FreeBSD [7] que al igual que /dev/random, nos genera un device /dev/rdrand que nos devuelve un stream de numeros aleartorios pero en esta ocacion tomados directamente de la instruccion rdrand para procesadores Ivy Bridge.

Codigo para generar un archivo de muestra:

Código:
dd if=/dev/random of=~/random.test count=1 bs=1M
dd if=/dev/rdrand of=~/rdrand.test count=1 bs=1M

Asi mismo desarrolle un programa que lee un archivo y cuenta el numero de veces que aparece cada valor en dicho archivo:


Salida del primer archivo
Código:
Abriendo ./random.test
Valor 0: 4161
Valor 1: 4307
Valor 2: 3964
Valor 3: 4124
Valor 4: 4076
Valor 5: 4032
Valor 6: 4031
Valor 7: 4152
Valor 8: 4146
Valor 9: 4078
Valor 10: 4155
Valor 11: 4121
Valor 12: 4144
Valor 13: 4117
Valor 14: 4180
Valor 15: 3984
Valor 16: 4113
Valor 17: 4188
Valor 18: 4069
Valor 19: 4127
Valor 20: 3980
Valor 21: 4019
Valor 22: 3959
Valor 23: 4067
Valor 24: 4054
Valor 25: 4124
Valor 26: 4123
Valor 27: 4070
Valor 28: 4151
Valor 29: 4178
Valor 30: 4115
Valor 31: 4117
Valor 32: 4119
Valor 33: 4090
Valor 34: 4120
Valor 35: 4126
Valor 36: 4053
Valor 37: 4055
Valor 38: 4084
Valor 39: 4048
Valor 40: 4137
Valor 41: 4125
Valor 42: 4029
Valor 43: 4060
Valor 44: 4077
Valor 45: 4128
Valor 46: 4205
Valor 47: 3959
Valor 48: 4082
Valor 49: 4019
Valor 50: 4034
Valor 51: 4107
Valor 52: 4125
Valor 53: 4112
Valor 54: 4050
Valor 55: 4011
Valor 56: 4087
Valor 57: 4071
Valor 58: 4039
Valor 59: 4095
Valor 60: 4093
Valor 61: 4088
Valor 62: 4091
Valor 63: 4006
Valor 64: 4081
Valor 65: 4047
Valor 66: 4102
Valor 67: 4138
Valor 68: 4106
Valor 69: 4019
Valor 70: 4167
Valor 71: 4118
Valor 72: 4145
Valor 73: 4216
Valor 74: 4129
Valor 75: 4210
Valor 76: 4188
Valor 77: 4079
Valor 78: 4130
Valor 79: 4156
Valor 80: 4129
Valor 81: 4075
Valor 82: 4069
Valor 83: 4097
Valor 84: 4113
Valor 85: 4034
Valor 86: 4107
Valor 87: 3944
Valor 88: 4084
Valor 89: 4310
Valor 90: 4082
Valor 91: 4075
Valor 92: 4110
Valor 93: 4113
Valor 94: 4063
Valor 95: 4133
Valor 96: 4207
Valor 97: 4031
Valor 98: 4166
Valor 99: 4009
Valor 100: 4249
Valor 101: 4076
Valor 102: 4155
Valor 103: 4051
Valor 104: 4052
Valor 105: 4115
Valor 106: 4157
Valor 107: 4013
Valor 108: 4093
Valor 109: 4076
Valor 110: 4126
Valor 111: 4156
Valor 112: 4099
Valor 113: 4079
Valor 114: 4049
Valor 115: 4125
Valor 116: 4018
Valor 117: 3990
Valor 118: 4014
Valor 119: 4114
Valor 120: 4058
Valor 121: 4086
Valor 122: 4016
Valor 123: 4034
Valor 124: 3991
Valor 125: 4044
Valor 126: 4224
Valor 127: 4047
Valor 128: 4189
Valor 129: 4160
Valor 130: 4056
Valor 131: 4073
Valor 132: 4009
Valor 133: 4154
Valor 134: 4163
Valor 135: 4130
Valor 136: 4108
Valor 137: 4226
Valor 138: 4099
Valor 139: 4198
Valor 140: 4004
Valor 141: 4037
Valor 142: 4139
Valor 143: 4129
Valor 144: 4085
Valor 145: 4211
Valor 146: 4036
Valor 147: 4010
Valor 148: 4136
Valor 149: 4167
Valor 150: 4135
Valor 151: 4100
Valor 152: 4061
Valor 153: 4115
Valor 154: 4022
Valor 155: 4074
Valor 156: 4164
Valor 157: 3978
Valor 158: 3999
Valor 159: 4041
Valor 160: 4094
Valor 161: 4003
Valor 162: 4008
Valor 163: 4063
Valor 164: 4200
Valor 165: 4202
Valor 166: 4192
Valor 167: 3978
Valor 168: 4120
Valor 169: 4133
Valor 170: 4204
Valor 171: 4176
Valor 172: 4100
Valor 173: 4092
Valor 174: 4109
Valor 175: 4071
Valor 176: 4091
Valor 177: 4067
Valor 178: 4044
Valor 179: 4070
Valor 180: 4024
Valor 181: 4012
Valor 182: 4130
Valor 183: 4062
Valor 184: 4096
Valor 185: 4092
Valor 186: 4110
Valor 187: 4031
Valor 188: 3931
Valor 189: 4065
Valor 190: 4156
Valor 191: 4167
Valor 192: 4033
Valor 193: 4176
Valor 194: 4000
Valor 195: 4174
Valor 196: 4054
Valor 197: 4126
Valor 198: 4121
Valor 199: 4089
Valor 200: 4154
Valor 201: 4192
Valor 202: 4087
Valor 203: 4164
Valor 204: 4176
Valor 205: 4134
Valor 206: 4082
Valor 207: 4103
Valor 208: 4234
Valor 209: 4022
Valor 210: 3978
Valor 211: 4188
Valor 212: 4104
Valor 213: 4168
Valor 214: 4005
Valor 215: 4065
Valor 216: 4118
Valor 217: 4102
Valor 218: 4108
Valor 219: 4077
Valor 220: 4094
Valor 221: 3951
Valor 222: 4078
Valor 223: 4005
Valor 224: 4012
Valor 225: 4131
Valor 226: 4190
Valor 227: 4058
Valor 228: 4036
Valor 229: 4111
Valor 230: 4137
Valor 231: 4000
Valor 232: 4175
Valor 233: 4164
Valor 234: 4253
Valor 235: 4067
Valor 236: 4081
Valor 237: 4037
Valor 238: 4116
Valor 239: 4155
Valor 240: 4137
Valor 241: 4025
Valor 242: 4052
Valor 243: 4140
Valor 244: 4132
Valor 245: 4115
Valor 246: 4063
Valor 247: 3924
Valor 248: 4174
Valor 249: 4098
Valor 250: 4115
Valor 251: 4105
Valor 252: 4083
Valor 253: 4138
Valor 254: 4152
Valor 255: 4098

Salida del segundo archivo

Código:
Abriendo ./rdrand.test
Valor 0: 4043
Valor 1: 4055
Valor 2: 4191
Valor 3: 4058
Valor 4: 4125
Valor 5: 4087
Valor 6: 4090
Valor 7: 4150
Valor 8: 4007
Valor 9: 4139
Valor 10: 4027
Valor 11: 4054
Valor 12: 4059
Valor 13: 4167
Valor 14: 4024
Valor 15: 4115
Valor 16: 4045
Valor 17: 4135
Valor 18: 4007
Valor 19: 3980
Valor 20: 4169
Valor 21: 4131
Valor 22: 3997
Valor 23: 4051
Valor 24: 4223
Valor 25: 4110
Valor 26: 4185
Valor 27: 4109
Valor 28: 4052
Valor 29: 4093
Valor 30: 4108
Valor 31: 4163
Valor 32: 4119
Valor 33: 4129
Valor 34: 4180
Valor 35: 4061
Valor 36: 4010
Valor 37: 4082
Valor 38: 4104
Valor 39: 4116
Valor 40: 4080
Valor 41: 4191
Valor 42: 4061
Valor 43: 4103
Valor 44: 4249
Valor 45: 4165
Valor 46: 4043
Valor 47: 4187
Valor 48: 4121
Valor 49: 4141
Valor 50: 4113
Valor 51: 4093
Valor 52: 4177
Valor 53: 3970
Valor 54: 4195
Valor 55: 4156
Valor 56: 4065
Valor 57: 4171
Valor 58: 4113
Valor 59: 4041
Valor 60: 4128
Valor 61: 4189
Valor 62: 4067
Valor 63: 4102
Valor 64: 4063
Valor 65: 4143
Valor 66: 4041
Valor 67: 4029
Valor 68: 4085
Valor 69: 4074
Valor 70: 4053
Valor 71: 4160
Valor 72: 4130
Valor 73: 4179
Valor 74: 4154
Valor 75: 4060
Valor 76: 4073
Valor 77: 4086
Valor 78: 4137
Valor 79: 4107
Valor 80: 4053
Valor 81: 4172
Valor 82: 4120
Valor 83: 4072
Valor 84: 3953
Valor 85: 4116
Valor 86: 4042
Valor 87: 4218
Valor 88: 4082
Valor 89: 3955
Valor 90: 4034
Valor 91: 4055
Valor 92: 4120
Valor 93: 4102
Valor 94: 3953
Valor 95: 4098
Valor 96: 4004
Valor 97: 3993
Valor 98: 4163
Valor 99: 3977
Valor 100: 4118
Valor 101: 4233
Valor 102: 4081
Valor 103: 4158
Valor 104: 4067
Valor 105: 4046
Valor 106: 4099
Valor 107: 4102
Valor 108: 4096
Valor 109: 4117
Valor 110: 4046
Valor 111: 4060
Valor 112: 4114
Valor 113: 4015
Valor 114: 4090
Valor 115: 4040
Valor 116: 4160
Valor 117: 4126
Valor 118: 4119
Valor 119: 4129
Valor 120: 4075
Valor 121: 4026
Valor 122: 4000
Valor 123: 4088
Valor 124: 4144
Valor 125: 4182
Valor 126: 4119
Valor 127: 4076
Valor 128: 4068
Valor 129: 4142
Valor 130: 4042
Valor 131: 4038
Valor 132: 4110
Valor 133: 4125
Valor 134: 3985
Valor 135: 4216
Valor 136: 4018
Valor 137: 4113
Valor 138: 4046
Valor 139: 4149
Valor 140: 4063
Valor 141: 4050
Valor 142: 4132
Valor 143: 4108
Valor 144: 4036
Valor 145: 4028
Valor 146: 4153
Valor 147: 4179
Valor 148: 4139
Valor 149: 4072
Valor 150: 4168
Valor 151: 4009
Valor 152: 4095
Valor 153: 4115
Valor 154: 4041
Valor 155: 3954
Valor 156: 4092
Valor 157: 4093
Valor 158: 4035
Valor 159: 4096
Valor 160: 4033
Valor 161: 4133
Valor 162: 3989
Valor 163: 4203
Valor 164: 4048
Valor 165: 4152
Valor 166: 4103
Valor 167: 4195
Valor 168: 4105
Valor 169: 4082
Valor 170: 4046
Valor 171: 4018
Valor 172: 4267
Valor 173: 4201
Valor 174: 4209
Valor 175: 4100
Valor 176: 4009
Valor 177: 3983
Valor 178: 4135
Valor 179: 4168
Valor 180: 4068
Valor 181: 4044
Valor 182: 4013
Valor 183: 3994
Valor 184: 4071
Valor 185: 4062
Valor 186: 4152
Valor 187: 4044
Valor 188: 4078
Valor 189: 4141
Valor 190: 4033
Valor 191: 4133
Valor 192: 4064
Valor 193: 4158
Valor 194: 3962
Valor 195: 4145
Valor 196: 4119
Valor 197: 4040
Valor 198: 3981
Valor 199: 4173
Valor 200: 4025
Valor 201: 4090
Valor 202: 4067
Valor 203: 4049
Valor 204: 4106
Valor 205: 4232
Valor 206: 3987
Valor 207: 4053
Valor 208: 4121
Valor 209: 4177
Valor 210: 4214
Valor 211: 4053
Valor 212: 4095
Valor 213: 4127
Valor 214: 4082
Valor 215: 4109
Valor 216: 4107
Valor 217: 4181
Valor 218: 4224
Valor 219: 4142
Valor 220: 4112
Valor 221: 4165
Valor 222: 4121
Valor 223: 4088
Valor 224: 4073
Valor 225: 3984
Valor 226: 4112
Valor 227: 4054
Valor 228: 4151
Valor 229: 4120
Valor 230: 4040
Valor 231: 4129
Valor 232: 4099
Valor 233: 4085
Valor 234: 4078
Valor 235: 4149
Valor 236: 4101
Valor 237: 3985
Valor 238: 3999
Valor 239: 4085
Valor 240: 4138
Valor 241: 4300
Valor 242: 4078
Valor 243: 4265
Valor 244: 4194
Valor 245: 4027
Valor 246: 4130
Valor 247: 4225
Valor 248: 4111
Valor 249: 4102
Valor 250: 4046
Valor 251: 4059
Valor 252: 3974
Valor 253: 4096
Valor 254: 4155
Valor 255: 4089

A simple vista parece que ambas salidas tienen una distribucion uniforme de los valores, con esto comprobamos la segunda propiedad de los RNG "La distribucion de todos los numeros generados debe de ser Uniforme"

Falta validar las otras 2 propiedades pero de momento es suficiente.

¿Entonces podemos decir que el Intel Secure Key RNG es Seguro?

No de momento con las pruebas hechas no hay manera de afirmar que sea seguro o inseguro.

Sin embargo las concluciones mencionadas en[10] comentan que la instroduccion de rdrand en los sistemas mejora y simplifica la generacion de numeros aleatorios ademas recomiendan usarlo junto con otros sources de entropia.



Referencias
[1] https://en.wikipedia.org/wiki/Random_number_generation
[2] https://www.schneier.com/academic/paperfiles/paper-yarrow.pdf
[3] https://software.intel.com/sites/default/files/m/d/4/1/d/8/441_Intel_R__DRNG_Software_Implementation_Guide_final_Aug7.pdf
[4] https://www.theregister.co.uk/2013/09/10/torvalds_on_rrrand_nsa_gchq/
[5] https://arstechnica.com/information-technology/2013/12/we-cannot-trust-intel-and-vias-chip-based-crypto-freebsd-developers-say/
[6] https://svnweb.freebsd.org/base/release/11.1.0/sys/dev/random/ivy.c?view=markup
[7] https://github.com/albertobsd/rdrand
[8] https://eprint.iacr.org/2014/504.pdf
[9] http://spectrum.ieee.org/computing/hardware/behind-intels-new-randomnumber-generator
[10] http://www.electronicdesign.com/learning-resources/understanding-intels-ivy-bridge-random-number-generator
7  Seguridad Informática / Hacking Wireless / Cable modem Ubee - WPA2 y WPS por defecto en: 6 Agosto 2017, 20:03
Fuente: https://albertobsd.blogspot.mx/2017/07/cable-modem-ubee-wpa2-y-wps-por-defecto.html




Bueno recientemente me instalaron el internet de Megacable (ISP de Internet y Televicion en Mexico ) y me entregaron un modem algo desconocido, pero realmente desconozco que tan usado sea esta marca de modems en las tecnologias de cable coaxial.

Me instalaron un  cable modem Ubee Modelo 1307

desconozco si estas condifuraciones sean para todos lo modelos he incluso para este mismo modelo en otra Compañia de cable.

La cable WPA/WPA2 por defecto para el equipo que me entregaron es PARTE de la MAC Address ORIGINAL. En especifico los ultimos 5 Octetos

Resalto "parte" y "original" ya que si escaneamos las redes Wireless la MAC address Wireless cambia en el ultimo octeto.

Ejemplo ficticio

MAC Adress Original: F8:DA:0C:00:00:00 (Esta es la que viene en nuestra etiqueta)
MAC Adress WAN: F8:DA:0C:00:00:01 (Esta es la que reconoce la compañia de cable)
MAC Adress MTA: F8:DA:0C:00:00:02 (NPI)
MAC Adress Ethernet: F8:DA:0C:00:00:03 (Mac address que ven las computadoras conectas por cable)
MAC Adress Wireless: F8:DA:0C:00:00:04 (Mac addres que ven los equipos wireless)

Entonces para este caso ficticio la cable WPA es DA0C000000
Y el SSID de la red Inalambrica es: Ubee0000

Los datos reales pueden cabiar.

Entonces si tenemos acceso a la MAC address inalambrica la clave serian los 4 octetos de en medio mas los 2 ultimos digitos del SSID.

Otro ejemplo

MAC Adress Wireless: F8:DA:0C:10:10:04
SSID: Ubee1000

La cable WPA seria los numeros resaltados a continuacion:
MAC Adress Wireless: F8:DA:0C:10:10:04
SSID: Ubee1000

Por lo que para este ejemplo seria DA0C101000

Ademas de todo esto el PIN WPS por default que venia en mi dispositivo es 12345670

Interfaz Web

La direccion para acceder a la interfaz web es http://192.168.0.1

El usurio y clave para entrar es user, user esto es:
usuario: user
contraseña: user

Recomendaciones
Desactivar el WPS
Cambiar el nombre de la red inalambrica
Cambiar la clave por defecto.


VULNERABLE A REAVER por defecto.

Atacando mi Equipo con Reaver:

Código:
# reaver -b F8:DA:0C:XX:XX:XX  -i mon0 -vv

Reaver v1.4-r119 WiFi Protected Setup Attack Tool
Copyright (c) 2011, Tactical Network Solutions, Craig Heffner <cheffner@tacnetsol.com>


[+] Switching mon0 to channel 10
[+] Waiting for beacon from F8:DA:0C:XX:XX:XX
[+] Associated with F8:DA:0C:XX:XX:XX (ESSID: EyL)
[+] Trying pin 12345670
[+] Sending EAPOL START request
[+] Received identity request
[+] Sending identity response
[+] Received M1 message
[+] Sending M2 message
[+] Received M3 message
[+] Sending M4 message
[+] Received M5 message
[+] Sending M6 message
[+] Received M7 message
[+] Sending WSC NACK
[+] Sending WSC NACK
[+] Pin cracked in 4 seconds
[+] WPS PIN: '12345670'
[+] WPA PSK: 'XXXXXXXXXXXXXX'
[+] AP SSID: 'XXXXXXXXXXXXXX'
[+] Nothing done, nothing to save.
8  Programación / Programación C/C++ / [Problema Reto C/C++] Sumatoria de Rangos de Impares en: 8 Marzo 2017, 22:24
Buenas!

Este problema lo vi en otro Foro, pero me gustaria ampliarlo y Discutir sobre la eficiencia del codigo contra la "FORMA FACIL".


Problema
Tu tienes que proporcionar la Suma de Todos los numeros Impares contenidos en un rango de numeros dados [a,b]

Ejemplo:
a = 5
b = 10
Numeros impares en el rango [5,10] = { 5,7,9 };
Sumatoria 5 +7 + 9 = 21

Ejemplo
a = 1
b = 5
Numeros impares en el rango [1,5] = { 1,3,5 };
Sumatoria 1+3 +5 = 9

Entrada del programa:
Pueden existir multiples casos para probar, La primera Linea contiene el valor T Donde T es el numero de casos a realizar,  1 <= T  <= 100000
Y seguido de T Casos, Cada Caso consiste en dos Numeros enteros a, b  donde 0 <= a <=b <=10000. En dos lineas sepaadas (1 linea por numero entero)

Ejemplo de Entrada:

Código:
2
5
10
1
5

Ejemplo de salida

Código:
Caso 1: 21
Caso 2: 8




La solucion que muchos aplican es codigo:

Código
  1. int T= 0,a = 0,b= 0,i,suma;
  2. scanf("%d\n",&T);
  3. i = 0;
  4. while(i < T) {
  5. scanf("%d\n",&a);
  6. scanf("%d\n",&b);
  7. suma = 0;
  8. while(a <= b) {
  9. if(a % 2 == 1) {
  10. suma += a;
  11. }
  12. a++;
  13. }
  14. printf("Case %i:%i\n",i+1,suma);
  15. i++;
  16. }
  17.  

Sin embargo en mi punto de vista es bastante ineficiente, ya que si te dan 10000 Veces el peor de los casos de [0,10000] (Pongo 10000 y no 100000 para que no desborde el entero de 32 bits...) En dado caso tu programa ejecutaria un ciclo de 10000 * 10000 = 100'000,000
Claro que para los procesadores modernos no hay tanta direrencia entre 100, Mi aproximacion fue sacar la formula para determinar la sumaria de los impares del rango de 0 a A y del rango de 0 a B

Y En teoria solo entro al ciclo T veces:

Código
  1. #include<stdio.h>
  2.  
  3. int main() {
  4. int T= 0,a = 0,b= 0,i;
  5. int rango_a,rango_b;
  6. scanf("%d\n",&T);
  7. i = 0;
  8. while(i < T) {
  9. scanf("%d\n",&a);
  10. scanf("%d\n",&b);
  11. if(a % 2 != 0) {
  12. a-=1;
  13. }
  14. rango_a = (((a/2)*a)/2); // Suma de Impares desde 0 hasta a-1
  15. if(b % 2 == 0) {
  16. rango_b = (((b/2)*b)/2); //Suma de Impares desde 0 hasta b
  17. }
  18. else {
  19. rango_b = ((((b+1)/2)*(b+1))/2); //Suma de Impares desde 0 hasta b
  20. }
  21. printf("Case %i:%i\n",i+1,rango_b-rango_a);
  22. i++;
  23. }
  24. return 0;
  25. }
  26.  



Consideren el siguiente archivo de Entrada 10000 veces rangos de [0,10000]
http://pastebin.com/raw/nK0xQ6cz
9  Foros Generales / Foro Libre / Bosque Cementerio? en: 1 Noviembre 2016, 02:29
Vi esta imagen y me agrado la idea que opinan ustedes?

10  Foros Generales / Noticias / Godaddy Expone Información sensible al usar el mail() de PHP en: 30 Septiembre 2016, 22:10
Si tienes hosting en GODADDY y envias correos mediante el MAIL del PHP te aconsejo que dejes de hacerlo:

Cuando tu envías un correo electrónico usando la función de mail de PHP el hosting agrega información de rastreo para los correos con el objetivo de poder rastrear cualquier abuso del mismo y eso esta BIEN, lo que NO esta bien es que agreguen la información en TEXTO PLANO. esto es envían información sensible como:

  • username del CPANEL
  • UID/GID del Proceso baja el cual se ejecuta el PHP (Un hosting linux claro)
  • Hosting principal asociado al Hosting
  • Host de segundario (Si es que existe)...
  • Ruta desde donde se ejecuta el script PHP
  • nombre del Script php que envia el correo

Ejemplo de los headers mencionados:

Código:
X-PHP-Script: (HOST_SECUNDARIO)/index.php for 189.181.XXX.XXX
X-AntiAbuse: This header was added to track abuse, please include it with any abuse report
X-AntiAbuse: Originator/Caller UID/GID - [123456 666] / [47 12]
X-AntiAbuse: Sender Address Domain - p3plcpnl0940.prod.phx3.secureserver.net
X-Get-Message-Sender-Via: p3plcpnl0940.prod.phx3.secureserver.net: authenticated_id: username_CPANEL/from_h
X-Source-Args: /usr/sbin/proxyexec -q -d -s /var/lib/proxyexec/cagefs.sock/socket /bin/cagefs.server
X-Source-Dir: (HOST_PRIMARIO):/FULL/PATH/OF/SCRIPT

Fuente:
https://albertobsd.blogspot.mx/2016/09/godaddy-expone-informacion-sensible-al.html
Páginas: [1] 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 ... 21
Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines