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

 

 


Tema destacado: Entrar al Canal Oficial Telegram de elhacker.net


  Mostrar Mensajes
Páginas: 1 2 3 4 5 6 [7] 8
61  Programación / Ingeniería Inversa / Re: Trimble RealWorks en: 1 Octubre 2019, 16:38 pm
Hola, creo que encuentras todo lo que tienes que hacer aquí en el foro.

Saludos.
62  Programación / Ingeniería Inversa / Re: dudas con ida pro en: 31 Agosto 2017, 21:53 pm
Siempre he trabajado con DBG64, ahora con mucha dificultad para remendar con IDA
Mis búsquedas llevan al, DIFF, guardar un Diff en el IDA y luego con herramienta externa de reparación.


aqui : https://github.com/iphelix/ida-patcher
63  Programación / Ingeniería Inversa / ID do usuário rockey4ND en: 31 Agosto 2017, 16:13 pm
ID de usuario rockey4ND

   Saludos

   ¿Alguien sabe cómo editar el user-id del dongle Rockey4ND para que sea válido para la fecha actual?

   He investigado mucho, y no he encontrado respuesta.


Gracias


*Tal vez he creado muchos temas, sin respuesta.
Cuando solucionar, promover compartir todos
64  Programación / Ingeniería Inversa / Re: Smart Card Chip Sim Utilizado en Impresoras Industriales en: 30 Agosto 2017, 22:29 pm
¿Tienes una foto del chip?
65  Programación / Ingeniería Inversa / Re: Instrucción   Push 18h, sysenter en: 24 Agosto 2017, 17:20 pm
tienes razón

Cuando se abre en el depurador

"$ Jhksdvjsfoiut9085-0t598gdsfgipoei-0fgb9dfk; l-hk0dgkhrlthkry; hyhk '
'Pokhprooh, q $', 0Ah, 0


'$ Welkgptrgoee-09kglsgm, ogisdg09rltgk-s0df9hrdskgj09dfgdsfuihg09et'
', Ldfkbdd $', 0Ah, 0

Después como en la foto

¿Cómo podemos tomar en texto puro?
66  Programación / Ingeniería Inversa / Instrucción   Push 18h, sysenter en: 24 Agosto 2017, 17:01 pm
Instrucción push 18h

En la depuración muchas cosas sucede y no puedo seguir.

Primero la instrucción push 18h
Después se pasan varias funciones
Por fin instrucción "sysenter"


¿Alguien esta familiarizado con estas instrucciones?
  Push 18h, sysenter

En Linux, binario ELF, quiero descifrar la clave AES 256, esta cifrada u ofuscada o sólo están en caracteres no imprimibles.

https://1drv.ms/i/s!Arl6LH9pZckyjU4r3yIe5uTztUwj

Lo que esta en la foto debería ser este formato

"\x93\xBB\x69\xDF\x37\xD5\x38\x57\xB8\x6B\x20\xE1\x45\xCB\xA0\x61\xDD\x7D\xCF\xED\x3A\xAC\xF2\xDB\x29\x35\x91\x6C\x27\x66\x0B\xAF"

Un apoyo?

67  Programación / Ingeniería Inversa / descifrar texto en: 22 Agosto 2017, 18:08 pm
Hola a todos

Tengo un gran desafío en la mano

  A continuación, resolví LuksCrypto en Linux, puedo montar el volumen protegido, he descompilado código con éxito.

Pero en la descompilación es de ELF binario para C, y no entiendo mucho C.


Necesito encontrar rutina cifra descifra un contenido de dongle rockey4nd.

FF 02 30 E4 56 9A 8A DF F1 0F 6B 9D A8 16 F7 3B 3B DD 7C 88 E9 3A 86 7E 06 EF E3 CE
C2 4E 0A 5C 1B 1A EF 1E C6 3A 45 86 54 F8 8D AC 4A 19 D3 D8 C3 8C 00 00 00 00 00 00 00

The AES key was encrypted
en vez de

256 bits:
Sal = 263BC60258FF4876
Chave = B374A26A71490437AA024E4FADD5B497FDFF1A8EA6FF12F6FB65AF2720B59CCF
Iv = 7E892875A52C59A3B588306B13C31FBD

esta .
'$jhksdvjsfoiut9085-0t598gdsfgipoei-0fgb9dfk;l-hk0dgkhrlthkry;hyhk'
'pokhprooh,q$',0Ah,0

'$welkgptrgoee-09kglsgm,ogisdg09rltgk-s0df9hrdskgj09dfgdsfuihg09et'

';ldfkbdd$',0Ah,0



Encontré una región muy sospechosa.

Parece estar leyendo un archivo, y usando el cifrado.

¿Sera justamente la memoria dongle?

¿Algún amigo me da una idea?

i
Código
  1. nt32_t function_8048c80(int32_t path, int32_t a2, void (**a3)(int32_t)) {
  2.    char * exec_argv[1]; // 0x8049002
  3.    char * envp[1]; // 0x8049002
  4.    int32_t v1;
  5.    char v2 = v1; // bp-224
  6.    int32_t v3 = *(int32_t *)20; // 0x8048ca4
  7.    int32_t result; // 0x804906e
  8.    if (path == 0) {
  9.        // 0x8049030
  10.        // branch -> 0x804900a
  11.        // 0x804900a
  12.        if (*(int32_t *)20 == v3) {
  13.            // 0x804901a
  14.            return -1;
  15.        }
  16.        // 0x8049056
  17.        __stack_chk_fail();
  18.        // branch -> 0x804905b
  19.        // 0x804905b
  20.        usleep(10);
  21.        result = shm_unlink((char *)&g30);
  22.        _exit(0);
  23.        return result;
  24.    }
  25.    // 0x8048cbe
  26.    signal(SIGINT, (void (**)(int32_t))function_8048c60);
  27.    signal(SIGTERM, (void (**)(int32_t))function_8048c60);
  28.    signal(SIGKILL, (void (**)(int32_t))function_8048c60);
  29.    signal(SIGQUIT, (void (**)(int32_t))function_8048c60);
  30.    signal(SIGSTOP, 0x8048c30);
  31.    int32_t fd = open((char *)path, O_RDONLY);
  32.    g2 = fd;
  33.    if (fd >= 0) {
  34.        // 0x8048d3c
  35.        int32_t v4;
  36.        __fxstat(3, fd, (struct stat *)&v4);
  37.        uint32_t v5;
  38.        if (v5 >= 29) {
  39.            // 0x8048d61
  40.            g3 = &v2;
  41.            lseek(g2, v5 - 29, SEEK_SET);
  42.            if (read(g2, (char *)g3, 29) == 29) {
  43.                // 0x8048d9c
  44.                if (function_8048b90((char *)g3, 0) == 0) {
  45.                    // 0x8048db4
  46.                    if (v2 == 1) {
  47.                        int32_t v6 = -0x5050506;
  48.                        int32_t offset;
  49.                        lseek(g2, offset, SEEK_SET);
  50.                        int32_t buf = 0;
  51.                        if (read(g2, (char *)&buf, 4) == 4) {
  52.                            int32_t v7 = &v6; // ebx
  53.                            int32_t v8;
  54.                            int32_t v9 = &v8; // 0x8048e69_0
  55.                            srandom(buf);
  56.                            *(char *)v7 = (char)random();
  57.                            int32_t v10 = v7 + 1; // 0x8048e7f
  58.                            v7 = v10;
  59.                            // branch -> 0x8048e78
  60.                            while (v10 != v9) {
  61.                                // 0x8048e78
  62.                                *(char *)v7 = (char)random();
  63.                                v10 = v7 + 1;
  64.                                v7 = v10;
  65.                                // continue -> 0x8048e78
  66.                            }
  67.                            int32_t v11 = random(); // 0x8048e86
  68.                            __sprintf_chk((char *)&g30, 1, 32, "ep-%ud", v11);
  69.                            uint32_t fd2 = shm_open((char *)&g30, 578, S_IRWXU); // 0x8048eca
  70.                            if (fd2 >= 0) {
  71.                                // 0x8048edb
  72.                                int32_t offset2;
  73.                                int32_t v12 = g7 - offset2; // 0x8048edb
  74.                                v7 = v12 - 29;
  75.                                if (ftruncate(fd2, v12 + 3) < 0) {
  76.                                    // 0x8049030
  77.                                    // branch -> 0x804900a
  78.                                    // 0x804900a
  79.                                    if (*(int32_t *)20 == v3) {
  80.                                        // 0x804901a
  81.                                        return -1;
  82.                                    }
  83.                                    // 0x8049056
  84.                                    __stack_chk_fail();
  85.                                    // branch -> 0x804905b
  86.                                    // 0x804905b
  87.                                    usleep(10);
  88.                                    result = shm_unlink((char *)&g30);
  89.                                    _exit(0);
  90.                                    return result;
  91.                                }
  92.                                // 0x8048f00
  93.                                lseek(g2, offset2, SEEK_SET);
  94.                                int32_t v13 = v7; // 0x8048f25
  95.                                if (v7 < 0) {
  96.                                    // if_8048f20_0_true
  97.                                    v13 = v12 - 14;
  98.                                    // branch -> after_if_8048f20_0
  99.                                }
  100.                                // after_if_8048f20_0
  101.                                g7 = 0;
  102.                                g3 = v9;
  103.                                int32_t fd3; // 0x8048fd6
  104.                                int32_t v14; // 0x8048fdf
  105.                                int32_t result2; // 0x8049024_2
  106.                                int32_t v15;
  107.                                if (v13 < 16) {
  108.                                    // 0x8048fab
  109.                                    close(g2);
  110.                                    close(fd2);
  111.                                    fd3 = shm_open((char *)&g30, O_RDONLY, S_IRWXU);
  112.                                    v14 = vfork();
  113.                                    if (v14 < 0) {
  114.                                        // 0x8049037
  115.                                        close(fd3);
  116.                                        shm_unlink((char *)&g30);
  117.                                        result2 = -1;
  118.                                        // branch -> 0x804900a
  119.                                    } else {
  120.                                        // 0x8048fe9
  121.                                        if (v14 == 0) {
  122.                                            // 0x804905b
  123.                                            usleep(10);
  124.                                            result = shm_unlink((char *)&g30);
  125.                                            _exit(0);
  126.                                            return result;
  127.                                        }
  128.                                        // 0x8048feb
  129.                                        exec_argv[0] = (char *)a3;
  130.                                        envp[0] = (char *)v15;
  131.                                        result2 = fexecve(fd3, exec_argv, envp) / 256 % 256;
  132.                                        // branch -> 0x804900a
  133.                                    }
  134.                                    // 0x804900a
  135.                                    if (*(int32_t *)20 == v3) {
  136.                                        // 0x804901a
  137.                                        return result2;
  138.                                    }
  139.                                    // 0x8049056
  140.                                    __stack_chk_fail();
  141.                                    // branch -> 0x804905b
  142.                                    // 0x804905b
  143.                                    usleep(10);
  144.                                    result = shm_unlink((char *)&g30);
  145.                                    _exit(0);
  146.                                    return result;
  147.                                }
  148.                                // 0x8048f40
  149.                                // branch -> 0x8048f40
  150.                                while (true) {
  151.                                    // 0x8048f40
  152.                                    g5 = v9;
  153.                                    memset((char *)&v8, 0, 32);
  154.                                    if (read(g2, (char *)g3, 16) >= 1) {
  155.                                        int32_t * v16 = (int32_t *)g3;
  156.                                        function_8049080(v16, v16, 16, (char *)&v6, 0);
  157.                                        write(fd2, (char *)g3, 16);
  158.                                        // branch -> 0x8048fa2
  159.                                    }
  160.                                    int32_t v17 = g7 + 1; // 0x8048fa2
  161.                                    g7 = v17;
  162.                                    if (v17 == v13 / 16) {
  163.                                        // break -> 0x8048fab
  164.                                        break;
  165.                                    }
  166.                                    // continue -> 0x8048f40
  167.                                }
  168.                                // 0x8048fab
  169.                                close(g2);
  170.                                close(fd2);
  171.                                fd3 = shm_open((char *)&g30, O_RDONLY, S_IRWXU);
  172.                                v14 = vfork();
  173.                                if (v14 < 0) {
  174.                                    // 0x8049037
  175.                                    close(fd3);
  176.                                    shm_unlink((char *)&g30);
  177.                                    result2 = -1;
  178.                                    // branch -> 0x804900a
  179.                                } else {
  180.                                    // 0x8048fe9
  181.                                    if (v14 == 0) {
  182.                                        // 0x804905b
  183.                                        usleep(10);
  184.                                        result = shm_unlink((char *)&g30);
  185.                                        _exit(0);
  186.                                        return result;
  187.                                    }
  188.                                    // 0x8048feb
  189.                                    exec_argv[0] = (char *)a3;
  190.                                    envp[0] = (char *)v15;
  191.                                    result2 = fexecve(fd3, exec_argv, envp) / 256 % 256;
  192.                                    // branch -> 0x804900a
  193.                                }
  194.                                // 0x804900a
  195.                                if (*(int32_t *)20 == v3) {
  196.                                    // 0x804901a
  197.                                    return result2;
  198.                                }
  199.                                // 0x8049056
  200.                                __stack_chk_fail();
  201.                                // branch -> 0x804905b
  202.                                // 0x804905b
  203.                                usleep(10);
  204.                                result = shm_unlink((char *)&g30);
  205.                                _exit(0);
  206.                                return result;
  207.                            }
  208.                        }
  209.                    }
  210.                }
  211.            }
  212.        }
  213.        // 0x8049028
  214.        close(g2);
  215.        // branch -> 0x8049030
  216.    }
  217.    // 0x8049030
  218.    // branch -> 0x804900a
  219.    // 0x804900a
  220.    if (*(int32_t *)20 == v3) {
  221.        // 0x804901a
  222.        return -1;
  223.    }
  224.    // 0x8049056
  225.    __stack_chk_fail();
  226.    // branch -> 0x804905b
  227.    // 0x804905b
  228.    usleep(10);
  229.    result = shm_unlink((char *)&g30);
  230.    _exit(0);
  231.    return result;
  232. }
  233.  
  234.  

Los códigos deben ir en etiquetas GeSHi
68  Programación / Ingeniería Inversa / Re: Ayuda con ollyDbg en: 6 Agosto 2017, 20:07 pm
Qual linguagem ?
69  Programación / Ingeniería Inversa / Modificación de contraseña para Rockey4nd en: 4 Agosto 2017, 17:38 pm
Hola amigos

    Necesito un apoyo.

   ¿Alguien sabe cómo utilizar las herramientas de modificación de contraseña para Rockey4nd?

Estoy tratando de utilizar las herramientas pero siempre del error de contraseñas básicas después, ya estropeado las contraseñas de 6 dongle :)

Gracias por cualquier ayuda

Saludos
70  Programación / Ingeniería Inversa / Re: Emular/Clonar mochila Sentinel Superpro/ultrapro en: 2 Agosto 2017, 20:19 pm
Hola.

Envíame el Dump y enlace para descargar el software, voy a intentar hacer para ti
Páginas: 1 2 3 4 5 6 [7] 8
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines