Maplemoon

逆向之路：笨拙者的坚持

Tue, 19 May 2026 09:00:37 +0800

最近开始重新温习小红本的JS大书，为后面的逆向工程做准备。说实话，看到前三章就已经收获颇丰，很多基础知识重新串联了起来，那种"原来如此"的感觉真的很美妙。

有时候我会怀疑，我这样的学习路径是不是太绕路了？别人可能直接就去实战了，而我却要从头开始重新梳理基础。但转念一想，这不就是我的学习方式吗？从来都不是按照最"聪明"的路径走，而是跟着自己的内心节奏。

我从来都不是什么聪明的学生，学东西也从来不是最快的那一个。记得学生时代，别人可能一节课就能理解的概念，我需要反复琢磨好几遍。工作后也是如此，面对新技术，我总是那个需要更多时间消化的人。

但有意思的是，这么30多年走下来，我发现自己竟然比很多人走得更远了。那些曾经看起来"笨拙"的学习方式，那些看似绕远的路径，反而让我建立了更扎实的基础，形成了更系统的知识体系。

很多时候在别人面前，我依然表现得很笨拙。但我渐渐明白，这种笨拙不是缺点，而是我独特的学习印记。它让我更注重理解本质，而不是追求表面的技巧；让我更愿意花时间去构建完整的知识框架，而不是急于求成。

逆向工程这条路，或许正需要这样的"笨拙"。因为真正的逆向，不是技巧的堆砌，而是对底层原理的深刻理解

从“一周搞定”到一个月：代理抓包、逆向分析与下载视频的踩坑实录

Wed, 13 May 2026 09:07:29 +0800

天真的乐观看似清晰的思路，在工程化的泥潭中举步维艰

“代理抓包、逆向分析、下载视频，这能有多难？”

一周前，我坐在电脑前信心满满地规划着这个“小项目”。思路清晰得令人振奋：架个代理服务器，拦截流量，分析加密协议，最后自动化下载。我连时间都规划好了：两天写代理，两天分析协议，一天写自动化脚本，剩下两天做优化和测试。

一周后，我盯着屏幕上密密麻麻的报错信息和半成品的代码，不得不承认：我原来想简单了。

第一阶段：代理抓包的天真设想

理想中的简单流程

启动Python代理服务器
客户端配置代理
拦截所有HTTP/HTTPS流量
记录和分析数据包

看起来多么简洁明了！然而现实很快给了我一记重击。

证书的“惊喜”

第一个拦路虎：HTTPS证书。

# 我最初天真的想法
def handle_https_request(client_socket, server_address):
    # 建立连接，转发数据...
    # 等等，HTTPS需要证书验证？

现代应用几乎全部使用HTTPS，而HTTPS代理需要生成并安装自签名证书，还要处理证书链验证。我原来以为Python的http.server或socketserver模块稍作修改就能搞定，结果发现需要：

动态生成针对每个域名的证书
处理证书链和信任问题
让客户端（浏览器或应用）信任我的根证书
处理证书过期和更新逻辑

这还只是开始。

工程化的复杂性

我原本想着“写个代理”，但一个生产级别的HTTP/HTTPS代理需要：

连接管理：同时处理数十甚至上百个连接
流量解析：正确解析各种编码和压缩格式
性能优化：避免成为瓶颈
错误处理：网络波动、超时、协议异常...
日志系统：结构化记录请求响应，便于分析

三天过去了，我的代理还只是个能处理简单HTTP请求的半成品。

第二阶段：抓包分析中的“魔鬼细节”

数据包的“真实面貌”

当我终于能够拦截流量时，发现实际的数据包和我预期的完全不同：

数据分片：一个请求可能分成多个TCP包
流式传输：视频数据往往采用流式传输，而不是完整的文件
加密和混淆：不仅仅是HTTPS，还有自定义的加密层
协议杂糅：WebSocket、HTTP/2、QUIC... 现代应用很少只用HTTP/1.1

逆向分析的工具链

我最初以为用Wireshark或Fiddler看看就行，但实际上需要一整套工具链：

# 实际需要的分析工具比想象的多
analysis_tools = {
    "流量拦截": ["mitmproxy", "Charles", "自定义代理"],
    "协议分析": ["Wireshark", "tcpdump", "scapy"],
    "逆向工程": ["IDA Pro", "Ghidra", "Frida"],
    "动态调试": ["Xposed", "Frida", "LLDB"],
    "加解密分析": ["CyberChef", "自定义解密脚本"]
}

每个工具都有自己的学习曲线，而把它们整合到自动化流程中又是另一回事。

第三阶段：视频下载的复杂现实

从“下载文件”到“流媒体处理”

我原本以为视频下载就是“找到文件URL，下载保存”，实际上：

分片传输：视频被切成多个ts/m4s片段
加密流：DRM保护，需要解密才能播放
动态URL：每次请求的URL都不同，有过期时间
质量切换：自适应码率，需要处理多个质量等级
合并处理：下载后需要正确合并和转码

协议逆向的艰难

逆向分析应用协议时，我遇到了：

混淆的JavaScript：代码被压缩和混淆，难以阅读
自定义加密：非标准加密算法，需要静态分析
反调试机制：应用检测到调试环境会自动关闭
频繁更新：协议每周甚至每天都有变化

工程化的挑战

从脚本到工程

我最大的误区是：把工程问题当成脚本问题。

一个可维护的系统需要：

# 工程化的项目结构 vs 我的脚本思维
my_naive_script.py
# vs
project/
├── proxy/           # 代理服务器模块
│   ├── certificate/ # 证书管理
│   ├── handlers/    # 请求处理器
│   └── utils/       # 工具函数
├── analysis/        # 流量分析模块
├── downloader/      # 下载模块
├── config/          # 配置文件
├── tests/           # 测试代码
└── docs/            # 文档

代码质量的忽视

在“快速实现”的压力下，我忽略了：

错误处理：各种异常情况的处理
日志系统：可调试的日志记录
配置管理：灵活配置不同环境
单元测试：确保功能正确性
文档：自己三个月后能看懂吗？

学到的教训

1. 时间估算的“三倍法则”

对于不熟悉的技术领域，将我最初的估算乘以3可能更接近现实。

2. 从最小可行产品开始

不应该一开始就想着构建完整的系统，而是：

先验证核心假设（协议可破解吗？）
构建最小可用的原型
逐步迭代和完善

3. 利用现有工具

我花了太多时间重造轮子。像mitmproxy这样的工具已经解决了90%的代理问题，我应该在它的基础上扩展，而不是从头开始。

4. 分而治之

将大问题分解：

先解决HTTP，再处理HTTPS
先处理明文协议，再研究加密协议
先下载小文件，再处理流媒体

5. 文档和测试先行

即使时间紧张，也要写基本的文档和测试。这在长期看来是节省时间，而不是浪费时间。

现在的进展与反思

一个月过去了，我的项目终于能工作了，但代码比我最初想象的复杂得多：

# 现在系统的复杂度
class VideoDownloadSystem:
    def __init__(self):
        self.proxy = MitmProxyWrapper()  # 基于mitmproxy的封装
        self.analyzer = ProtocolAnalyzer()  # 协议分析器
        self.downloader = AdaptiveVideoDownloader()  # 自适应下载器
        self.decryptor = DRMDecryptor()  # DRM解密器
        
    async def download_video(self, url):
        # 现在需要处理几十种异常情况
        # 和数百行代码
        pass

结语

这次经历让我深刻理解了理论思路和工程实现之间的鸿沟。在纸上画流程图时，一切看起来那么简单；在代码中实现时，每个箭头都可能变成一周的工作。

清晰的是思路，模糊的是细节，而魔鬼就在细节中。

对于那些想进入这个领域的朋友，我的建议是：准备比你认为多三倍的时间，从最小可行产品开始，多利用现有工具，不要害怕重构，最重要的是——保持耐心。

有时候，最难的不是解决技术问题，而是接受“这个问题比我预期的要复杂得多”这个事实。

后记：这个项目最终花了四周时间，而不是一周。但它教会我的，远超过一个简单的视频下载工具。在技术的道路上，有时候绕远路才是最短的路径。

在A股寻“宝”的第五天：寻找价值，也寻找平静

Sat, 09 May 2026 15:51:34 +0800

在A股寻“宝”的第五天：寻找价值，也寻找平静

最近几天，我几乎把自己埋在A股三千多只股票的数据里，试图用价值投资的筛子，淘出那几粒被市场忽视的金沙。结果？眼睛酸了，脑袋晕了，但手里依然空空的。

价值投资，不只是“便宜”

许多人误以为价值投资就是寻找“便宜的股票”，于是市盈率、市净率成了他们唯一的标尺。但真正的价值投资，是寻找那些价格低于内在价值的公司，而这内在价值的判断，需要深入理解企业的商业模式、护城河、管理团队和行业前景。

A股市场有其特殊性：散户占比高、情绪波动大、政策影响显著。这些因素使得纯粹基于财务数据的价值投资策略往往水土不服。有时候，一家看似“便宜”的公司，其背后可能隐藏着商业模式落后、行业衰退或治理结构等问题。

寻找标的的几个维度

经过这几天的摸索，我总结了几点寻找价值标的的思路：

1. 商业模式的可理解性

巴菲特强调投资自己能够理解的企业。在A股，这意味着寻找那些商业模式简单透明、收入来源清晰、盈利模式可持续的公司。避免那些故事动听但难以验证的“概念股”。

2. 护城河的深度

寻找那些在细分领域拥有难以复制的优势的企业，可能是品牌、专利、网络效应，或是规模经济。在A股，一些传统行业的龙头企业在多年竞争中形成的壁垒，常常被市场低估。

3. 管理层的诚信与能力

阅读年报、股东大会记录，关注管理层如何对待小股东，他们的战略是否一致且可执行。在A股市场，公司治理是价值投资不可忽视的一环。

4. 安全边际

即使找到好公司，也需要等待合适的价格。设定自己的估值区间，耐心等待市场给出机会。在情绪驱动的A股，这种机会可能比我们想象的更频繁。

一个案例的思考

在筛选过程中，我关注了一家区域性消费公司。从表面看，它的市盈率低于行业平均，现金流稳定，负债率低。但深入研究后发现，其主业面临新兴模式的冲击，而管理层应对迟缓，转型努力多停留在口号。

这让我意识到，数字背后的故事同样重要。价值投资不是简单地“买入并持有”，而是“以合理的价格买入优质资产并持有”。

在寻找中学会等待

价值投资最反人性的地方在于，它要求我们在市场狂热时保持冷静，在市场恐慌时保持勇气。在A股这样一个波动剧烈的市场，这种品质尤为珍贵。

也许，寻找价值投资标的的过程本身就有价值。它强迫我们深入研究企业、理解商业本质、培养耐心和纪律。这些品质，不仅对投资有益，对生活也同样重要。

今夜，我依然没有找到那个“完美”的标的。但我知道，当机会来临时，那些埋头研究的日子，会让我有足够的勇气和信心扣动扳机。

投资是一场长跑，而寻找价值的过程，本身就是价值的一部分。

“价格是你付出的，价值是你得到的。”——沃伦·巴菲特

勇气，才是谦虚的底色，算是人生半途的一点体悟

Thu, 07 May 2026 09:19:39 +0800

勇气，才是谦虚的底色

最近总在想一个问题：为什么有些人明明很谦虚，却让人感觉底气十足；而有些人也是谦虚退让，却总透着一股自卑和敏感？

想来想去，发现差的不是谦虚本身，而是勇气。

谦虚不等于软弱

我们从小被教育要谦虚，要退让。可有时候，这种谦虚退让做着做着，就变了味。你开始不敢表达自己的想法，不敢争取应得的东西，甚至在别人面前连正常说话都觉得心虚。

这不是谦虚，这是缺了勇气的谦虚。

真正的谦虚，是心里有底的。就像孔子说的"君子泰而不骄"，那种从容不迫的气质，不是装出来的，而是内心有力量支撑的。

儒家的勇气：该争的时候就得争

儒家讲"当仁不让于师"，这话特别实在。面对仁义道德的事情，连老师面前都不能退让。这不是不尊重，而是对原则的坚守。

生活中也是这样。你可以在小事上谦让，但在大是大非面前，必须有勇气站出来。这种勇气不是咄咄逼人，而是内心有杆秤，知道什么该争，什么该让。

我有个朋友就是这样。平时待人接物特别谦和，可一旦遇到原则问题，眼神立马就变了。那种坚定，反而让人更尊重他。

道家的勇气：懂得什么时候该退

道家说"柔弱胜刚强"，这话听着像是在教人软弱，其实恰恰相反。水看起来最软，却能穿石。这种看似退让实则坚韧的力量，需要更大的勇气。

有时候，退一步不是认输，而是看清了更大的格局。就像老子说的"勇于不敢则活"，知道什么时候该进，什么时候该退，这本身就是一种智慧和勇气。

我见过太多人，因为不敢退，最后把自己逼到绝路。真正的勇气，是敢于承认自己的局限，敢于在适当的时候示弱。

佛家的勇气：直面内心的恐惧

佛家讲放下，但放下最难的不是外在的东西，而是内心的执着。自卑、敏感、情绪不佳，说到底都是放不下"我"。

要放下这个"我"，需要多大的勇气啊。你得直面自己内心最深处的恐惧，承认自己的不完美，接受生命的无常。这种向内看的勇气，比向外争的勇气更难能可贵。

就像禅宗说的"大死一番，方能大活"。你得先有勇气"死"掉那个虚荣的、自卑的自己，才能真正"活"出自在的人生。

勇气，让谦虚有了温度

说到底，谦虚本身没有错，错的是没有勇气支撑的谦虚。

有勇气的谦虚，是温暖的，是让人舒服的。它不卑不亢，既有对他人的尊重，也有对自己的肯定。

没有勇气的谦虚，是冰冷的，是让人压抑的。它透着自卑和不安，既委屈了自己，也让人觉得别扭。

所以啊，别把谦虚和勇气对立起来。真正的谦虚，恰恰需要勇气来支撑。就像一棵树，根扎得越深，枝叶才能越谦逊地低垂。

在这个人人都在教我们"要谦虚"的时代，或许更应该提醒自己：别忘了给谦虚加点勇气。

无符号short转int：补码原理下的可预测结果

Tue, 28 Apr 2026 09:25:45 +0800

类型转换是一个常见但容易被忽视的细节。特别是当涉及到无符号短整型（unsigned short）向有符号整型（int）的强制转换时，如果理解不当，可能会导致意想不到的结果。

基础知识回顾

数据类型大小

在大多数现代系统上：

unsigned short：2字节（16位），取值范围：0 ~ 65,535
int：4字节（32位），取值范围：-2,147,483,648 ~ 2,147,483,647

补码表示法

计算机中，有符号整数采用补码形式存储：

正数：补码与原码相同
负数：补码 = 反码 + 1

16位补码的表示范围：-32,768 ~ 32,767

转换原理分析

核心机制

当unsigned short强制转换为int时，转换过程遵循以下规则：

二进制位保持不变：原始的16位二进制数据完全保留
符号扩展：根据原始数据的最高位（第15位）进行符号扩展
重新解释：按照int的补码规则重新解释这32位数据

关键点：符号位的判定

对于unsigned short来说，所有16位都是数值位。但当转换为int时：

如果原始值 < 32,768（0x8000），最高位为0，转换后为正数
如果原始值 ≥ 32,768（0x8000），最高位为1，转换后为负数

实际案例演示

案例1：小数值转换（正数）

unsigned short us = 10000;  // 0x2710
int i = (int)us;
printf("%d\n", i);  // 输出：10000

二进制分析：

us:  0010 0111 0001 0000  (10000)
i:   0000 0000 0000 0000 0010 0111 0001 0000  (10000)

案例2：边界值转换（负数）

unsigned short us = 40000;  // 0x9C40
int i = (int)us;
printf("%d\n", i);  // 输出：-25536

二进制分析：

us:  1001 1100 0100 0000  (40000)
i:   1111 1111 1111 1111 1001 1100 0100 0000  (符号扩展)

补码转换计算：

最高位为1，表示负数
取反：0110 0011 1011 1111
加1：0110 0011 1100 0000 = 25536
结果：-25536

案例3：最大值转换

unsigned short us = 65535;  // 0xFFFF
int i = (int)us;
printf("%d\n", i);  // 输出：-1

二进制分析：

us:  1111 1111 1111 1111  (65535)
i:   1111 1111 1111 1111 1111 1111 1111 1111  (符号扩展)

补码转换：全1的补码表示-1

数学公式推导

当unsigned short值us ≥ 32,768时，转换后的int值i为：

i = us - 65536

验证：

us = 32768 → i = 32768 - 65536 = -32768
us = 40000 → i = 40000 - 65536 = -25536
us = 65535 → i = 65535 - 65536 = -1

实际应用中的注意事项

1. 数组索引问题

unsigned short index = 40000;
int arr[100];
arr[index];  // 危险！实际访问arr[-25536]

2. 循环边界判断

unsigned short count = 50000;
for(int i = 0; i < count; i++) {
    // 当count转换为-15536时，循环条件永远为真
}

3. 比较运算陷阱

unsigned short us = 40000;
if(us > 0) {
    // 永远为真
}
if((int)us > 0) {
    // 可能为假！
}

避免陷阱的最佳实践

1. 显式类型转换

unsigned short us = 40000;
// 明确意图
int i = (int)(unsigned int)us;  // 保持正值

2. 使用条件判断

unsigned short us = 40000;
int i;
if(us < 32768) {
    i = (int)us;
} else {
    // 处理大数值情况
    i = us;  // 或其他处理逻辑
}

3. 使用更大的无符号类型

unsigned short us = 40000;
unsigned int ui = (unsigned int)us;  // 保持正值

完整测试代码

#include <stdio.h>
#include <stdint.h>

void analyze_conversion(unsigned short us) {
    int i = (int)us;
    uint32_t binary = (uint32_t)us;
    
    printf("us = %5u (0x%04X) -> i = %6d (0x%08X)\n", 
           us, us, i, (unsigned int)i);
}

int main() {
    printf("无符号short转int转换分析：\n");
    printf("========================================\n\n");
    
    // 测试边界值
    analyze_conversion(0);
    analyze_conversion(32767);
    analyze_conversion(32768);
    analyze_conversion(40000);
    analyze_conversion(65535);
    
    printf("\n========================================\n");
    printf("规律总结：\n");
    printf("当 us < 32768 时，转换结果为正数，值不变\n");
    printf("当 us >= 32768 时，转换结果为负数，i = us - 65536\n");
    
    return 0;
}

总结

可预测性：unsigned short到int的转换结果完全可预测，遵循补码规则
符号扩展：转换时会进行符号扩展，最高位决定正负
数值关系：当值≥32768时，结果 = 原值 - 65536
编程建议：理解这一机制，避免在比较、索引等场景中出现逻辑错误

二进制旅行

Mon, 27 Apr 2026 08:26:10 +0800

二进制之下，计算之基：从补码到人工智能的“一维”思考

最近我花了一些时间，系统地学习了计算机中信息的表示方法。这一章内容，从表面上看，是计算机科学中最基础、甚至有些“枯燥”的知识点——二进制、位运算、补码、整数与浮点数的存储格式、32/64位系统的差异……然而，当我真正沉下心来理解时，却获得了一种近乎“顿悟”的体验：原来计算机世界里所有的抽象，无论多么高级、多么绚丽，最终都落到了二进制这一层。再往深处看，所有的二进制数据，本质上就是一串一维向量。而人工智能、压缩算法、乃至整个软件体系的精妙，都建立在这个简单而又强大的基础之上。

一切抽象，终归二进制

无论我们写下一行高级语言代码，渲染一个3D模型，还是播放一段4K视频，在计算机的视角里，它们最终都被转化为由0和1组成的序列。这是我们踏入计算机世界学到的第一课，却也可能是最容易在后续学习中忽略的一课。

当我们用Python定义一个类，用JavaScript操作一个网页元素，用Java编写一个多线程程序时，我们站在了层层抽象之上。这些抽象极大地提升了开发效率，但有时也会让我们忘记：最终驱动硬件执行任务的，是处理器对特定二进制指令的解释与运算。

从一维向量到多维空间：人工智能的底层逻辑

学习过程中，一个让我豁然开朗的认知是：计算机内存中连续存放的二进制数据，本质上就是一个一维向量。无论是一个整数、一段文本，还是一张图片，在内存中都以线性方式排列。

这让我立刻联想到了人工智能领域——特别是深度学习。AI模型处理的数据，无论是图像、语音还是文本，在输入神经网络之前，通常都会被转换为多维张量（Tensor）。然而，无论张量有多少个维度，在内存中它依然是以一维方式连续存储的。神经网络中大量的线性代数运算，在硬件层面被转化为对连续内存块的批量计算。

而更本质的是，这些计算最终都会落实到位运算。矩阵乘法的加速、卷积运算的优化，在硬件指令集和底层算法库中，常常依赖于精细的位级操作来提升效率。人工智能这座大厦，竟也建立在二进制和位运算的地基之上。

位运算：被低估的“超能力”

位运算（Bitwise Operation）——包括与（AND）、或（OR）、异或（XOR）、非（NOT）以及移位操作——常常在初学编程时被一带而过。但在深入理解计算机系统后，我才真正认识到它的强大。

压缩算法是位运算的经典舞台。例如，哈夫曼编码通过可变长编码表示符号，其中每个符号的编码和解码都离不开移位和掩码操作。在ZIP、JPEG、MP3等无处不在的格式中，位运算在数据压缩与解压过程中扮演着核心角色，它直接操作数据的最小单位，实现了极高的空间效率。

此外，位运算在以下场景中也展现着独特魅力：

权限系统：用一个整数的不同位表示不同权限，通过位运算快速检查与组合
性能优化：某些算术运算可用位运算替代，在底层代码中提升速度
加密算法：许多加密操作依赖于位级别的混淆与扩散
网络协议：数据包的封装与解析常涉及位字段操作

补码：负数表示的智慧

计算机如何表示负数？这个问题引出了补码这一精妙设计。补码表示法不仅统一了正负数的加减运算，让CPU只需一套加法电路即可处理减法，更巧妙地解决了“零”有两种表示的问题（原码中+0和-0不同）。

理解补码，不仅仅是记住“取反加一”的规则，更是理解计算机如何用有限的二进制位表示无限整数范围的智慧。这种“模运算”思想，在哈希函数、循环缓冲区等场景中反复出现。

数据类型与系统边界：知道你的“容器”

了解int、float在32位和64位系统中的范围，不仅仅是应付考试的知识点。它关乎程序的可移植性、安全性与效率。

为什么一个int在32位系统上是4字节（通常-2³¹ ~ 2³¹-1），而在64位系统上可能仍是4字节或变为8字节？
为什么浮点数计算会有精度误差？0.1 + 0.2为什么不等于0.3？
当我们需要处理超过20亿的计数时，应该选择什么类型？

理解这些，意味着我们知道每个数据类型的边界，能够预见整数溢出的风险，理解浮点比较的陷阱，从而写出更健壮的软件。

基础不牢，地动山摇

回顾这次学习，我更加坚信：计算机科学中，越是基础的知识，往往越具有持久的力量。二进制、位运算、补码、数据类型——这些看似简单的概念，构成了我们理解一切高级主题的“元认知”。

当我未来学习操作系统内核、研究算法优化、探索机器学习框架时，今天打下的基础将成为我理解复杂性的“解码器”。我知道神经网络中的张量在内存中如何布局，能想象数据压缩时位模式的变换，能预测在不同系统上我的程序会有怎样的行为差异。

计算机的世界，从最基础的二进制到最前沿的人工智能，有着令人惊叹的统一性。而发现这种统一性，正是学习过程中最愉悦的体验之一。如果你也在学习计算机的道路上，不妨偶尔回到这些基础知识，很可能会获得新的启发——因为所有的高级，都建立在扎实的基础之上。

真正理解计算机的人，不是那些能写出最复杂代码的人，而是那些能看透复杂背后简单本质的人。

今天刚开通

Thu, 06 May 2021 14:16:59 +0800

你好，世界。开启分享个人生活博客