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


Tema destacado: ¿Eres nuevo? ¿Tienes dudas acerca del funcionamiento de la comunidad? Lee las Reglas Generales


  Mostrar Mensajes
Páginas: 1 ... 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 [20] 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 ... 235
191  Programación / Programación Visual Basic / Re: extraer adjuntos de correos EML en: 11 Noviembre 2020, 15:07 pm
hola, muchas gracias por todo, pero no consigo que me extraiga el adjunto..

Que tal ya veo algo no esta bien pero no puedo saber que es si no veo el eml que le pasas, si gustas puedes mandarme el EML a mi correo, mi informacion esta por ahi publica
192  Programación / Programación Visual Basic / Re: extraer adjuntos de correos EML en: 10 Noviembre 2020, 18:20 pm
Lo hice pero actualmente solo para un solo archivo eml, ya que me da flojera hacerlo para todo un directorio y que busque los archivos eml etc etc etc...

Lo hice en C. se que este es el subforo de VB, pero la verdad VB no me gusta mucho para este tipo de operaciones, de hechos me gusta el VBA para automatizar trabajos en Excel

Imagen de prueba que funciona:


Y el archivo se crea en el directorio pasado como segundo parametro.



Por cierto si el siguiente código fuente si se compila en algunos compiladores de Windows puede dar muchos warning, pero con gcc de MinGW no me tira ningun warning ni error como esta en la imagen.

Código
  1. /*
  2. gcc -o dump_eml.exe dump_eml_attachments.c
  3. */
  4.  
  5. #include<stdio.h>
  6. #include<stdlib.h>
  7. #include<string.h>
  8. #include<stdint.h>
  9.  
  10. static char encoding_table[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
  11.                                'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
  12.                                'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
  13.                                'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
  14.                                'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
  15.                                'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
  16.                                'w', 'x', 'y', 'z', '0', '1', '2', '3',
  17.                                '4', '5', '6', '7', '8', '9', '+', '/'};
  18. static char *decoding_table = NULL;
  19. static int mod_table[] = {0, 2, 1};
  20.  
  21. unsigned char *base64_decode(const char *data,
  22.                             size_t input_length,
  23.                             size_t *output_length);
  24. void build_decoding_table();
  25. void base64_cleanup();
  26.  
  27. int open_and_extract_from_eml(char *filename,char *path_destino);
  28. int isEmptyLine(char *line);
  29. char *content_disposition = "Content-Disposition: attachment;";
  30.  
  31. int main(int argc, char **argv ) {
  32. if(argc != 3) {
  33. printf("Uso: %s <Carpeta_con_EMLs> <Carpeta_destino_adjuntos>\n",argv[0]);
  34. exit(0);
  35. }
  36. open_and_extract_from_eml(argv[1],argv[2]);
  37. return 0;
  38. }
  39.  
  40. int  open_and_extract_from_eml(char *filename,char *path_destino) {
  41. FILE *eml_file, *temp_file;
  42. char *dest_file,*temp0,*temp1;
  43. char *line,*buffer_base64 = NULL,*buffer_decoded;
  44. char *full_writen_file;
  45. int len_dest_file_name,offset,len_content_disposition,len_base64_line,len_base64_buffer, len_output,len_path_destino,entrar;
  46. len_content_disposition = strlen(content_disposition);
  47. len_path_destino = strlen(path_destino);
  48. line = malloc(1024);
  49. eml_file = fopen(filename,"rb");
  50. offset = 0;
  51. while(!feof(eml_file) && fgets(line,1024,eml_file) != NULL) {
  52. if(memcmp(line,content_disposition,len_content_disposition) == 0) {
  53. printf("Encontrado: %s",line);
  54. temp0 = strstr(line,"filename=");
  55. if(temp0 ==NULL ) {
  56. //tal vez la proxima linea?
  57. memset(line,0,1024);
  58. fgets(line,1024,eml_file);
  59. }
  60.  
  61. temp0 = strstr(line,"filename=");
  62. if(temp0 !=NULL ) {
  63. temp1 = strstr(temp0 +10,"\"");
  64. if(temp1 == NULL) {
  65. //No hay " finales
  66. exit(0);
  67. }
  68. len_dest_file_name = temp1 - (line + (temp0 - line) + 10 );
  69. //printf("len_dest_file_name %i\n",len_dest_file_name);
  70. dest_file = malloc(len_dest_file_name+1);
  71. strncpy(dest_file,(line + (temp0 - line) + 10),len_dest_file_name);
  72. dest_file[len_dest_file_name] = '\0';
  73.  
  74. memset(line,0,1024);
  75. fgets(line,1024,eml_file);
  76. //printf("Nueva linea leida \"%s\"",line);
  77. if(!isEmptyLine(line)) {
  78. //Deberia de ser una linea vacia;
  79. exit(0);
  80. }
  81. buffer_base64 = NULL;
  82. offset = 0;
  83. memset(line,0,1024);
  84. entrar = 1;
  85. while(entrar && fgets(line,1024,eml_file) != NULL &&  !isEmptyLine(line) ) { //leemos hasta la proxima linea vacia o hasta encontrar un '=' al final de la linea
  86. len_base64_line = strlen(line);
  87. buffer_base64 = realloc(buffer_base64,offset+len_base64_line+1);
  88. if(line[len_base64_line-1] == '\n'  || line[len_base64_line-1] == '\r'){
  89. line[len_base64_line-1] ='\0';
  90. len_base64_line--;
  91. }
  92. if(line[len_base64_line-1] == '\n'  || line[len_base64_line-1] == '\r'){
  93. line[len_base64_line-1] ='\0';
  94. len_base64_line--;
  95. }
  96.  
  97. memcpy(buffer_base64+offset,line,len_base64_line);
  98. offset+=len_base64_line;
  99. if(line[len_base64_line-1] == '=') {
  100. entrar = 0;
  101. }
  102. memset(line,0,1024);
  103. }
  104. buffer_base64[offset] = '\0';
  105. //printf("Encoded buffer: %s\n",buffer_base64);
  106. len_base64_buffer = strlen(buffer_base64);
  107. buffer_decoded = base64_decode(buffer_base64,len_base64_buffer,&len_output);
  108. buffer_decoded[len_output] = '\0';
  109. /*
  110. printf("OK\n");
  111. printf("Decoded buffer: %s\n",buffer_decoded);
  112. printf("Path destino: %s\n",path_destino);
  113. printf("len_dest_file_name: %i\n",len_dest_file_name);
  114. printf("len_path_destino: %i\n",len_path_destino);
  115. */
  116. full_writen_file = malloc(len_dest_file_name + len_path_destino+10);
  117. sprintf(full_writen_file,"%s/%s",path_destino,dest_file);
  118. printf("Destino: %s\n",full_writen_file);
  119. temp_file = fopen(full_writen_file,"wb");
  120. fwrite(buffer_decoded,1,len_output,temp_file);
  121. fclose(temp_file);
  122.  
  123. free(buffer_base64);
  124. free(dest_file);
  125. free(full_writen_file);
  126. }
  127. else {
  128. printf("Se encontro %s, pero no se encontro Filename omitiendo!\n",content_disposition);
  129. }
  130. }
  131. memset(line,0,1024);
  132. }
  133. free(line);
  134. }
  135.  
  136. int isEmptyLine(char *line) {
  137. if(line[0] == '\0' || line[0] == '\n' || line[0] == '\r')
  138. return 1;
  139. return 0;
  140. }
  141.  
  142. unsigned char *base64_decode(const char *data,
  143.                             size_t input_length,
  144.                             size_t *output_length) {
  145.  
  146.    if (decoding_table == NULL) build_decoding_table();
  147.  
  148.    if (input_length % 4 != 0) return NULL;
  149.  
  150.    *output_length = input_length / 4 * 3;
  151.    if (data[input_length - 1] == '=') (*output_length)--;
  152.    if (data[input_length - 2] == '=') (*output_length)--;
  153.  
  154.    unsigned char *decoded_data = malloc(*output_length);
  155.    if (decoded_data == NULL) return NULL;
  156.  
  157.    for (int i = 0, j = 0; i < input_length;) {
  158.  
  159.        uint32_t sextet_a = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];
  160.        uint32_t sextet_b = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];
  161.        uint32_t sextet_c = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];
  162.        uint32_t sextet_d = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];
  163.  
  164.        uint32_t triple = (sextet_a << 3 * 6)
  165.        + (sextet_b << 2 * 6)
  166.        + (sextet_c << 1 * 6)
  167.        + (sextet_d << 0 * 6);
  168.  
  169.        if (j < *output_length) decoded_data[j++] = (triple >> 2 * 8) & 0xFF;
  170.        if (j < *output_length) decoded_data[j++] = (triple >> 1 * 8) & 0xFF;
  171.        if (j < *output_length) decoded_data[j++] = (triple >> 0 * 8) & 0xFF;
  172.    }
  173.  
  174.    return decoded_data;
  175. }
  176.  
  177. void build_decoding_table() {
  178.    decoding_table = malloc(256);
  179.    for (int i = 0; i < 64; i++)
  180.        decoding_table[(unsigned char) encoding_table[i]] = i;
  181. }
  182.  
  183.  
  184. void base64_cleanup() {
  185.    free(decoding_table);
  186. }

El programa lo puedes utilizar para todo un directorio pero con ayuda de batch creo recordar que existe una instrucción for que te ayuda a procesar todos los archivos de un subdirectorio y pasarlos a un programa.

Saludos!
193  Programación / Programación Visual Basic / Re: extraer adjuntos de correos EML en: 10 Noviembre 2020, 15:59 pm
Te puedo ayudar , pero no tengo compilador de VB ni de tecnologías Microsoft en este momento, pasame un archivo EML y con gusto le hecho un ojo para extraer todas los adjuntos, por cierto que ya debería de existir un programa que haga eso no?



Edito ya vi la estructura del archivo y no esta tan complicada.

Pregunta:

Quieres todos los adjuntos incluidos los que aparecen en el body del mensaje como imagenes y demas o solo considerados realmente "attachment" ?

Las imágenes del body y demás tienen un "inline" en el código ejemplo
Código:
Content-Disposition: inline; filename="background.gif"

O solo los "attachment"
Código:
Content-Disposition: attachment; filename="attachment.txt"


Saludos!
194  Programación / Programación C/C++ / Re: COMPRESOR LZ78 en: 8 Noviembre 2020, 20:55 pm
No se hacen tareas.

Saludos!
195  Seguridad Informática / Criptografía / Re: Como crackear una cartera bitcoin. Teoria y practica en: 8 Noviembre 2020, 19:40 pm

Interesante si ya vi varias noticias confirmando lo mismo, no sabía que esa cartera estaba relacionada con el silk road.

En fin, yo como lo mencione en el primer post me interese en el tema por lo "famoso" de esa cartera, lamentablemente me interese muy tarde en ese tema, ya que solo una semana después de de empezar a entender lo que hacia el bitcoin core para cifrar las llaves privadas, la cartera mencionada fue vaciada.

Prueba de concepto.

Veremos a continuación una prueba de concepto de cómo funcionaria el crackeo por fuerza bruta de forma secuencial o aleatorio, el
ejemplo esta "Arreglado" solo se  utiliza para  mostrar que el método funciona cuando el valor correcto llegue.

El código está publicó en github:

https://github.com/albertobsd/crackBTCwallet



Recalco, es muy pero muy IMPROBABLE que se encuentre por medio de algún ataque tipo Aleatorio. No es imposible, pero a no ser que cuente con un exceso de poder de computo, no se alcanzara a obtener el key utilizado en una vida completa..
196  Foros Generales / Foro Libre / Re: Cansado de encontrar vídeos latinos en youtube en: 6 Noviembre 2020, 01:14 am
A mi me pasa con las peliculas que ponen, en Español  :laugh:

Cuando me la descargo, aparece el acento tan caracteristico de Mexico, y los personajes que interpretan las voces, al estar acostumbrado a la voz del Personaje, a veces te da un poco de risa. Pero supongo que a los Mexicanos tambien les dará risa la voz Española.

Exacto me pasa un poco eso cuando veo series españolas.

Tambien me pasa y no se por que cuando busco un trailer de alguna película No se en español. tengo que especificar que sea Latino por que si no, por lo general me aparecen películas en español de españa.

Bravo por la respuesta de Machacado y tincopasan, son las mas adecuadas explicando la proporción de hispanoablantes latino americanos contra hispanohablantes españoles.

Saludos!
197  Programación / Programación C/C++ / Re: Círculo para dibujar una luna en: 5 Noviembre 2020, 20:58 pm
Tiene que ser en C++? Que api están utilizando para graficar?

Ya para este caso utilizaría un canvas HTML5, pero bueno no se cual sea tu caso.

Saludos!
198  Programación / Programación C/C++ / Re: Valores hexadecimales en código en: 5 Noviembre 2020, 14:43 pm
La ventaja es que puedes agregar cualquiertipo de valor. Independientemente mente di es un valor ascii printable o no printable
199  Comunicaciones / Redes / Re: Mi Red Wifi se conecta pero no me deja navegar (Necesito Vuestra Ayuda) en: 5 Noviembre 2020, 01:19 am
Por recomendación de seguridad no te recomendaria descargar nada de lo cual no estes enterado como funciona.

El diagnostico lo puedes hacer directamente desde tu computadora.

Código:
ping www.google.com


Funciona? Que error exacto devuelve?

Código:
ipconfig /all

Busca tu puerta de enlace y realiza ping a esa dirección

Código:
ping X.X.X.X

Funciona? que error devuelve

Código:
traceroute 8.8.8.8

Funciona que error devuelve?

Hay muchas pruebas mas que se pueden hacer pero si no empiezas a entender estas pruebas básicas, no podras seguir con otras
200  Seguridad Informática / Criptografía / Como crackear una cartera bitcoin. Teoria y practica en: 4 Noviembre 2020, 19:42 pm

Como crackear una cartera bitcoin. (Teoria y practica).

Bueno esta investigación comenzó a manera de broma y solo por hobby. En las platicas que tenemos en la comunidad de elhacker.net en Telegram ( https://t.me/elhackerdotnet )

Se menciono hace tiempo la existencia de una  cartera de bitcoin con 69 Mil BTC, al tipo de cambio actual hoy 4 de Noviembre de 2020 serian unos 995 millones de dólares, entre bromas se menciono que teníamos que crackearla con algún computador cuántico.

En fin, el proceso "normal" para abrir una cartera cifrada utilizando las aplicaciones oficiales de Bitcoin-Core es el siguiente.

Primero cargamos la cartera

Código:
bitcoin-cli loalwallet "wallet.dat"

"wallet.dat" es un archivo que debe de existir en el directorio ~/.bitcoin/wallets/

Se puede llamar de otro modo, el punto es que debe de exisitir en ese path

Segundo desbloqueamos la cartera con nuestra passphrase o mas comúnmente contraseña

Código:
bitcoin-cli walletpassphrase "passphrase o password" 60

Entre comillas tenemos nuestro password y el 60 a continuación indica que desbloqueamos la cartera por 60segundos

Si el password es correcto no marcara error, de lo contrario lo indicará.

Código:
error code: -14
error message:
Error: The wallet passphrase entered was incorrect.

Ahora la forma lenta e ineficiente de intentar crackearla por fuerza fruta probando directamente distintos passphrase desde la misma terminal.
Sigue siendo lento incluso aunque se utilice algún script bash por que pasar del bash al programa y de regreso es ineficiente.

Necesitamos saber que hace internamente la aplicación, para tratar de reproducirlo en un programa en C y ejecutarlo por aparte posiblemente con multihilo para mejorar la eficiencia

¿Que hace el bitcoin core con nuestro passphrase?

Nuestro passphrase es combinado con un salt que se encuentra almacenado en el archivo, mediante un algoritmo estilo PBKDF y con mas de 25000 iteraciones generan un hash sha512.

De estos 64 bytes generados mediante PBKDF, se utilizan los primeros 32 bytes como KEY para inicializar el contexto de AES y los siguientes 16 bytes como IV para el algoritmo CBC

A este algoritmo AES256CBC se le pasa como parámetro para descifrar el mKey (master KEY) cifrado y se obtiene un mKey Descifrado

El master key ya descifrado se le hacen varias pruebas, se utiliza este valor como KEY para otros descifrados y en este caso como IV en todas las pruebas se utilizan 16 bytes del public Key de la cartera bitcoin obtenidos por una función interna llamada GetHash que desconozco que valores devuelva exactamente, solamente me limite a llamarla.

Y si el master key ya descifrado pasa todas las pruebas se almacena en memoria para sea utilizado en el futuro.

Fin de la triste Historia.  :silbar:

Resumen en pseudo codigo

El siguiente codigo en Pseudo C esta solo para representare que hace la aplicación internamente.

Código
  1. prekey = PBKDF(passphrase,IV, N Iteraciones,"sha512");
  2. memcpy(KEY,prekey,32);
  3. memcpy(IV,prekey+32,16);
  4. aesctx = AES256_init(KEY);
  5. if( AES256CBC_decrypt(aesctx,IV,ENC_mKey,DEC_mKEY) > 0) {
  6. foreach(OthersENC as oENC) {
  7. oCtx = AES256_init(DEC_mKEY);
  8. if(!AES256CBC_decrypt(oCtx,IV_fromPublickey,oENC,dummy) > 0) {
  9. return false;
  10. }
  11. }
  12. return true;
  13. }

Entonces si nuestro plan es un ataque por fuerza bruta podemos saltarnos el PBKDF que se ejecuta N Iteraciones (Mínimo 25000) y saltar directamente al Decrypt de AES.

Tenemos 2 opciones:

1.- Generar un par (KEY,IV) 48 bytes random o secuencial y empezar con el primer AES256CBC_decrypt y utilizar el valor generado para continuar con los AES256CBC_decrypt dentro del for.

2.- O generar solamente un KEY de 32 bytes random o secuencial y pasar directamente a los AES256CBC_decrypt dentro del For.

Asi con 32 bytes solo tenemos 1 de 115792089237316195423570985008687907853269984665640564039457584007913129639936 posibilidades de dar con la KEY correcto.
xD xD xD

Resultados vistos en la práctica.

Con la opción 1 solamente el 0.4% de los valores aleatorios generados pasaban el primer AES256CBC_decrypt posteriormente solo el 0.4% de esos valores pasaban el primer AES256CBC_decrypt dentro del FOR

Para la cartera que cree con el propósito de realizar las pruebas los challenge dentro del FOR eran sobre 500.

Sin embargo para la cartera lackeada con 69K BTC solo está disponible un solo challenge dentro del FOR, al ser solo dos AES256CBC_decrypt me dio bastantes KEY "Falsos positivos" aproximadamente uno de cada millón de valores random generados (KEY,IV) pasaban ambas pruebas

En conclusión

La aproximación por Fuerza Bruta a AES256CBC es improbable que funcione ojo, improbable no imposible, Tal vez en el futuro con mejor poder de computo disponible, o tal vez con Múltiples equipos trabajando de forma sincronizada con alguna RED tipo BOINC o algún tipo de BOTNET

Tengo el código utilizado para realizar este proceso, un poco de manera hardcodeada Ya que los Valores cifrados los saque directamente mediante Hexedit, si alguien esta interesado en la estructura del archivo no dude en comentarlo.

Saludos

Posdata
La cartera de 69K BTC fue vaciada por alguien el dia de ayer. 3 de Noviembre a las 3PM
https://twitter.com/albertobsd/status/1323752623510446080
https://decrypt.co/es/47133/wallet-de-bitcoin-con-955-millones-famosa-entre-hackers-se-acaba-de-vaciar?amp=1
Páginas: 1 ... 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 [20] 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 ... 235
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines