morphine.cpp

morphine 源码

{
        BYTE Result=2;
        *AMem=0x8B;                                                     //mov
        AMem++;
        if(AReg2==REG_EBP)
        {
                Result++;
                *AMem=AReg1*8+0x45;                             //reg32,ebp
                AMem++;
                *AMem=0x00;                                             //+0
        }
        else
        {
                *AMem=AReg1*8+AReg2;                    //reg32,regmem
        }
        AMem++;
        if(AReg2==REG_ESP)
        {
                Result++;
                *AMem=0x24;                                             //esp
                AMem++;
        }
        return(Result);
}

BYTE MovRegMemReg32(PBYTE &AMem,BYTE AReg1,BYTE AReg2)
{
        BYTE Result=2;
        *AMem=0x89;                                                     //mov
        AMem++;
        if(AReg1==REG_EBP)
        {
                Result++;
                *AMem=AReg2*8+0x45;                             //reg32,ebp
                AMem++;
                *AMem=0x00;                                             //+0
        }
        else
        {
                *AMem=AReg2*8+AReg1;                    //reg32,regmem
        }
        AMem++;
        if(AReg1==REG_ESP)
        {
                Result++;
                *AMem=0x24;                                             //esp
                AMem++;
        }
        return(Result);
}

BYTE MovReg32RegMemIdx8(PBYTE &AMem,BYTE AReg1,BYTE AReg2,BYTE AIdx)
{
        BYTE Result=3;
        *AMem=0x8B;                                                     //mov
        AMem++;
        *AMem=AReg1*8+AReg2+0x40;                       //AReg1,AReg2
        AMem++;
        if(AReg2==REG_ESP)
        {
                Result++;
                *AMem=0x24;                                             //esp
                AMem++;
        }
        *AMem=AIdx;                                                     //AIdx
        AMem++;
        return(Result);
}

void PushNum32(PBYTE &AMem,DWORD ANum)
{
        *AMem=0x68;                                                     //push
        AMem++;
        memcpy(AMem,&ANum,4);
        AMem+=4;
}

void JmpReg32(PBYTE &AMem,BYTE AReg)
{
        *AMem=0xFF;                                                     //jmp | call
        AMem++;
        *AMem=0xE0+AReg;                                        //reg32
        AMem++;
}

void CallReg32(PBYTE &AMem,BYTE AReg)
{
        *AMem=0xFF;                                                     //jmp | call
        AMem++;
        *AMem=0xD0+AReg;                                        //reg32
        AMem++;
}

void Cld(PBYTE &AMem)
{
        *AMem=0xFC;                                                     //cld
        AMem++;
}

void Std(PBYTE &AMem)
{
        *AMem=0xFD;                                                     //std
        AMem++;
}

void Nop(PBYTE &AMem)
{
        *AMem=0x90;                                                     //nop
        AMem++;
}

void Stc(PBYTE &AMem)
{
        *AMem=0xF9;                                                     //stc
        AMem++;
}

void Clc(PBYTE &AMem)
{
        *AMem=0xF8;                                                     //clc
        AMem++;
}

void Cmc(PBYTE &AMem)
{
        *AMem=0xF5;                                                     //cmc
        AMem++;
}

void XchgReg32Rand(PBYTE &AMem)
{
        *AMem=0x87;                                                     //xchg
        AMem++;
        *AMem=0xC0+RandomReg32All()*9;          //reg32
        AMem++;
}

BYTE XchgReg32Reg32(PBYTE &AMem,BYTE AReg1,BYTE AReg2)
{
        BYTE Result;
        if(AReg2==REG_EAX){ AReg2=AReg1; AReg1=REG_EAX; }
        if(AReg1==REG_EAX) ThrowTheDice(&Result,2);
        else Result=2;
        if(Result==2)
        {
                *AMem=0x87;                                             //xchg
                AMem++;
                *AMem=0xC0+AReg2*8+AReg1;               //reg32
        }
        else
        {
                *AMem=0x90+AReg2;                               //xchg eax,reg32
        }
        AMem++;
        return(Result);
}

void MovReg32Rand(PBYTE &AMem)
{
        *AMem=0x8B;                                                     //mov
        AMem++;
        *AMem=0xC0+RandomReg32All()*9;          //reg32
        AMem++;
}

void IncReg32(PBYTE &AMem,BYTE AReg)
{
        *AMem=0x40+AReg;                                        //inc reg32
        AMem++;
}

void DecReg32(PBYTE &AMem,BYTE AReg)
{
        *AMem=0x48+AReg;                                        //dec reg32
        AMem++;
}

BYTE IncReg32Rand(PBYTE &AMem)
{
        BYTE Result=RandomReg32All();
        IncReg32(AMem,Result);
        return(Result);
}

BYTE DecReg32Rand(PBYTE &AMem)
{
        BYTE Result=RandomReg32All();
        DecReg32(AMem,Result);
        return(Result);
}

BYTE LeaReg32Reg32(PBYTE &AMem,BYTE AReg1,BYTE AReg2)
{
        BYTE Result=2;
        *AMem=0x8D;                                                     //mov
        AMem++;
        if(AReg2==REG_EBP)
        {
                Result++;
                *AMem=AReg1*8+0x45;                             //reg32,ebp
                AMem++;
                *AMem=0x00;                                             //+0
        }
        else
        {
                *AMem=AReg1*8+AReg2;                    //reg32,regmem
        }
        AMem++;
        if(AReg2==REG_ESP)
        {
                Result++;
                *AMem=0x24;                                             //esp
                AMem++;
        }
        return(Result);
}

BYTE LeaReg32Reg32MemIdx8(PBYTE &AMem,BYTE AReg1,BYTE AReg2,BYTE AIdx)
{
        BYTE Result=3;
        *AMem=0x8D;                                                     //lea
        AMem++;
        *AMem=0x40+AReg1*8+AReg2;                       //reg32,reg32mem
        AMem++;
        if(AReg2==REG_ESP)
        {
                Result++;
                *AMem=0x24;                                             //esp
                AMem++;
        }
        *AMem=AIdx;                                                     //idx8
        AMem++;
        return(Result);
}

void LeaReg32Rand(PBYTE &AMem)
{
        *AMem=0x8D;                                                     //lea
        AMem++;
        *AMem=0x00+RandomReg32EspEbp()*9;       //reg32
        AMem++;
}

void LeaReg32Addr32(PBYTE &AMem,BYTE AReg,DWORD AAddr)
{
        *AMem=0x8D;                                                     //lea
        AMem++;
        *AMem=0x05+AReg*8;                                      //reg32
        AMem++;
        memcpy(AMem,&AAddr,4);                          //addr32
        AMem+=4;
}

void TestReg32Rand(PBYTE &AMem)
{
        *AMem=0x85;                                                     //test
        AMem++;
        *AMem=0xC0+RandomReg32All()*9;          //reg32
        AMem++;
}

void OrReg32Rand(PBYTE &AMem)
{
        *AMem=0x0B;                                                     //or
        AMem++;
        *AMem=0xC0+RandomReg32All()*9;          //reg32
        AMem++;
}

void AndReg32Rand(PBYTE &AMem)
{
        *AMem=0x23;                                                     //and
        AMem++;
        *AMem=0xC0+RandomReg32All()*9;          //reg32
        AMem++;
}

void TestReg8Rand(PBYTE &AMem)
{
        BYTE LReg8;
        LReg8=RandomReg8ABCD();
        *AMem=0x84;                                                     //test
        AMem++;
        *AMem=0xC0+LReg8*9;                                     //reg8
        AMem++;
}

void OrReg8Rand(PBYTE &AMem)
{
        BYTE LReg8;
        LReg8=RandomReg8ABCD();
        *AMem=0x0A;                                                     //or
        AMem++;
        *AMem=0xC0+LReg8*9;                                     //reg8
        AMem++;
}

void AndReg8Rand(PBYTE &AMem)
{
        BYTE LReg8;;
        LReg8=RandomReg8ABCD();
        *AMem=0x22;                                                     //and
        AMem++;
        *AMem=0xC0+LReg8*9;                                     //reg8
        AMem++;
}

void CmpRegRegNum8Rand(PBYTE &AMem)
{
        BYTE LRnd;
        LRnd=(BYTE)Random(3);
        *AMem=0x3A+LRnd;                                        //cmp
        AMem++;
        if(LRnd<2) LRnd=(BYTE)Random(0x40)+0xC0;
        else LRnd=(BYTE)Random(0x100);
        *AMem=LRnd;                                                     //reg16 | reg32 | num16
        AMem++;
}

BYTE CmpReg32Reg32(PBYTE &AMem,BYTE AReg1,BYTE AReg2)
{
        *AMem=0x39;                                                     //cmp
        AMem++;
        *AMem=0xC0+AReg1+AReg2*8;                       //reg1,reg2            
        AMem++;
        return(2);
}

void CmpReg32Num8(PBYTE &AMem,BYTE AReg,BYTE ANum)
{
        *AMem=0x83;                                                     //cmp
        AMem++;
        *AMem=0xF8+AReg;                                        //reg32
        AMem++;
        *AMem=ANum;                                                     //num8
        AMem++;
}

void CmpReg32RandNum8(PBYTE &AMem,BYTE AReg)
{
        CmpReg32Num8(AMem,AReg,(BYTE)Random(0x100));
}

void CmpRandReg32RandNum8(PBYTE &AMem)
{
        CmpReg32RandNum8(AMem,Ra