ƽ - LCG - LSG |׿ƽ||ƽܛ|ŷƱ  www.ykwek.com

 һܴa
 ע[Register]

QQ

ֻһ_ʼ

: ctf Ó ̳
б l
鿴: 12323|؏: 97
һ} һ}

欧洲篮球联赛直播 : [ԭ] X86ָ֮ʹaK

  [朽]
Dָnj
ҹdzǡ l 2020-1-9 15:52
ҹdzǡ 2020-1-9 22:30 ݋

ԭ

ŷƱ www.ykwek.com MƷĕr򽛳^ĺһֱԼWFһεָydemoҲҪ̫s(䌍Լ˶)ֹIDA F5h()Ϳ(ȥĎ)ҊָyǰһδajccָֳɻKjccָׁͨfdzҊDָTjzjnzjmp....?ĸοIDA؈D@Nloc_xxxܿK

ֱ^һc@DaֳɉḴװ

K֮ٴy[ظK֮gֱ“ϵʹoBgߟo
oͨ^F5δa

ԭʼµĴaKAҳjccָ޸ԓָDA
ͨ^AD_ĴaKaKAԸFһЩ\ӑBӋDַģ
@NҲţƽ̹aKAҲƷְlؓ؟ְlָD

Ȼ@ֻƽ̹ȥҲ׺oBaԭ
қ]вķҵĻ뷨λMлкFȡFָ
ՈһµĿgÿlָSCyµĿgָCɗlָĈԭʼһ
Բfďs㷨ӋһlָĵַҲʹֱ^DָM
FÿlָgϵSCyLj׃găɗlָ֮gҲһЩСSCĻָMиɔ_

ޏDPϵضλ@Ӿˌһġ
ʹù:Լ]һPERʹõudis86Rʹõasmjit

asmjit

udis86


˼oһaKReʼַʹСIDAsub_xxxעĹ
D

_ReǺyÿgɵĺܶһijЩretָYβ
Щ]retָЩҲpush xxx_^ֻMܼ^ĺ

BIDA@NeķgܰٷְRea͔ЩgѲ֔ʹaϾgһ
delphi?Տs߹fZijЩe?strong>ָ@Nrǟo

PڴaReԼٿYһЩҎtóRe󲿷ֺ㷨
r]мReijЩdelphiҎt@a͔sһ

1.jmp immediate()

  • g^ӛjccָDĿĵַÿζjccָĿĵַ^ӛDĿĵַһ

    2.retYβRe

  • retָt^ǰ汣DַͮǰַǰַDַtYСDĿַtDַ_ʼ^m

    3.rYβД

  • DğoljmpָtY
  • ҵnop (0x90)tY
  • ҵBmɂint3  (0xCC)tY
  • ҵadd [eax], al  (0x00,0x00....)tY
  • һlָǟoljmptYjmpָĿ˵ַַ
  • һlָһ_ʼ(ָpush espmov ebp, esp) tYһlַַָ

    4.Call immediate()

  • callָtĿĵַʼַ

    5.

  • {ԇϢҲԸ{ԇϢ^ָͺ@Ҏt϶ȫԸÿgIJͬԶxҎt
  • ˼·Ǐpeļc_ʼʹ㷨lʽ{þͰ{Ŀصַ؏Դ

ִa

/***
* ָc
*/
typedef struct _Instr_Flow_Node
{
    bool isJmpDown;//Ƿ
    DWORD64 jmpRange;//DС
    ud_mnemonic_code type;//ָ
    ud_type operatorType;//    1.D 2.Ĵ 3.ȴַ
    bool isJcc = false;//Ƿjcc͵ָ
    bool isCall = false;//ǷCall͵ָ
    DWORD64 loadImageAddress;//ǰָ̓Mȴ
    DWORD64 memoryFileAddress;//ǰָļȴ
    DWORD64 jmpLoadImageAddress;//DĿĵ̓Mȴ
    DWORD64 jmpMemoryFileAddress;//DĿĵļȴ
    DWORD insnLen;//ָL

    //jccD͵Dƫ
    struct
    {
        union
        {
            int8_t sbyte;
            int16_t sword;
            int32_t sdword;
        };
    } jmpOffset;

    bool operator < (const _Instr_Flow_Node & node) const
    {
        return this->memoryFileAddress < node.memoryFileAddress;    //  < 
    }

    bool isInvalid()
    {
        return this->type == UD_Iinvalid;
    }

} InstrFlowNode;
FunctionNode X86Analysis::AnalysisFunction(DWORD64 begin, DWORD bufferSize, map<DWORD64, FunctionNode>* functionMap, map<DWORD64, FunctionNode>* excludeMap, DWORD64 pc)
{
    ud_t ud;
    ud_init(&ud);
    ud_set_mode(&ud, 32);
    ud_set_syntax(&ud, UD_SYN_INTEL);
    ud_set_input_buffer(&ud, (uint8_t*)begin, bufferSize);
    ud_set_pc(&ud, pc);
    InstrFlowNode jcc_max, jcc_flow;
    memset(&jcc_max, 0, sizeof(jcc_max));
    while (ud_disassemble(&ud))
    {
        jcc_flow = GetInstrNode(&ud);

        if (jcc_flow.isInvalid())
        {
            //oЧָ(ָܻ)tֹͣԓǰɵIJ,ܺLȞ0
            FunctionNode function;
            function.memoryFileAddress = begin;
            function.loadImageAddress = pc;
            function.size = begin - (jcc_flow.memoryFileAddress - jcc_flow.insnLen);
            return function;
        }

        if (jcc_flow.isJcc && (jcc_flow.operatorType == UD_OP_JIMM))
        {
            if (jcc_flow.jmpMemoryFileAddress > jcc_max.jmpMemoryFileAddress)
            {
                //ӛCFGDDĿ˵ַDָ
                jcc_max = jcc_flow;
            }
        }

        switch (jcc_flow.type)
        {

        case UD_Ijmp:
        {
            //olDĿ˵ַСںʼ߮ǰDָǺһlָtҕY
            //Ŀ˵ַAc
            if (jcc_flow.operatorType == UD_OP_JIMM)
            {

                if ((jcc_flow.jmpMemoryFileAddress < begin) || (jcc_flow.memoryFileAddress == begin))
                {
                    if (functionMap != nullptr)
                    {
                        //ųmapвѽ^ĺt빝c
                        if ((excludeMap != nullptr) && (!excludeMap->empty()))
                        {
                            if (excludeMap->find(jcc_flow.jmpMemoryFileAddress) == excludeMap->end())
                            {
                                FunctionNode node(jcc_flow.jmpMemoryFileAddress, jcc_flow.jmpLoadImageAddress);
                                functionMap->operator[](node.memoryFileAddress) = node;
                            }

                        }
                        else
                        {
                            FunctionNode node(jcc_flow.jmpMemoryFileAddress, jcc_flow.jmpLoadImageAddress);
                            functionMap->operator[](node.memoryFileAddress) = node;
                        }

                    }

                    return FunctionNode
                    (
                        begin,
                        pc,
                        jcc_flow.memoryFileAddress + jcc_flow.insnLen - begin
                    );
                }
            }
            break;
        }
        case UD_Icall:
        {
            if (functionMap != nullptr)
            {
                if (jcc_flow.operatorType == UD_OP_JIMM)
                {
                    if ((excludeMap != nullptr) && (!excludeMap->empty()))
                    {
                        //ųmapвѽ^ĺt빝c
                        if (excludeMap->find(jcc_flow.jmpMemoryFileAddress) == excludeMap->end())
                        {

                            //4ֹcall
                            FunctionNode node(jcc_flow.jmpMemoryFileAddress, jcc_flow.jmpLoadImageAddress);
                            functionMap->operator[](node.memoryFileAddress) = node;
                        }

                    }
                    else
                    {
                        //4ֹcall
                        FunctionNode node(jcc_flow.jmpMemoryFileAddress, jcc_flow.jmpLoadImageAddress);
                        functionMap->operator[](node.memoryFileAddress) = node;
                    }

                }
            }
            break;
        }

        case UD_Iret:
        {
            if (jcc_max.jmpMemoryFileAddress > jcc_flow.memoryFileAddress)
            {
                //ret֮߀CFG

                DWORD skip_bytes = jcc_max.jmpLoadImageAddress - ud.pc;
                ud_input_skip(&ud, skip_bytes);
                ud_set_pc(&ud, jcc_max.jmpLoadImageAddress);
            }
            else
            {
                return FunctionNode
                (
                    begin,
                    pc,
                    jcc_flow.memoryFileAddress + jcc_flow.insnLen - begin
                );
            }
            break;
        }

        case UD_Inop:
        case UD_Iint3:
        {
            if (ud_insn_mnemonic(&ud) == UD_Iint3)
            {
                //ٳFBmɂCCָfReĩβ
                if (*((ud_insn_ptr(&ud) + 1)) != 0xCC)
                {
                    break;
                }
            }
            return FunctionNode
            (
                begin,
                pc,
                jcc_flow.memoryFileAddress - begin
            );
        }
        case UD_Iadd:
        {
            if (!memcmp(ud_insn_hex(&ud), "0000", 4))
            {
                return FunctionNode
                (
                    begin,
                    pc,
                    jcc_flow.memoryFileAddress - begin
                );
            }
            break;
        }

        default:
        {
        }

        }

        //ĴaǺ_ʼ
        DWORD64 ptr = jcc_flow.memoryFileAddress + jcc_flow.insnLen;
        if (LookNextBegin(ptr))
        {
            //ųmapвѽ^ĺt빝c
            if ((excludeMap != nullptr) && (!excludeMap->empty()))
            {
                if (excludeMap->find(ptr) == excludeMap->end())
                {
                    FunctionNode node(ptr, jcc_flow.loadImageAddress + jcc_flow.insnLen);
                    functionMap->operator[](ptr) = node;
                }

            }
            else
            {
                FunctionNode node(ptr, jcc_flow.loadImageAddress + jcc_flow.insnLen);
                functionMap->operator[](ptr) = node;
            }

            return FunctionNode
            (
                begin,
                pc,
                jcc_flow.memoryFileAddress + jcc_flow.insnLen - begin
            );
        }
    }

    return FunctionNode
    (
        begin,
        pc,
        bufferSize
    );

}

procmon.exewinmainIDAȵЧD

IDAReӋһºС0x0045E6B4-0x0045D840=3700ԼReYһ


õϢMзǰvķMлõµĴaK
ҵrelocεǰһºϲrelocһµtextѻaMȥ
textκ愓relocޏضλϢ
֮ǰȒӛ䛮ǰضλϢ^ЌԭʼضλϢµضλϢ“ϵһԱMضλޏ

ִaF

char* x86PEObfuscate::BrokenFunction(FunctionNode function,DWORD *obfucodeSize, vector<RelocFixer> &relocFixBox,DWORD64 VirtulAddress)
{

    //ָ
    vector<InstrFlowNode> instrbox = this->m_Analysis.InstrExtract(function.memoryFileAddress, function.size, function.loadImageAddress);
    if (instrbox.empty())
    {
        return nullptr;
    }

    //@ȡPEضλ
    map<DWORD, vector<WORD>> relocTable;
    vector<RelocInstr>relocInstrBox;
    bool hasReloc = this->m_pefile.getRelocTable(relocTable);
    if (hasReloc)
    {
        //õָеضλϢ
        checkReloc(instrbox, relocTable, relocInstrBox);
    }

    class ObfuscateInstr
    {
    public:
        ObfuscateInstr() {};
        ObfuscateInstr(const ObfuscateInstr&o)
        {
            this->memoryAddress = o.memoryAddress;
            this->virtulAddress = o.virtulAddress;
            this->prexCodeSize = o.prexCodeSize;
            this->size = o.size;
            this->code = new char[this->size];
            memcpy(this->code, o.code, this->size);
        }
        ~ObfuscateInstr() 
        {
            if (code != nullptr)
            {
                delete[] code;
            }
        }

        //ԓָKSC䵽ȴеĵַԱָޏ͌ҵַ
        //SCʽchunkboxеָK䵽ȴ
        //ޏ͵ĕrvchunkboxԪصmemoryAddress朽ָK
        //vchunkboxĕr˜ҵinstrboxеԭʼָԪДஔǰǷjccָ
        //DŽtԭʼָȴַkeyorign_chunk_mapҵĿָKַӋޏͮǰָ
        DWORD64 memoryAddress = 0;// ԓK¿gĵַ
        DWORD64 virtulAddress = 0;// ԓK VA
        DWORD prexCodeSize = 0;  //KԭʼָǰָL=ԭʼָԓָKƫ
        char *code = nullptr;//K
        DWORD size = 0;

    };

    //ÿlָAMA̎
    vector<ObfuscateInstr> chunkbox;
    x86::Gp registers[] = { x86::eax,x86::ebx,x86::ecx,x86::edx,x86::esi,x86::edi };
    bool first = true;  //true ָ̎ĵһlָ pop reg
    int index;

    for (auto instr : instrbox)
    {

        CodeHolder code;
        code.init(CodeInfo(ArchInfo::kIdX86));
        x86::Assembler assember(&code);

        //ԭʼָǰ
        if (!first)
        {
            assember.pop(registers[index]);
            assember.popfd();//?־?        }
        else
        {
            first = false;
        }

        DWORD prexCodeSize = code.sectionById(0)->buffer().size();  //ǰYָL

        //̎ԭʼָ
        int insn_len;
        if ((instr.isJcc||instr.isCall)&&(instr.operatorType == UD_OP_JIMM))
        {
            char *new_jcc = new char[6];
            DWORD jcc_padding = 0xAAAAAAAA;//jccDƫ
            WORD jcc_opcode = this->jcc_long_opcode[instr.type];
            if ((instr.type == UD_Icall) || (instr.type == UD_Ijmp))
            {
                //ԭʼָcalljmp @ɷNָopcodejxָLȲһ Ϊ̎   0xE8  0xE9
                memcpy(new_jcc, (char*)&jcc_opcode, 1);     
                memcpy(new_jcc + 1, &jcc_padding, 4);//0xAAAAAAAAռλޏ
                insn_len = 5;
            }
            else
            {
                memcpy(new_jcc, (char*)&jcc_opcode, 2);   //0F 80  ....
                memcpy(new_jcc + 2, &jcc_padding, 4);//0xAAAAAAAAռλޏ
                insn_len = 6;
            }
            assember.embed(new_jcc, insn_len);
            delete[] new_jcc;
        }
        else
        {
            insn_len = instr.insnLen;
            assember.embed((char*)instr.memoryFileAddress, instr.insnLen);//  Ŀָ jccָ ֱӌȴ
        }

        //ԭʼָ
        assember.pushfd();//?־?        index = this->GetRandomKey() % sizeof(registers) / sizeof(x86::Gp);  //SCxĴ
        assember.mov(x86::dword_ptr(x86::esp, -4), registers[index]);
        assember.add(x86::esp, -4);
        Label label = assember.newLabel();
        assember.call(label);
        assember.bind(label);
        assember.pop(registers[index]);

        int num = -(13 + prexCodeSize + insn_len);//12+1
        assember.add(registers[index], num);  //õָK_ʼַ

        assember.add(registers[index], 0xdeadbeaf);   //0xdeadbeafռλޏ
        assember.push(registers[index]);
        assember.ret();

        CodeBuffer& buffer = code.sectionById(0)->buffer();
        ObfuscateInstr instrchunk;
        instrchunk.code = new char[buffer.size()];
        ::memcpy(instrchunk.code, buffer.data(), buffer.size());
        instrchunk.size = buffer.size();
        instrchunk.prexCodeSize = prexCodeSize;
        chunkbox.push_back(instrchunk);
    }

    //ָKSCy䵽¿g
    DWORD buffer_index = 0;
    DWORD buffer_size = function.size * 100;
    char * buffer = new char[buffer_size];  //Ո100ԭʼgĴС
    map<DWORD64, DWORD64> orign_chunk_map;   //ޏDָ keyԭʼָȴַvalueDZ^ָSCĵַ
    vector <int> indexTable;   //chunkbox
    for (int i = 0; i < chunkbox.size(); i++)
    {
        indexTable.push_back(i);//chunkbox
    }
    while (!indexTable.empty())
    {
        //SCxָKƒȴ
        int key = this->GetRandomKey() % indexTable.size();
        int index = indexTable[key];
        memcpy(buffer + buffer_index, chunkbox[index].code, chunkbox[index].size);
        DWORD64 addr = (DWORD64)buffer + buffer_index;
        DWORD64 va = VirtulAddress + (addr - (DWORD64)buffer);
        chunkbox[index].memoryAddress = addr;   //SCõĵַ
        chunkbox[index].virtulAddress = va;  //ԓָKva
        orign_chunk_map.insert(pair<DWORD64, DWORD64>(instrbox[index].memoryFileAddress, addr));

        buffer_index += chunkbox[index].size;

        //SCa5-20ֹ
        int junk_size = this->GetRandomKey() % 16 + 6;
        this->GetRandomBytes(buffer + buffer_index, junk_size);
        buffer_index += junk_size;

        //tmpchunkЄhǰָԪ
        auto iter = indexTable.begin();
        iter += key;
        indexTable.erase(iter);
    }

    //ޏָgjccDĿĵַ  עһlָ̎
    DWORD offset_flag = 0xdeadbeaf;
    DWORD jcc_flag = 0xAAAAAAAA;
    for (int i = 0; i < chunkbox.size(); i++)
    {
        char *begin = (char*)chunkbox[i].memoryAddress;
        char *end = (char*)chunkbox[i].memoryAddress + chunkbox[i].size;
        DWORD offset;
        if (i < chunkbox.size() - 1)
        {
            offset = chunkbox[i + 1].memoryAddress - chunkbox[i].memoryAddress;

        }
        else
        {
            //Ǻһlָ,tSCǰһlԭʼָ֮ĉK()
            int k = this->GetRandomKey() % (chunkbox.size() - 1);
            offset = chunkbox[k].memoryAddress - chunkbox[i].memoryAddress;
        }
        //ޏָ
        char* ptr = this->SearchBytes(begin, end, (char*)&offset_flag, sizeof(DWORD));
        memcpy(ptr, &offset, 4);

        if ((instrbox[i].isJcc|| instrbox[i].isCall) && (instrbox[i].operatorType == UD_OP_JIMM))
        {
            //ޏjccָDƫ
            char* ptr = this->SearchBytes(begin, end, (char*)&jcc_flag, sizeof(DWORD));
            DWORD64 addr = 0;
            if ((instrbox[i].type == UD_Icall)||(orign_chunk_map.count(instrbox[i].jmpMemoryFileAddress)<=0))
            {
                //Ժλ
                //ǰָcallߡcall(ijNjmp)mapЛ]DĿָӛ
                //āfҲfǰָĿĵַڱg
                //@ﲻƣ䌍Ҳ̎γ
                //jmpLoadImageAddressǼdַܕַSC׃
                //vaַ׃
                //chunkbox[i].memoryAddress=begin - (DWORD64)bufferԓָKʼKƫ
                //VirtulAddressǼdַva
                addr = instrbox[i].jmpLoadImageAddress;
                DWORD64 va = VirtulAddress + ((DWORD64)begin + chunkbox[i].prexCodeSize - (DWORD64)buffer);
                offset = addr - va - 5;//e9:jmp imm e8:call imm   ָL5
            }
            else
            {
                addr = orign_chunk_map[instrbox.jmpMemoryFileAddress] + chunkbox[i].prexCodeSize;

                if (instrbox[i].type == UD_Ijmp)  //e9:jmp imm e8:call imm   ָL5
                {
                    offset = addr - ((DWORD64)begin + chunkbox[i].prexCodeSize) - 5;//Ŀ-ǰ-ǰָL
                }
                else
                {
                    offset = addr - ((DWORD64)begin + chunkbox[i].prexCodeSize) - 6;//Ŀ-ǰ-ǰָL
                }
            }

            memcpy(ptr, &offset, 4);
        }

    }

    //µضλ
    for (auto relocInstr : relocInstrBox)
    {
        DWORD index = relocInstr.index;
        DWORD64 relocVa = chunkbox[index].virtulAddress + chunkbox[index].prexCodeSize + relocInstr.off;
        DWORD rva = relocVa - this->m_pefile.getOptionHeader()->ImageBase;
        DWORD orignRva = instrbox[index].loadImageAddress + relocInstr.off - this->m_pefile.getOptionHeader()->ImageBase;
        WORD typeOffset = rva % 0x1000;  //µtypeOffset
        DWORD newPage = rva - typeOffset;
        typeOffset |= ((WORD)(relocInstr.type << 12));
        RelocFixer fixer;
        fixer.orignRva = orignRva;
        fixer.newPage = newPage;
        fixer.typeOffset = typeOffset;
        relocFixBox.push_back(fixer);
    }

    //޸ԭڴa
    //ԭʼʣga
    char *begin = (char*)function.memoryFileAddress;
    char opcode[] = { 0xe9,00,00,00,00,0xc3 };  //jmp imm
    DWORD64 firstCodeVa = VirtulAddress + (chunkbox[0].memoryAddress - (DWORD64)buffer);//aKָva
    DWORD jmpoffset = firstCodeVa - function.loadImageAddress - 5;
    memcpy(opcode + 1, &jmpoffset, 4);
    memcpy(begin, opcode, 6);
    begin += 6;
    this->GetRandomBytes(begin, function.size - 6);

    char *obfucode = new char[buffer_index];
    memcpy(obfucode, buffer, buffer_index);
    *obfucodeSize = buffer_index;
    delete[] buffer;
    return obfucode;
}

procmon.exewinmainMзprocmon2.exe

procmon2.exe\

ǰ:

:

ԭֻܺFˁyĹǺܺεֻWһdemo
a׃[ܵȵȹܶ]м]ʲôgap
ldemo binObfuscater.exeprocmon.exeͬһĿ\мprocmon.obf.exe
Obfuscater.exe̎exeͺҶõĴпpatchһ

DƬ1.png (108.96 KB, dΔ: 3)

DƬ1.png

DƬ2.png (63.76 KB, dΔ: 2)

DƬ2.png

DƬ3.png (53.26 KB, dΔ: 3)

DƬ3.png

DƬ4.png (118 KB, dΔ: 3)

DƬ4.png

DƬ5.png (79.11 KB, dΔ: 2)

DƬ5.png

DƬ6.png (357.08 KB, dΔ: 2)

DƬ6.png

DƬ7.png (270.22 KB, dΔ: 1)

DƬ7.png

DƬ8.png (323.43 KB, dΔ: 3)

DƬ8.png

DƬ9.png (127.53 KB, dΔ: 3)

DƬ9.png

DƬ10.png (118.04 KB, dΔ: 2)

DƬ10.png

DƬ11.png (63.81 KB, dΔ: 3)

DƬ11.png

DƬ12.png (81.5 KB, dΔ: 3)

DƬ12.png

DƬ13.png (17.78 KB, dΔ: 3)

DƬ13.png

DƬ14.png (84.54 KB, dΔ: 2)

DƬ14.png

DƬ15.png (10.46 KB, dΔ: 3)

DƬ15.png

.jpg (6.12 KB, dΔ: 3)

.jpg

demo.rar

1.49 MB, dΔ: 55, de: ێ -1 CB

Mu

46ێ +46 ֵ +42
chen_null + 1 x[email protected]
alittlehorse + 1 xlԭƷƽՓ
13697i + 1 Ļ؏
FJFJ + 1 + 1 ӑՓ@
Id!0tNe + 1 Һٝͬ
yaoyao7 + 1 + 1 ӑՓ@
ʎ + 1 + 1 ӑՓ@
+ 1 + 1 ӑՓ@
pklong007 + 1 + 1 @6ҵȲ˱ƺΕr_@N̶
ԏ + 1 + 1 x[email protected]
springwillow + 1 ҬFڶ߀㲻W
Үd + 1 + 1 xČFh҂Ŭȡø
fsrank + 1 + 1 x[email protected]
eyey000 + 1 + 1 x[email protected]
zhan + 1 + 1 x[email protected]
poisonbcat + 1 + 1 x[email protected]
С + 1 + 1 ӑՓ@
QGZZ + 1 + 1 x[email protected]
w. + 1 + 1 Һٝͬ
ѩ250 + 1 + 1 x[email protected]
Mr.Eleven + 1 + 1 x[email protected]
Spwpun + 1 + 1 ӑՓ@
yixi + 1 + 1 x[email protected]
snatch2null + 1 ӑՓ@
Mouse + 1 + 1 x[email protected]
+ 1 Ļ؏
solly + 1 + 1 ӑՓ@
sunnylds7 + 1 + 1 Ļ؏
yppsniper + 1 + 1 Һٝͬ
wmsuper + 3 + 1 x[email protected]
N0LL + 1 + 1 x[email protected]
KCNKCN + 1 + 1 ӑՓ@
straychild + 1 + 1 ӑՓ@
Nachtmusik + 1 x[email protected]
kakudesu + 1 + 1 Ļ؏
gaosld + 1 + 1 ӑՓ@
blmk + 2 + 1 Һٝͬ
+ 2 + 1 x[email protected]
aassaa + 1 + 1 Һٝͬ
gongyong728125 + 1 + 1 Ļ؏
chh183 + 1 + 1 ӑՓ@
+ 1 + 1 Һٝͬ
Ravey + 1 + 1 x[email protected]
zhanglei91186 + 1 + 1 Һٝͬ
magus + 1 + 1 ӑՓ@
Dyingchen + 1 + 1 ӑՓ@

鿴ȫu

Ԍ݋]:

  • · |}: 238, ӆ: 88

lǰҪՓܕҪҵĴ𰸻ѽ˰l^ͬՈ؏Ͱl

؏

e

]
Hmily l 2020-1-11 10:37
ҹdzǡ l 2020-1-9 22:27
ʹmd¾݋Űһ DƬ^߀ǺܕmarkdownŰrӲ

DƬdiscuzԎcݔMȥ

Mu

1ێ +1 ֵ +1
xiaomin86 + 1 + 1 Ļ؏

鿴ȫu

]
 | ҹdzǡ l 2020-3-11 13:23 <
1364847132 l 2020-3-11 11:57
ʲôھg煢ollvmPass

ֻnjWһЩ|demo]ֱ̎bin]^ollvmҲ֪զollvmdelphi֮
ɳl
Dyingchen l 2020-1-9 16:03
Waқ]ʲôõkЛ]ʲôk
3#
lynn l 2020-1-9 16:07
Ĥݰ!
4#
2Burhero l 2020-1-9 17:34
x
5#
a1069517910 l 2020-1-9 20:02
x??
6#
l 2020-1-9 21:42
x
7#
 | ҹdzǡ l 2020-1-9 22:27 <
ʹmd¾݋Űһ DƬ^߀ǺܕmarkdownŰrӲ

cu

DƬdiscuzԎcݔMȥ  Ԕ ؏ l 2020-1-11 10:37
8#
ol416 l 2020-1-10 00:32
Ĥݰ!
9#
Hmily l 2020-1-10 08:34
@ҹdzǡ ߀D]N
10#
gongyong728125 l 2020-1-10 09:57
WWxx

eҎt 棺Kֹˮ؏c}oP`P

ٻ؏ ղ б

RSSӆ|С|“ϵ҂|ŷƱ ( ICP16042023̖ | W 11010502030087̖ )

GMT+8, 2020-4-7 00:52

Powered by Discuz!

Copyright © 2001-2020, Tencent Cloud.

ٻ؏ ŷƱ б