【reverse】手把手带你基于dll实现多次SMC

这篇具有很好参考价值的文章主要介绍了【reverse】手把手带你基于dll实现多次SMC。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

引言

SMC,即self modifying code,自修改代码,逆向入门SMC可以看一下我的题解。我打算实现一个类似于【网鼎杯2020青龙组】jocker的SMC方案。这个方案不需要用到汇编,因此门槛极低(连小小前端都能学会)。为什么要基于dll呢?因为代码段加密功能是通过外部python脚本完成的,将自修改代码拆分为独立dll实现上更方便。

仓库:https://github.com/Hans774882968/self-modify-code-hello

编译器:g++8.1.0。

本文juejin:https://juejin.cn/post/7228629361652727845/

本文CSDN:https://blog.csdn.net/hans774882968/article/details/130469189

本文52pojie:https://www.52pojie.cn/thread-1780843-1-1.html

作者:hans774882968以及hans774882968以及hans774882968

实现普通的dll调用

先编译一个dll。

enc.h

#pragma once

#include <bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for(int i = (a);i <= (b);++i)
#define re_(i,a,b) for(int i = (a);i < (b);++i)
#define dwn(i,a,b) for(int i = (a);i >= (b);--i)

enc.cpp

#include "enc.h"

int enc_arr[14] = {67, 91, 48, 88, 80, 75, 41, 93, 116, 92, 33, 83, 68, 69};
int private_key[4] = {43, 56, 68, 62};

extern "C" __declspec (dllexport) bool can_get_flag (string s);
void internal_func();

bool can_get_flag (string s) {
    internal_func();
    int n = s.size();
    if (n != 14) return false;
    re_ (i, 0, n) {
        if ( (s[i] ^ private_key[i % 4]) != enc_arr[i]) return false;
    }
    return true;
}

void internal_func () {
    puts ("internal_func");
}

命令:

g++ enc.cpp -g -shared -o enc.dll

接下来写一个普通的控制台应用来调用dll,main.cpp

#include <bits/stdc++.h>
#include <windows.h>
using namespace std;
typedef bool (*flag_func) (string);
#define rep(i,a,b) for(int i = (a);i <= (b);++i)
#define re_(i,a,b) for(int i = (a);i < (b);++i)
#define dwn(i,a,b) for(int i = (a);i >= (b);--i)

int main() {
    HMODULE h = LoadLibrary ("enc.dll");
    // 不知道为什么,必须强转才能过编译
    flag_func can_get_flag = (flag_func) GetProcAddress (h, "can_get_flag");
    puts ("Input flag:");
    string inp;
    cin >> inp;
    if (can_get_flag (inp) ) {
        cout << "Congratulations! Your flag: " << inp << endl;
    } else {
        puts ("Incorrect flag");
    }
    return 0;
}

main.cpp不需要任何配置,直接编译即可。

实现基于dll的SMC

接下来在以上代码的基础上实现SMC。

思路很简单:先编译出enc.dll,接着写一个脚本修改enc.dll,最后写C++代码main.cpp调用enc.dll和解密enc.dll中的加密函数。main.cpp至少需要编译2次。

首先打开IDA,查看enc.dll待加密函数can_get_flag的文件偏移(IDA下方状态栏会显示光标位置对应的文件偏移和Virtual Address):[0x9b0, 0xa66]。然后写一个小脚本来实现enc.dll的修改(TODO:有佬教教我更优雅的做法嘛QAQ)。

enc_dll.py

enc_key = [67, 91, 48, 88, 80, 75, 41, 93, 116, 92, 33, 83, 68, 69]


def enc(content, st, ed):
    res = []
    for i in range(st, ed + 1):
        res.append(content[i] ^ enc_key[(i - st) % len(enc_key)])
    return bytes(res)


st = 0x9b0
ed = 0xa66
with open('enc.dll', 'rb') as f1:
    content = f1.read()
    res = [content[:st]]
    enc_res = enc(content, st, ed)
    res.append(enc_res)
    res.append(content[ed + 1:])
    with open('enc_e.dll', 'wb') as f2:
        for r in res:
            f2.write(r)

最后修改一下main.cpp,加上:

  1. 修改内存页为可写的代码,change_page函数。主要是用了Windows APIVirtualProtect函数。
  2. 运行时解密的代码。
#include <bits/stdc++.h>
#include <windows.h>
using namespace std;
typedef bool (*flag_func) (string);
typedef unsigned char uint8;
#define rep(i,a,b) for(int i = (a);i <= (b);++i)
#define re_(i,a,b) for(int i = (a);i < (b);++i)
#define dwn(i,a,b) for(int i = (a);i >= (b);--i)

const int enc_key[14] = {67, 91, 48, 88, 80, 75, 41, 93, 116, 92, 33, 83, 68, 69};

void change_page (void *addr) {
    DWORD old;
    SYSTEM_INFO si;
    UINT64 _addr = (UINT64) addr;
    GetSystemInfo (&si);
    int page_size = si.dwPageSize;
    _addr -= (UINT64) addr % page_size;

    if (!VirtualProtect ( (PVOID) _addr, page_size, PAGE_EXECUTE_READWRITE, &old) )
        printf ("Error: %x\n", GetLastError() );

    return;
}

int main() {
    HMODULE h = LoadLibrary ("enc_e.dll");
    // 不知道为什么,必须强转才能过编译
    flag_func can_get_flag = (flag_func) GetProcAddress (h, "can_get_flag");
    change_page ( (void *) can_get_flag);
    // 故意没有把 SMC 解密的代码封装为独立函数
    int sz = 0xa66 - 0x9b0;
    uint8 *st = (uint8 *) can_get_flag, *ed = (uint8 *) (can_get_flag) + sz;
    for (uint8 *i = st; i <= ed; ++i) *i ^= enc_key[ (i - st) % 14];

    puts ("Input flag:");
    string inp;
    cin >> inp;
    if (can_get_flag (inp) ) {
        cout << "Congratulations! Your flag: " << inp << endl;
    } else {
        puts ("Incorrect flag");
    }
    return 0;
}

值得注意的是,GetProcAddress是根据dll的导出表来找到函数地址的,因此我们修改了can_get_flag的数据后,依旧能够找到其地址。

用x64dbg动态调试,进入enc_e.dll的内存空间,就能看到自修改代码的效果。

基于dll实现多次SMC

在这里看到了一道看上去很难的题,它的第一步就是要解密多次SMC。即:解密一段代码后,发现这段代码也是SMC,于是需要继续解密。这就导致你的IDApython脚本需要写递归,更为复杂。我在这里打算实现一个多次SMC,同样不需要直接操作汇编,门槛极低。因为我比较菜,所以把这件事分为两步:前期准备、正式实现。前期准备把多次SMC的demo代码写好;正式实现则是参考上述demo代码,使用模板引擎来生成所需代码,期望的效果是:在第一次编译enc.dll后只需要进行少量人工操作就能进行第二次编译。

前期准备

为了实现多次SMC,我们需要考虑更多的问题:

  1. 每个SMC函数的起点、终点如何确定。
  2. 有许多函数需要导出,许多函数所在的内存空间要修改为可写……

问题2可以用代码生成技术解决,这就是为什么我选用了模板引擎。问题1比较棘手,我采用的可行但粗糙的做法是:让每个SMC函数结构相同,于是它们的大小也都相同。再通过读dll的导出表,来确定每个SMC函数的起点。这样每个SMC函数的起点和终点都可以确定。

操作过程:

  1. 编写enc.h, enc.cpp,第一次编译enc.dll(编译命令同上)。
  2. 查看函数大小,修改enc.cpp,第二次编译enc.dll
  3. 编写enc_dll.py,生成enc_e.dll
  4. 编写、编译main.cpp

enc.h

#pragma once

#include <bits/stdc++.h>
#include <windows.h>
using namespace std;
typedef unsigned char uint8;
#define rep(i,a,b) for(int i = (a);i <= (b);++i)
#define re_(i,a,b) for(int i = (a);i < (b);++i)
#define dwn(i,a,b) for(int i = (a);i >= (b);--i)

enc.cpp

#include "enc.h"

extern "C" __declspec (dllexport) void change_page (void *addr);
extern "C" __declspec (dllexport) bool can_get_flag (string s);
extern "C" __declspec (dllexport) void smc1 (void);
extern "C" __declspec (dllexport) void smc2 (void);
extern "C" __declspec (dllexport) void smc3 (void);
void internal_func();

void change_page (void *addr) {
    DWORD old;
    SYSTEM_INFO si;
    UINT64 _addr = (UINT64) addr;
    GetSystemInfo (&si);
    int page_size = si.dwPageSize;
    _addr -= (UINT64) addr % page_size;

    if (!VirtualProtect ( (PVOID) _addr, page_size, PAGE_EXECUTE_READWRITE, &old) )
        printf ("Error: %x\n", GetLastError() );

    return;
}

bool can_get_flag (string s) {
    internal_func();
    const int enc_arr[14] = {67, 91, 48, 88, 80, 75, 41, 93, 116, 92, 33, 83, 68, 69};
    const int private_key[4] = {43, 56, 68, 62};
    int n = s.size();
    if (n < 14) return false;
    re_ (i, 0, 14) {
        if ( (s[i] ^ private_key[i % 4]) != enc_arr[i]) return false;
    }
    return true;
}

void internal_func () {
    puts ("internal_func");
}

const int sz1 = 0xB50 - 0xA3D;
const int sz2 = 0xC5F - 0xB6C;

void smc1() {
    const int enc_key1[14] = {55, 7, 39, 227, 9, 26, 205, 157, 109, 61, 254, 56, 207, 69};
    uint8 *st = (uint8 *) can_get_flag, *ed = (uint8 *) (can_get_flag) + sz1;
    for (uint8 *i = st; i <= ed; ++i) *i ^= enc_key1[ (i - st) % 14];
    internal_func();
}

void smc2() {
    const int enc_key2[14] = {155, 254, 177, 21, 171, 126, 74, 154, 136, 15, 99, 93, 175, 252};
    uint8 *st = (uint8 *) smc1, *ed = (uint8 *) (smc1) + sz2;
    for (uint8 *i = st; i <= ed; ++i) *i ^= enc_key2[ (i - st) % 14];
    smc1();
}

void smc3() {
    const int enc_key3[14] = {40, 124, 172, 226, 104, 12, 179, 114, 101, 183, 45, 169, 121, 164};
    uint8 *st = (uint8 *) smc2, *ed = (uint8 *) (smc2) + sz2;
    for (uint8 *i = st; i <= ed; ++i) *i ^= enc_key3[ (i - st) % 14];
    smc2();
}

注意点:

  1. 这里的smc1~3需要尽量写成模板引擎容易实现的形式,即需要高度相似
  2. enc_arr, enc_key1等数组都应该放到栈里,从而能被加密,否则逆向难度极低。
  3. sz1, sz2分别是can_get_flagsmc1~3的函数大小,需要先编译一次dll,看到大小以后再进行修改。这也是上面说enc.dll需要编译至少2次的原因。
  4. main.cpp负责解密smc3,随后调用smc3实现所有函数的运行时解密。

main.cpp

#include <bits/stdc++.h>
#include <windows.h>
using namespace std;
typedef bool (*flag_func) (string);
typedef void (*cp_func) (void *);
typedef void (*smc_func) (void);
typedef unsigned char uint8;
#define rep(i,a,b) for(int i = (a);i <= (b);++i)
#define re_(i,a,b) for(int i = (a);i < (b);++i)
#define dwn(i,a,b) for(int i = (a);i >= (b);--i)

const int enc_key4[14] = {16, 113, 174, 24, 78, 9, 90, 95, 207, 146, 136, 125, 69, 203};

int main() {
    HMODULE h = LoadLibrary ("enc_e.dll");
    // 不知道为什么,必须强转才能过编译
    flag_func can_get_flag = (flag_func) GetProcAddress (h, "can_get_flag");
    cp_func change_page = (cp_func) GetProcAddress (h, "change_page");
    smc_func smc1 = (smc_func) GetProcAddress (h, "smc1");
    smc_func smc2 = (smc_func) GetProcAddress (h, "smc2");
    smc_func smc3 = (smc_func) GetProcAddress (h, "smc3");
    vector<void *> funcs = { (void *) can_get_flag, (void *) smc1, (void *) smc2, (void *) smc3};
    for (auto func : funcs) {
        change_page (func);
    }
    // 故意没有把 SMC 解密的代码封装为独立函数
    const int sz2 = 0xC5F - 0xB6C;
    uint8 *st = (uint8 *) smc3, *ed = (uint8 *) (smc3) + sz2;
    for (uint8 *i = st; i <= ed; ++i) *i ^= enc_key4[ (i - st) % 14];
    smc3();

    puts ("Input flag:");
    string inp;
    cin >> inp;
    if (can_get_flag (inp) ) {
        cout << "Congratulations! Your flag: " << inp << endl;
    } else {
        puts ("Incorrect flag");
    }
    return 0;
}

注意点:

  1. 需要修改内存页为可写。
  2. 需要运行时解密smc3,随后调用。

enc_dll.py

import pefile

peobj = pefile.PE('enc.dll')


def get_smc_funcs():
    candidate_funcs = [[symb.name.decode('utf-8'), symb.address] for symb in peobj.DIRECTORY_ENTRY_EXPORT.symbols]
    smc_funcs = list(filter(lambda x: 'can_get_flag' in x[0] or 'smc' in x[0], candidate_funcs))
    return smc_funcs


enc_keys = {
    "can_get_flag": [55, 7, 39, 227, 9, 26, 205, 157, 109, 61, 254, 56, 207, 69],
    "smc1": [155, 254, 177, 21, 171, 126, 74, 154, 136, 15, 99, 93, 175, 252],
    "smc2": [40, 124, 172, 226, 104, 12, 179, 114, 101, 183, 45, 169, 121, 164],
    "smc3": [16, 113, 174, 24, 78, 9, 90, 95, 207, 146, 136, 125, 69, 203]
}


def enc(st, ed, enc_key):
    dat = peobj.get_data(st, ed - st + 1)
    res = bytes([v ^ enc_key[i % len(enc_key)] for i, v in enumerate(dat)])
    peobj.set_bytes_at_rva(st, res)


def main():
    smc_funcs = get_smc_funcs()
    print([[f[0], hex(f[1])] for f in smc_funcs])  # dbg
    sz1 = 0xB50 - 0xA3D
    sz2 = 0xC5F - 0xB6C
    for i, (func_name, st) in enumerate(smc_funcs):
        ed = st + (sz1 if func_name == 'can_get_flag' else sz2)
        enc_key = enc_keys[func_name]
        enc(st, ed, enc_key)
    res = peobj.write()
    with open('enc_e.dll', 'wb') as res_f:
        res_f.write(res)


if __name__ == '__main__':
    main()

和上一节《实现基于dll的SMC》不同,我改成了使用pefile包来进行dll的读写,这样代码会优雅得多。注意点:

  1. pefile官方文档语焉不详,建议直接看源码,<py安装路径>\Lib\site-packages\pefile.py
  2. 我们需要从导出表读取函数起始地址,这也是为什么需要使用pefile包。从源码中看到,peobj.DIRECTORY_ENTRY_EXPORT.symbolsExportData[]类型,ExportDataaddress就是我们需要的函数起始地址,它是rva。所以在实现代码的过程中,选用读写API时,挑选入参要求为rva的API即可。
  3. enc_keys是为每个SMC函数随机生成的密钥数组,在后文《正式实现》中需要做到自动生成。

正式实现

有了前期准备,这一步就是纯体力活了。具体操作:

  1. 我们需要使用模板引擎,来生成enc.cpp, enc_dll.py, main.cpp。这里选择了jinja2。记生成代码的文件名为generate_files.py,写好代码后运行一下,生成代码。
  2. 编译enc.h, enc.cpp,获取enc.dll,查看can_get_flagsmc1的大小,修改generate_files.py,再次运行生成代码。接下来再次编译enc.h, enc.cpp生成enc.dll,然后运行enc_dll.py生成enc_e.dll
  3. 最后编译main.cpp即可。

相关代码都可以在这里查看。generate_files.py

import jinja2
import random

SMC_NUM = 100
sz1 = 0xC9B - 0xA3D
sz2 = 0xDAA - 0xCB7
enc_key_obj_list = []
smc_func_names = []
smc_func_body_obj_list = []


def prepare_data():
    global smc_func_names
    for i in range(SMC_NUM + 1):
        random_enc_key = [random.randint(0, 255) for _ in range(14)]
        enc_key_obj_list.append({
            'name': ('smc%s' % i) if i else 'can_get_flag',
            'enc_key': random_enc_key,
            'enc_key_str': ', '.join([str(v) for v in random_enc_key])
        })
    smc_func_names = ['smc%s' % (i + 1) for i in range(SMC_NUM)]
    for i in range(SMC_NUM):
        # gen_main_cpp 用了 enc_key_obj_list[-1]['enc_key_str'],因此不需要再用
        smc_func_body_obj_list.append({
            'name': smc_func_names[i],
            'enc_key_str': enc_key_obj_list[i]['enc_key_str'],
            'to_decrypt': smc_func_names[i - 1] if i else 'can_get_flag',
            'to_call': smc_func_names[i - 1] if i else 'internal_func',
        })


def gen_enc_dll_py():
    fname = 'enc_dll.py.jinja'
    with open(fname, 'r', encoding='utf-8') as f:
        template = f.read()
        t = jinja2.Template(template)
        code = t.render(
            sz1=hex(sz1),
            sz2=hex(sz2),
            enc_key_obj_list=enc_key_obj_list
        )
        with open(fname[:-6], 'w', encoding='utf-8') as res_f:
            res_f.write(code)


def gen_main_cpp():
    fname = 'main.cpp.jinja'
    with open(fname, 'r', encoding='utf-8') as f:
        template = f.read()
        t = jinja2.Template(template)
        code = t.render(
            enc_key_last_str=enc_key_obj_list[-1]['enc_key_str'],
            smc_func_names=smc_func_names,
            sz2=hex(sz2)
        )
        with open(fname[:-6], 'w', encoding='utf-8') as res_f:
            res_f.write(code)


def gen_enc_cpp():
    fname = 'enc.cpp.jinja'
    with open(fname, 'r', encoding='utf-8') as f:
        template = f.read()
        t = jinja2.Template(template)
        code = t.render(
            smc_func_names=smc_func_names,
            sz1=hex(sz1),
            sz2=hex(sz2),
            smc_func_body_obj_list=smc_func_body_obj_list
        )
        with open(fname[:-6], 'w', encoding='utf-8') as res_f:
            res_f.write(code)


def main():
    prepare_data()
    gen_enc_dll_py()
    gen_main_cpp()
    gen_enc_cpp()


if __name__ == '__main__':
    main()

赏析:更简洁的SMC方案

在GitHub看到的一种很简洁的SMC方案。原理很简单:在运行时修改一个函数(在这个例子中是malicious)的函数体,使得一个变量的初值改变,从而随心所欲地控制函数走向的分支。可以往上添加反调试逻辑,就体现了这种随心所欲。具体实现如下:

  1. 首先写一段代码,在这个例子中是change_page函数,将SMC函数malicious所在的内存页修改为可写。
  2. 然后编译一次,查看malicious的汇编代码,找到赋值语句对应汇编的位置,并修改初值。注意仓库作者没提到但很重要的一点:这一步是和平台有关的。这就是为什么需要编译至少2次。
  3. 再编译一次。因为没有改动到malicious函数,所以它生成的汇编代码也不会改变。

我在原有代码的基础上做了些微不足道的修改。首先看代码:

#include <stdio.h>   // I/O
#include <windows.h> // Mem

// supposed malicious function
void malicious (void) {
    // i is always zero
    int i = 0;
    // thus this check is always fail
    // unless SMC changes this value
    if (i == 0x114514)
        // this is the malicious behavior
        printf ("I'm a malware i = %08x\n", i);
    else printf ("not malware i = %d\n", i);
}

// simple anti analysis function
BOOL anti_analysis() {
    return IsDebuggerPresent();
}

// page permission, as in the previous examples
void change_page (void *addr) {
    DWORD old;
    SYSTEM_INFO si;
    UINT64 _addr = (UINT64) addr;
    GetSystemInfo (&si);
    int page_size = si.dwPageSize;
    _addr -= (UINT64) addr % page_size;

    if (!VirtualProtect ( (PVOID) _addr, page_size, PAGE_EXECUTE_READWRITE, &old) )
        printf ("Error: %x\n", GetLastError() );

    return;
}

#define FUNC_ADJUST_OFFSET 0x08 // Function entry offset
#define INSTR_OFFSET 0x3        // instruction offset within the function
#define INSTR_DATA 0x114514          // new instruction bytes

// Program entry
int main() {
    // try first time
    // will be non-malicious
    malicious();

    //debug print
    printf ("PID %u\n", GetCurrentProcessId() );

    // anti-analysis trick
    if (!anti_analysis() ) {
        // SMC, as in the previous case
        void *func_addr = (char *) malicious + FUNC_ADJUST_OFFSET;
        change_page ( (void *) malicious);
        int *instruction = (int *) ( (char *) func_addr + INSTR_OFFSET);
        *instruction = INSTR_DATA;
    }

    // try second time
    // this time will be malicious
    malicious();

    return 0;
}

我们首先要编译一次,查看malicious的汇编代码:

.text:0000000000401550                               ; __int64 malicious(void)
.text:0000000000401550                               public _Z9maliciousv
.text:0000000000401550                               _Z9maliciousv proc near                 ; CODE XREF: main+D↓p
.text:0000000000401550                                                                       ; main:loc_40174D↓p
.text:0000000000401550                                                                       ; DATA XREF: main+46↓o
.text:0000000000401550                                                                       ; .pdata:000000000040506C↓o
.text:0000000000401550
.text:0000000000401550                               var_4= dword ptr -4
.text:0000000000401550
.text:0000000000401550 55                            push    rbp
.text:0000000000401551 48 89 E5                      mov     rbp, rsp
.text:0000000000401554 48 83 EC 30                   sub     rsp, 30h
.text:0000000000401558 C7 45 FC 00 00 00 00          mov     [rbp+var_4], 0
.text:0000000000401558
.text:000000000040155F
.text:000000000040155F                               loc_40155F:                             ; DATA XREF: main+3B↓o
.text:000000000040155F 83 7D FC 00                   cmp     [rbp+var_4], 0
.text:0000000000401563 74 13                         jz      short loc_401578
.text:0000000000401563
.text:0000000000401565 8B 45 FC                      mov     eax, [rbp+var_4]
.text:0000000000401568 89 C2                         mov     edx, eax
.text:000000000040156A 48 8D 0D 8F 2A 00 00          lea     rcx, Format                     ; "I'm a malware i = %d\n"
.text:0000000000401571 E8 CA 16 00 00                call    printf
.text:0000000000401571
.text:0000000000401576 EB 11                         jmp     short loc_401589
.text:0000000000401576
.text:0000000000401578                               ; ---------------------------------------------------------------------------
.text:0000000000401578
.text:0000000000401578                               loc_401578:                             ; CODE XREF: malicious(void)+13↑j
.text:0000000000401578 8B 45 FC                      mov     eax, [rbp+var_4]
.text:000000000040157B 89 C2                         mov     edx, eax
.text:000000000040157D 48 8D 0D 92 2A 00 00          lea     rcx, aNotMalwareID              ; "not malware i = %d\n"
.text:0000000000401584 E8 B7 16 00 00                call    printf

我们的目标就是这句:.text:0000000000401558 C7 45 FC 00 00 00 00 mov [rbp+var_4], 0。于是可以修改代码里定义的FUNC_ADJUST_OFFSETINSTR_OFFSET。修改好后再编译一次即可看到效果。文章来源地址https://www.toymoban.com/news/detail-432774.html

参考资料

  1. https://www.cnblogs.com/rixiang/p/8954822.html
  2. https://www.cygwin.com/cygwin-ug-net/dll.html

到了这里,关于【reverse】手把手带你基于dll实现多次SMC的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【数据结构】—堆详解(手把手带你用C语言实现)

                                            食用指南:本文在有C基础的情况下食用更佳                                          🔥 这就不得不推荐此专栏了: C语言                                        ♈️ 今日夜电波: 水星—今泉愛夏              

    2024年02月07日
    浏览(62)
  • 【数据结构】—手把手带你用C语言实现栈和队列(超详细!)

                                       食用指南:本文在有C基础的情况下食用更佳                                     🔥 这就不得不推荐此专栏了:C语言                                   ♈️ 今日夜电波:Tell me —milet                    

    2024年02月14日
    浏览(119)
  • 手把手带你实现Dubbo集成Nacos作为注册中心(超详细+全代码)

    Nacos简介 什么是Nacos? Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service的首字母简称,一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。 Nacos 致力于帮助您发现、配置和管理微服务。Nacos 提供了一组简单易用的特性集,帮助您快速实现动态服务发现、服

    2024年02月09日
    浏览(55)
  • 【是C++,不是C艹】 手把手带你实现Date类(附源码)

    💞💞 欢迎来到 Claffic 的博客 💞💞  👉  专栏: 《是C++,不是C艹》👈 前言: 恍惚间,已经两个月没更新了 (;´д`)ゞ 我忏悔...  但C++的学习不能停止!这期带大家实践一波,手把手教大家实现一个Date类,以感受C++类的魅力 注: 你最好是学完了C语言,并学过一些初

    2024年02月10日
    浏览(38)
  • 手把手带你实现ChatGLM2-6B的P-Tuning微调

    参考文献:chatglm2ptuning 注意问题1:AttributeError: ‘Seq2SeqTrainer’ object has no attribute \\\'is_deepspeed_enabl torch.distributed.elastic.multiprocessing.errors.ChildFailedError: 可能是版本太高,可以参考chatglm2的环境 1. ChatGLM2-6B的P-Tuning微调 ChatGLM2-6B :https://github.com/THUDM/ChatGLM2-6B 模型地址 :https://hug

    2024年02月17日
    浏览(58)
  • 从0到1,手把手带你开发截图工具ScreenCap------001实现基本的截图功能

    从0到1,手把手带你开发windows端的截屏软件ScreenCap 当前版本:ScreenCap---001 支持全屏截图 支持鼠标拖动截图区域 支持拖拽截图 支持保存全屏截图 支持另存截图到其他位置 注:博主所有资源永久免费,若有帮助,请点赞转发是对我莫大的帮助 注:博主本人学习过程的分享,

    2024年02月05日
    浏览(46)
  • 从0到1,手把手带你开发截图工具ScreenCap------002实现设置默认保存的图片位置

    在ScreenCap实现截图功能后增加设置图片默认保存位置的功能 实现选择文件夹作为截图的默认保存位置 注:博主所有资源永久免费,若有帮助,请点赞转发是对我莫大的帮助 注:博主本人学习过程的分享,引用他人的文章皆会标注原作者 注:本人文章非盈利性质,若有侵权请

    2024年02月05日
    浏览(75)
  • 从0到1,手把手带你开发截图工具ScreenCap------003实现最小化程序到托盘运行

    为了方便截图干净,实现最小化程序到托盘运行,简洁,勿扰 实现最小化程序到托盘运行 实现托盘菜单功能 实现回显主窗体 实现托盘开始截屏 实现气泡信息提示 实现托盘程序提示 实现托盘退出程序 封装完好,可复用 注:博主所有资源永久免费,若有帮助,请点赞转发是

    2024年02月05日
    浏览(53)
  • 手把手带你使用ESP8266 与 STM32F103C8实现网络服务器

    随着现在物联网设备的而越来越多,现在市场上出现越来越多的物联网设备,其中 ESP8266 是最受欢迎、价格便宜且易于使用的模块,它可以将您的硬件连接到互联网。 今天我们就以ESP8266和STM32来实现一台网络服务器,我们使用 ESP8266 将 STM32F103C8 连接到互联网。 ESP8266 Wi-Fi 模

    2024年01月23日
    浏览(129)
  • 手把手带你搞懂AMS启动原理

    彻底搞懂AMS即ActivityManagerService,看这一篇就够了 最近那么多教学视频(特别是搞车载的)都在讲AMS,可能这也跟要快速启动一个app(甚至是提高安卓系统启动速度有关),毕竟作为安卓系统的核心系统服务之一,AMS以及PMS都是很重要的,而我之前在 应用的开端–PackageManag

    2024年02月12日
    浏览(123)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包