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


 


Tema destacado: Análisis del vídeo del hackeo al Sindicato de los Mossos de Esquadra


  Mostrar Temas
Páginas: [1]
1  Programación / Programación C/C++ / Programador C ++ en: 16 Junio 2020, 16:32
Necesitamos un programador de C ++.
Para trabajar con la reversión de viejos programas.
Juegos retro.
Requisito, programar bien, solo con C ++.
Contáctame en privado, los interesados.
Saludos.



2  Programación / Ingeniería Inversa / Necesitamos revertir el código Intel HEX. en: 27 Marzo 2020, 02:17
Necesito recuperar una función de este binario.
¡Esto es muy antiguo y no funciona en PC!
Esto actualmente no tiene dueño!
Hay una muy buena recompensa para quienes resuelven.

Código C. https://mega.nz/#!P9MA0aTA!H7clkfY15i-VEE3SgyhN6gy1GPZDuUyruHU9e7iI4Ks

La función es un keygen
733013600 => 1870603295
394246093 => 1140865507 
811144690 => 1265428534
Resumen de la misión: encontrar la función que produce las contraseñas de ejemplo.
Quién tener verdadero interés me advierte, envíe binario.


Saludos.
3  Programación / Ingeniería Inversa / Unpack Themida & WinLicense 2.0 en: 9 Octubre 2019, 13:14
Hola, ¿alguien ha tenido éxito con esto?

Hay scripts ollydbg para Windows XP.
Pero nada me funciona.

Toda ayuda es bienvenida!
Saludos.
4  Programación / Ingeniería Inversa / Dongle Eutron HID. en: 5 Octubre 2019, 16:59
Hola, sobre emulación dongles Eutron HID.

El caso es que no puedo descomprimir y eliminar el dongle de la aplicación.
Lo he hecho varias veces, pero en este caso no es factible.
Entonces, me pregunto si alguien puede ayudarme a emular, traté de adaptarme en el kit no hid, PID 25, pero no funcionó.
Me parece que PID 26 ha actualizado sus rutinas de cifrado y esas cosas.
No quiero necesitar descompilar un controlador para arreglar rutinas.
Esa sería la última opción.

¡Finalmente, toda ayuda será apreciada!
Saludos.


5  Programación / Ingeniería Inversa / ID do usuário rockey4ND en: 31 Agosto 2017, 16:13
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
6  Programación / Ingeniería Inversa / Instrucción   Push 18h, sysenter en: 24 Agosto 2017, 17:01
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?

7  Programación / Ingeniería Inversa / descifrar texto en: 22 Agosto 2017, 18:08
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
8  Programación / Ingeniería Inversa / Modificación de contraseña para Rockey4nd en: 4 Agosto 2017, 17:38
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
9  Programación / Ingeniería Inversa / Habilitar Menu en: 2 Junio 2017, 05:03
Hola.

Tengo un programa donde Demo está deshabilitado el menú de abrir y guardar documentos.

Es posible habilitar, tal vez en un editor hexa?
Dice Nasm / Tasm sin embargo creo que es firma falta, probable ser Delphi.



¿Alguna idea amigos ?
Toda la ayuda es bienvenido.
10  Programación / Ingeniería Inversa / Dongle Neokey en: 30 Mayo 2017, 19:12
Ola

¿Alguien con experiencia en Cracking dongle Neokey?
Mejor camino, crear nuevo dll, eliminar llamadas?

: No tengo el dongle

Todo el apoyo es bienvenido. Saludos
Páginas: [1]
Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines