Menú

Mostrar Mensajes

Esta sección te permite ver todos los mensajes escritos por este usuario. Ten en cuenta que sólo puedes ver los mensajes escritos en zonas a las que tienes acceso en este momento.

Mostrar Mensajes Menú

Mensajes - AlbertoBSD

#101
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.




    [youtube=640,360]https://www.youtube.com/watch?v=GTl4ytJ3jBU[/youtube]

    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!
#102
Seguridad / Re: ¿cómo detectar escaneos en mi red?
20 Noviembre 2020, 04:48 AM
Lo ideal seria instalar un sistema Tipo IDS, como SNORT para ver el trafico en bruto o cargarle reglas tal que te avise quien como cuando y donde del escaneo.

Saludos!
#103
Cita de: B€T€B€ en 19 Noviembre 2020, 01:34 AM
por no hablar de que los resultados son increíbles.


B€T€B€ Eres tu el cliente del video?

Si yo tuviera en mi casa un servicio de fibra óptica, si considera ese tipo de instalación.

Pero donde vivo no hay fibra :(, solo tengo Internet por 4G y con velocidad limitada :(

Saludos!
#104
Seguridad / Re: Como proteger una cartera Bitcoin
19 Noviembre 2020, 01:18 AM
Cita de: B€T€B€ en 19 Noviembre 2020, 00:24 AM
Consérvala como oro en paño; el Bitcoin se está disparando.

Así es, la verdad en momento quería invertir pero también sonaban y siguen sonando muchas noticias de estafas por internet con respecto a comprar bitcoin, muchos sitios hackeados incluso hace 9 años. Me arrepiento de no haberlo hecho, pero ni modo ya pasó.

Saludos!

#105
Seguridad / Re: Como proteger una cartera Bitcoin
18 Noviembre 2020, 19:13 PM
Cita de: el-brujo en 18 Noviembre 2020, 16:57 PM
AlbertoBSD Muy bueno. La billetera 1HQ3Go3ggs8pFnXuHVHRytPCq5fGG8Hbhx no sería tuya?  :silbar:

No ya quisiera si hubiese sido mía la hubiera protegido mejor desde el principio.

Mi cartera es la siguiente: 1H3TAVNZFZfiLUp9o9E93oTVY9WgYZ5knX

Lamentablemente yo me interese en este tema tan solo semana y media antes de que dejaran en ceros la cartera mencionada, no me dio oportunidad de intentar crackearla con mi metodo directo al KEY AES256, es decir omitiendo el KeyDerivation.

He hecho un video explicando los métodos de ataque y mostrando como la edición del nDeriveIterations hace totalmente inviable los métodos por fuerza bruta.
[youtube=640,360]https://www.youtube.com/watch?v=PAcf-3vMGzQ[/youtube]

Saludos!
#106
Yo en lo personal nunca delegaba el trabajo a herramientas del sistema y nunca las llamaría por "system(......)" y aunque ese código posiblemente funcione es ineficiente.

void arrancarPing(const char* ip)
{
   char command[255] = {0};

   sprintf(command, "ping %s > ping2.txt", ip);
   system(command);
}


Es de lo más ineficiente que existe. Mi recomendación es que no utilices ese código, ya que te cierra la mente a otras posibilidades.

Yo en lo personal dependiendo del sistema operativo buscaría la librería exacta de mi sistema para realizar ping de forma nativa, es decir buscaría como generar paquetes ICMP directamente desde código fuente.

En windows

https://docs.microsoft.com/en-us/windows/win32/api/icmpapi/nf-icmpapi-icmpsendecho

En linux:

https://www.geeksforgeeks.org/ping-in-c/

FreeBSD

https://github.com/freebsd/freebsd/blob/master/sbin/ping/ping.c


Esto te sirve mucho por que aprendes a programar para un sistema u otro y también sirve por que aprenderias como funciona el protocolo ICMP.

Saludos!
#107
Programación C/C++ / Re: Linked List
18 Noviembre 2020, 04:52 AM
De que, siempre que tengas problemas con este tipo de estructuras utiliza algun diagrama para validar lo que estás haciendo, ayuda muchísimo.

Saludos!
#108
Programación C/C++ / Re: Linked List
18 Noviembre 2020, 04:31 AM
El problema que tienes es el siguiente, imagina que tienes una lista como la que sigue

[1]->[2]->[3]->[4]

Y quieres insertar uno nuevo después de [1] efectivamente después de [1] estas insertando un [5] pero a [5] nunca le dices que el Next es [2] y por lo tanto se pierde el "Link" que tenían y deja de ser linked list...

Espero que con eso veas como solucionarlo.

Los pasos son, guardar el next después de [1] y agregarlo al elemento que acabas de agregar en este caso seria [5]->next = [2]


Saludos!
#109
Programación C/C++ / Re: Linked List
18 Noviembre 2020, 04:08 AM
Cita de: michellcrh en 18 Noviembre 2020, 03:57 AM
pero los elementos que estaban después ya no los imprime.

void insertAfter(int llave, int dato) {
    struct node *l,*t;


     if (start == NULL) { // Primera vez
      start = t;//t en este punto no esta inicializado a nada.

#110
Programación C/C++ / Re: Linked List
18 Noviembre 2020, 03:48 AM
Pues claro que no lo puedes generar por que esta vacía esa función.

void insertAfter(int llave, int dato) {

}


Llevas algo de ese parte ?