assembler.cpp

Ollydbg环境下的一款插件源代码

                    *strTokenName += '\r';
                else if ('t' == ch)
                    *strTokenName += '\t';
                else if ('\\' == ch)
                    *strTokenName += '\\';
                else
                {
                    *strTokenName += '\\';;
                    ungetc(ch, fii->fp);
                }
            }
            else
                *strTokenName += ch;
            state = TOK_DQUOTE;
            break;
        }
    }
}

int CAssembler::ProcessInvoke(
    /* [in][out] */     FILEINFO *fii,
    /* [in] */          const PASSTYPE pt
)
{
    ASSERT(fii);

    int nRetResult = 0;
    int nRetCode;

    int nOrigLineNum = fii->LineNum;
    long lLastFileOffset;
    TOKENTYPE tt;
    MNEMONICTYPE mt;
    CString strTokenName;
    APIPARAMETER apiParameter;
    CList<APIPARAMETER, APIPARAMETER> listApiParameters;
    int i;
    int nCount;
    int nCommaTrigger = 0;

    for (;;)
    {
        apiParameter.lFileOffset = ftell(fii->fp);

        tt = NextToken(fii, &strTokenName);
        if (nOrigLineNum != fii->LineNum)
        {
            fii->LineNum = nOrigLineNum;
            break;
        }
        if (TOK_COMMA == tt)
        {
            if (nCommaTrigger)
            {
                nCommaTrigger = !nCommaTrigger;
                continue;
            }
            else
            {
                Error(
                    ERR_ERRORONID,
                    m_VM->GetMnemonicName(MC_PUSH),
                    fii->FileName,
                    fii->LineNum
                );
                goto Exit0;
            }
        }
        else if (TOK_INDEXOF == tt)
        {
            tt = NextToken(fii, &strTokenName);
            if (TOK_REGISTER != tt)
            {
                Error(
                    ERR_ERRORONID,
                    m_VM->GetMnemonicName(MC_PUSH),
                    fii->FileName,
                    fii->LineNum
                );
                goto Exit0;
            }
            int nRegIndex;
            nRetCode = m_VM->GetRegisterIndex(
                strTokenName.GetLength() + 1,
                strTokenName,
                &nRegIndex
            );
            strTokenName.Format("%d", nRegIndex);
        }
        else if (TOK_EOF == tt)
            break;
        else if (TOK_ERR == tt)
            goto Exit0;

        apiParameter.Name = strTokenName;
        listApiParameters.AddTail(apiParameter);

        nCommaTrigger = !nCommaTrigger;

        lLastFileOffset = ftell(fii->fp);
    }

    nCount = listApiParameters.GetCount();
    for (i = 0; i < nCount - 1; ++i)
    {
        apiParameter = listApiParameters.GetTail();
        listApiParameters.RemoveTail();
        fseek(fii->fp, apiParameter.lFileOffset, SEEK_SET);
        if (PT_PASS1 == pt)
        {
            nRetCode = m_VM->GetMnemonicLen(MC_PUSH);
            AddCodeLen(nRetCode);
        }
        else if (PT_PASS2 == pt)
        {
            GenPush(fii, 0);
        }
    }

    strTokenName = listApiParameters.GetTail().Name;
    nRetCode = IsMnemonic(
        strTokenName.GetLength() + 1,
        strTokenName,
        &mt
    );
    if (0 != nRetCode)  // it is a mnemonic
    {
        if (PT_PASS1 == pt)
        {
            nRetCode = m_VM->GetMnemonicLen(mt);
            AddCodeLen(nRetCode);
        }
        else if (PT_PASS2 == pt)
        {
            AddOpcode(mt);
        }
    }
    else
    {
        Error(ERR_NOID, strTokenName, fii->FileName, fii->LineNum);
        goto Exit0;
    }

    fseek(fii->fp, lLastFileOffset, SEEK_SET);

    nRetResult = 1;
Exit0:
    return nRetResult;
}

int CAssembler::ProcessEmbeddedAsm(
    /* [in][out] */     FILEINFO *fii,
    /* [in] */          const PASSTYPE pt
)
{
    ASSERT(fii);

    int nRetResult = 0;
    int nRetCode;

    TOKENTYPE tt;
    CString strTokenName;
    int nAssembledLen;
    CString strLine;
    t_asmmodel model;
    t_thread* pThread = NULL;
    unsigned long ip;
    unsigned long ulThreadID;
    int nPrevLineNum;
    int nNewStatement = 1;
    unsigned long ulCount = 0;
    unsigned int nCodeTotalLen = 0;
    int nPrevLineLen;
    char szError[TEXTLEN] = { 0 };
    CList<CString, CString&> listEmbeddedAsmLine;

    ulThreadID = Getcputhreadid();
    if (NULL == ulThreadID)
    {
        ShowErrMsg(
            "Please open or attach to a process before compiling embedded asm!"
        );
        goto Exit0;
    }

    pThread = Findthread(ulThreadID);
    OM_PROCESS_ERROR(pThread);

    ip = pThread->reg.ip;

    nRetCode = Match(fii, TOK_LBRACE);
    OM_PROCESS_ERROR(nRetCode);

    for (;;)
    {
        nPrevLineLen = strLine.GetLength();
        tt = NextToken(fii, &strTokenName, 1);
        switch (tt)
        {
        case TOK_RBRACE:
            if (nAssembledLen < 0)
            {
                strLine = strLine.Left(nPrevLineLen);
                strLine.TrimRight();
                Error(
                    ERR_EMBEDDEDASMCANTCOMPILE,
                    strLine,
                    fii->FileName,
                    nPrevLineNum
                );
                goto Exit0;
            }
            else
                goto Exit1;
        case TOK_COMMA:
            strLine += ',';
            break;
        case TOK_ERR:
        case TOK_EOF:
            goto Exit0;
        case TOK_LBRACKET:
            strLine += '[';
            break;
        case TOK_RBRACKET:
            strLine += ']';
            break;
        case TOK_DOT:
            strLine += '.';
            break;
        case TOK_OPERATOR:
            strLine += strTokenName;
            break;
        default:
            strLine += strTokenName;
            break;
        }

        nAssembledLen = ::Assemble(
            (char *)(LPCTSTR)strLine,
            ip + nCodeTotalLen,
            &model,
            0,
            0,
            szError
        );
        if (nAssembledLen >= 0)
        {
            ++ulCount;

            nCodeTotalLen += nAssembledLen;

            // 5 = sizeof E9 XXXXXXXX
            if (nCodeTotalLen + 5 > EMBEDDED_CODE_SIZE)
            {
                strTokenName.Format(
                    "Compiled embedded asm code size is %d, TOO BIG!"
                    " Can not greater than %d bytes.",
                    nCodeTotalLen + 5,
                    EMBEDDED_CODE_SIZE
                );
                Error(
                    ERR_EMBEDDEDCODESIZETOOBIG,
                    strTokenName,
                    fii->FileName,
                    fii->LineNum
                );
                goto Exit0;
            }

            listEmbeddedAsmLine.AddTail(strLine);

            strLine.Empty();
            nNewStatement = 1;
        }
        else if (nNewStatement)
        {
            strLine += ' ';
            nNewStatement = 0;
            nPrevLineNum = fii->LineNum;
        }
    }

Exit1:
    if (PT_PASS1 == pt)
    {
        // 9 = MC_EMBEDDEDASM + count (long) + CodeTotalLen
        AddCodeLen(9 + 4 * ulCount);
    }
    else if (PT_PASS2 == pt)
    {
        AddOpcode(MC_EMBEDDEDASM);
        Add1LCode(ulCount);
        Add1LCode(nCodeTotalLen);
        for (unsigned long i = 0; i < ulCount; ++i)
        {
            strLine = listEmbeddedAsmLine.GetHead();
            listEmbeddedAsmLine.RemoveHead();
            Add1LCode(m_unDataLen);
            S(strLine.GetLength() + 1, strLine);
        }
    }

    nRetResult = 1;
Exit0:
    return nRetResult;
}

int CAssembler::GenerateCodes(
    /* [size_is][in] */ const UINT unFileNameSize,
    /* [in] */          const char *szFileName
)
{
    ASSERT(szFileName);

    int nRetResult = 0;
    int nRetCode;

    FILE *fp_in = NULL;
    CString strTokenName;
    FILEINFO fii;
    TOKENTYPE tt;
    MNEMONICTYPE mt;
    
    OM_PROCESS_ERROR((strlen(szFileName) + 1) == unFileNameSize);

    fp_in = fopen(szFileName, "rt");    // do NOT use "rb" here!
    OM_PROCESS_ERROR(fp_in);

    strcpy(fii.FileName, szFileName);
    fii.fp = fp_in;
    fii.LineNum = 1;
    ++m_nFileListCount;

    while (!m_nStopFlag)
    {
        tt = NextToken(&fii, &strTokenName);
        switch (tt)
        {
        case TOK_TOKEN:
            nRetCode = IsMnemonic(
                strTokenName.GetLength() + 1,
                strTokenName,
                &mt
            );
            if (0 != nRetCode)      // it is a mnemonic
            {
                switch (mt)
                {
                case MC_INCLUDE:
                    ProcessInclude(&fii, PT_PASS2);
                    break;
                case MC_INVOKE:
                    ProcessInvoke(&fii, PT_PASS2);
                    break;
                case MC_NOP:
                    I(&fii, MC_NOP);
                    break;
                case MC_MOV:
                    GenArithmetic(&fii, MC_MOV);
                    break;
                case MC_ADD:
                    GenArithmetic(&fii, MC_ADD);
                    break;
                case MC_SUB:
                    GenArithmetic(&fii, MC_SUB);
                    break;
                case MC_MUL:
                    GenArithmetic(&fii, MC_MUL);
                    break;
                case MC_DIV:
                    GenArithmetic(&fii, MC_DIV);
                    break;
                case MC_INC:
                    IR(&fii, MC_INC);
                    break;
                case MC_DEC:
                    IR(&fii, MC_DEC);
                    break;
                case MC_XCHG:
                    IRR(&fii, MC_XCHG);
                    break;
                case MC_AND:
                    GenArithmetic(&fii, MC_AND);
                    break;
                case MC_OR:
                    GenArithmetic(&fii, MC_OR);
                    break;
                case MC_XOR:
                    GenArithmetic(&fii, MC_XOR);
                    break;
                case MC_NOT:
                    IR(&fii, MC_NOT);
                    break;
                case MC_SHL:
                    GenArithmetic(&fii, MC_SHL);
                    break;
                case MC_SHR:
                    GenArithmetic(&fii, MC_SHR);
                    break;
                case MC_CMP:
                    GenArithmetic(&fii, MC_CMP);
                    break;
                case MC_JMP:
                    IL(&fii, MC_JMP);
                    break;
                case MC_JE:
                    IL(&fii, MC_JE);
                    break;
                case MC_JNE:
                    IL(&fii, MC_JNE);
                    break;
                case MC_JB:
                    IL(&fii, MC_JB);
                    break;
                case MC_JNAE:
                    IL(&fii, MC_JNAE);
                    break;
                case MC_JNB:
                    IL(&fii, MC_JNB);
                    break;
                case MC_JAE:
                    IL(&fii, MC_JAE);
                    break;
                case MC_JBE:
                    IL(&fii, MC_JBE);
                    break;
                case MC_JNA:
                    IL(&fii, MC_JNA);
                    break;
                case MC_JA:
                    IL(&fii, MC_JA);
                    break;
                case MC_JNBE:
                    IL(&fii, MC_JNBE);
                    break;
                case MC_PUSH:
                    GenPush(&fii);
                    break;
                case MC_POP:
                    IR(&fii, MC_POP);
                    break;
                case MC_HALT:
                    I(&fii, MC_HALT);
                    break;
                case MC_LDS:
                    IRS(&fii, MC_LDS);
                    break;
                case MC_INPUTTEXT:
                    I(&fii, MC_INPUTTEXT);
                    break;
                case MC_INPUTHEXLONG:
                    I(&fii, MC_INPUTHEXLONG);
                    break;
                case MC_PRINTNUM:
                    I(&fii, MC_PRINTNUM);
                    break;
                case MC_PRINTBUF:
                    I(&fii, MC_PRINTBUF);
                    break;
                case MC_MSG:
                    I(&fii, MC_MSG);
                    break;
                case MC_MSGYN:
                    I(&fii, MC_MSGYN);
                    break;
                case MC_READMEMLONG:
                    I(&fii, MC_READMEMLONG);
                    break;
                case MC_WRITEMEMLONG:
                    I(&fii, MC_WRITEMEMLONG);
                    break;
                case MC_FILL:
                    I(&fii, MC_FILL);
                    break;
                case MC_FINDOPCODE:
                    I(&fii, MC_FINDOPCODE);
                    break;
                case MC_REPLACEBYTES:
                    I(&fii, MC_REPLACEBYTES);