Muy buena iniciativa Suerte a los participantes

Respiro hondo y me preparo para escribir sobre el que como muchos sabréis fue mi primer lenguaje.

En mi opinión aprender un lenguaje te enriquece sea el que sea. No importa lo poco popular o antiguo que sea. Cada lenguaje te enseña una forma distinta de indicarle a la máquina qué hacer. Cada lenguaje tiene sus particularidades y aprenderlas te abrirá la mente.

Un lenguaje de programación no es más que una herramienta para resolver un problema.
Seleccionar la apropiada depende de ti. Es por eso que no aprender un lenguaje es perder la oportunidad de tener una herramienta extra en tu arsenal.

---

Hablando particularmente sobre VB6:
{Aclaro que me refiero a la experiencia de programar usando el compilador de MS. Si hablase únicamente sobre el lenguaje me atendría a la sintaxis y la especificación del mismo.}

Tiene una curva de aprendizaje excelente. Basta abrir el IDE arrastrar un par de controles, hacer doble click en ellos y estar listo para programar en un evento.
Las capas de abstracción que otorga son muy útiles para nuevos desarrolladores pero todo eso tiene un coste; te acostumbra a lo fácil.

La peor parte con diferencia es lo mal que ha envejecido el compilador. Es seguramente el compilador más estúpido que se esté utilizando hoy en día. Incapaz de realizar las optimizaciones más simples y limitando el acceso al programador avanzado a características internas de la implementación. En mi opinión un compilador moderno debe de tener un backend en LLVM o como mínimo permitir sacar ensamblados.

Para finalizar mi mensaje añadiré que si bien creo que conocer el lenguaje, ser capaz de leerlo no hará daño a nadie y otorgará una herramienta de desarrollo rápido, no creo que nadie deba usar VB6 como su lenguaje principal. Pero otra vez, todo depende del problema y el uso que vayas a darle.

Mi recomendación es que aprendan otros lenguajes que compilan a binario con sintaxis BASIC como freebasic que es prácticamente compatible con código VB6.

---

Podría escribir mucho más pero creo que eso sintetiza mi opinión. Ojalá alguien más se anime a participar y abriendo debate pueda continuar expandiendo mi opinión

Saludos! Happy coding

A mí me funciona perfectamente.

Comprueba que tu antivirus no esté deshaciendo el hook para meter el suyo. Algunos AVs como Avast tienen hooks en userland, interceptando las llamadas al sistema.

Para comprobar que te hookea correctamente abre un proceso en el OllyDbg luego desde el código hookeas. Te vas al OllyDbg y actualizas la memoria.

Saludos

#ifndef __RA_ARRAY__
#define __RA_ARRAY__

#include <intrin.h>
#define ULONG unsigned long

template <typename T>
class random_access_array{
    const ULONG elements;
    const ULONG R;
    ULONG       a;
    ULONG       c;
    T*          buffer;

    const ULONG nextPowerOf2(ULONG n)const{
        if ((n & (n - 1)) == 0)
            return n;

        n |= (n >> 1);
        n |= (n >> 2);
        n |= (n >> 4);
        n |= (n >> 8);
        n |= (n >> 16);
        return n + 1;
    }

    ULONG LCG(ULONG X, ULONG a, ULONG c, ULONG R){
        return (a*X + c) % R;
    }

    ULONG randmax(ULONG max){
        return LCG((ULONG) __rdtsc(), 0x43FD43FDUL, 0xC39EC3UL, max);
    }

    size_t getRealIdx(int index){
        ULONG X = 0;
        while (index-- >= 0)
            while ((X = LCG(X, a, c, R)) >= elements){}

        return X;
    }

public:
    random_access_array(T* buffer, size_t elements) : elements(elements), buffer(buffer), R(nextPowerOf2(elements)){
        a = 2 * randmax(R / 2) + 1;
        c = 4 * randmax(R / 4) + 1;
    }

    random_access_array(T* buffer, size_t elements, ULONG a, ULONG c) : elements(elements), buffer(buffer), R(nextPowerOf2(elements)), a(a), c(c){}

    T& operator [](size_t i){
        return buffer[getRealIdx(i)];
    }

    T  operator [](const size_t i) const{
        return buffer[getRealIdx(i)];
    }
};

#endif//__RA_ARRAY__
Ejemplo de uso:
    #define SIZE 573

    random_access_array<int> ra(new int[SIZE], SIZE);

    for (int i = 0; i < SIZE; i++)
        ra[i] = i;

    for (int i = 0; i < SIZE; i++)
        cout << ra[i] << endl;
Utilidad real:
    #define SIZE sizeof(s) - 1

    char s[] = "!eru!akklccr !rza";

    random_access_array<char> ra(s, SIZE, 5, 25);

    for (int i = 0; i < SIZE; i++)
        cout << ra[i];
Saludos

Es la forma más corta que llamar a un API de forma dinámica que encontrarás

La shellcode de unos 90bytes se encarga de recorrer el SAFEARRAY de VARIANTs metiendo en el stack los parámetros para el API. Además busca en la IAT del proceso la importación de DllFunctionCall() para obtener el puntero del API. (http://pastebin.com/5gnLv7xn)

¿Para desbloquearlo hay que llevarlo a clase o qué?

;use32
; Karcrack - 190713
proc NotEmulated
   push  cs             ;//put 0x23 in stack
   call  to64
   ret
to64:
   push  $CB0033        ;//put 0x33 in stack
   call  to64 + 3       ;//call to retf
use64
   xor   rax, rax       ;//DEC EAX; XOR EAX, EAX
   inc   rax            ;//DEC EAX; INC EAX
   retf                 ;//Back to x86
endp   
El método consiste en ejecutar ensamblador x64 dentro de un proceso x86 usando la heaven's gate. Básicamente la técnica consiste en cambiar el segmento de código.

Si ensamblamos en x64 las siguientes instrucciones:
xor rax, rax
inc raxY luego las desensamblamos como si fuese x86 veremos que se transforma en:
dec eax
xor eax, eax
dec eax
inc eaxEl prefijo que indica que se trata de un registro de 8bytes es "dec eax". Se observa que si las instrucciones se ejecutan en x64 devuelve 1 en EAX pero si se hace en x86 devuelve 0.

No conozco ningún emulador que detecte el cambio de segmento y cambie la arquitectura que emula jaja

Disfrutad

No me quejo de los títulos sino más bien de los contenidos. Debería de haber algún sistema de votos y si algún documento recibe muchos votos negativos tal vez no merezca estar en la biblioteca...

Lástima que no pueda verlo porque soy un fracasado

Uno usando FPU
        push $30
        pop  eax
        push eax
        fld  dword[FS:eax]
        fstp dword[esp]
        pop  eax
        ret