远楒

ZIP 文件结构与解析流程核心笔记

Fri, 24 Apr 2026 02:10:00 +0800

ZIP 文件结构与解析流程核心笔记

ZIP文件基础结构图示

具体的结构和解析流程在后面会有详细介绍。

ZIP文件主要由三部分构成:

Local File Header: 每个压缩文件的起始位置，包含文件的元数据信息；
Central Directory(CD): 压缩文件的目录，记录了所有文件的元数据信息；
End of Central Directory(EOCDR): 压缩文件的结束位置，包含目录的元数据信息。

只考虑非分卷压缩的情况，EOCDR中包含指向Central Directory的偏移量，Central Directory的大小，以及CD条目的项数。

中央目录区包含了所有文件的元数据信息，每个文件的元数据信息由一个Central Directory Entry(CD Entry)表示。每个CD项中含有指向对应Local File Header的偏移量。

本地文件头区包含了每个压缩文件的元数据信息，每个文件的元数据信息由一个Local File Header(LFH)表示。文件的实际数据(压缩或未压缩)紧跟在其对应的LFH后面。

ZIP文件解析流程

本地文件头区已经包含了每个压缩文件的元数据信息，理论上仅通过读取LFH就能解压出压缩包内的所有文件，因此在解析ZIP文件时就产生了两种解析方式。

标准解析模式: 先读取整个Central Directory，然后根据CD项中的偏移量，随机访问到对应文件的LFH，从而获取文件的元数据信息。
流式解析模式: 从Local File Header开始，顺序解析每个压缩文件的元数据信息，直到无法读取有效的LFH签名为止。

目前大多数ZIP解析器默认采用标准解析模式，忽略掉没有被CD条目指向的LFH。

标准解析模式

从EOCDR中获取指向Central Directory的偏移量，然后根据CD项中的偏移量，随机访问到对应文件的LFH，从而获取文件的元数据信息。

sequenceDiagram participant Parser as 解析器 participant File as ZIP文件 participant LFH as 本地文件头 participant CD as 中央目录 participant EOCDR as 中央目录结束记录 Parser->>File: 从文件末尾查找EOCDR签名 File-->>Parser: 返回EOCDR位置 Parser->>EOCDR: 读取EOCDR内容 EOCDR-->>Parser: 返回EOCDR数据 Parser->>Parser: 提取Central Directory偏移量 Parser->>File: 跳转到Central Directory位置 loop 读取所有CD项 Parser->>CD: 读取一个CentralDirectoryHeader CD-->>Parser: 返回CD项数据 Parser->>Parser: 保存CD项 end loop 根据CD项读取所有LFH Parser->>CD: 从CD项获取Local File Header偏移量 CD-->>Parser: 返回偏移量 Parser->>File: 跳转到对应的Local File Header位置 Parser->>LFH: 读取LocalFileHeader LFH-->>Parser: 返回LFH数据 Parser->>Parser: 保存LFH end

流式解析模式

从Local File Header开始，顺序解析每个压缩文件的元数据信息，直到无法读取有效的LFH签名为止。

sequenceDiagram participant Parser as 解析器 participant File as ZIP文件 participant LFH as 本地文件头 Parser->>File: 将文件指针定位到文件开头 loop 顺序读取Local File Header Parser->>LFH: 尝试读取LocalFileHeader alt 成功读取LFH签名 LFH-->>Parser: 返回LocalFileHeader数据 Parser->>Parser: 保存LFH Parser->>File: 继续读取下一个LFH else 未找到有效的LFH签名或读取失败 File-->>Parser: 返回读取失败 Parser->>Parser: 停止解析 end end

手工篡改ZIP进行实验

zip_analyze目录为一个Zip解析器实例，可以使用两种解析模式读取未加密的Zip文件结构。另外该目录下包含两个Zip文件，分别为zip_demo.zip和zip_demo_hacked.zip。两者的区别在于zip_demo_hacked.zip在zip_demo.zip的基础上，在LFH区添加了一个额外的文件hacked.txt对应的LFH及其数据。具体如下图所示：

使用zip_analyze解析zip_demo_hacked.zip文件，在标准解析模式下，zip_analyze忽略掉了仅在LFH中存在的hacked.txt文件；而在流式解析模式下，zip_analyze能够成功解析出hacked.txt文件的信息。

Zip文件具体分析

根据官方文档, Zip文件的结构如下:

[local file header 1]
[encryption header 1]
[file data 1]
[data descriptor 1]
.
.
.
[local file header n]
[encryption header n]
[file data n]
[data descriptor n]
[archive decryption header]
[archive extra data record]
[central directory header 1]
.
.
.
[central directory header n]
[zip64 end of central directory record]
[zip64 end of central directory locator]
[end of central directory record]

本地文件头 - Local File Header

    uint32_t signature;
    uint16_t version_needed;
    uint16_t general_bit_flag;
    uint16_t compression_method;
    uint16_t last_mod_time;
    uint16_t last_mod_date;
    uint32_t crc32;
    uint32_t compressed_size;
    uint32_t uncompressed_size;
    uint16_t filename_length;
    uint16_t extra_field_length;
    std::string filename;
    std::unique_ptr<uint8_t[]> extra_field;

本地文件头的extra_field没有固定的内容，不同的压缩器可能会在extra_field中添加不同的信息。但是在extra_field中添加信息时通常要遵循统一的结构: 标签 - 长度 - 数据。

Tag（2 字节）：标识该扩展块的类型（如操作系统相关信息、压缩算法扩展等）。
Length（2 字节）：表示后续数据的长度。
Data：具体的扩展数据，格式由 Tag 定义。

具体标签值和含义的映射可以参考官方文档的4.5.2节，其中列举了由PKWARE定义的标签值和含义。

general_bit_flag

加密头 - Encryption Header

是否存在: 仅当general_bit_flag的第0位为1时，才存在加密头。

加密头的具体长度与结构由general_bit_flag的第6位确定：

当第六位为0时，加密头格式为传统PKWARE加密格式，长度为12字节；
当第六位为1时，加密头格式强加密格式，长度为可变，至少30字节。

IVSize    2 bytes  - 初始化向量大小
IVData    IVSize   - 初始化向量数据
Size      4 bytes  - 剩余解密头数据大小
Format    2 bytes  - 格式定义 (当前必须为3)
AlgID     2 bytes  - 加密算法标识符
Bitlen    2 bytes  - 密钥长度 (32-448 bits)
Flags     2 bytes  - 处理标志
ErdSize   2 bytes  - 加密随机数据大小
ErdData   ErdSize  - 加密的随机数据
Reserved1 4 bytes  - 证书处理保留字段
Reserved2 (var)    - 证书处理保留字段
VSize     2 bytes  - 密码验证数据大小
VData     VSize-4  - 密码验证数据 (加密)
VCRC32    4 bytes  - 密码验证数据的CRC32 (加密)

校验密码是否正确即是通过加密头内的部分字段进行的。

数据描述符 - Data Descriptor

用于在流式压缩场景下，将压缩数据的CRC-32、压缩大小和未压缩大小等信息从文件数据中分离出来。

由于lfh在文件数据之前，因此在流式压缩场景下，无法提前确定lfh中的crc32, compressed_size和uncompressed_size字段。此时，需要在文件数据之后添加一个数据描述符，用于存储这些信息。

    uint32_t signature;             /* 0x08074b50 */
    uint32_t crc32;
    uint32_t compressed_size;
    uint32_t uncompressed_size;

归档解密头 - Archive Decryption Header

结构与加密头相同，不同的是加密头是在每个文件数据之前，而归档解密头是在所有文件数据之后。归档解密头的位置由Zip64 End of Central Directory Record中的Start of Central Directory字段指定。

使用归档解密头可以支持加密整个中央目录结构，保护所有文件的元数据。

只在Zip64格式下才会存在归档解密头。

归档解密头的结构与Encryption Header完全相同。

归档额外数据记录 - Archive Extra Data Record

Archive Extra Data Record 主要用于存储与中央目录加密相关的额外信息，特别是：

数字证书信息：存储 PKCS#7 证书存储、X.509 证书 ID 和签名等
加密相关数据：存储加密接收者证书列表等

其结构定义如下：

    uint32_t signature;             /* 0x08074b50 */
    uint32_t extra_field_length;
    std::unique_ptr<uint8_t[]> extra_field;

中央目录头 - Central Directory Header

    uint32_t signature;
    uint16_t version_made_by;
    uint16_t version_needed;
    uint16_t general_bit_flag;
    uint16_t compression_method;
    uint16_t last_mod_time;
    uint16_t last_mod_date;
    uint32_t crc32;
    uint32_t compressed_size;
    uint32_t uncompressed_size;
    uint16_t filename_length;
    uint16_t extra_field_length;
    uint16_t file_comment_length;
    uint16_t disk_number_start;
    uint16_t internal_attr;
    uint32_t external_attr;
    uint32_t local_header_offset;
    std::string filename;
    std::unique_ptr<uint8_t[]> extra_field;
    std::string file_comment;

中央目录头与本地文件头之间存在许多冗余字段，原则上相对应的一对中央目录头和本地文件头，表示含义相同的字段值应该是相同的。

【武大软件逆向课程/第四周】加减乘除运算的逆向特征

Sat, 15 Mar 2025 06:27:52 +0000

汇编语言预备知识

指令简介与总览

汇编指令	指令格式	功能	备注
lea	`lea reg, addr`	主要用于将一个内存地址加载到寄存器中，而不是将该地址处的数据加载到寄存器。	如在`printf`函数中，将格式字符串的地址加载到指定寄存器中供`printf`函数读取。
inc	`inc reg`	寄存器自增1	变量加一
mov	`mov reg, imm`	将立即数赋值到寄存器中	`imm`意为立即数(immediate number)
imul	指令格式见详解	用于执行带符号整数乘法。	它可以接受一个、两个或三个操作数，具体取决于你想要执行的乘法类型。
mul	`mul source`	用于执行无符号整数乘法。	`mul` 指令只接受一个操作数，这个操作数可以是寄存器或内存地址。根据操作数的大小（8位、16位、32位或64位），乘积会被存储在特定的寄存器组合中。
shl/shr	`shl/shr dest, cnt`	逻辑左/右移	`shr`用于将寄存器或内存中的二进制数值向右移动指定的位数。这个操作会将每个位都向右移动，并在左侧补0。对于无符号数来说，这相当于除以2的幂次；而对于有符号数，它仅当被移位的数据视为无符号时有效，因为逻辑右移不会复制符号位。
sar	`sar dest, count`	算术左/右移	`sar`指令用于将指定的二进制数按算术右移的方式移动指定的位数。算术右移是指在右移时，最高位（符号位）保持不变，低位移出，高位补上符号位的值。这通常用于有符号数的除以2的幂次操作。
cdq	`cdq`	将32位寄存器`eax`中的有符号数符号扩展为64位，结果存储在由`edx:eax`组成的64位寄存器中	它会把`eax`的第31位（符号位）复制到`edx`的每一位。如果`eax`的符号位是0（即正数），则`edx`会被设置为0；如果符号位是1（即负数），则`edx`会被设置为全1。通常在执行32位有符号除法（如`idiv`指令）之前使用，以确保被除数的符号位正确扩展到高位寄存器，从而保证除法运算的正确性。
cqo	`cqo`	将64位寄存器`rax`中的有符号数符号扩展为128位，结果存储在由`rdx:rax`组成的128位寄存器中	它会把`rax`的第63位（符号位）复制到`rdx`的每一位。如果`rax`的符号位是0，则`rdx`被设置为0；如果符号位是1，则`rdx`被设置为全1。在64位模式下，通常在执行64位有符号除法之前使用，确保被除数的符号位正确扩展到高位寄存器。

imul - 带符号整数乘法

一个操作数

imul src

这种形式假设隐含的目标操作数是累加器（对于16位操作为AX，对于32位操作为EAX，对于64位操作为RAX）。该指令将累加器与source相乘，并将结果存储回累加器和其对应的双倍宽度寄存器（即对于16位操作为DX:AX，对于32位操作为EDX:EAX，对于64位操作为RDX:RAX）。

两个操作数

imul dest, source

这种形式将source与dest相乘，并将结果存储在dest中。dest可以是一个寄存器或内存位置，而source可以是一个寄存器、内存位置或立即数。注意，结果被截断到目标操作数的大小。

三个操作数

imul dest, source1, source2

这种形式将source1与source2相乘，并将结果存储在dest中。source1和source2可以是寄存器、内存位置或立即数，但dest必须是寄存器。结果同样被截断到目标操作数的大小。

mul - 无符号整数乘法

mul的功能

MUL是一个单操作数指令，它隐式地使用AL（8位）、AX（16位）、EAX（32位）或RAX（64位）作为其中一个乘数，具体取决于操作数的大小和处理器模式。

对于字节乘法（8位），结果被存储在AX寄存器中；对于字乘法（16位），结果被存储在DX:AX寄存器对中；对于双字乘法（32位），结果被存储在EDX:EAX寄存器对中；对于四字乘法（64位），结果被存储在RDX:RAX寄存器对中。

mul的示例

; 8 
mov al, 0x05       ; AL = 5
mov bl, 0x03       ; BL = 3
mul bl             ; AX := AL * BL
; AL = 5 * 3 = 15 (0x0F), AH = 0

; 16
mov ax, 0x0123     ; AX = 291
mov bx, 0x0004     ; BX = 4
mul bx             ; DX:AX := AX * BX
; AX = 291 * 4 = 1164 (0x048C), DX = 0

; 32
mov eax, 0x12345678 ; EAX = 305419896
mov ebx, 0x00000002 ; EBX = 2
mul ebx             ; EDX:EAX := EAX * EBX
; EAX = 305419896 * 2 = 610839792 (0x2468ACF0), EDX = 0

scanf与printf函数

scanf会使用多个寄存器：rcx，rdx，r8等等，均存储输入项的地址，其中rcx为格式化字符串的地址。 printf使用的寄存器与scanf类似。

逆向分析程序1

使用IDA打开reverse_basic.exe，反汇编结果如下：

; int __fastcall main(int argc, const char **argv, const char **envp)
main proc near

var_18= dword ptr -18h
var_14= dword ptr -14h
var_10= qword ptr -10h
arg_0= qword ptr  8
arg_8= qword ptr  10h
arg_10= qword ptr  18h

; __unwind { // __GSHandlerCheck
mov     [rsp+arg_0], rbx
mov     [rsp+arg_8], rbp
mov     [rsp+arg_10], rsi
push    rdi
sub     rsp, 30h
mov     rax, cs:__security_cookie
xor     rax, rsp
mov     [rsp+38h+var_10], rax
lea     r8, [rsp+38h+var_18]
lea     rdx, [rsp+38h+var_14]
lea     rcx, aDD        ; "%d %d"
call    sub_140001080
mov     ecx, [rsp+38h+var_18]
mov     eax, 38E38E39h
add     ecx, [rsp+38h+var_14]
imul    r8d, ecx, 7
lea     rcx, Format     ; "%d\n"
lea     ebx, ds:0[r8*8]
lea     edi, [rbx+rbx*8]
mul     edi
mov     esi, edx
mov     edx, r8d
shr     esi, 1
mov     ebp, esi
shr     ebp, 3
call    sub_140001020
mov     edx, ebx
lea     rcx, Format     ; "%d\n"
call    sub_140001020
mov     edx, edi
lea     rcx, Format     ; "%d\n"
call    sub_140001020
mov     edx, esi
lea     rcx, aU         ; "%u\n"
call    sub_140001020
mov     edx, ebp
lea     rcx, aU         ; "%u\n"
call    sub_140001020
mov     eax, 24924925h
lea     rcx, aU         ; "%u\n"
mul     ebp
sub     ebp, edx
shr     ebp, 1
add     edx, ebp
shr     edx, 2
call    sub_140001020
xor     eax, eax
mov     rcx, [rsp+38h+var_10]
xor     rcx, rsp        ; StackCookie
call    __security_check_cookie
mov     rbx, [rsp+38h+arg_0]
mov     rbp, [rsp+38h+arg_8]
mov     rsi, [rsp+38h+arg_10]
add     rsp, 30h
pop     rdi
retn
; } // starts at 1400010E0
main endp

可以发现该程序的结构大致是，进行一些运算之后，集中打印运算结果。其中sub_140001020即为prinf函数，sub_140001080为scanf函数。

lea     r8, [rsp+38h+var_18]
lea     rdx, [rsp+38h+var_14]
lea     rcx, aDD        ; "%d %d"
call    sub_140001080

因此此程序会读取两个四字节数据写入var_14和var_18。

mov     ecx, [rsp+38h+var_18]
mov     eax, 38E38E39h
add     ecx, [rsp+38h+var_14]
imul    r8d, ecx, 7

分析接下来的指令，程序将读取的两个数相加之后乘以7，将结果存到r8d中。

lea     rcx, Format     ; "%d\n"
lea     ebx, ds:0[r8*8]
lea     edi, [rbx+rbx*8]
mul     edi
mov     esi, edx
mov     edx, r8d
shr     esi, 1
mov     ebp, esi
shr     ebp, 3
call    sub_140001020

lea ebx, ds:0[r8*8]通过地址计算的方式计算了r8 * 8的值存入ebx中，然后类似地计算rbx * 9存入edi中。

然后经过其他无关运算后，调用printf将r8d(乘以7的结果)打印出来（先将r8d赋给edx）。

mov     edx, ebx
lea     rcx, Format     ; "%d\n"
call    sub_140001020
mov     edx, edi
lea     rcx, Format     ; "%d\n"
call    sub_140001020

这一段打印出ebx和edi。

mov     edx, esi
lea     rcx, aU         ; "%u\n"
call    sub_140001020
mov     edx, ebp
lea     rcx, aU         ; "%u\n"
call    sub_140001020

根据这两个打印可以知道，在上面的运算中，esi和ebp被存入了运算结果，让我们再次分析上面被我们忽视的部分指令：

mov     eax, 38E38E39h
...
lea     rcx, Format     ; "%d\n"
lea     ebx, ds:0[r8*8]
lea     edi, [rbx+rbx*8]
mul     edi
mov     esi, edx
mov     edx, r8d
shr     esi, 1
mov     ebp, esi
shr     ebp, 3
call    sub_140001020

mul edi的作用：会计算edi * eax，将结果存入edx: eax中，eax被赋值为38E38E39h，是编译器将除以9运算进行优化使用的魔数。因此esi为edi / 9。然后将esi存入ebp后右移3位。

mov     eax, 24924925h
lea     rcx, aU         ; "%u\n"
mul     ebp
sub     ebp, edx
shr     ebp, 1
add     edx, ebp
shr     edx, 2
call    sub_140001020

24924925h是除以7的魔数，因此这里计算ebp除以7后打印出来。

综上，我们可以复原这个可执行文件的原c文件：

#include <stdio.h>

int main(int argc, char *argv[]) {
    int a, b, c;
    scanf("%d %d", a, b);
    c = a + b;
    int n1 = c * 7;
    int n2 = n1 * 8;
    int n3 = n2 * 9;
    unsigned int n4 = n3 / 9;
    unsigned int n5 = n4 / 8;
    unsigned int n6 = n5 / 7;
    
    printf("%d\n", n1);
    printf("%d\n", n2);
    printf("%d\n", n3);
    printf("%u\n", n4);
    printf("%u\n", n5);
    printf("%u\n", n6);
    
    return 0;
}

逆向分析程序2

; int __fastcall main(int argc, const char **argv, const char **envp)
main proc near

var_18= dword ptr -18h
var_14= dword ptr -14h
var_10= qword ptr -10h
arg_0= qword ptr  8

; __unwind { // __GSHandlerCheck
mov     [rsp+arg_0], rbx
push    rdi
sub     rsp, 30h
mov     rax, cs:__security_cookie
xor     rax, rsp
mov     [rsp+38h+var_10], rax
lea     r8, [rsp+38h+var_14]
lea     rdx, [rsp+38h+var_18]
lea     rcx, aDD        ; "%d %d"
call    sub_140001080
mov     eax, [rsp+38h+var_14]
lea     rcx, Format     ; "%d\n"
mov     edi, [rsp+38h+var_18]
lea     ebx, [rdi+rax]
imul    edi, eax
lea     edx, [rdi+rbx]
call    sub_140001020
mov     eax, 66666667h
imul    [rsp+38h+var_18]
sar     edx, 1
mov     ecx, edx
shr     ecx, 1Fh
add     edx, ecx
lea     rcx, Format     ; "%d\n"
call    sub_140001020
mov     r8d, [rsp+38h+var_14]
lea     rcx, Format     ; "%d\n"
lea     edx, [r8+r8*4]
call    sub_140001020
sub     ebx, [rsp+38h+var_18]
lea     rcx, Format     ; "%d\n"
mov     edx, ebx
call    sub_140001020
mov     eax, edi
lea     rcx, Format     ; "%d\n"
cdq
idiv    [rsp+38h+var_14]
mov     edx, eax
call    sub_140001020
xor     eax, eax
mov     rcx, [rsp+38h+var_10]
xor     rcx, rsp        ; StackCookie
call    __security_check_cookie
mov     rbx, [rsp+38h+arg_0]
add     rsp, 30h
pop     rdi
retn
; } // starts at 1400010E0
main endp

lea     r8, [rsp+38h+var_14]
lea     rdx, [rsp+38h+var_18]
lea     rcx, aDD        ; "%d %d"
call    sub_140001080

容易知道，这里使用scanf函数读入两个数据存入var_18， var_14中。

mov     eax, [rsp+38h+var_14]
lea     rcx, Format     ; "%d\n"
mov     edi, [rsp+38h+var_18]
lea     ebx, [rdi+rax]
imul    edi, eax
lea     edx, [rdi+rbx]
call    sub_140001020

这段首先将var_14和var_18分别存入eax和edi中。计算ebx = rdi + rax，计算edi = edi * eax，计算edx = rdi + rbx。即为计算edx = var_14 + var_18 + var_14 * var_18然后打印出来。

mov     eax, 66666667h
imul    [rsp+38h+var_18]
sar     edx, 1
mov     ecx, edx
shr     ecx, 1Fh
add     edx, ecx
lea     rcx, Format     ; "%d\n"
call    sub_140001020

这里是使用魔数66666667h优化除法运算。实际上计算的是var_18 / 5。

mov     r8d, [rsp+38h+var_14]
lea     rcx, Format     ; "%d\n"
lea     edx, [r8+r8*4]
call    sub_140001020

容易知道这里计算的是var_14 * 5，使用var_14 * 4 + var_14优化。

sub     ebx, [rsp+38h+var_18]
lea     rcx, Format     ; "%d\n"
mov     edx, ebx
call    sub_140001020
mov     eax, edi
lea     rcx, Format     ; "%d\n"
cdq
idiv    [rsp+38h+var_14]
mov     edx, eax
call    sub_140001020

ebx在之前存储着var_18 + var_14的结果，因此这里计算ebx - var_18后打印。

edi存储着var_18 * var_14的结果，这里计算var_18 * var14 / var_14后打印。

源码：

#include <stdio.h>

int main() {
    int var_18, var_14;
    scanf("%d %d", &var_18, var_14);
    int a = var_18 + var_14;
    int b = var_18 * var_14;
    
    printf("%d\n", a + b);
    printf("%d\n", var_18 / 5);
    printf("%d\n", var_14 * 5);
    printf("%d\n", a - var_18);
    printf("%d\n", b / var_14);
    
    return 0;
}

【武大软件逆向课程/第一周】扫雷逆向分析批量插旗及机器指令表.exe文件字体更换

Wed, 19 Feb 2025 17:43:52 +0800

作业目标

逆向分析扫雷程序winmine.exe，并编写程序对其进行批量插旗
更换机器指令表.exe内的显示字体

扫雷

定位绘制雷区的代码位置

使用Ollydbg打开winmin.exe。

在当前模块中右键->查找->当前模块中的名称（标签），在弹出的窗口中寻找名称为Bitblt的函数。这里可以直接右键->在每个参考上设置断点，但是我的Ollydbg会报错。因此采用后续的方法。

选中Bitblt项后，按回车键Enter，在弹出的窗口中再次按回车Enter。

执行上述操作后弹出的窗口即为Bitblt的源码，在源码首行按F2或者右键设置断点。

设置断点后按F9或功能按钮运行程序，程序会暂停在断点处。此时按Ctrl + F9或者功能按钮执行到返回，程序会运行到函数Bitblt调用处的下一行。

观察上下文程序可以发现是类似于一个循环的结构，其中esi寄存器为循环变量。

定位雷区数据地址

在这一节内需要观察不同操作下内存区域的变化。

在Ollydbg中可以通过单击任意数据来刷新数据窗口中的内容。

如果想要重新绘制扫雷窗口，需要最小化后恢复窗口。

观察内存读取部分，代码中只有两句可能是对于数组的读取。分别为：

mov    al, byte ptr [ebx+esi]
push   dword ptr [eax*4+1005A20]

这里可以记录一下Bitblt调用处的地址1002706，然后取消所有断点重新运行程序，将游戏切换到高级模式，随机点击一个地块。这里为了便于定位雷区数据位置，我们多次开局点击地块，直到仅连锁翻开一个地块（这样对雷区数据的影响较小，数据特征更明显）。

然后将在数据窗口中右键->转到->表达式或者按Ctrl + G，输入内存读取部分的常量地址1005A20跳转到该地址。观察数据窗口内该地址处的数据。

发现并不符合雷区数据的特征（至少应该出现大量相同的两种数据）。实际上作为绘制雷区的函数，对数组下标的访问应该具有循环变量，也就是esi寄存器应该参与内存地址的计算，而这条指令并不符合。

因此选择下面的指令来寻找雷区数据所在的内存地址。

mov    al, byte ptr [ebx+esi]

在这条指令上打断点后最小化扫雷窗口，再恢复窗口，查看ebx寄存器的值，发现是内存地址1005360，在数据窗口中跟踪该地址。

该地址处的内存数据如下。可以大致推测，未翻开的雷区和未翻开的空白对应数据为0x0F或0x8F。

再次重开游戏，翻开第一个地块以定位数据区域首个元素的位置，如下图所示。

对比可知1005361为首的地址存放雷区数据。

分析地块状态对应的内存值

非雷区地块

从上一节的最后一个图可以得知，翻开的2地块对应的内存值为0x42。推测翻开的n对应的内存值为0x4n。

翻开相邻地块进行验证，可知推测成立，同时也得知未翻开的非雷区对应的内存值为0x0F。

雷区地块

再次观察内存区域，在9个地块后，有一个地块的内存值为不同的0x8F，翻开该地块后再次观察内存区域变化。

可知未翻开的雷为0x8F，翻开的雷为0x8A，踩中的雷为0xCC。

插旗地块与存疑地块

重开游戏并刷新数据窗口。在任意0x8E和0x0F对应的地块上右键以插旗后，刷新数据窗口，观察对应数据变化。扫雷游戏中还有一种标记，在插旗的地块上再次右键可以变为问号地块，这里称为存疑地块，与本次任务并不相关，但是这里还是给出其对应的内存值。

观察上图可知，插旗地块的0x?F被替换为0x?E，存疑地块的0x?F被替换为0x?D。

至此，所有地块状态对应的内存值均被我们分析出来。

简单总结一下，地块状态对应的内存值如下：

地块状态	内存值	地块状态	内存值
未翻开的空地	0x0F	插旗的空地	0x0E
翻开的空地	0x4n(n为要显示的数字)	存疑的空地	0x0D
未翻开的地雷	0x8F	插旗的地雷	0x8E
翻开的地雷	0x8A	存疑的地雷	0x8D
踩中的地雷	0xCC

此外，按Ctrl + ↓调整数据窗口首列数据从0x01偏移开始展示，可以发现在高级模式下30 * 16的布局下，每30个地块的数据后都有两个0x10，用于标注此行结束，在后面编写程序时，应当注意处理这个间隔区域。

编写程序以批量插旗地雷

程序如下：

#include <windows.h>
#include <stdio.h>
#include <tchar.h>
#include <tlhelp32.h>

#define GET_OFFSET(ROW, COL) ((ROW) * 32 + (COL))

void print_sign(BYTE val) {
    if (val == 0x0F || val == 0x8F) {
        printf("--");
    } else if (val == 0x0E || val == 0x8E) {
        printf("||");
    } else if (val == 0x0D || val == 0x8D) {
        printf("??");
    } else if (val == 0x40) {
        printf("..");
    } else if (val == 0x8A) {
        printf("**");
    } else if (val == 0xCC) {
        printf("XX");
    } else if (val == 0x10) {
    } else {
        printf("%01X", val & 0x0F);
        printf("%01X", val & 0x0F);
    }
    printf(" ");
}

int main() {
    DWORD pid = 0;          // Target process ID
    HANDLE hProcess = NULL;
    LPVOID targetAddress = (LPVOID)0x1005361; // Target memory address
    BYTE readBuffer[512] = {0};
    // BYTE writeData[4] = {0xAA, 0xBB, 0xCC, 0xDD}; // Example data to write
    SIZE_T bytesRead = 0;
    // SIZE_T bytesWritten = 0;

    // Create a snapshot of all processes
    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hSnapshot == INVALID_HANDLE_VALUE) {
        printf("Failed to create process snapshot, error code: %d\n", GetLastError());
        return 1;
    }

    PROCESSENTRY32 pe = {sizeof(PROCESSENTRY32)};
    if (Process32First(hSnapshot, &pe)) {
        do {
            if (_tcsicmp(pe.szExeFile, _T("winmine.exe")) == 0) {
                pid = pe.th32ProcessID;
                printf("Process found: winmine.exe, PID: %u\n", pid);
                break;
            }
        } while (Process32Next(hSnapshot, &pe));
    } else {
        printf("Failed to retrieve process information, error code: %d\n", GetLastError());
    }

    CloseHandle(hSnapshot);

    if (pid == 0) {
        printf("Process winmine.exe not found\n");
        return 1;
    }

    // Open the target process with required permissions for memory operations
    hProcess = OpenProcess(
        PROCESS_VM_READ | PROCESS_VM_WRITE | PROCESS_VM_OPERATION,
        FALSE,
        pid
    );

    if (hProcess == NULL) {
        printf("Failed to open process, error code: %d\n", GetLastError());
        return 1;
    }

    // Read memory content
    if (!ReadProcessMemory(
        hProcess,
        targetAddress,
        readBuffer,
        sizeof(readBuffer),
        &bytesRead
    )) {
        printf("Failed to read memory, error code: %d\n", GetLastError());
        CloseHandle(hProcess);
        return 1;
    }
    printf("Read %d bytes of data:\n", bytesRead);
    for (int i = 0; i < 16; i++) {
        for (int j = 0; j < 32; j++) {
            print_sign(readBuffer[GET_OFFSET(i, j)]);
        }
        printf("\n");
    }


    printf("Start flaging all the mines..\n");
    // Write to memory
    int count = 0;
    for (int i = 0; i < 16; i++) {
        for (int j = 0; j < 32; j++) {
            BYTE flag_mine = 0x8E;
            if (readBuffer[GET_OFFSET(i, j)] == 0x8F) {
                WriteProcessMemory(
                    hProcess,
                    targetAddress + GET_OFFSET(i, j),
                    &flag_mine,
                    sizeof(flag_mine),
                    NULL
                );
                count++;
            }
        }
    }
    printf("Finish! the count of mines: %d\n", count);

    CloseHandle(hProcess);
    // system("pause");
    return 0;
}

这段程序将会在打印雷区当前状态后，将所有0x8F修改为0x8E，即将所有的未翻开的地雷插上旗子，用户应当在新一局游戏内翻开任意地块后运行此程序，然后最小化再恢复窗口以重新绘制雷区。

打印当前状态过程中，未翻开的所有地块将记为--，插旗地块记为||，翻开的空地记为..，翻开的数字地块记为该数字，翻开的地雷记为**，踩中的地雷记为XX。

实验结果

运行结果如下图所示：

刷新窗口后成功插旗。

降低雷数为20后重新运行，便于验证结果正确性，手动翻开所有未插旗地块，中间笑脸图标带上墨镜（表示游戏胜利），可见结果正确。

更换机器指令表.exe显示字体

定位控制字体显示的WinAPI

使用Ollydbg打开机器指令表.exe。

在API文档及网络资料中查询其内涉及的API。

API名称	功能
GetModuleHandle	检索指定模块的模块句柄。模块必须已由调用进程加载。
GetCommandLine	检索当前进程的命令行字符串。
ExitProcess	结束调用进程及其所有线程。
GetSystemMetrics	用于获取关于显示器、鼠标、键盘等系统参数的信息。

观察发现在程序有效的程序段中涉及的三个WinAPI均与字体显示无关。还剩下一个call 004031，推测其很可能控制字体的显示。其上的四个push可能包含参数，尝试修改为push 0D 观察程序变化。修改两个push后运行程序并无明显变化。可见这两个参数并不控制该程序的字体显示。

在call 00401031处设断点并单步步入，依次检索遇见的到的WinAPI功能。

API名称	功能
CreateWindowEx	用于创建一个窗口（包括各种控件如按钮、文本框等）。
SetWindowLong	更改指定窗口的属性。该函数还将指定偏移量处的32位(长)值设置为额外的窗口内存。
GetStockObject	用于获取预定义的图形对象（如画笔、画刷和字体）的句柄。

其中GetStockObject涉及字体的显示，在4010C6处调用，其上一条指令push 0B很可能控制字体的显示。

将push 0B修改为push 0E后继续运行程序，可见字体明显发生变化。

将修改保存到文件

选中被修改的指令，在指令窗口中右键->复制到可执行文件->选择，在弹出的新窗口中选中被修改的指令，右键->保存文件。将新可执行文件命名为机器指令表2.exe。

双击运行修改前后的机器指令表，对比两者的字体差异。

Widgets修复与开发

Wed, 12 Feb 2025 16:33:24 +0800

计划

添加widget，展示当前博文的tags

右侧边栏的tag-cloud和categories不能处理hidden博文

tag-cloud识别hidden博文

把layouts/partials/widget/tag-cloud.html的渲染tag-cloud的逻辑进行如下修改：

        <div class="tagCloud-tags">
-        {{ range first $limit $context.Site.Taxonomies.tags.ByCount }}
-            <a href="{{ .Page.RelPermalink }}" class="font_size_{{ .Count }}">
-                {{ .Page.Title }}
-            </a>
+        {{- $cateTaxonomy := $context.Site.GetPage "tags" -}}
+        {{- $cateTerms := $cateTaxonomy.Pages -}}
+        {{ range first $limit $cateTerms }}
+            {{- $pages := .Pages -}}
+            {{- $filteredPages := where $pages ".Params.hidden" "!=" true -}}
+            {{ if $filteredPages }}
+                <a href="{{ .RelPermalink }}" class="font_size_{{ len $filteredPages}}">
+                    {{ .Title }}
+                </a>
+            {{ end }}
+        {{ end }}
    </div>

如另一篇博文中的方法，从$context.Site中获取所有tags然后过滤掉hidden == true的博文后，判断$filteredPages中是否还有元素，如果有则渲染这个tag。

添加模板文件

在layouts/partials/widget文件夹下新建文件cur-tags.html，添加如下内容：

{{- $context := .Context -}}
{{ if .Context.Page.Params.Tags }}
<section class="widget curTags">
    <div class="widget-icon">
        {{ partial "helper/icon" "tag" }}
    </div>
    <h2 class="widget-title section-title">{{ T "widget.curTags.title" }}</h2>
    <div class="curTags-tags">
        {{ range (.Context.Page.GetTerms "tags") }}
            <a href="{{ .RelPermalink }}">
                {{ .LinkTitle }}
            </a>
        {{ end }}
    </div>
</section>
{{ end }}

首先判断当前文章是否有tag，然后根据其他widget的模板修改成current tags，使用GetTerms方法获得当前文章的tags，作为<a>标签的参数。

注意<h2>标签中的T函数，用于在修改页面语言时批量替换文本，我们需要在对应文件中添加widget.curTags.title命名空间的值。

添加i18n替换文本

在i18n/en.yaml和i18n/zh-cn.yaml中添加相关内容，在widget域下添加内容：

widget:
+    curTags:
+        title:
+            other: Tags of current blog

添加scss样式表

在assets/scss/partials/widgets.scss中添加curTags的样式。

/* Current tags widget */
.curTags {
    .curTags-tags {
        display: flex;
        flex-wrap: wrap;
        gap: 10px;

        a {
            background: var(--card-background);
            box-shadow: var(--shadow-l1);
            border-radius: var(--tag-border-radius);
            padding: 8px 20px;
            color: var(--card-text-color-main);
            font-size: 1.4rem;
            transition: box-shadow 0.3s ease;

            &:hover {
                box-shadow: var(--shadow-l2);
            }
        }
    }
}

自此，current tags控件的开发已经成功，在stack/config.yaml中添加配置项即可。

params:
    widgets:
        page:
+          - type: cur-tags

Archive页改造

Sun, 02 Feb 2025 22:46:55 +0800

Archive页介绍

archive页面展示了当前博文的所有类型，在此之下依据年份时序展示所有博文。

改造计划:

添加对以tag分类的支持
- 支持在archive页展示tag模块
- 修改tag–tile的大小
- 修改tag–tile的排列方式
- 为tag分类的每一个tile添加不同颜色
修复在archive页面的category tile展示异常
修复category详细页的文章数量异常
添加archive页面对应配置项

使用开发者工具检查archive页面元素

发现category分类的元素为：

    <h2 class="section-title">类别 - Categories</h2>
    <div class="subsection-list">
        <div class="article-list--tile">
            <article>
            </article>
        </div>
    </div>

显然<div class="article-list--tile">的class属性命名并不合理，因为在archive首页展示的category列表的每一个tile并不是一篇article，因此应当修改为<div class="category-list--tile">。

在文件themes/hugo-theme-stack/layouts/_default/archives.html中将<div class="article-list--tile">修改为<div class="category-list--tile">。

同时将下列文件中的选择器article-list--tile修改为category-list--tile。在scss文件中建议保留原有的选择器，新增修改名称后的选择器。

themes/hugo-theme-stack/assets/scss/partials/article.scss
themes/hugo-theme-stack/assets/scss/partials/layout/list.scss
/home/fendy/Project/BlogSrc/themes/hugo-theme-stack/assets/ts/main.ts

修复category tile展示异常

本质上是没有添加对hidden文章的判断逻辑，在themes/hugo-theme-stack/layouts/_default/archives.html中添加筛选逻辑：

    <h2 class="section-title">类别 - {{ $cateTaxonomy.Title }}</h2>
    <div class="subsection-list">
        <div class="category-list--tile">
            {{ range $cateTerms }}
                {{- $pages := .Pages -}}
                {{- $filteredPages := where $pages ".Params.hidden" "!=" true -}}
                {{ if $filteredPages }}
                    {{ partial "article-list/tile" (dict "context" . "size" "250x150" "Type" "taxonomy") }}
                {{ end }}
            {{ end }}
        </div>
    </div>

添加对tag分类的支持

支持在archive页展示tag模块

在themes/hugo-theme-stack/layouts/_default/archives.html中，类别模块的下方添加如下代码：

    {{- $tagTaxonomy := $.Site.GetPage "taxonomyTerm" "tags" -}}
    {{- $tagTerms := $tagTaxonomy.Pages -}}
    {{ if $tagTerms }}
    <h2 class="section-title">标签 - {{ $tagTaxonomy.Title }}</h2>
    <div class="subsection-list">
        <div class="tag-list--tile">
            {{ range $tagTerms }}
                {{/* 获取当前标签下的所有页面 */}}
                {{- $pages := .Pages -}}
                {{/* 过滤掉 hidden 为 true 的页面 */}}
                {{- $filteredPages := where $pages ".Params.hidden" "!=" true -}}
                {{ if $filteredPages }}
                    {{ partial "article-list/tile" (dict "context" . "Type" "tag" "pages" $filteredPages) }}
                {{ end }}
            {{ end }}
        </div>
    </div>
    {{ end }}

添加tag的样式并修改tag–tile的大小

在themes/hugo-theme-stack/assets/scss/partials/article.scss中添加:

.tag-list--tile {
    article {
        border-radius: var(--card-border-radius);
        overflow: hidden;
        position: relative;
        height: 350px;
        width: 250px;
        box-shadow: var(--shadow-l1);
        transition: box-shadow 0.3s ease;
        background-color: var(--card-background);

        &:hover {
            box-shadow: var(--shadow-l2);
        }

        .article-details {
            border-radius: var(--card-border-radius);
            position: relative;
            height: 100%;
            width: 100%;
            display: flex;
            flex-direction: column;
            justify-content: flex-end;
            z-index: 2;
            padding: 15px;

            @include respond(sm) {
                padding: 20px;
            }
        }

        .article-title {
            font-size: 2rem;
            font-weight: 500;
            color: var(--card-text-color-main);

            @include respond(sm) {
                font-size: 2.2rem;
            }
        }
    }
}

在themes/hugo-theme-stack/assets/scss/partials/layout/list.scss中添加:

    .tag-list--tile {
        display: flex;

        article {
            width: 120px;
            height: 30px;
            margin-right: 20px;
            flex-shrink: 0;

            .article-title {
                margin: 0;
                font-size: 1.8rem;
            }

            .article-details {
                padding-bottom: 5px;
                text-align: center;
            }
        }
    }

添加archives页面对应配置项

设计配置项

由于目前archives页面有三个板块：Categories，Tags，Dates。考虑添加如下配置项（标注出的为默认配置，不进行配置也会以下面代码块给定的配置渲染）：

params:
    archives:
        showCategories: true
        showTags: false
        showDates: true

修改对应源码读取配置项

修改layouts/_default/archives.html文件，将{{ if $term }}判断语句添加一个与项，同时修改变量名。最终修改后结果如下：

{{ if and (eq (.Site.Params.archives.showCategories | default true) true) (gt (len $cateTerms) 0) }}

同理，在渲染tags和dates板块的部分使用如下语句对包裹：

{{ if and (eq (.Site.Params.archives.showTags | default false) true) (gt (len $tagTerms) 0) }}
{{ /* 渲染Tags板块 */ }}
{{ end }}


{{ if eq (.Site.Params.archives.showDates | default true) true }}
{{ /* 渲染Dates板块*/ }}
{{ end }}

修复category详细页的文章数量异常问题

在layouts/_default/list.html文件中进行如下修改：

-    <h3 class="section-count">{{ T "list.page" (len .Pages) }}</h3>
+    {{- $filteredPages := where .Pages ".Params.hidden" "!=" true -}}
+    <h3 class="section-count">{{ T "list.page" (len $filteredPages) }}</h3>

把.Pages的元素个数替换为筛选后的元素个数。

新增分类方式：collections

设计配置项

在layouts/_default/archives.html中添加配置项showCollections。

params:
    archives:
        showCategories: true
+        showCollections: true
        showTags: false
        showDates: true

修改archive.html渲染collections列表

<!-- Collections Section -->
{{- $collectionTaxonomy := $.Site.GetPage "collections" -}}
{{- $collectionTerms := $collectionTaxonomy.Pages -}}
{{ if and (eq (.Site.Params.archives.showCollections | default false) true) (gt (len $collectionTerms) 0) }}
<h2 class="section-title">合集 - {{ $collectionTaxonomy.Title }}</h2>
<div class="subsection-list">
    <div class="category-list--tile">
        {{ range $collectionTerms }}
            {{- $pages := .Pages -}}
            {{- $filteredPages := where $pages ".Params.hidden" "!=" true -}}
            {{ if $filteredPages }}
                {{ partial "article-list/tile" (dict "context" . "size" "250x150" "Type" "taxonomy") }}
            {{ end }}
        {{ end }}
    </div>
</div>
{{ end }}

在文件layouts/_default/archives.html中需要的位置添加如上代码。这篇博客是在categories和tags中间添加。

修改配置文件

修改hugo.toml添加如下配置项。

[taxonomies]
category = 'categories'
tag = 'tags'
collection = 'collections'

新建模板文件

在content文件夹下新建文件夹collections，在collections文件夹下如category一般新建分类项。如新建子目录及文件test-collection/_index.md，并在子目录中添加如下内容：

---
title: "测试用"
description: "test"
---

在这之后就可以在博文的front-matter中添加如下内容，以将这篇博文归类到一个合集中：

collections = "test-collection"

效果展示

新建合集rvs-enr-crs选择一篇博文添加collections = "rvs-env-crs"。

可见成功生效。

hugo+GithubIO自建博客踩坑实录

Sun, 02 Feb 2025 17:21:58 +0800

此博客搭建过程参考的资料在"关于"页面可详细了解。本文具体步骤也可能会给出具体参考的内容。

不能正确渲染主题 - 2025.01.28

此博客采用源码-博客页分离的结构搭建。

源码为hugo个人博客的源码，设为github私有仓库，通过git action，在每次push之后，通过hugo -D命令云端编译生成public文件夹中的内容之后将public文件夹内的内容推送到GitHub - XingfenD/xingfen-star.github.io仓库中。

在搭建阶段，我将themes子文件夹下的第三方主题仓库设置为该主项目的子模块，导致在上传到私有仓库后，themes文件夹中没有实际的主题文件。最终导致无法编译出所选主题的页面。

我在github action中添加步骤Print Directory以打印路径信息，最终定位此问题并修复，完整的githu action如下。

最终博客项目的结构为三个仓库：

Hugo源码仓库(通过gitignore忽略public, resources, themes文件夹)
主题仓库(Hugo源码仓库的public文件夹)
Github Page仓库(Hugo源码仓库的public文件夹)

name: deploy

# 代码提交到main分支时触发github action
on:
  push:
    branches:
      - main

jobs:
  deploy:
    runs-on: ubuntu-22.04
    steps:
        - name: Checkout
          uses: actions/checkout@v4
          with:
              fetch-depth: 0

        - name: Setup Hugo
          uses: peaceiris/actions-hugo@v3
          with:
              hugo-version: "latest"
              extended: true

        - name: Print Directory
          run: tree -L 3 -d

        - name: Clone Theme
          run: git clone https://github.com/XingfenD/hugo-theme-custom.git themes

        - name: Git Configuration
          run: |
            git config --global core.quotePath false
            git config --global core.autocrlf false
            git config --global core.safecrlf true
            git config --global core.ignorecase false

        - name: Build Web
          run: hugo -D

        - name: Print Directory
          run: tree -L 3 -d

        - name: Deploy Web
          uses: peaceiris/actions-gh-pages@v4
          with:
              personal_token: ${{ secrets.ACTION_ACCESS_TOKEN }}
              external_repository: XingfenD/xingfen-star.github.io
              publish_branch: main
              publish_dir: public
              commit_message: auto deploy

主题配置后代码块显示异常 - 2025.02.02

使用hugo-theme-stack主题后

发现在白天模式下的代码块颜色异常，如下图所示：

在通过修改hugo-theme-stack主题的scss文件后成功定位异常原因：

hugo编译md文件后生成的博文html文件中的codeblock为如下结构:

<div class="highlight">
    <pre style="">
        <code class="language-markdown">
            <span class="line">
            ...
        </code>
    </pre>
</div>

图中所示的深色异常颜色为<pre>标签的style属性控制，因此导致全局scss文件失效。

阅读官方文档后，在`hugo.toml`中添加配置：

markup.highlight.noClasses=false

问题得以修复。

修改配置文件以激活右侧边栏 - 2025.02.12

阅读Stack主题官方文档右侧边栏配置项可以了解如何修改配置文件以激活右边栏。

在config.yaml文件中修改配置项[params.widgets]:

params:
    widgets:
        homepage:
          - type: search
          - type: categories
            params:
              limit: 10
          - type: tag-cloud
            params:
              limit: 10

        page:
          - type: toc
          - type: categories
            params:
              limit: 5
          - type: tag-cloud
            params:
              limit: 5

配置生效后右侧边栏效果如下图:

不能正确渲染`abbr`, `sub`等特殊html标签 - 2025.02.12

查阅在线资料修复Hugo静态生成器中忽略原始HTML的方法后，在hugo.toml中添加配置项：

markup.goldmark.renderer.unsafe=true

成功渲染，效果如图。

Markdown 语法指南

Sun, 02 Feb 2025 00:00:00 +0000

本文提供了可以在 Hugo 内容文件中使用的最基本 Markdown 语法样本，同时也展示了基本 HTML 元素是否可以通过 Hugo 主题中的 CSS 被装饰。

标题

以下 HTML <h1>—<h6> 元素代表六个级别的章节标题。<h1> 是最高级别，而 <h6> 是最低级别。

# H1
## H2
### H3
#### H4
##### H5
###### H6

H1

H2

H3

H4

H5

H6

段落

Xerum, quo qui aut unt expliquam qui dolut labo. Aque venitatiusda cum, voluptionse latur sitiae dolessi aut parist aut dollo enim qui voluptate ma dolestendit peritin re plis aut quas inctum laceat est volestemque commosa as cus endigna tectur, offic to cor sequas etum rerum idem sintibus eiur? Quianimin porecus evelectur, cum que nis nust voloribus ratem aut omnimi, sitatur? Quiatem. Nam, omnis sum am facea corem alique molestrunt et eos evelece arcillit ut aut eos eos nus, sin conecerem erum fuga. Ri oditatquam, ad quibus unda veliamenimin cusam et facea ipsamus es exerum sitate dolores editium rerore eost, temped molorro ratiae volorro te reribus dolorer sperchicium faceata tiustia prat.

Itatur? Quiatae cullecum rem ent aut odis in re eossequodi nonsequ idebis ne sapicia is sinveli squiatum, core et que aut hariosam ex eat.

引用块

引用块元素表示来自另一个源的内容，并且可选地带有必须在 footer 或 cite 元素内的引用，以及可选的如注释和缩写的行内更改。

无属性的引用块

Tiam, ad mint andaepu dandae nostion secatur sequo quae. 注意在引用块中可以使用 Markdown 语法。

带有属性的引用块

> 不要通过共享内存来通信，而是通过通信来共享内存。<br>
> — <cite>Rob Pike[^1]</cite>

[^1]: 上述引用摘自 Rob Pike 在 Gopherfest 2015 年 11 月 18 日[演讲](https://www.youtube.com/watch?v=PAAkCSZUG1c)的部分内容。

不要通过共享内存来通信，而是通过通信来共享内存。
— Rob Pike¹

表格

表格不属于核心 Markdown 规范的一部分，但 Hugo 开箱即用地支持它们。

名称	年龄
Bob	27
Alice	23

表格中的内联 Markdown

斜体	粗体	代码
斜体	粗体	`代码`

A	B	C	D	E	F
Lorem ipsum dolor sit amet, consectetur adipiscing elit.	Phasellus ultricies, sapien non euismod aliquam, dui ligula tincidunt odio, at accumsan nulla sapien eget ex.	Proin eleifend dictum ipsum, non euismod ipsum pulvinar et. Vivamus sollicitudin, quam in pulvinar aliquam, metus elit pretium purus	Proin sit amet velit nec enim imperdiet vehicula.	Ut bibendum vestibulum quam, eu egestas turpis gravida nec	Sed scelerisque nec turpis vel viverra. Vivamus vitae pretium sapien

代码块

使用反引号的代码块

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>示例 HTML5 文档</title>
</head>
<body>
  <p>测试</p>
</body>
</html>

使用四个空格缩进的代码块

    <!doctype html>
    <html lang="en">
    <head>
      <meta charset="utf-8">
      <title>示例 HTML5 文档</title>
    </head>
    <body>
      <p>测试</p>
    </body>
    </html>

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>示例 HTML5 文档</title>
</head>
<body>
  <p>测试</p>
</body>
</html>

使用 Hugo 的内部 highlight 短代码的代码块

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>示例 HTML5 文档</title>
</head>
<body>
  <p>测试</p>
</body>
</html>

Diff 代码块

[dependencies.bevy]
git = "https://github.com/bevyengine/bevy"
rev = "11f52b8c72fc3a568e8bb4a4cd1f3eb025ac2e13"
- features = ["dynamic"]
+ features = ["jpeg", "dynamic"]

列表类型

有序列表

第一项
第二项
第三项

无序列表

列表项
另一个项目
再一个项目

嵌套列表

水果
- 苹果
- 橙子
- 香蕉
奶制品
- 牛奶
- 奶酪

其他元素——abbr, sub, sup, kbd, mark

<abbr title="图形交换格式">GIF</abbr> 是一种位图图像格式。

H<sub>2</sub>O

X<sup>n</sup> + Y<sup>n</sup> = Z<sup>n</sup>

按下 <kbd>CTRL</kbd> + <kbd>ALT</kbd> + <kbd>Delete</kbd> 结束会话。

大多数 <mark>蝾螈</mark> 是夜行性的，并猎食昆虫、蠕虫和其他小生物。

GIF 是一种位图图像格式。

H₂O

Xⁿ + Yⁿ = Zⁿ

按下 CTRL + ALT + Delete 结束会话。

大多数蝾螈是夜行性的，并猎食昆虫、蠕虫和其他小生物。

超链接图片

上述引用摘自 Rob Pike 在 Gopherfest 2015 年 11 月 18 日演讲的部分内容。 ↩︎

c语言getopt.h库解析

Wed, 22 Jan 2025 13:29:03 +0800

getopt.h简介

getopt.h 是C语言中一个用于处理命令行参数的内嵌库。可以通过以下两个函数来调用其功能：

getopt()
getopt_long()

函数 `getopt()`

getopt() 用于解析仅包含短选项的指令，例如 -g、-o、-f。

`getopt()` 示例程序

使用 getopt() 的参数处理框架如下：

#include <stdio.h>
#include <getopt.h>

int main(int argc, char *argv[]) {
    int opt;

    /* parse the command line input */
    while ((opt = getopt(argc, argv, "f:o:kh")) != -1) {
        switch (opt) {
            case 'f':
                printf("Arg -f: %s\n", optarg);
                break;
            case 'o':
                printf("Arg -o: %s\n", optarg);
                break;
            case 'k':
                printf("Arg -k do not need arguments:%s\n", optarg);
                break;
            case 'h':
                printf("Arg -k do not need arguments:%s\n", optarg);
                break;
            case '?': // An invalid option was found or a required argument is missing.
                if (optopt == 'f' || optopt == 'o') {
                    printf("Option -%c requires an argument.\n", optopt);
                } else {
                    printf("Unknown option -%c.\n", optopt);
                }
                break;
            default:
                printf("Unexpected situation.\n");
                break;
        }
    }

    /* extra arguments handling */
    if (optind < argc) {
        printf("Remaining arguments: ");
        for (; optind < argc; optind++) {
            printf("%s ", argv[optind]);
        }
    } /* optind < argc */
}

编译并运行如下指令：./test_short.out -v yuanshen -f arg:f -o arg:o -k arg:k -h arg:h

> ./test_short.out -v yuanshen -f arg:f -o arg:o -k arg:k -h arg:h
./test_short.out: invalid option -- 'v'
Invalid option: v
Arg -f: arg:f
Arg -o: arg:o
Arg -k do not need arguments:(null)
Arg -k do not need arguments:(null)
Remaining arguments: yuanshen arg:k arg:h %

`getopt()`详细说明

全局变量

全局变量	用途
optopt (int)	遇到未知选项或缺少必要参数时设置，存储导致错误的选项字符。
optarg (char*)	存储当前选项的参数值。当解析需要参数的选项（例如 `-f file.txt` 中的 `file.txt`）时，`optarg` 指向该字符串。
optind (int)	在解析命令行参数过程中，追踪位置，具体指示下一个要处理的参数的索引。

以下代码段会打印所有未被 getopt() 识别的参数（忽略这些参数的输入顺序）：

/* extra arguments handling */
if (optind < argc) {
    printf("Remaining arguments: ");
    for (; optind < argc; optind++) {
        printf("%s ", argv[optind]);
    }
}

模式字符串

模式字符串的定义是 const char *__shortopts，在示例程序中，其实例为 "f:o:kh"。

顾名思义，模式字符串定义了 getopt() 和 getopt_long() 函数中将被识别的短选项。冒号 : 跟在短选项字符后表示该选项需要一个参数。

以 "f:o:kh" 为例，此模式字符串接收4个选项。选项 -f 和 -o 需要输入参数，而选项 -k 和 -h 不需要。

注意：如果 -f 后跟一个选项，该选项会被视为参数。

函数 `getopt_long()`

getopt_long() 用于解析既包含短选项（如 -g、-o、-f）又包含长选项（如 --version、--input）的指令。

函数 getopt_long 识别一个结构体数组 struct option，该数组定义了长选项的信息。

struct option 的原型及相关介绍如下：

struct option {
    const char *name;   /* 长选项的名称 */
    int has_arg;        /* 是否需要参数 */
    int *flag;          /* 如果用户提供了此选项，*flag 将被赋值为 @val */
    int val;            /* 将长选项与短选项绑定，或赋值给 @*flag */
};

字段 has_arg 有两个有效值，即宏 no_argument 和 required_argument。

如果字段 flag 未提供，则字段 val 会被视为与当前长选项绑定的短选项。

如果提供了字段 flag，当用户提供当前长选项时，字段 val 将被赋值给 *flag。

用实例详细说明

以下是一个使用 struct option 数组和模式字符串的实例：

/* the corresponding pattern string */
const char *pattern = "suR:";

struct option long_options[] = {
    /* long option only */
    /* with flag set - 1 */
    { "onlyset1",   no_argument,        &onlyset1,      1   },

    /* long option only */
    /* with flag set - 2 */
    { "onlyset2",   no_argument,        &onlyset1,      2   },

    /* long option only */
    /* with flag set - 3 */
    { "onlyset3",   no_argument,        &onlyset2,      3   },

    /* long option only ( bind failed ) */
    /* with flag set, with val bind */
    { "setbind",    no_argument,        &setbind_flag,  's' },

    /* short and long option */
    /* without flag set, with val bind */
    { "unsetbind",  no_argument,        NULL,           'u' },

    /* short and long option */
    /* require argument */
    { "RequireArg", required_argument,  NULL,           'R' },
};

考虑到短选项和长选项，当提到某个功能的option时，可能会有以下三种情况：

仅有短选项
仅有长选项
同时具有短选项和长选项

结合模式字符串和 struct option 数组，程序接收的选项如下：

短选项	长选项
	–onlyset1
	–onlyset2
	–onlyset3
	–setbind
-s
-u	–unsetbind
-R	–RequireArg

选项 -s 和 --setbind 并未绑定在一起，因为在与 "setbind" 对应的结构体元素中设置了字段 flag。

参数需求冲突

当短选项和长选项中都定义了参数需求时，可能会发生冲突。

我们通过一个实例进行说明：

/* the corresponding pattern string */
const char *pattern = "c:d";

struct option long_options = {
    /* short and long option */
    /* conflict argument require - 1 */
    { "Conflict1",  no_argument,        NULL,           'c' },

    /* short and long option */
    /* conflict argument require - 2 */
    { "Conflict2",  required_argument,  NULL,           'd'},

    /* end of the array ( all zero ) */
    { 0,            0,                  0,              0   }
};

我们可以看到，上述程序将一个需要参数的短选项 -c 与一个不需要参数的长选项 --Conflict1 绑定在一起。

同时，它还将一个不需要参数的短选项 -d 与一个需要参数的长选项 --Conflict2 绑定在一起。

该程序运行正常，但关于参数的配置也会生效。

当用户提供 -c 或 --Conflict1 时，程序会进入同一个分支，但 --Conflict1 不会读取后续的参数，而 -c 会读取。

当用户提供 -d 或 --Conflict2 时，结果则相反。

`getopt_long()` 示例程序

以下是使用 getopt_long() 的参数处理框架：

#include <stdio.h>
#include <getopt.h>

/* test instructions:
    ./test_long.out --onlyset1 --onlyset2 --onlyset3
    ./test_long.out -s --setbind
    ./test_long.out --unsetbind --RequireArg arg:RequireArg
    ./test_long.out -u -R arg:R

    ./test_long.out -c arg:c -d arg:d
    ./test_long.out --Conflict1 arg:Conflict1 --Conflict2 arg:Conflict2

    ./test_long.out -c arg:c --Conflict1 arg:Conflict1
    ./test_long.out --Conflict1 arg:Conflict1 -c arg:c
*/

int main(int argc, char *argv[]) {
    int opt;
    int onlyset1 = 0;
    int onlyset2 = 0;
    int setbind_flag = 0;

    struct option long_options[] = {
        /* long option only */
        /* with flag set - 1 */
        { "onlyset1",   no_argument,        &onlyset1,      1   },

        /* long option only */
        /* with flag set - 2 */
        { "onlyset2",   no_argument,        &onlyset1,      2   },

        /* long option only */
        /* with flag set - 3 */
        { "onlyset3",   no_argument,        &onlyset2,      3   },

        /* long option only ( bind failed ) */
        /* with flag set, with val bound */
        { "setbind",    no_argument,        &setbind_flag,  's' },

        /* short and long option */
        /* without flag set, with val bound */
        { "unsetbind",  no_argument,        NULL,           'u' },

        /* short and long option */
        /* require argument */
        { "RequireArg", required_argument,  NULL,           'R' },

        /* short and long option */
        /* conflict argument require - 1 */
        { "Conflict1",  no_argument,        NULL,           'c' },

        /* short and long option */
        /* conflict argument require - 2 */
        { "Conflict2",  required_argument,  NULL,           'd'},

        /* end of the array ( all zero ) */
        { 0,            0,                  0,              0   }
    };

    int long_index = 0;
    while ((opt = getopt_long(argc, argv, "suR:c:d", long_options, &long_index)) != -1) {
        switch (opt) {
            case 0:
                /* provide long option with flag set */
                printf("long option with flag set recognized!\n");
                printf("long option name is %s\n", long_options[long_index].name);
                if (long_options[long_index].flag != NULL) {
                    printf("the flag value is %d\n", *(long_options[long_index].flag));
                }
                break;
            case 's':
                /* provide option -s instead of --setbind */
                printf("long option (short option only), with flag set, with val bound.\n");
                printf("setbind_flag == %d\n", setbind_flag);
                break;
            case 'u':
                /* provide option -u and --unsetbind */
                printf("long option, without flag set, with val bound.\n");
                break;
            case 'R':
                /* provide option -R and --RequireArg */
                printf("long option require argument.\n");
                printf("the argument: %s\n", optarg);
                break;
            case 'c':
                /* -c require an argument while --Conflict1 not */
                printf("conflict argument require - 1\n");
                printf("the argument: %s\n", optarg);
                break;
            case 'd':
                /* --Conflict2 require an argument while -d not */
                printf("conflict argument require - 2\n");
                printf("the argument: %s\n", optarg);
                break;
            case '?':
                /* Unrecognized option or missing argument */
                printf("Unknown option or missing argument.\n");
                break;
        }
        printf("\n");
    }

    /* Process remaining non-option arguments */
    for (int index = optind; index < argc; index++)
        printf("Non-option argument %s\n", argv[index]);

    return 0;
}

运行测试指令并分析测试结果

编译运行时的测试指令如下：

./test_long.out --onlyset1 --onlyset2 --onlyset3
./test_long.out -s --setbind
./test_long.out --unsetbind --RequireArg arg:RequireArg
./test_long.out -u -R arg:R

./test_long.out -c arg:c -d arg:d
./test_long.out --Conflict1 arg:Conflict1 --Conflict2 arg:Conflict2

./test_long.out -c arg:c --Conflict1 arg:Conflict1
./test_long.out --Conflict1 arg:Conflict1 -c arg:c

结果如下：

> ./test_long.out --onlyset1 --onlyset2 --onlyset3
long option with flag set recognized!
long option name is onlyset1
the flag value is 1

long option with flag set recognized!
long option name is onlyset2
the flag value is 2

long option with flag set recognized!
long option name is onlyset3
the flag value is 3

指令 ./test_long.out --onlyset1 --onlyset2 --onlyset3 展示了 getopt_long() 的基本功能。

它改变了 flag 地址中的值。

> ./test_long.out -s --setbind
long option (short option only), with flag set, with val bound.
setbind_flag == 0

long option with flag set recognized!
long option name is setbind
the flag value is 115

指令 ./test_long.out -s --setbind 展示了绑定失败（当 flag 字段被设置时）。

--setbind 和 -s 会进入不同的分支。

> ./test_long.out --unsetbind --RequireArg arg:RequireArg
long option, without flag set, with val bound.

long option require argument.
the argument: arg:RequireArg

> ./test_long.out -u -R arg:R
long option, without flag set, with val bound.

long option require argument.
the argument: arg:R

这对比展示了绑定成功的结果（当 flag 字段未设置时）。

--unsetbind 和 -u 被绑定在一起，进入相同的分支。

--RequireArg 和 -R 也是一样。

> ./test_long.out -c arg:c -d arg:d
conflict argument require - 1
the argument: arg:c

conflict argument require - 2
the argument: (null)

Non-option argument arg:d

> ./test_long.out --Conflict1 arg:Conflict1 --Conflict2 arg:Conflict2
conflict argument require - 1
the argument: (null)

conflict argument require - 2
the argument: arg:Conflict2

Non-option argument arg:Conflict1

这对比展示了参数要求的冲突。

-c 和 --Conflict1 被绑定在一起，但 -c 需要一个参数。

-d 和 --Conflict2 被绑定在一起，但 --Conflict2 需要一个参数。

结果显示，绑定在一起的选项会进入相同的分支。

但是，是否读取或忽略参数取决于用户提供的选项是否需要参数。

> ./test_long.out -c arg:c --Conflict1 arg:Conflict1
conflict argument require - 1
the argument: arg:c

conflict argument require - 1
the argument: (null)

Non-option argument arg:Conflict1


> ./test_long.out --Conflict1 arg:Conflict1 -c arg:c
conflict argument require - 1
the argument: (null)

conflict argument require - 1
the argument: arg:c

Non-option argument arg:Conflict1

冲突选项的另一个对比结果。

归档

Tue, 28 May 2019 00:00:00 +0000

关于

Thu, 28 Feb 2019 00:00:00 +0000

关于远楒

「远楒」取音「远思」，意在表达两层含义：一是对事物进行深入的思考与探究，二是对过往的人、事、时光怀有遥远的思念。

英文名为 yoresee（/ˈjɔːsiː/），由古英语词汇 yore（往昔）与 see（看见）组合而成，直译为「看见往昔」或「回望过去」。这一命名与中文「远楒」相呼应——既体现对过往的注视，也暗含对未来的展望。

更新计划

功能	完成日期	备注
添加一种widget，显示当前blog的tags	2025-02-18
实现代码块过长自动折叠功能
添加回到顶部与底部按钮
修复代码块颜色不正常显示的问题		可能是浏览器问题
新增一种归档方式 - 合集(collection) 并将相关博文的索引逻辑从tag改为collection	2025-02-20

参考资料

本博客站"远楒"的搭建过程参考如下在线资料:

Hugo中文文档

莱特雷-letere的个人博客

如何用 GitHub Pages + Hugo 搭建个人博客 - KrislinBlog

Hugo使用Github Action自动部署博客到Github Pages - Tomial’s Blog

Stack主题配置文件说明文档

使用的Hugo主题为Stack，本博客站使用的定制化主题仓库为XingfenD/hugo-theme-custom。本站的具体开发与改造过程可进入站内归档页的"博客搭建"类别具体了解。

搜索

Mon, 01 Jan 0001 00:00:00 +0000

链接

Mon, 01 Jan 0001 00:00:00 +0000

To use this feature, add links section to frontmatter.

This page’s frontmatter:

links:
  - title: GitHub
    description: GitHub is the world's largest software development platform.
    website: https://github.com
    image: https://github.githubassets.com/images/modules/logos_page/GitHub-Mark.png
  - title: TypeScript
    description: TypeScript is a typed superset of JavaScript that compiles to plain JavaScript.
    website: https://www.typescriptlang.org
    image: ts-logo-128.jpg

image field accepts both local and external images.

远楒

ZIP 文件结构与解析流程核心笔记

ZIP 文件结构与解析流程核心笔记

ZIP文件基础结构图示

ZIP文件解析流程

标准解析模式

流式解析模式

手工篡改ZIP进行实验

Zip文件具体分析

本地文件头 - Local File Header

general_bit_flag

加密头 - Encryption Header

数据描述符 - Data Descriptor

归档解密头 - Archive Decryption Header

归档额外数据记录 - Archive Extra Data Record

中央目录头 - Central Directory Header

相关流程

Zip64解析流程

启用中央目录加密时的解析流程

校验密码是否正确

传统PKWARE加密格式校验密码

强加密

启用中央目录加密

【武大软件逆向课程/第四周】加减乘除运算的逆向特征

汇编语言预备知识

指令简介与总览

imul - 带符号整数乘法

一个操作数

两个操作数

三个操作数

mul - 无符号整数乘法

mul的功能

mul的示例

scanf与printf函数

逆向分析程序1

逆向分析程序2

【武大软件逆向课程/第一周】扫雷逆向分析批量插旗及机器指令表.exe文件字体更换

作业目标

扫雷

定位绘制雷区的代码位置

定位雷区数据地址

分析地块状态对应的内存值

非雷区地块

雷区地块

插旗地块与存疑地块

编写程序以批量插旗地雷

实验结果

更换机器指令表.exe显示字体

定位控制字体显示的WinAPI

将修改保存到文件

Widgets修复与开发

计划

右侧边栏的tag-cloud和categories不能处理hidden博文

tag-cloud识别hidden博文

添加一种展示当前博文tags的Widget

添加模板文件

添加i18n替换文本

添加scss样式表

Archive页改造

Archive页介绍

使用开发者工具检查archive页面元素

修复category tile展示异常

添加对tag分类的支持

支持在archive页展示tag模块

添加tag的样式并修改tag–tile的大小

添加archives页面对应配置项

设计配置项

修改对应源码读取配置项

修复category详细页的文章数量异常问题

新增分类方式：collections

设计配置项

修改archive.html渲染collections列表

修改配置文件

新建模板文件

效果展示

hugo+GithubIO自建博客踩坑实录

不能正确渲染主题 - 2025.01.28

主题配置后代码块显示异常 - 2025.02.02

修改配置文件以激活右侧边栏 - 2025.02.12

不能正确渲染abbr, sub等特殊html标签 - 2025.02.12

不能正确渲染`abbr`, `sub`等特殊html标签 - 2025.02.12

函数 `getopt()`

`getopt()` 示例程序

`getopt()`详细说明

函数 `getopt_long()`

`getopt_long()` 示例程序