Quisiera abrir el siguiente hilo para saber si es posible determinar la paridad de un punto en una curva Eliptica utilizada en criptografía.

Encontré un video en youtube donde un programador de C# afirma tener la formula para determinar si un punto dado es par o impar para una curva en especifico.

Tiene una pagina

:http://remon78eg.tk/curve/mod2/

Utiliza un valor P custom: 115792089237316195423570985008687907853269984665640564039457584007908834675927

El cual afirma que es un valor débil o vulnerable.

El usuario no revela mucho de su método o test de paridad de un punto o publickey.

Las preguntas aquí son las siguientes:
¿Qué tiene de débil o vulnerable su orden de la curva?
¿Cuál seria el test de paridad que se pueda implementar para determinar si un punto (X,Y) pertenece a una privatekey par o impar?

Saludos!

TL:TR

El balance actual de los desafios 969 Bitcoin (29 Millones USD a la fecha de hoy 16 de Abril 2023).

Numero total de desafios es de 160 de los cuales ya fueron reclamados 76 quedando pendiente 84, la dificultad de los mismos es exponencial y cada desafio es el doble de dificl que el anterior.

Link con la informacion de todos los desafios:

https://docs.google.com/spreadsheets/d/1vZyRZ67iNl7aIwYNB55OY8LvZLAaoBxSanxqnGMZlWA/edit?usp=sharing

---

Lista de rompecabezas al final:

Muy buen día a todos últimamente hablando con Kub0x sobre curvas elípticas me sugirió publicar aquí los rompecabezas existentes de bitcoin, hay aproximadamente 12 bitcoin en premios. Para los rompecabezas Importantes y algunos otros bitcoin para rompecabezas pequeños.

Los rompecabezas se puede abordar de varias formas, pero abordarlos por fuerza bruta es casi imposible a no ser que tengan mucha mucha mucha suerte (El tema de Fuerza bruta exclusiva no va a ser tratado aqui).

Estos rompecabezas fueron hechos con el propósito explicito de ser crackeados desde el 2015 y en caso de conseguirlo pueden tomar el bitcoin de premio que se encuentra ahi, ya que el autor para eso los creo, fueron creados cuando el bitcoin se cambiaba por  160 Dolares cada uno, hoy en dia cuesta cada uno mas de 40 Mil dólares

A continuación los rompecabezas en el siguiente formato:

Puzzles:



Para quienes piensen  abordar el puzzle por fuerza bruta, estos son mas o menos los tiempos estimados para escanear el rango completo de acuerdo a la velocidad conseguida:


Si tienen alguna duda favor de comentarla en este hilo.

He creado un canal privado de Telegram, si alguno gusta discutir el tema ahí, favor de enviarme mensaje privado a https://t.me/albertobsd y si lo considero oportuno los agregare al grupo.

---

Take Bobby's Bitcoin

WEB:

Estos son 2 Desafios

#1
Wallet con 1.0 BTC
Public Address: 1JxWyNrkgYvgsHu8hVQZqTXEB9RftRGP5m
Private Key: 6PnQmAyBky9ZXJyZBv9QSGRUXkKh9HfnVsZWPn4YtcwoKy5vufUgfA3Ld7
BIP-38 Passphrase: ???

#2
Wallet con 1.0 BTC
Public Address: 1QGtbKxx6FKDD66LwnrzHCAHmyZ7mDHqC4
Private Key: ???
BIP-38 Passphrase: 594Y-L2RW-4ME7-2XVX-9B41
BIP-38 Confirmation Code: cfrm38VUh2i5qzzCqedWtc8ekFxT3UpcQnfb42JRrLbTWCRTfgVTCXqLp3FYxqiyQDo4D3DyWzY


Bitcoin Challenge Transaction

Transaccion: https://www.blockchain.com/es/btc/tx/08389f34c98c606322740c0be6a7125d9860bb8d5cb182c02f98461e5fa6cd15


El balance total restante es de 98.74 Bitcoin, las direcciones son:



Saludos!

Ok, veamos necesito una forma eficiente de ordenar un archivo de de 100 GB, Cada registro del archivo son 36 Bytes en binario.

Usualmente lo hacia con archivos pequeños 10 o 5 GB pero en RAM. Esto con el algoritmo Introsort y es bastante eficiente, pero ahora estoy utilizando el mismo método pero en Disco duro ya que el archivo es muy grande, Lo que estoy haciendo es leer los registros del disco, cargarlos en memoria, compararlos y escribir en disco en caso de que necesiten ser ordenados. Este proceso es muy lento directo en el disco duro.

Podría tratar de dividir el proceso he ir cargando de 10 en 10 GB en RAM u otra cantidad ordenarlos en memoria y seguir con los demás pedazos, sin embargo el problema es ordenar entre pedazos separados.

El proceso de generación de registros es aleatorio y no se en que orden se generaran los registros, quiero hacer este proceso lo mas eficiente y rápido posible, ya que si funciona este archivo tendré que generar un archivo similar de 500 o 1000 GB. No tengo problemas de Espacio en disco.

¿Alguna idea adicional a hacerlo directo desde el disco duro?

---

Edit:

Ayer miestras publicaba este teme tambien pense en la solucion, pero no queria publicarla hasta implementarla.

Dado que la generación de los registros es aleatoria y es uniforme entre el rango de A a B entonces se me ocurre que una vez generado el archivo de 100 GB, dividir el rango de A a B en subrangos manejables en RAM
por decil algo tengo los siguientes rangos para registros de 32 bytes:


Entonces buscamos en el archivo los valores que entren en alguno de los rango anteriores, se ordenan en RAM y se escriben en un archivo aparte. Una vez completado el proceso para todos los sub-rangos se unen los archivos en uno solo y se borra el archivo desordenado.

Esto se puede hacer así debido a que la distribución de los registros es uniforme en el rango original de A a B, en caso de que la data este sesgada y existan mas valores en un sub-rango dado es conveniente poner un limite de cantidad de registros leídos para que el mismo no sobrepase la cantidad de RAM.

Saludos!

Pues nada compañeros esta próxima semana cumplo 15 años registrado en el foro.

Yo se que tengo mas años viendo el foro, sin embargo hasta ese momento abrí mi cuenta.

Quiero agradecer a todos los miembros de este foro, a los que ya no están y a los que aun siguen. En este foro he aprendido mucho, de muchos temas distintos, aunque sea un poco de todo, estoy muy agradecido.

Desde ya muchas GRACIAS

Saludos!

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