Recientemente me interesa ese tipo de temas otra vez, he aprendido mucho y me gustaría compartirlo con ustedes.

Si no saben de que va el tema aquí dejo unos links.

Block cipher mode of operation
https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation

Wikipedia Padding oracle attack
https://en.wikipedia.org/wiki/Padding_oracle_attack

Padding oracle attack
https://robertheaton.com/2013/07/29/padding-oracle-attack/

Este tipo de Ataque tiene ciertas condiciones iniciales para ser llevado acabo.

• El cliente solo puede saber si su paquete fue aceptado o no.

Esto es debido al check que hace el servidor sobre el mensaje recibido

• El servidor no Cambia de KEY utilizada durante el proceso de cifrado y descifrado.

Esto es debido a una mala implementación, ya que el servidor debería de renovar el KEY cada X tiempo y con cada cliente distinto.

• El servidor tiene algún leak de información ya sea por error o mediante otro tipo de ataque.
• El cliente solo podrá descifrar Una parte de la información, excepto por el Bloque inicial

Dejo a continuación una imagen de prueba y el código, proximamente subire un video hablando del tema.






Codigo, este codigo ejemplifica el cliente y servidor mediante un hilo distinto, lo hice de esta manera para no complicarme con el protocolo en RED de los mismo, se puede hacer sin hilos, y solo con llamadas a funcion, pero la idea es garantizar que el cliente no tiene acceso al servidor.

/*
Desarollado por AlbertoBSD 
email alberto.bsd@gmail.com
g++ -O3 -o opk_example opk_example.c -Wint-to-pointer-cast  -pthread
*/
 
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include<pthread.h>
#include<unistd.h>
#include"ctaes/ctaes.c"
 
#define AES_BLOCKSIZE 16
 
struct timespec tim, tim2,sim,sim2;
 
void crear_server();
char *tohex(char *ptr,int length);
void *process_server(void *vargp);
 
int MyCBCEncrypt(AES256_ctx *ctx, const unsigned char iv[AES_BLOCKSIZE], const unsigned char* data, int size, bool pad, unsigned char* out);
int MyCBCDecrypt(AES256_ctx *ctx, const unsigned char iv[AES_BLOCKSIZE], const unsigned char* data, int size, bool pad, unsigned char* out);
 
/* Values between Server and client */
int values_do;
int values_pad;
int values_length;
int values_leaked;
char *values_enc;
char *values_leak;
 
pthread_mutex_t mtx_values;  //Mutex for those values
 
int main(){
  /*
    Set global values;
  */
  tim.tv_sec = 0;
  tim.tv_nsec = 50000;
 
  sim.tv_sec = 0;
  sim.tv_nsec = 50000;
  values_do = 0;
  values_pad = 0;
  values_length = 0;
  values_leaked = 0;
  values_enc = (char*) malloc(48);
  values_leak = (char*) malloc(48);
  crear_server();  //create child "server"
 
  //This main process is the client
  int i,j,k,entrar;
  char *secret,*temp,*try_enc;
  char *decrypted;
  unsigned char GUESS;
  secret = (char*) malloc(48);
  try_enc = (char*) malloc(48);
  decrypted = (char*) malloc(16);
  memset(decrypted,0,16);
  do  {  
    sleep(1);
  }while(values_leaked==0); //We need to wait to the leaked data
 
  memcpy(secret,values_leak,48);
 
  temp = tohex(secret,48);
  printf("process_client: leaked is %s\n",temp);
  free(temp);
  i = 0;
  j = 0;
  while(i < 16)  {
    memcpy(try_enc,secret,32);
 
    pthread_mutex_lock(&mtx_values);
    switch(values_do)  {
      case 0:
        GUESS = j;
        decrypted[15-i] = GUESS;
        for(k = 0; k <= i;k++)  {
          try_enc[15-k] = try_enc[15-k] ^ decrypted[15-k] ^ (unsigned char)(i+1);
        }
 
        values_do = 1;
        values_length = 32;
        memcpy(values_enc,try_enc,32);
      break;
      case 1:
      break;
      case 2:
        if(values_pad)  {
          i++;
          printf("Encontrado valor: %c : %.2x\n",GUESS,GUESS);
          j = 0;
        }
        else  {
          j++;
        }
        values_do = 0;
      break;
    }
    pthread_mutex_unlock(&mtx_values);
    nanosleep(&tim , &tim2);
  }
  printf("Decrypted data: %s\n",decrypted);
 
}
 
void *process_server(void *vargp)  {
  AES256_ctx ctx;
  FILE *urandom;
  const char *secret = "The password is: Ywgo/@g:2$0Qsz<";
  char *key,*dec,*enc,*iv,*temp;
  int length,i,pad_valid,outlen;
  unsigned char pad;
  key = (char*) malloc(32);
  dec = (char*) malloc(48);
  enc = (char*) malloc(48);
  iv  = (char*) malloc(16);
  urandom = fopen("/dev/urandom","rb");
  fread(key,1,32,urandom);
  fread(iv,1,16,urandom);
  fclose(urandom);
 
  AES256_init(&ctx,(const unsigned char*) key);
 
  /* LEAK THE secret */
  pthread_mutex_lock(&mtx_values);
  memset(enc,0,48);
 
 
  outlen = MyCBCEncrypt(&ctx, (const unsigned char*) iv, (const unsigned char*) secret, strlen(secret), true, (unsigned char*) enc);
 
  memcpy(values_leak,enc,outlen);
  values_leaked = 1;
  pthread_mutex_unlock(&mtx_values);
  /*END LEAK*/
 
  do  {
    nanosleep(&sim , &sim2);
    pthread_mutex_lock(&mtx_values);
    if(values_do == 1)  {
      length = values_length;
      pad_valid = 0;
      if(length <= 48)  {
        memcpy(enc,values_enc,length);
 
        outlen = MyCBCDecrypt(&ctx,( const unsigned char*) iv, (const unsigned char*) enc, length, true, (unsigned char*) dec);
        if(outlen > 0)  {
          pad_valid =  1;
          printf("Decrypted data seems legit : %i bytes\n",outlen);
          temp = tohex(dec,length);
          printf("Decrypted data %s\n",temp);
          free(temp);
        }
        else  {
          printf("Decrypted data doesnt seems legit\n",outlen);
          temp = tohex(dec,length);
          printf("Decrypted data %s\n",temp);
          free(temp);
        }
      }
      values_do = 2;
      values_pad = pad_valid;
    }
    pthread_mutex_unlock(&mtx_values);
  }while(1);
  pthread_exit(NULL);
}
 
void crear_server()  {
  int s;
  pthread_t tid;
  pthread_attr_t attr;
  s = pthread_attr_init(&attr);
  if (s != 0)  {
    perror("pthread_attr_init");
    exit(6);
  }
  s = pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
  if(s != 0)  {
    perror("pthread_attr_setstacksize");
    exit(8);
  }
  s = pthread_create(&tid,&attr,process_server,NULL);
  if(s != 0)  {
    perror("pthread_create");
  }
  pthread_attr_destroy(&attr);
}
 
char *tohex(char *ptr,int length){
  char *buffer;
  int offset = 0;
  unsigned char c;
  buffer = (char *) malloc((length * 2)+1);
  for (int i = 0; i <length; i++) {
  c = ptr[i];
  sprintf((char*) (buffer + offset),"%.2x",c);
  offset+=2;
  }
  buffer[length*2] = 0;
  return buffer;
}
 
 
int MyCBCDecrypt(AES256_ctx *ctx, const unsigned char iv[AES_BLOCKSIZE], const unsigned char* data, int size, bool pad, unsigned char* out)
{
  int written = 0;
  bool fail = false;
  const unsigned char* prev = iv;
  if (!data || !size || !out)
    return 0;
  if (size % AES_BLOCKSIZE != 0)
    return 0;
  while (written != size) {
    AES256_decrypt(ctx, 1, out, data + written);
    for (int i = 0; i != AES_BLOCKSIZE; i++)
      *out++ ^= prev[i];
    prev = data + written;
    written += AES_BLOCKSIZE;
  }
  if (pad) {
    unsigned char padsize = *--out;
    fail = !padsize | (padsize > AES_BLOCKSIZE);
    padsize *= !fail;
    for (int i = AES_BLOCKSIZE; i != 0; i--)
      fail |= ((i > AES_BLOCKSIZE - padsize) & (*out-- != padsize));
    written -= padsize;
  }
  return written * !fail;
}
 
int MyCBCEncrypt(AES256_ctx *ctx, const unsigned char iv[AES_BLOCKSIZE], const unsigned char* data, int size, bool pad, unsigned char* out)
{
  int written = 0;
  int padsize = size % AES_BLOCKSIZE;
  unsigned char mixed[AES_BLOCKSIZE];
 
  if (!data || !size || !out)
    return 0;
 
  if (!pad && padsize != 0)
    return 0;
 
  memcpy(mixed, iv, AES_BLOCKSIZE);
 
  // Write all but the last block
  while (written + AES_BLOCKSIZE <= size) {
    for (int i = 0; i != AES_BLOCKSIZE; i++)
      mixed[i] ^= *data++;
    AES256_encrypt(ctx, 1, out + written, mixed);
    memcpy(mixed, out + written, AES_BLOCKSIZE);
    written += AES_BLOCKSIZE;
  }
  if (pad) {
    // For all that remains, pad each byte with the value of the remaining
    // space. If there is none, pad by a full block.
    for (int i = 0; i != padsize; i++)
      mixed[i] ^= *data++;
    for (int i = padsize; i != AES_BLOCKSIZE; i++)
      mixed[i] ^= AES_BLOCKSIZE - padsize;
    AES256_encrypt(ctx, 1, out + written, mixed);
    written += AES_BLOCKSIZE;
  }
  return written;
}
 

Saludos!

Como proteger una cartera Bitcoin

No sabemos qué pasará en el futuro, es decir no sabemos si nos robaran la cartera o la perderemos en algún USB y alguien la encontrara. Tampoco sabemos la cantidad de poder de computo que existira.

Pero además de tener cifrada nuestra cartera con un buen passphrase de más de 40 caracteres, se puede lograr una mejor seguridad, para en el caso de que sea robada sea inviable que por medio de fuerza bruta directo contra el passphrase.

Nuestra Cartera está protegida con el resultado de un hash sha512 derivado N veces a partir de nuestro Passphrase y un salt.

Es decir:


Normalmente el cliente bitcoin-core calcula ese N de tal forma que la Operación en total no lleve más de 1 Segundo

¿Por que? ¿Por que ponérsela fácil a los crackers de wallets?

Se puede editar el código fuente del bitcoin-core de tal forma que cuando nosotros cambiemos el passphrase este utilice un número N tal que N el proceso completo de PBKDF2_algo lleve al menos uno o dos minutos por passphare, es un pequeño precio de espera. Y el resultado será sumamente desalentador para quien se robe o encuentre la cartera.

¿Como hacer esta modificacion?

Si revisamos la versión estable y actual al dia de hoy, el bitcoin core 0.20 el archivo wallet.cpp tiene la solución:

https://github.com/bitcoin/bitcoin/blob/0.20/src/wallet/wallet.cpp En la linea 322 tenemos lo siguiente:

bool CWallet::ChangeWalletPassphrase(const SecureString& strOldWalletPassphrase, const SecureString& strNewWalletPassphrase)
{
    bool fWasLocked = IsLocked();
 
    {
        LOCK(cs_wallet);
        Lock();
 
        CCrypter crypter;
        CKeyingMaterial _vMasterKey;
        for (MasterKeyMap::value_type& pMasterKey : mapMasterKeys)
        {
            if(!crypter.SetKeyFromPassphrase(strOldWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod))
                return false;
            if (!crypter.Decrypt(pMasterKey.second.vchCryptedKey, _vMasterKey))
                return false;
            if (Unlock(_vMasterKey))
            {
                int64_t nStartTime = GetTimeMillis();
                crypter.SetKeyFromPassphrase(strNewWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod);
                pMasterKey.second.nDeriveIterations = static_cast<unsigned int>(pMasterKey.second.nDeriveIterations * (100 / ((double)(GetTimeMillis() - nStartTime))));
 
                nStartTime = GetTimeMillis();
                crypter.SetKeyFromPassphrase(strNewWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod);
                pMasterKey.second.nDeriveIterations = (pMasterKey.second.nDeriveIterations + static_cast<unsigned int>(pMasterKey.second.nDeriveIterations * 100 / ((double)(GetTimeMillis() - nStartTime)))) / 2;
 
                if (pMasterKey.second.nDeriveIterations < 25000)
                    pMasterKey.second.nDeriveIterations = 25000;
 
                WalletLogPrintf("Wallet passphrase changed to an nDeriveIterations of %i\n", pMasterKey.second.nDeriveIterations);
 
                if (!crypter.SetKeyFromPassphrase(strNewWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod))
                    return false;
                if (!crypter.Encrypt(_vMasterKey, pMasterKey.second.vchCryptedKey))
                    return false;
                WalletBatch(*database).WriteMasterKey(pMasterKey.first, pMasterKey.second);
                if (fWasLocked)
                    Lock();
                return true;
            }
        }
    }
 
    return false;
}

Y solo tendria que quedar de la siguiente manera:

bool CWallet::ChangeWalletPassphrase(const SecureString& strOldWalletPassphrase, const SecureString& strNewWalletPassphrase)
{
    bool fWasLocked = IsLocked();
 
    {
        LOCK(cs_wallet);
        Lock();
 
        CCrypter crypter;
        CKeyingMaterial _vMasterKey;
        for (MasterKeyMap::value_type& pMasterKey : mapMasterKeys)
        {
            if(!crypter.SetKeyFromPassphrase(strOldWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod))
                return false;
            if (!crypter.Decrypt(pMasterKey.second.vchCryptedKey, _vMasterKey))
                return false;
            if (Unlock(_vMasterKey))
            {
                pMasterKey.second.nDeriveIterations = 133707331;
 
                WalletLogPrintf("Wallet passphrase changed to an nDeriveIterations of %i\n", pMasterKey.second.nDeriveIterations);
 
                if (!crypter.SetKeyFromPassphrase(strNewWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod))
                    return false;
                if (!crypter.Encrypt(_vMasterKey, pMasterKey.second.vchCryptedKey))
                    return false;
                WalletBatch(*database).WriteMasterKey(pMasterKey.first, pMasterKey.second);
                if (fWasLocked)
                    Lock();
                return true;
            }
        }
    }
 
    return false;
}

Si quitamos todo lo relacionado con el calculo del tiempo y agregamos la linea:

pMasterKey.second.nDeriveIterations = 133707331;

En mi caso con el bitcoin-core oficial recompilado y con un procesador Intel Xeon CPU E3-1271 v3 @ 3.60GHz cambiar el passphrase toma alrededor de un minuto

Saludos!

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


"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


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á.


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.  

Resumen en pseudo codigo

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

prekey = PBKDF(passphrase,IV, N Iteraciones,"sha512");
memcpy(KEY,prekey,32);
memcpy(IV,prekey+32,16);
aesctx = AES256_init(KEY);
if( AES256CBC_decrypt(aesctx,IV,ENC_mKey,DEC_mKEY) > 0)	{
	foreach(OthersENC as oENC)	{
		oCtx = AES256_init(DEC_mKEY);
		if(!AES256CBC_decrypt(oCtx,IV_fromPublickey,oENC,dummy) > 0)	{
			return false;
		}
	}
	return true;
}

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

Anteriormente no me había fijado la salida del descifrado por AES 256 CBC con Pad habilitado.

Normalmente uno solo espera la data original descifrada, vamos que si ciframos la palabra "hola" esperamos de vuelta la misma palabra "hola" ya descifrada.

Cuando encriptas sin padding cada bloque del tamaño  "AES_BLOCKSIZE" devuelve la misma cantidad de bloques. Pero el cifrar con Padding agrega cierta cantidad mas de datos.

Por ejemplo si ciframos 32 bytes con AES256CBC con Padding nos devuelve un buffer con 48 bytes de data

Y cuando desciframos esos 48 bytes, nos devuelve la data original de 32 bytes + un buffer "sucio" es decir que hay mas datos en el buffer, en mi caso he comprobado que para este ejemplo siempre devuelve un buffer sucio de 16 bytes y cada uno de esos bytes tiene valor de uno.

Mi pregunta es ¿Es normal esto, o solo es la forma en la que trabaja la librería ctaes?

hice un programa que muestra que independientemente del key y del IV utilizados  siempre pasa lo mismo




De ser normal esto se podría tomar ese buffer sucio como una comprobación de que la key y el iv utilizados son los correctos?


Saludos

Publico este tema aquí, ya que no se en qué sección queda mejor publicarlo.

Estoy intentando extraer la información Cifrada de una cartera bitcoin, en específico la información del Key para posteriormente intentar descifrarlo por algún ataque de fuerza bruta.

Quiero extraerla por que no quiero depender del bitcoin core ya que si se realiza el ataque por fuerza bruta mediante algún script bash o algun otro metodo NO compilado, el ataque puede ser realmente ineficiente.

También quiero brincarme algunos pasos innecesarios de funciones tipo rehash o PBKDF2 (key derivation) ya que aunque no consumen mucho CPU si quitan algunos miles de ciclos de procesamiento que a la larga pueden hacer aun mas eterno el proceso de crackeo.

Segun he leido la informacion del Key cifrado el salt y el numero de iteraciones esta contenida en un campo de 64 bytes del wallet.dat llamado mkey.

Segun vi en el siguiente Link:


La data contiene los siguientes campos:

mkey, nID, encrypted_key, salt, derivation_method, derivation_rounds, other_derivation_parameters

mkey es solo el ascii "mkey", se que el encrypted_key debe de ser de 32 bytes y el salt de 16, restando solo 12 bytes para los otros datos, sin embargo no estoy seguro del orden de los mismos.

Si vemos la siguiente imagen:





Vemos que ahí esta la data, escribí un pequeño programa que la encuentra y la extrae, pero no se en que orden este, con ver los datos de esta cartera y otras me doy cuenta de algunos datos que pueden ser números como los primeros 8 bytes después del mkey, pueden ser números, al igual que los últimos 4 antes de ckey.

---

Edit

Solucionado el master key cifrado son 48 bytes que se encuentran a un offset de -72 bytes de la primera coincidencia del string mkey.

Para esta cartera en cuestión el Master Key Cifrado es:

CEC646179A7F947349A0AA99EC7122B01F72BF18FFA4FDC760635D8C13109DA196D3DC802D5AABB23FA6C6AABA9A1DBB

Saludos

Recientemente publique el tema:Como determina la función AES256CBCDecrypt una correcta desencriptación El cual esta relacionado con este de forma algo indirecta.

Todo esto viene del análisis que estoy realizando al código fuente del Bitcoin Core.

Hoy hablaré sobre la función BytesToKeySHA512AES la cual es una de las primeras que se utilizan cuando intentas desbloquear una cartera bitcoin protegida con un passphrase.

BytesToKeySHA512AES básicamente toma las passphrase ingresada + un salt proporcionado por el mismo archivo wallet.dat y los transforma en un (key, iv) para posteriormente utilizarlos como material para descifrar la llave cifrada.

El código fuente de BytesToKeySHA512AES, lo pueden encontrar en

 

Tiene 3 parámetros de entrada y 2 de salida
Entrada:
Salt
Passphrase
Count

Salida:
Key
IV

La parte interesante del código es la siguiente:

    for(int i = 0; i != count - 1; i++)
        di.Reset().Write(buf, sizeof(buf)).Finalize(buf);

Básicamente obtiene el hash sha512 de si mismo (count -1) veces ya la que primera vez fue el hash sha512 de (passphrase + IV) como muestra el siguiente código:

    di.Write((const unsigned char*)strKeyData.data(), strKeyData.size());
    di.Write(chSalt.data(), chSalt.size());
    di.Finalize(buf);

Posteriormente copia los primeros 32 bytes al Key y los siguientes 16 bytes al Vector IV

Si no están familiarizados con la sintaxis  del codigo anterior dejare un código en PHP ejemplificando lo que hace la función:

<?php
$salt = "BBBBBBBBBBBBBBBB";
$passphrase = "AAAAA";
$key_ ="";
$iv_ = "";
BytesToKeySHA512AES($salt ,$passphrase,2,$key_, $iv_ );
 
echo "Key:\n";
var_dump($key_);
echo "IV:\n";
var_dump($iv_);
 
function BytesToKeySHA512AES($chSalt,$strKeyData,$count,&$key,&$iv)	{
	$ctx = hash_init('sha512');
	hash_update($ctx,$strKeyData);
	hash_update($ctx,$chSalt);
	$buf = hash_final($ctx,true);
	$i = 0;
	while($i != $count -1)	{
 
		/* //Estas tres líneas básicamente se transforman en una simple llamada a hash
		$ctx = hash_init('sha512');
		hash_update($ctx,$buf);
		$buf = hash_final($ctx,true);
		*/
		$buf = hash('sha512',$buf,true);
		$i++;
	}
	echo "hash:\n";
	var_dump($buf);
	$key = mb_substr($buf,0,32);
	$iv = mb_substr($buf,32,16);
}
?>

Lo escribí en PHP ya que es mas fácil darle seguimiento a las funciones hash, solo que no estoy 100% seguro de como manejar las copia de los bytes del hash resultante al key y al IV respectivamente.

Saludos

Muy buena dia, estoy con una pequeña duda ya que estoy tratando de automatizar un proceso de crackeo por fuerza bruta de una key de 256 bits (Se que es improbable, sin embargo la clave esta ahi del 0 al 2^256)  

La función original recibe 2 parametros un un KeyCifrada, y el candidato a Key como segundo parametro:

Decrypt(KeyCifrada,KeyCandidato);

Dicha función realiza un llamado internamente a AES256CBCDecrypt



y si nLen es igual a 0 entonces retorna false indicando que Key Candidato no es un Key valido.

Mi duda es la siguiente como determina internamente AES256CBCDecrypt  que la KeyCandidato es valida.

Saludos

---

Edit
Platicando con Kub0x me corrigio el KeyCandidato no es parámetro de entrada si no de salida

Si vemos el link

en la linea 112 hay se muestra que las comprobaciones las hace directamente sobre el texto descifrado y si alguna de ellas no pasa simplemente regresa 0.

Me comenta kub0x que  existen varios valores Key y IV de entrada que podrian dar una salida valida, siendo esto un falso positivo, sin embargo me gustaría investigar cuantas veces pasa eso en realidad.

Saludos

---

Edit 2
Tal como menciono Kub0x, el proceso arroja muchos falsos positivos.

Programe un programa multihilo para crackear un key


Con solo 4 Hilos y solo probando 1554 hashes random me dio 4 resultados que la función AES256CBCDecrypt considera válidos, pense que serian mucho menos el ratio de falsos positivos, pero asi no me da tiempo de probarlos manualmente, tendrás que optimizar ese proceso también.

Muy buenos días compañeros.

Por algun momento pense en colar el titulo de "ayuda mi programa se cierra sin motivo", pero no es demasiado genérico y solo un novato lo haría

Quiero explorar los diversos motivos por los que un programa en C se cierra. De momento vienen a mi mente los siguientes motivos:

• llamaa explicita a exit o variantes
• bufferoverflow y variantes de segment fault
• NULL pointer... (parecido al anterior)
• No poder asignar mas memoria
• No poder crear mas threads

Algunos son salidas explícitamente programadas y otras son por bugs.

Tengo un proyecto en C, es un servidor WEB multihilo:

https://github.com/albertobsd/chttpserv

De momento funciona bien cuando hago peticiones mediante  curl incluso soporta un ciclo sin fin de peticiones:

while true; do curl -i http://localhost:3002/ ; done

Sin embargo cuando le hago las peticiones desde cualquier otro navegador que procese todos los archivos y CIERRO el navegador a media carga el programa simplemente se sale sin mensaje de error.

OJO que solo es cuando cierro a media carga, si espero a que termine de cargar la pagina por completo esto no sucede.

Consideraciones:

• Estoy totalmente seguro de que la mayoría de las funciones que pueden dar error están correctamente procesadas y muestran el error correspondiente:

		s = pthread_create(&tid,&attr,thread_process,(void *)tothread);
		if(s != 0)	{
			perror("pthread_create");
		}
 

• Todas las funciones de lectura y escritura en el socket se valida si leyeron o escribieron los datos y no devolvio error:

	while(sended >= 0  && readed >= 0 && !feof(fd)  )	{
			readed = fread(buffer,1,128,fd);
			if(readed > 0)
				sended = send(hsc->client_fd,buffer,readed,0);
		}
		if(sended ==  -1)	{
			perror("send");
		}
		if(readed == -1)	{
			perror("fread");
		}
 

• También estoy seguro que no es un problema de memoria ya que tengo una libreria propia con la que me he asegurado tras varias pruebas de que todos los apuntadores asignados con malloc/calloc son liberados y no se vuelven a utilizar, ademas de indicarme la cantidad de memoria dinamica actualmente utilizada.
• De igual manera todos los sockets son cerrados mediante:

	shutdown(hsc->client_fd,SHUT_RDWR);
	close(hsc->client_fd);

Se que el problema tiene que ver con Sockets ya que solo cuando cierro el navegador a media carga el programa termina.

Me he quedado un poco estancado, ya que siento que no avanzo si no soluciono ese error.

No les pido que depuren mi codigo, ya que no esta 100% documentado.

Pregunto: ¿Alguien a tenido el mismo problema?, ¿Que otros motivos hacen que el programa se cierre y no caiga error en ninguna función?

Saludos

Seguramente muchos de ustedes han visto esos códigos javascript Semiofucados ejemplo:

!function(a){function k(k){for(var n,a,f=k[0],d=k[1],u=k[2],l=0,b=[];l<f.length;l++)o[a=f[l]]&&b.push(o[a][0])
....

Y asi le sigue por unos cuantos Kilobytes de codigo minificado.

Entonces esa es la pregunta, cual es la mejor forma de depurar que es lo que esta haciendo, pregunto por que javascript es bastante permisivo con la sintaxis.

Obvio primer paso:
-- Utilizar alguna de esas paginas para que el código se vea indentado y tabulado

Saludos!