SunBK201's Blog

校园网防检测: UA3F - 新一代 UA 修改方法

Sun, 03 Dec 2023 03:37:08 +0800

太长不看（写于 2025.11）

修改 User-Agent 字段：使用 UA3F，默认配置开箱即用，ipk 安装即可。

UA3F 的使用教程见：猴子也能看懂的 UA3F 使用教程

前言

目前众多高校依旧对校园网络共享行为进行严格限制，具体表现为：

对每人接入校园网络的设备数量进行限制
如果存在接入路由器并存在多人使用时，将采取断网、封禁等惩罚措施

为了能够绕过校园网的接入设备数量的限制，有众多同仁对校园网的共享检测机制进行研究，我也在关于某大学校园网共享上网检测机制的研究与解决方案一文中归纳总结出校园网的共享检测常见方法：

TTL 字段的检测
HTTP User-Agent 头部检测
DPI 检测技术
IPv4 Identification 字段
时钟偏移的检测技术
Flash Cookie 检测

其中上述的一部分方法随着历史原因与技术的迭代已经被废弃：

Flash Cookie 检测: 随着 HTML5 与 WebGL 等技术的出现，Flash 已经于 2020 年退出历史舞台
IPv4 Identification 字段: 经过验证 iPhone、Mac 等移动设备的 Identification 会保持为 0

而剩下的时钟偏移的检测实际落地应用场景有待考证，DPI 检测技术由于会对网络设备造成过高的负载压力，因此部分高校可能不会开启此功能。

对于 TTL 字段的检测，目前已有成熟有效的方法能够绕过检测，即利用 netfilter/iptables 对 TTL 进行修改即可。那么目前防检测方案唯一有待优化的就是剩下来的 HTTP User-Agent 头部检测，而 User-Agent 头部检测也是目前各大高校最常用的防共享检测方案之一。在之前的工作中，有同仁提出了 XMURP-UA，一个用于修改 User-Agent 的内核模块，但是存在性能以及无法处理 80 端口以外的流量等问题；为了弥补 XMURP-UA 的端口覆盖不全的问题，UA2F 被提出，其最大的贡献在于借助 libnetfilter_queue 将 TCP Flow 进行 HTTP 解析并将 UA 修改，该方法能够处理任意端口流量。

但是经过长期的实践，UA2F 存在以下问题：

由于依赖于 netfilter/libnetfilter_queue 的外部动态库，因此实际构建与部署较为复杂，需要涉及对 OpenWrt 的交叉编译，对用户存在门槛。
UA2F 依赖于 netfilter/iptables 进行流重定向，因此与 Clash 等代理工具存在冲突问题，因此对于依赖于 Clash 等代理工具的用户，不得不采用二级路由的形式已实现 Clash 与 UA2F 的共存。

UA3F: 新一代 UA 修改方法

为了解决上述 UA2F 存在的问题，我提出一种全新的 HTTP User-Agent 修改方法: UA3F

由上图所示，UA3F 依赖于 Clash 等基于规则的代理工具，UA3F 本身最为一个 SOCKS5 代理对本机提供服务，借助 Clash，UA3F 能够捕获入站全部流量，由 Clash 向 UA3F 转发的全部潜在的 HTTP 流量，这里值得注意的是，UA3F 可以接受任何基于 TCP 协议的流量，但是只关注于 HTTP，UA3F 会尝试解析 TCP 流并判断当前连接是否承载 HTTP 流量，如果判定非 HTTP 连接，则直接转发，如果判定为 HTTP 连接，则进行 HTTP 流量解析并定位修改 User-Agent 头部。

通过上述方式，UA3F 可以做到：

与 Clash 共存
借助 Clash 的流量重定向，UA3F 可以截获到全部 HTTP 流量
UA3F 对外作为一个定制的 SOCKS5 代理，与 Clash 部署到同一路由器设备，相当于将远程的代理服务器转移到本地，由本地进行流量转发处理，因此 UA3F 依赖 Clash 但并不需要外部远程代理服务器进行加密代理转发。
自定义 UA 内容

UA3F 使用

# 无参数执行，默认监听端口为 1080，默认 UA 修改为 FFF
./ua3f

# 可以修改监听端口与自定义 UA
# 以下通过下面参数可以让 UA3F 监听端口为 8080，UA 修改为 HELLO
./ua3f -p 8080 -f HELLO

UA3F 作为一个 SOCK5 服务，Clash 可以十分方便进行配接入，下面提供一个 Clash 的配置用于接入：

proxies:
  - name: "ua3f"
    type: socks5
    server: 127.0.0.1
    port: 1080
    url: http://connectivitycheck.platform.hicloud.com/generate_204

rules:
  - PROCESS-NAME,ua3f,DIRECT
  - MATCH,ua3f

这里值得注意的是，请确保 PROCESS-NAME,ua3f,DIRECT 置于规则列表的最顶部。对于部分用户有代理加密需求的用户，可以在上述 2 条规则之间加入自定义的加密代理规则，例如:

rules:
  - PROCESS-NAME,ua3f,DIRECT
  - DOMAIN-SUFFIX,google.com,Proxy
  - MATCH,ua3f

通过与加密代理的配合，可以实现：

直连网络流量通过 UA3F 进行处理转发
加密代理网络流量通过 Clash 连接外部代理服务器进行代理转发

结束

校园网防共享检测的需求对我来说已经消失，但是观察到目前现有方法的限制与问题，我进行了 UA3F 的初步实现，目前已经开源: https://github.com/SunBK201/UA3F，UA3F 的实现处于初级阶段，可能存在一些问题，因此欢迎各位同学进行反馈与指正。

欢迎加入讨论组进行讨论交流：Telegram

命令行界面设计指南

Sun, 15 Jan 2023 00:28:23 +0800

https://sunbk201.github.io/cli-guidelines-zh/

About

Sun, 01 Jan 2023 00:00:00 +0000

hi guys!

Contact Me: me@sunbk201.com

Twitter @SunBK201
GitHub @SunBK201
RSS @SunBK201

正则表达式高阶使用：负向零宽度断言

Fri, 31 Dec 2021 00:00:00 +0000

当我在写 Surge 的规则配置文件时，我发现我需要通过正则表达式使用 policy-regex-filter 进行过滤，具体的需求是：排除包含指定字符串的节点，过滤获得没有包含指定字符串的节点。

这是个难题，平时使用正则表达式主要是“匹配”的思想，这次要使用“否定排除”的思想。

零宽度断言 (zero-width-assertions) 解决了这个问题。我们这里讨论的是否定的断言。零宽度断言所匹配到的内容并不会保存到结果中去。

^((?!hede).)*$

上面的正则表达式是用来匹配排除包含 hede 的结果。

一个字符串包含 n 个字符的 list，在每个字符的前后都包涵一个空的字符串，因此含有 n 个字符的 list 拥有 n+1 个空字符串。我们来看下这个字符串 "ABhedeCD" :

    ┌──┬───┬──┬───┬──┬───┬──┬───┬──┬───┬──┬───┬──┬───┬──┬───┬──┐
S = │e1│ A │e2│ B │e3│ h │e4│ e │e5│ d │e6│ e │e7│ C │e8│ D │e9│
    └──┴───┴──┴───┴──┴───┴──┴───┴──┴───┴──┴───┴──┴───┴──┴───┴──┘
index    0      1      2      3      4      5      6      7

其中，e 们都是空字符串，表达式 (?!hede). 会检查每个的 e 的后面有没有 “hede” 子字符串，如果没有，. 会匹配任意一个字符（除了换行符），这种行为称为“零宽度断言”，因为他们没有消耗任何字符，仅仅只是在断言或证实某些东西。因此，在上面的例子中，对于每个空字符串都会被验证其之后有无 “hede”，之后再与 . 匹配。表达式 (?!hede). 只会进行一次上面的验证，因此，我们将其成组重复多次：((?!hede).)*。最后，我们锚定首尾：^((?!hede).)*$。

"ABhedeCD" 最终会在 e3 处失败，因为 e3 之后存在字符串 “hede”。

我们再将其拓展一下，可以匹配排除包含多个指定字符串的节点：

^((?!(本站|流量|过期|下架|用户群|官网|精简)).)*$

准确来说，上面使用的属于「正向否定查找」，常规用法是：x(?=y)，含义是仅仅当 x 后面不跟着 y 时匹配 x。

例如，仅仅当这个数字后面没有跟小数点的时候，\d+(?!\.) 匹配一个数字。正则表达式 \d+(?!\.) 匹配 141 而不是 3.141。

但 (?!hede). 的这种用法属实少见，其思想是将其匹配字符之前的部分看作是一个字符串（空字符串）（[空字符串](?!hede).），而检查是这个空字符串的后面是否匹配 (?!hede)。

多线程简介：走进并发世界

Thu, 26 Aug 2021 00:00:00 +0000

现代计算机有能力在同一时间进行多种操作。在硬件进步和愈发智能的操作系统的支持下，这一特性能够使我们的程序运行得更快，无论是在执行速度还是响应速度方面。

利用多线程的优势编写软件是非常有趣的，但是也非常困难：它需要你了解你的计算机的内部。多线程是操作系统提供的一种充满魔力的工具，在这一篇我们将尝试掀开多线程的面纱，让我们开始吧！

进程和线程：命名

现代操作系统可以同时运行多个程序。这就是为什么你可以在你的浏览器（一个程序）中阅读这篇文章，同时在你的媒体播放器（另一个程序）中听音乐。每个程序被称为一个正在执行的进程。操作系统可以利用许多软件技巧，使一个进程与其他进程一起运行，或者充分利用底层硬件的优势。无论哪种方式，最后的结果都是你感觉到所有程序都在同时运行。

在操作系统中运行进程并不是同时执行几个操作的唯一方法。每个进程能够在其内部同时运行子任务，称为线程。你可以把线程看作是进程本身的一个片段。每个进程在启动时至少会触发一个线程，这被称为主线程。然后，根据程序或程序员的需要，可以启动或终止其他线程。多线程是指在一个进程中运行多个线程。

例如，你的媒体播放器很可能运行多个线程：一个用于渲染界面–这通常是主线程，另一个用于播放音乐，等等。

进程与线程的不同

每个进程都有操作系统分配的自己的一大块内存。默认情况下，该内存不能与其他进程共享：你的浏览器不能访问分配给媒体播放器的内存，反之亦然。如果你运行同一个进程的两个实例，也就是说，如果你启动浏览器两次，也会发生同样的事情。操作系统将每个实例视为一个新的进程，分配给它自己独立的内存部分。因此，默认情况下，两个或更多的进程没有办法共享数据，除非他们执行高级技巧 – 进程间通信（IPC）。

与进程不同，线程共享操作系统分配给其父进程的同一块内存：媒体播放器主界面的数据可以很容易地被音频引擎访问，反之亦然。因此，两个线程之间的对话更容易。除此之外，线程通常比进程更轻量：它们占用资源更少，创建速度更快，这就是为什么它们也被称为轻量级进程。

线程是一种使你的程序同时执行多个操作的方便方法。如果没有线程，你将不得不为每个任务编写一个程序，将它们作为进程运行，并通过操作系统使它们同步。这将更加困难（ IPC 很麻烦）和缓慢（进程比线程更重）。

绿色线程：纤维

到目前为止，所提到的线程是操作系统的事情：一个想要启动一个新线程的进程必须与操作系统对话。不过，并不是每一个平台都原生支持线程。绿色线程，也被称为纤维，是一种模拟，使多线程程序能够在不原生支持线程的环境中工作。例如，在底层操作系统没有原生线程支持的情况下，虚拟机可以实现绿色线程。

绿色线程的创建和管理速度较快，因为它们完全绕过了操作系统，但也有缺点。关于这点我们之后再讲。

“绿色线程”这个名字是指 Sun Microsystem 的 Green Team，他们在 90 年代设计了最初的 Java 线程库。如今，Java 不再使用绿色线程：他们早在 2000 年就转向了本地线程。其他一些编程语言 – Go、Haskell 或 Rust 等等–都实现了绿色线程的类似产物，而不是本地线程。

线程的用途

为什么一个进程要采用多线程？正如我之前提到的，并行做事会大大加快事情的进展。假设你要在你的电影编辑器中渲染一部电影。编辑器可以很聪明地将渲染操作分散到多个线程中，每个线程处理电影的一个部分。因此，如果用一个线程处理，比如说，需要一个小时，用两个线程则需要 30 分钟；用四个线程则需要 15 分钟，以此类推。

真的就这么简单吗？有三个要点需要考虑：

并非每个程序都需要多线程。因为如果你的应用程序执行顺序操作或经常等待用户进行 IO，多线程可能不是那么有益；
你不能把更多的线程扔给一个应用程序来使它运行得更快：每个子任务都必须经过深思熟虑和精心设计，以执行并行操作。
并不能 100% 保证线程会真正并行地执行它们的操作，也就是在同一时间会发生什么：这很大程度上取决于底层硬件。最后一个是至关重要的：如果你的电脑不支持同时进行多项操作，操作系统就必须伪造这些操作。我们将在一分钟内看到如何做。现在，让我们把并发看作是有任务同时运行的感觉，而真正的并行则是任务在同一时间运行。

是什么让并发和并行成为可能

计算机中的中央处理单元（CPU）负责运行程序的工作。它由几个部分组成，其中最主要的是所谓的核心：这是实际进行计算的地方。一个核心一次只能运行一个操作。

这当然是一个主要的缺点。由于这个原因，操作系统已经开发了先进的技术，使用户能够同时运行多个进程（或线程），特别是在图形环境中，甚至在单核机器上。最重要的一项技术叫做抢占式多任务，抢占式多任务是指中断一个任务，切换到另一个任务，然后在稍后的时间恢复第一个任务的能力。

因此，如果你的 CPU 只有一个核心，操作系统的部分工作就是将这个单一核心的计算能力分散到多个进程或线程中，这些线程在一个循环中一个接一个地执行。这种操作给你一种错觉，即有一个以上的程序在并行运行，或者一个程序同时做多件事情（如果是多线程）。并发性得到了满足，但真正的并行性–同时运行进程的能力–仍然缺失。

今天，现代的CPU通常有一个以上的内核，其中每个内核一次执行一个独立的操作。这意味着，有了两个或更多的核心，真正的并行是可能的。例如，我的 Intel Core i7 有 8 个核心：它可以同时运行 8 个不同的进程或线程。

单核上的运行多线程应用：有意义吗？

在单核机器上，真正的并行化是不可能实现的。尽管如此，如果你的应用程序能够从中受益，那么编写一个多线程程序仍然是有意义的。当一个进程采用多个线程时，即使其中一个线程执行缓慢或阻塞的任务，抢占式多任务也能保持应用程序的运行。

例如，你正在开发一个桌面应用程序，从一个非常慢的磁盘上读取一些数据。如果你编写的程序只有一个线程，那么整个应用程序就会冻结，直到磁盘操作完成：分配给唯一线程的 CPU 功率在等待磁盘唤醒时被浪费了。当然，除了这个进程之外，操作系统还在运行许多其他进程，但你的具体应用程序不会有任何进展。

让我们以多线程的方式来重新思考你的应用程序。线程 A 负责磁盘访问，而线程 B 负责主界面。如果线程 A 因为设备速度慢而被卡住等待，线程 B 仍然可以运行主界面，保持你的程序的响应速度。这是可能的，因为有两个线程，操作系统可以在它们之间切换 CPU 资源，而不会卡在较慢的那一个。

越多线程，越多问题

正如我们所知，线程共享其父进程的同一块内存。这使得两个或多个线程在同一个应用程序中交换数据变得非常容易。例如：一个电影编辑器可能持有很大一部分共享内存，其中包含视频时间线。这样的共享内存被几个工作线程读取，这些线程被指定用于将电影渲染到文件中。他们都只需要一个到该内存区域的句柄（例如一个指针），以便从其中读取并将渲染的帧输出到磁盘。

只要有两个或更多的线程从同一内存位置读取，事情就能顺利进行。当至少有一个线程向共享内存写东西，而其他线程则从该内存中读取时，麻烦就来了。这时会出现两个问题：

数据竞争：当一个写者线程修改内存时，一个读者线程可能正在从内存中读取。如果写者还没有完成它的工作，读者就会得到损坏的数据。
竞态条件：读者线程应该在写者写完之后才读。如果相反的情况发生呢？比数据竞争更微妙的是，竞争条件是指两个或多个线程以不可预测的顺序做他们的工作，而事实上，这些操作应该以适当的顺序进行才能正确完成。即使你的程序已被保护为防止数据竞争，也可能触发竞争条件。

线程安全的概念

如果一段代码能够正常工作，即没有数据竞争或竞态条件，即使许多线程同时执行它，也可以说它是线程安全的。你可能已经注意到，一些编程库声明自己是线程安全的：如果你正在编写一个多线程程序，你要确保任何其他的第三方函数可以在不同的线程中使用而不会引发并发问题。

数据竞争的根源

我们知道，一个 CPU 核心一次只能执行一条机器指令。这样的指令被说成是原子性的，因为它是不可分割的：它不能被分解成更小的操作。希腊语中的「atom」（ἄτομος；atomos）的意思是不可切割。

不可分割的属性使得原子操作在本质上是线程安全的。当一个线程对共享数据执行原子写操作时，没有其他线程可以读取半成品的修改。相反，当一个线程对共享数据进行原子读取时，它读取的是整个数值，因为它出现在一个时间点上。线程没有办法从原子操作中溜走，因此不可能发生数据竞争。

坏消息是，绝大多数的操作都是非原子性的。即使是像 x = 1 这样的琐碎赋值，在某些硬件上也可能是由多个原子机器指令组成的，使得赋值本身作为一个整体是非原子的。因此，如果一个线程读取 x，而另一个线程执行赋值，就会触发数据竞争。

竞态条件

抢占式多任务让操作系统完全控制线程管理：它可以根据高级调度算法启动、停止和暂停线程。作为一个程序员，你无法控制执行的时间或顺序。事实上，像这样的简单代码是无法保证的：

writer_thread.start()
reader_thread.start()

将以这个特定的顺序启动两个线程。多次运行这个程序，你会注意到它在每次运行中的表现是不同的：有时写程序的线程先启动，有时则是读程序的。如果你的程序需要写程序总是在读程序之前运行，你肯定会遇到一个竞态条件。

这种行为被称为非决定性的：每次的结果都会改变，你无法预测它。调试受竞态条件影响的程序是非常烦人的，因为你不可能总是以可控的方式重现这个问题。

教会线程们如何相处：并发控制

数据竞争和竞态条件都是现实世界的问题：有些人甚至因为它们而死亡。容纳两个或多个并发线程的艺术被称为并发控制：操作系统和编程语言提供了几种解决方案来处理它。其中最重要的是：

同步：一种确保资源一次只被一个线程使用的方法。同步是指将你的代码的特定部分标记为「保护」，这样两个或更多的并发线程就不会同时执行它，从而破坏你的共享数据。
原子操作：由于操作系统提供的特殊指令，一堆非原子操作（如前面提到的赋值）可以变成原子操作。这样一来，无论其他线程如何访问，共享数据总是保持在一个有效的状态。
不可变的数据：共享数据被标记为不可变的，没有什么可以改变它：线程只允许从它那里读取，消除了根本原因。我们知道线程可以安全地从同一内存位置读取，只要他们不修改它。这就是函数式编程背后的主要理念。

This is a version from Internal Pointers.

1500 字节是如何成为互联网的 MTU 的？

Thu, 15 Jul 2021 00:00:00 +0000

以太网无处不在，数以万计的硬件供应商都在讨论和实现它。然而，几乎每个以太网链路都都有一个共同的数字，那就是 MTU：

$ ip l
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 state UNKNOWN
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
2: enp5s0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 state UP 
    link/ether xx:xx:xx:xx:xx:xx brd ff:ff:ff:ff:ff:ff

MTU（最大传输单元）规定了一个数据包可以有多大。一般来说，当你在自己的局域网上与其他设备通信时，MTU 大约为 1500 字节，互联网也几乎普遍采用 1500 字节。然而，这并不意味着这些链路层技术不能传输更大的数据包。

例如，802.11（WiFi）的 MTU 为 2304 字节，或者如果你的网络使用 FDDI，那么你的 MTU 约为 4352 字节。以太网本身有一个 “巨型帧 “的概念，MTU 可以设置为 9000 字节（在支持的网卡、交换机和路由器上）。

然而，这些设定在互联网上几乎无关大局。由于互联网的骨干网现在大多是由以太网链路组成的，因此事实上数据包的最大尺寸现在被非正式地设定为 1500 字节，以避免数据包在链路上被分片。

从表面上看，1500 是一个奇怪的数字，我们通常期望计算中的许多常数都是基于数学常量的，比如 2 的幂。

那么，1500 是怎么来的，为什么我们还在使用它？

神奇的数字

以太网的第一次重大突破是以 10BASE-2（廉价网）和 10BASE-5（稠密网）的形式出现的，这些数字大致表明一个网段可以跨越多少百米。

由于当时有许多竞争性协议，而且存在硬件限制，以太网原作者在一封电子邮件中指出，数据包缓冲区的内存要求在神奇的 1500 数字上有一些作用。

回过头来看，一个较长的最大值可能会更好，但如果它在早期增加了网卡的成本，可能会阻止以太网的广泛接受。

然而，这并不是故事的全部。1980年发表的 Ethernet: Distributed Packet Switching for Local Computer Networks 一文是对网络上较大数据包的效率成本分析的早期说明。这在当时对以太网特别重要，因为以太网网络将在所有系统之间共享相同的同轴电缆，或者以太网集线器，一次只允许一个数据包在以太网段的所有成员之间传输。

我们必须选择一个数字，使得数据在这些共享（有时是繁忙的）网段上的传输延迟不会太高，但这也意味着数据包头的开销不会太大。(见上面链接的论文第 15-16 页的一些表格)

看来，当时的工程师们最多只挑选了 1500 字节，或大约 12000 比特作为最佳"安全"值。

从那时起，各种其他的传输系统陆续出现，但其中最低的MTU值仍然是以太网的 1500 字节。大于网络上的最低 MTU 将导致 IP 分片，或者需要进行路径 MTU 检测。这两种情况都有各自的问题。即使是大型操作系统供应商有时也会将默认 MTU 降到更低。

效率问题

所以现在我们知道，互联网的 MTU 上限为1500，主要是由于传统的延迟数字和硬件限制，这对互联网的效率有多大影响？

如果我们看一下一个主要的互联网流量交换点（AMS-IX）的数据，我们会发现，至少有20%经过交换点的数据包是最大尺寸的。我们还可以看到局域网的总流量：

如果你把这两张图结合起来，你得到的结果大致上是这样的。这是对每个数据包大小区间的流量的估计。

或者，如果我们只看所有这些以太网序言和报头引起的流量，我们会得到同样的图表，但有不同的尺度。

这表明大量的带宽被花在最大的数据包类的包头上。由于峰值流量显示最大的数据包桶的开销约为 246GBit/s，我们可以假设，如果我们在有条件的情况下都采用了巨型帧，那么这个开销将只有约 41GBit/s。

但我认为在这一点上，宽广的互联网上已经有人这样做过。虽然一些互联网通信公司以 9000MTU 运营，但绝大多数并非如此，而且一次又一次地证明，共同改变互联网的想法是非常困难的。

This is a version from benjojo.

关于 SSD，每一位开发者都应该知道的一些知识

Wed, 23 Jun 2021 00:00:00 +0000

基于闪存的 Solid-State Drives (SSDs) 固态硬盘已经在很大程度上取代了磁盘，成为标准的存储介质。从程序员的角度来看，固态硬盘和磁盘看起来非常相似：两者都是持久性的，通过文件系统和系统调用实现基于页面（如 4KB）的访问，并且具有大容量。

然而，也有一些重要的区别，如果想达到最佳的 SSD 性能，这些区别就变得很重要。周所周知，SSD 更加复杂，如果只是简单地认为它们是快速的磁盘，那么它们的性能表现会显得相当难以理解。这篇文章的目的是让大家了解为什么 SSD 会有这样的性能表现，这有助于构建能够充分利用它们的软件。请注意，我讨论的是 NAND 闪存，而不是英特尔 Optane 内存，后者具有不同的特性）。

驱动器（Drives）不是磁盘（Disks）

固态硬盘经常被称为磁盘，但这是一种误导，因为它们在半导体上存储数据，而不是在机械磁盘上。要从一个随机块中读取或写入，磁盘必须机械地将其磁头移动到正确的位置，这需要 10ms 的时间。相比之下，从固态硬盘中进行随机读取，需要大约 100us–快 100 倍。这种低读取延迟就是为什么系统从固态硬盘启动要比从磁盘启动快得多的原因。

并行性

磁盘和固态硬盘的另一个重要区别是，磁盘有一个磁头，只在顺序访问时表现良好。相比之下，固态硬盘由几十个甚至几百个闪存芯片（“并行单元”）组成，可以同时访问。

固态硬盘透明地将较大的文件以页为单位在闪存芯片上存储，而硬件预取器则确保顺序扫描能够利用所有可用的闪存芯片。然而，在闪存层面上，顺序读取和随机读取之间没有太大的区别。事实上，对于大多数固态硬盘来说，随机读取页面也有可能实现利用几乎全部的带宽。要做到这一点，必须同时安排数百个随机 IO 请求，以保持所有闪存芯片的工作。这可以通过启动大量线程或使用异步 IO 接口（如 libaio 或 io_uring）来实现。

写入

写入时，事情变得更加有趣，例如，如果我们测试下写入延迟，我们可以测量到低至10us的结果–比读快 10 倍。然而，延迟看起来如此之低，是因为固态硬盘在易失性 RAM 上进行了写入缓存。NAND 闪存的实际写入延迟约为 1ms - 比读取慢 10 倍。在消费级固态硬盘上，这可以通过在写完后发出 sync/flush 来衡量，以确保数据在闪存上的持久性。在大多数数据中心/服务器固态硬盘上，写延迟无法直接测量：sync/flush 将立即完成，因为即使在断电的情况下备用电池依旧可以保证写缓存的持久性。

为了在相对较高的写入延迟下实现高的写入带宽，写使用了与读相同的技巧：他们同时访问多个闪存芯片。因为写缓存可以异步写入页面，所以甚至没有必要同时安排那么多的写入来获得良好的写入性能。然而，写入的延迟不可能总是被完全掩盖：例如，由于写入占用闪存芯片的时间是读的10倍，写入会导致对同一闪存芯片的读取有明显的尾部延迟。

Out-Of-Place 写入

我们对 SSD 的理解忽略了一个重要的事实：NAND 闪存的页面不能被覆盖。页的写入只能在事先已被擦除的块内按顺序进行。这些擦除块的大小为多 MB，由数百个页面组成。在一个新的固态硬盘上，所有的块都已被擦除，人们可以直接开始写入新的数据。

然而，更新页面就不那么容易了。如果只是为了就地覆盖一个页面而擦除整个区块，那就太浪费了。因此，固态硬盘通过将新版本的页面写到一个新的位置来执行页面更新。这意味着逻辑和物理页面地址是解耦的。存储在 SSD 上的映射表将逻辑（软件）地址转换为物理（闪存）位置。这个组件也被称为 Flash Translation Layer（FTL）。

例如，让我们假设我们有一个 SSD，有 3 个擦除块，每个有 4 个页面。对 P1, P2, P0, P3, P5, P1 页的一连串写入可能会导致以下物理 SSD 状态：


Block 0	P1 (old)	P2	P0	P3
Block 1	P5	P1	→
Block 2

这时，我们已经没有空闲的擦除块了（尽管从逻辑上来说，应该还有空间）。在写入另一个页面之前，SSD 首先要擦除一个块。在这个例子中，对于垃圾回收器来说，最好是擦除第 0 块，因为只有其中的一个页面还在使用。在擦除第0块后，我们为 3 个写页腾出了空间：


Block 0	P1 (old)	P2 (old)	P0	P3 (old)
Block 1	P5	P1 (old)	P3	P4
Block 2	P7	P1	P6	P2

写入放大与超额配置

为了垃圾回收 block 0，我们不得不物理地移动 P0 页，尽管在逻辑上该页没有发生什么。换句话说，对于闪存 SSD 来说，物理（闪存）写入的数量通常高于逻辑（软件）写入的数量。两者之间的比例被称为写入放大（WA）。在我们的例子中，为了给 0 区块的 3 个新页面腾出空间，我们不得不移动 1 个页面。因此，我们有 4 个物理写，3 个逻辑写，也就是说，写放大率为 1.33。

高写入放大率会降低性能，并减少闪存的使用寿命。写入放大率有多大，取决于访问模式和固态硬盘的满度。大的连续写入有低的写入放大率，而随机写入是最糟糕的情况。

让我们假设我们的 SSD 被填充到 50%，我们进行随机写入。在稳定状态下，无论我们在哪里擦除一个区块，该区块的大约一半的页面仍然在使用，并且平均要被复制。因此，50% 的填充系数的写入放大率是 2。一般来说，填充系数 f 的最坏情况下的写入放大率是 1/(1-f)。


f	0.1	0.2	0.3	0.4	0.5	0.6	0.7	0.8	0.9	0.95	0.99
WA	1.11	1.25	1.43	1.67	2.00	2.50	3.33	5	10	20	100

因为在填充系数接近 1 的情况下，写入放大率会变得不合理地高，大多数固态硬盘都有隐藏的备用容量。这种超额配置通常为总容量的 10-20%。当然，通过创建一个空的分区并永远不向其写入，也很容易增加更多的超额配置。

总结

目前，固态硬盘已经变得相当便宜，而且它们具有非常高的性能。例如，三星 PM1733 服务器固态硬盘每 TB 价格约为 200 EUR ，并承诺提供接近 7GB/s 的读取和 4GB/s 的写入带宽。实际上，要实现如此高的性能，需要了解 SSD 的工作原理，这篇文章就是描述了闪存 SSD 最重要的底层机制。

我尽量让这篇文章简短，要想了解更多，这篇教程是一个不错的起点。最后，由于 SSD 已经变得如此之快，操作系统的 I/O 堆栈往往成为性能瓶颈。Linux 的实验结果可以在这篇的 CIDR 2020论文中找到。

关于 iOS SSID 格式字符串 BUG 的快速分析

Mon, 21 Jun 2021 00:00:00 +0000

数天前，Twitter 上的一条推文爆出了一个iOS Wi-Fi 的 BUG：

@vm_call: After joining my personal WiFi with the SSID “%p%s%s%s%s%n”, my iPhone permanently disabled it’s WiFi functionality. Neither rebooting nor changing SSID fixes it :~)

看起来这是一个格式化字符串的错误，现在这种 BUG 已经很少见了。我用相同的 SSID 设置了一个热点，用我的测试设备尝试加入，wifid 很快就崩掉了。

以下是崩溃日志 wifid-2021-06-20-xxxxxx.ips:

Thread 2 name:  Dispatch queue: com.apple.wifid.managerQueue
Thread 2 Crashed:
0   libsystem_platform.dylib      	0x00000001ebcb9724 _platform_strlen + 4
1   CoreFoundation                	0x00000001a381d84c __CFStringAppendFormatCore + 8812
2   CoreFoundation                	0x00000001a381efa8 _CFStringCreateWithFormatAndArgumentsReturningMetadata + 160
3   WiFiPolicy                    	0x00000001d0895f8c -[WFLogger WFLog:message:] + 192
4   ???                           	0x000000010692c00c 0 + 4405248012
5   wifid                         	0x0000000100f58a74 0x100e40000 + 1149556
6   wifid                         	0x0000000100f58c74 0x100e40000 + 1150068

所以这真的是格式化字符串错误！

反编译 dyld_shared_cache 中的这个函数 -[WFLogger WFLog:message:]，有 2 处对 CFStringCreateWithFormatAndArguments 的引用:

v7 = j__CFStringCreateWithCString_107(0LL, a4, 0x8000100u); // the format string
    if ( v7 || (v7 = j__CFStringCreateWithCString_107(0LL, a4, 0)) != 0LL )
  {
  if ( self->_destination == 2 )
  {
    v8 = j__CFStringCreateWithFormatAndArguments_26(0LL, 0LL, v7, v21);
    v18[3] = (__int64)v8;
  }

 if ( self->_destination != 2
  && (!self->_wflRunningOnWatchClassDevice || self->_wflEnableDualLoggingOnWatchClassDevice) )
{
  *(_QWORD *)&v16.tm_sec = 0LL;
  *(_QWORD *)&v16.tm_hour = &v16;
  *(_QWORD *)&v16.tm_mon = 0x2020000000LL;
  *(_QWORD *)&v16.tm_wday = 0LL;
  v10 = j__CFStringCreateWithFormatAndArguments_26(0LL, 0LL, v7, v21); // <-- here

用 lldb debug 这个 issue 很麻烦了，因为这个 method 太常见了。因此，使用 frida frida-trace -U wifid -m ‘-[WFLogger WFLog:message:]’, 然后使用以下通知脚本：

  onEnter(log, args, state) {
  const msg = '' + args[3].readUtf8String();
  log(`-[WFLogger WFLog:${args[2]} message:${msg}]`);
  if (msg.indexOf('%p%s%s%s%s%n') > -1) {
    for (let i = 3; i < 10; i++) {
      log(args[i], JSON.stringify(Process.findRangeByAddress(args[i])));
    }

    log('called from:\n' +
      Thread.backtrace(this.context, Backtracer.ACCURATE)
      .map(DebugSymbol.fromAddress).join('\n') + '\n');
  }
},

这是在崩溃之前的日志：

17863 ms -[WFLogger WFLog:0x3 message:Dequeuing command type: “%@” pending commands: %ld]

17863 ms -[WFLogger WFLog:0x3 message:{ASSOC+} Attempting Apple80211AssociateAsync to %p%s%s%s%s%n]

根据 backtrace，这就是根本原因：

v27 = sub_1000A25D4(v21);
v28 = objc_msgSend(
        &OBJC_CLASS___NSString,
        "stringWithFormat:",
        CFSTR("Attempting Apple80211AssociateAsync to %@"),
        v27);
v29 = objc_msgSend(&OBJC_CLASS___NSString, "stringWithFormat:", CFSTR("{ %@+} %@"), CFSTR("ASSOC"), v28);
v30 = objc_autoreleasePoolPush();
v31 = (void *)qword_100251888;
if ( qword_100251888 )
{
    v32 = objc_msgSend(v29, "UTF8String");
    objc_msgSend(v31, "WFLog:message:", 3LL, v32);
}
objc_autoreleasePoolPop(v30);

它将 SSID concat 到一个格式字符串，并将其传递给 WFLog:message: 方法，目的地是 3，所以是 CFStringCreateWithFormatAndArguments 的第二个 xref 引发了拒绝服务。

对于可利用性，目前还没有问题，其余的参数也不像是可以控制的。因此，我不认为这个 bug 是可利用的。毕竟，要触发这个 bug，你需要连接到该 WiFi，其中的 SSID 对受害者是可见的。钓鱼 Wi-Fi 或许更有效。

This is a version from Schou.

main 通常是个函数，那么什么时候不是呢？

Fri, 18 Jun 2021 00:00:00 +0000

这始于我的同伴，尽管他已经知道如何编程，但却被迫参加我大学的计算机科学入门课程。我们跟他开玩笑说，他需要做一个可以运行的程序，但是评分的老师不能搞明白它是如何运行的。所以要求就是制作一个满足作业要求的程序，同时又要混淆视听，让评分人认为它不应该能运行起来。考虑到这一点，我开始回想起之前见过的C语言技巧库，其中有一点特别突出。我将通过这个技巧完成这个特殊的程序，这个技巧的想法来自一篇博客 main is usually a function，这让我想到什么时候 main 不是一个函数？

（你可以下载我在这里写的代码，注意我是在 64-bit Linux 进行编写的，因此你如果在其它平台运行，你或许需要进行调整。）

我解决问题的过程通常和大多数程序员做的事情一样。第 1 步：在谷歌上搜索有关问题。第 2 步：点击第一页上每个看起来相关的链接。如果没有解决，尝试不同的查询，然后重复。值得庆幸的是，这个问题的答案出现在 Stackoverflow 首次搜索中。在 1984 年，一个奇怪的程序赢得了 IOCCC，其中 main 被声明为 short main[] = {...}，不知何故，这个程序成功做了一些事情，并打印到屏幕上！这是一个很好的例子。不幸的是，它是为一个完全不同的架构和编译器编写的，所以我真的没有简单的方法来找出它做了什么，但从它只是一堆数字的事实来看，我可以推测，那里的数字只是一些短函数的编译二进制，链接器在寻找主函数时只是把它扔到它的位置。

有了我们的假设，即程序的代码只是以数组形式表示的主函数的编译汇编，让我们看看是否可以通过制作一个小程序来复制这一现象，看看我们是否可以做到这一点。

char main[] = "Hello world!";

$ gcc -Wall main_char.c -o first
main_char.c:1:6: warning: ‘main’ is usually a function [-Wmain]
  char main[] = "Hello world!";
      ^
$ ./first
Segmentation fault

好了，它成功了… 因此我们的下一个目标是它能真正打印一些东西到屏幕上。回想一下我有限的 ASM 经验，我记得有不同的 section 决定了不同东西的去处。与我们最相关的两个section是.text section 和 .datasection。.text 包含所有可执行的代码，它是只读的，而 .data 包含可读和可写的代码，但它是不可执行的。在我们的例子中，我们只能填入 main 函数的代码，所以任何被放在 .data section 的东西都是不可行的。我们需要找到一种方法，在 main 函数内获得字符串 “Hello world!” 并引用它。

我开始研究如何用尽可能少的代码来打印东西。由于我知道目标系统将是64位Linux，我发现我可以调用系统的写入调用，它将会输出到屏幕上。现在回过头来看这段代码，我认为我不需要为此使用汇编，但同时，我真的很高兴我能够学到一些东西。开始写内联 GCC ASM 是最难的部分，但一旦我掌握了它，一切就开始变得容易了。

不过，开始并不容易。事实证明，我通过谷歌能找到的大部分ASM知识都是以下内容：非常老旧，英特尔的语法，而且是 32 位系统。记住在我们的方案中，我们需要文件在 64 位系统上用 gcc 编译，不需要对编译器标志进行任何特殊的修改，所以这意味着没有特殊的编译标志，也不能包括任何自定义的链接步骤，我们要使用 GCC 内联 AT&T 语法。我的大部分时间都花在了寻找有关64位系统的现代汇编的信息上了！我想这是一个很好的例子。也许是我的 Google-fu 有所欠缺 :) 这一部分几乎都是试验和错误。我的目标只是用 gcc inline ASM 的 write syscall 向屏幕打印 “Hello world!"，为什么这么难呢？对于想学习如何做这个的人，我推荐以下网站： Linux syscall list, Intro to Inline ASM, Differences between Intel and AT&T Syntax.

最终，我的 ASM 代码完成了，而且看起来它可以工作！记住，我的目标是制作一个 main，它是一个打印 Hello World 的 ASM 数组。

void main() {
    __asm__ (
        // print Hello World
        "movl $1, %eax;\n"  /* 1 is the syscall number for write on 64-bit */
        "movl $1, %ebx;\n"  /* 1 is stdout and is the first argument */
        "movl $message, %esi;\n" /* load the address of string into the second argument*/
        "movl $13, %edx;\n"  /* third argument is the length of the string to print*/
        "syscall;\n"
        // call exit (so it doesn't try to run the string Hello World)
        // maybe I could have just used ret instead?
        "movl $60,%eax;\n"
        "xorl %ebx,%ebx; \n"
        "syscall;\n"
        // Store the Hello World inside the main function
        "message: .ascii \"Hello World!\\n\";"
    );
}

$ gcc -Wall asm_main.c -o second
asm_main.c:1:6: warning: return type of ‘main’ is not ‘int’ [-Wmain]
  void main() {
      ^
$ ./second
Hello World!

YES! 它打印出来了! 现在让我们看看编译后的十六进制代码，它应该与我们写的 ASM 代码一一对应起来。

(gdb) disass main
  Dump of assembler code for function main:
      0x00000000004004ed <+0>:     push   %rbp             ; Compiler inserted
      0x00000000004004ee <+1>:     mov    %rsp,%rbp
      0x00000000004004f1 <+4>:     mov    $0x1,%eax        ; It's our code!
      0x00000000004004f6 <+9>:     mov    $0x1,%ebx
      0x00000000004004fb <+14>:    mov    $0x400510,%esi
      0x0000000000400500 <+19>:    mov    $0xd,%edx
      0x0000000000400505 <+24>:    syscall
      0x0000000000400507 <+26>:    mov    $0x3c,%eax
      0x000000000040050c <+31>:    xor    %ebx,%ebx
      0x000000000040050e <+33>:    syscall
      0x0000000000400510 <+35>:    rex.W                   ; String hello world
      0x0000000000400511 <+36>:    gs                      ; it's garbled since
      0x0000000000400512 <+37>:    insb   (%dx),%es:(%rdi) ; it's not real ASM
      0x0000000000400513 <+38>:    insb   (%dx),%es:(%rdi) ; so it couldn't be
      0x0000000000400514 <+39>:    outsl  %ds:(%rsi),(%dx) ; disassembled
      0x0000000000400515 <+40>:    and    %dl,0x6f(%rdi)
      0x0000000000400518 <+43>:    jb     0x400586
      0x000000000040051a <+45>:    and    %ecx,%fs:(%rdx)
      0x000000000040051d <+48>:    pop    %rbp             ; Compiler-inserted
      0x000000000040051e <+49>:    retq
End of assembler dump.

这看起来是个有戏的 main，现在让我们去抓取它的十六进制内容，并将其作为字符串 dump 出去，看看是否能正常工作。我的方法是加载 gdb，像这样在 main 处打印 hex。上次我们拆解 main 的时候，看到它有 49 个字节长，所以可以用 dump 命令把十六进制保存到文件中。

# example of how to print the hex
(gdb) x/49xb main
0x4004ed <main>:    0x55    0x48    0x89    0xe5    0xb8    0x01    0x00    0x00
0x4004f5 <main+8>:  0x00    0xbb    0x01    0x00    0x00    0x00    0xbe    0x10
0x4004fd <main+16>: 0x05    0x40    0x00    0xba    0x0d    0x00    0x00    0x00
0x400505 <main+24>: 0x0f    0x05    0xb8    0x3c    0x00    0x00    0x00    0x31
0x40050d <main+32>: 0xdb    0x0f    0x05    0x48    0x65    0x6c    0x6c    0x6f
0x400515 <main+40>: 0x20    0x57    0x6f    0x72    0x6c    0x64    0x21    0x0a
0x40051d <main+48>: 0x5d
# example of how to save it to a file
(gdb) dump memory hex.out main main+49

现在我们有了 hex dump，我们可以用我知道的最简单的方法将它们全部转换成整数，那就是使用 python。在Python 2.6 和 2.7中，你可以用下面的方法将其转换为方便我们使用的 int 数组。

>>> import array
>>> hex_string = "554889E5B801000000BB01000000BE10054000BA0D0000000F05B83C00000031DB0F0548656C6C6F20576F726C64210A5D".decode("hex")
>>> array.array('B', hex_string)
array('B', [85, 72, 137, 229, 184, 1, 0, 0, 0, 187, 1, 0, 0, 0, 190, 16, 5, 64, 0, 186, 13, 0, 0, 0, 15, 5, 184, 60, 0, 0, 0, 49, 219, 15, 5, 72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33, 10, 93])

我想如果我的 bash foo 和 unix 知识更丰富的话，我可以找到一个更简单的方法来做这件事，但在谷歌上搜索 “编译后的函数的十六进制转储 “这样的东西，会得到几个关于如何用各种语言打印十六进制的问题。不管怎么说，我们现在有了一个逗号分隔的函数数组，所以让我们把它放到一个新的文件中。

char main[] = {
    85,                 // push   %rbp
    72, 137, 229,       // mov    %rsp,%rbp
    184, 1, 0, 0, 0,    // mov    $0x1,%eax
    187, 1, 0, 0, 0,    // mov    $0x1,%ebx
    190, 16, 5, 64, 0,  // mov    $0x400510,%esi
    186, 13, 0, 0, 0,   // mov    $0xd,%edx
    15, 5,              // syscall
    184, 60, 0, 0, 0,   // mov    $0x3c,%eax
    49, 219,            // xor    %ebx,%ebx
    15, 5,              // syscall
    // Hello world!\n
    72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100,
    33, 10,             // pop    %rbp
    93                  // retq
};

$ gcc -Wall compiled_array_main.c -o third
compiled_array_main.c:1:6: warning: ‘main’ is usually a function [-Wmain]
  char main[] = {
      ^
$ ./third
Segmentation fault

Segfault！我做错了什么？是时候再次启动 gdb，看看错误是什么了。由于 main 不再是一个函数，我们不能简单地使用 break main 来在那里设置断点。相反，我们可以使用 break _start 在调用 libc runtime startup 的方法上获得一个断点（该函数调用 main），我们可以看到我们传递给 __libc_start_main 的地址。

$ gdb ./third
(gdb) break _start
(gdb) run
(gdb) layout asm
    ┌───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
 B+>│0x400400 <_start>                       xor    %ebp,%ebp                                                                       │
    │0x400402 <_start+2>                     mov    %rdx,%r9                                                                        │
    │0x400405 <_start+5>                     pop    %rsi                                                                            │
    │0x400406 <_start+6>                     mov    %rsp,%rdx                                                                       │
    │0x400409 <_start+9>                     and    $0xfffffffffffffff0,%rsp                                                        │
    │0x40040d <_start+13>                    push   %rax                                                                            │
    │0x40040e <_start+14>                    push   %rsp                                                                            │
    │0x40040f <_start+15>                    mov    $0x400560,%r8                                                                   │
    │0x400416 <_start+22>                    mov    $0x4004f0,%rcx                                                                  │
    │0x40041d <_start+29>                    mov    $0x601060,%rdi                                                                  │
    │0x400424 <_start+36>                    callq  0x4003e0 <__libc_start_main@plt>                                                │

通过测试，我发现在 %rdi 上 push 的值是 main 的位置，但这次似乎有些不对劲。等一下，它把 main 放在了 .data 部分! 早些时候我提到了 .text 是只读可执行代码的位置，而 .data 是不可执行的读写值的位置！这就是问题所在，这段代码试图运行被标记为不可执行的内存，这是导致 segfault 的原因。我怎么能让编译器相信我的 “main” 属于 .text 呢！？好吧，我的搜索结果是空的，我确信这就是道路的尽头。是时候收工了，game over。

但那晚没有找到解决方案我就无法入睡。我继续搜索，再搜索，直到我在一个 stackoverflow 的帖子上找到一个非常明显和简单的解决方案，可惜我已经找不到网址了。我所要做的就是把 main 函数声明为const 把它改成 const char main[] = { 从而让它进入正确的 section，所以让我们再试着编译。

$ gcc -Wall const_array_main.c -o fourth
const_array_main.c:1:12: warning: ‘main’ is usually a function [-Wmain]
  const char main[] = {
            ^
$ ./fourth
SL).....]

emmmm, 它现在在做什么! 是时候再次使用 gdb，看看发生了什么。

gdb ./fourth
(gdb) break _start
(gdb) run
(gdb) layout asm

所以看一下代码，我们可以看到 main 的地址在 ASM 的 _start 指令中，在我的机器上看起来是这样的 mov $0x4005a0,%rdi 我们可以用这个在 main 上设置一个断点，通过做 break *0x4005a0，然后用 c 继续执行。

(gdb) break *0x4005a0
(gdb) c
(gdb) x/49i $pc     # $pc is the current executing instruction
...
    0x4005a4 <main+4>:   mov    $0x1,%eax
    0x4005a9 <main+9>:   mov    $0x1,%ebx
    0x4005ae <main+14>:  mov    $0x400510,%esi
    0x4005b3 <main+19>:  mov    $0xd,%edx
    0x4005b8 <main+24>:  syscall
...

我剪掉了一些不重要的汇编。如果你没有注意到出错的地方，push 到 print 的地址 (0x400510) 并不是我们存储字符串 "Hello world!\n " 的地址(0x4005c3)！它实际上仍然指向原始编译的可执行文件中的计算位置，而不是使用相对寻址来打印它。这意味着我们需要修改汇编代码，以便加载相对于当前地址的字符串的地址。就目前而言，在 32 位代码中完成这个任务相当困难，但幸运的是我们使用的是 64 位ASM，所以我们可以使用 lea 指令来轻松完成。

void main() {
  __asm__ (
        // print Hello World
        "movl $1, %eax;\n"  /* 1 is the syscall number for write */
        "movl $1, %ebx;\n"  /* 1 is stdout and is the first argument */
        // "movl $message, %esi;\n" /* load the address of string into the second argument*/
        // instead use this to load the address of the string
        // as 16 bytes from the current instruction
        "leal 16(%eip), %esi;\n"
        "movl $13, %edx;\n"  /* third argument is the length of the string to print*/
        "syscall;\n"
        // call exit (so it doesn't try to run the string Hello World
        // maybe I could have just used ret instead
        "movl $60,%eax;\n"
        "xorl %ebx,%ebx; \n"
        "syscall;\n"
        // Store the Hello World inside the main function
        "message: .ascii \"Hello World!\\n\";"
    );
}

$ gcc -Wall relative_str_asm.c -o fifth
relative_str_asm.c:1:6: warning: return type of ‘main’ is not ‘int’ [-Wmain]
  void main() {
      ^
$ ./fifth
Hello World!

现在我们可以使用前面讨论过的技术，将十六进制的值提取成一个整数数组。但是这一次，我想通过使用整整 4 个字节的 ints 来使它变得更有伪装性和技巧性。我们可以通过在 gdb 中把信息作为一个 int 打印出来，而不是把十六进制转储到一个文件中，然后再复制粘贴到程序中。

gdb ./fifth
(gdb) x/13dw main
0x4004ed <main>:    -443987883  440 113408  -1922629632
0x4004fd <main+16>: 4149    899584  84869120    15544
0x40050d <main+32>: 266023168   1818576901  1461743468  1684828783
0x40051d <main+48>: -1017312735

我选择了数字 13，因为 main 的长度为 49 字节，为了安全起见，49/4 取整为 13。由于我们提前退出了这个函数，所以应该不会有什么影响。现在剩下的就是把这个复制粘贴到我们的 compiled_array_main.c 中并运行它。

const int main[] = {
  -443987883, 440, 113408, -1922629632,
  4149, 899584, 84869120, 15544,
  266023168, 1818576901, 1461743468, 1684828783,
  -1017312735
};

$ gcc -Wall final_array.c -o sixth
final_array.c:1:11: warning: ‘main’ is usually a function [-Wmain]
  const int main[] = {
            ^
$ ./sixth
Hello World!

自始至终，我们都忽略了关于 warning: ‘main’ is usually a function 的警告信息 :)

我猜，当我的朋友交出这样的作业时，会因为糟糕的编码风格而扣分，然而并不会说别的……

This is a version from James Rowe.

String Hashing 如何工作？

Tue, 15 Jun 2021 00:00:00 +0000

字符串哈希是一种将字符串转换为哈希数字的技术。我们为什么需要这样做？有时我们需要比较超长字符串，此时我们可以比较生成的哈希，而不是比较字符串，从而提升效率。

假设你需要比较下面的两个字符串：

const A = "imagine that this is a string of 200 characters"
const B = "imagine that this is a string of 200 characterz"

假设两个字符串都有 200 个字符。一个暴力的方法是依次比较每个字符，看它们是否匹配。像下面这样：

const A = "imagine that this is a string of 200 characters"

const B = "imagine that this is a string of 200 characterz"

function equal(A, B) {
  let i;
  for(i = 0; i < A.length; i++){
    if (A[i] !== B[i]) {
      return false;
    }
  }
  return true;
}

console.log(equal(A,B));

对于超长字符串来说，这并不是最佳选择，因为它的性能是 O(min(A, B))。

当然，我们可以通过添加一个比较 A 大小和 B 大小的条件来使其成为 O(n)。像下面这样：

function equal(A, B) {
  if (A.lenght !== B.length) return false;
  let i;
  for(i = 0; i < A.length; i++){
    if (A[i] !== B[i]) {
      return false;
    }
  }
  return true;
}

正如我所说，最坏的情况是 O(n)，但在实际生产环境中，我们需要比较一个真正的超长字符串。

字符串哈希可以将我们的字符串转换成一个整数，这将作为一个哈希数字。因此，我们比较两个哈希值 hash(A)==hash(B) ，性能会是 O(1)。这是我们比较两个字符串的最佳选择。

String Hash 公式

我们规定 p 和 m 是素数，s[0], s[1], s[2]… 是每个字符的值，在这里是字符编码。

p: 素数，大致等于所使用的不同字符的数量。例如，如果我们要计算一个只包括英文小写字母的单词的哈希值，31 会是个不错的数字。然而，如果我们还会使用大写字母的话，那么 53 是一个合适的选择。

m: 这个数字越大，两个随机字符串出现碰撞的概率就越小。这个变量也应该是素数。

10 ^ 9 + 9 是个常用的选择。

比如我们使用下面一组：

p = 31
m = 1e9 + 9
word = 'apple'

我们想要得到 apple 的哈希，因此我们使用 String Hash 公式：

进一步：

字符编码为：

"a" = 97
"p" = 112
"p" = 112
"l" = 108
"e" = 101

在公式中进行替换：

然后我们化简得到公式：

最终：

我们最终得到 apple 的哈希为 96604250。

以下是 JavaScript 的实现：

function hash(word) {
  var p = 31;
  var m = 1e9 + 9;
  var hash_value = 0;
  for(var i = 0; i < word.length; i++) {
      var letter = word[i];
      var charCode = letter.charCodeAt();
      hash_value = hash_value + (charCode * Math.pow(p, i))
  }
  return hash_value % m;
}

console.log(hash("apple"));

This is a version from Jorge Chávez.

什么是 /dev/null：介绍一下比特桶 (Bit Bucket)

Mon, 14 Jun 2021 00:00:00 +0000

如果你之前曾经使用过 Linux，你很有可能遇到过比特桶 (Bit Bucket)，通常写为 /dev/null。了解这个特殊的文件是如何工作的以及它的重要性，有利于使之成为我们极有用的工具。我们将讨论什么是 /dev/null，如何使用它，以及为什么它为什么叫做比特桶。我们还将探讨一些例子，说明它在通常情况下是如何使用的。

为什么叫 “比特桶”？

早期的计算机使用打孔卡来存储数据和编程代码。当机器打完孔后，未使用的材料会掉进一个桶里。随着时间的推移，比特桶成为一个通用术语，指的是一个丢弃无用比特的地方。

/dev/null 的其他名字是 black hole、null route、punch bucket、null device，或者只是 null。

/dev/null 文件

/dev/null 文件是一个在启动时产生的伪设备文件。它没有大小（0字节），在磁盘上占用 0 个块，对所有用户都有读/写权限。下面的截图显示，该文件和上次系统重启的日期和时间相同。

这是一个被称为字符设备文件的特殊文件。这允许该文件像一个设备（空设备）一样运作，它没有缓冲，可以接受数据流。当你访问一个设备文件时，你是在与一个驱动程序进行通信。在 /dev/null 的情况中，它就像一个带有驱动程序的有具体用途的伪设备。它会丢弃你写给它的任何东西，并且只在读取时返回一个 EOF 字符。发送 EOF 或多或少意味着让进程意识到不会有更多的输入被发送（End of File）。

/dev/null 文件的使用

使用 /dev/null 抑制输出

/dev/null 文件最常被用来抑制输出。在下面的例子中，我们使用 > 重定向操作符，将 stat 命令的输出发送到比特桶中。

stat /etc/passwd > /dev/null

这样做有效地抑制了输出的命令（标准输出）。

我们可以使用 /dev/null，通过重定向标准错误（STDERR）来抑制错误输出，如下：

stat /etc/passwdss 2> /dev/null

我们把文件名改为 passwdss，但它并不存在。这通常会显示一个 “No such file or directory “的错误。不过，由于我们将 STDERR（标准错误）输出重定向到 /dev/null，所以这个错误被丢弃了。

注意: 要了解更多关于重定向和标准数据流（STDIN、STDOUT、STDERR）的知识，请阅读 Linux I/O, Standard Streams, and Redirection。

注意: 发送到 /dev/null 的数据会被立即丢弃，无法恢复。

使用 /dev/null 来输入 EOF（End of File）

/dev/null 的另一个常见用途是提供一个空白或空的输入，除了EOF字符外什么都没有。你可能并不清楚为什么需要这样一个函数。然而，有很多工具需要一个EOF字符才能进行。例如，mailx 工具将允许你从命令行中输入一个电子邮件。它会一直等待输入，直到它收到一个EOF字符，这个字符是通过点击 CTRL + D 来发送的。

注意：EOT（传输结束）和 EOF（文件结束）有技术上的差异，归结为编码问题，不在本教程的范围内。

如果我们想发送一封空白的电子邮件，我们将不得不进入交互式模式，并点击 CTRL + D，没有输入。如果是在脚本或其他无人看管的情况下使用，这将是不切实际的。作为一种变通方法，我们可以将 /dev/null 重定向到 mailx 命令中，让它为我们做这件事。

mailx -s "Just Another Email" user@putorius.net < /dev/null
Null message body; hope that's ok

使用 /dev/null 来清空一个文件

/dev/null 文件的另一个常见用途是清空文件的内容。如果你使用 > 重定向操作符将 /dev/null 重定向到一个文件中，它将有效地删除该文件的内容。

sunbk201@BKALIEN:~$ ls -l scp.log
-rw-r--r-- 1 sunbk201 sunbk201 13 Jun 13 20:48 scp.log
sunbk201@BKALIEN:~$ cat /dev/null > scp.log
sunbk201@BKALIEN:~$ ls -l scp.log
-rw-r--r-- 1 sunbk201 sunbk201 0 Jun 13 20:48 scp.log
sunbk201@BKALIEN:~$ cat scp.log

另一个选择是使用 cp 命令将 /dev/null 复制到该文件上，像这样：

sunbk201@BKALIEN:~$ ls -l scp.log
-rw-r--r-- 1 sunbk201 sunbk201 13 Jun 13 20:49 scp.log
sunbk201@BKALIEN:~$ cp /dev/null scp.log
sunbk201@BKALIEN:~$ ls -l scp.log
-rw-r--r-- 1 sunbk201 sunbk201 0 Jun 13 20:50 scp.log

总结

比特桶（/dev/null）对于系统管理员、开发工程师和几乎所有使用命令行的人来说都是一个重要而有用的工具。在这篇文章中，我们讨论了 /dev/null 的一些最常见的用途，一旦你知道它的作用，你可能会发现越来越多的使用方法。

Resource and Links:

This is a version from putorius.

3 Tribes of Programming - 3 大编程阵营

Sun, 06 Jun 2021 00:00:00 +0000

有一个老笑话，计算机科学其实是一个谎言，因为它不怎么跟计算机相关，也不是真正的科学。

有趣的笑话，每个人都笑了, 然后有人说 “但是它还是跟计算机有些相关性的，不是吗？”。

在外面，有争论是这样的：

“ I’ll happily renounce “programmer” in favor of “applied mathematician” or something, whatever it takes to avoid C. - https://t.co/DsIEo5x4uI / Twitter 有些人认为，我们计算机中的整个现代堆栈（内核、操作系统、浏览器、虚拟机）是用C + ASM 编写的。所以你应该了解 C 和 ASM。

这真的很重要吗？问题的关键在于：一个程序，指令序列与逻辑思想的表达，两者谁更重要？

也可能两者都不是，而程序只是我们为其他人制作的东西。如果没有阅读它的读者，任何一条信息都是无意义的。如果不参考它们所处的外部世界，程序是否也毫无意义？

一个朋友曾经向我吹嘘，他可以用Ada证明大多数程序是正确的，而且完全没有错误。我问他能不能证明这个函数是正确的。

fn sub(a, b) { return a + b }

他说：“当然，这太简单了”。于是我问他他的测试工具如何发现函数有错误的名字，他笑着慌了手脚。

三大编程阵营

显然，程序拥有所有以上这些属性。但我认为从根本上说，程序员有三种类型，按我们最推崇的理想来划分。

你是一个诗人，一个数学家。编程是你的诗歌。
你是一个黑客。你让硬件跟着你的想法运作。
你是一个创造者。你创造事物为人们所用。我们在这些理想的基础上自我选择进入同侪的社区。我们使用编码语言来向我们的同侪表达这些理想。

我认为每个群体都有自己的准则，和自己的子版块。他们有自己的编程语言、英雄与反派。

编程即数学的应用

第一个阵营认为，编程从根本上说是一种思想的表达 - 一种我们可以用生命来馈赠的数学诗歌。在冯·诺依曼机器上执行它们只是一个实现细节。

带着这种心态，下面这些细节就很重要：

源代码：源代码应该读起来像诗歌一样 - 稠密又浓重，只需要很少的几行代码来表达一个想法。一旦理解，简练的程序看起来就像是对你的程序的美丽而明显的描述。源代码的精炼比执行的简单或快速更重要。高级语言比低级语言更优秀，因为高级语言能让你更清楚地表达你的意图。执行：程序如何被计算机执行只是编译器的一个执行细节，代码的简单比执行的快速更重要。正确性：如果准确的实现了规范，那么程序将会是正确的。我们可以使用Ada来证明程序的正确性。 UI：代码如何与人进行互动与他程序的实现是两码事，漂亮的代码比漂亮的用户界面更重要。举例: Rich Hickey, Brett Victor

这类程序员可能是最不常见的，这可能是因为这种人很难找到工作。在 stackoverflow 统计的的所有语言中，Haskell 在的周末使用率最高。

现代编程语言的大部分（可以说是全部）的进步都源自于这个阵营的努力。如果你用 React 做了一个网站，你应该知道，不变性模型和把你的观点表达为从数据到 DOM 的纯函数模型来自函数式编程。实际上，大多数现代语言的功能都是由那些把编程当作思想的人发明的。几年（或几十年）之后，这些功能被复制到更流行的语言中，并被当作新的想法。

我有一个朋友，他花了几个月的时间喜欢上了 J，他最终用 J 写了一个小游戏，他把他的代码描述成这个完美无瑕的水晶。后来他想把它做成多人游戏 - 但要做到这一点，他就必须处理迟延问题。而这将需要分割一些美丽的内部流程。他无法忍受这一点，所以他完全放弃了这个项目。

这个故事很有趣，但我有点嫉妒我的朋友。我打赌他学到了很多东西，而且玩得很开心。这样的经历使我们变得更加优秀。

去年年底我参加了一个 Haskell 的短期课程，我向主讲老师提出了挑战。我告诉他：“这的确不错，但我打赌我仍然可以用我的实用语言比你更快地做出有用的软件”。他说不可能 - 使用 haskell，他相信他可以实现任何我可以实现的东西，而且更快、更好，代码更少。我们没有验证这个说法 - 但我仍然想知道 - 他是对的吗？

最喜欢的语言：Haskell, Lisp, ML (Ocaml, etc), Closure, ADA

居所：FP meetups, Lambda the ultimate, Strange Loop, Research.

Steve Yegge making fun of this tribe

编程即硬件 Hack

第二个阵营认为，编程从根本上是与计算机的硬件联系在一起的。没有计算机就无法运行任何程序，因此要进行有效地编程，我们必须时刻牢记计算机 - 硬件和软件。

优雅和美丽不仅来自于简单的代码库，而且来自于该代码库以一种优雅和有效的方式驱动硬件。

因此，优雅之处在于：

源代码：代码应该是简洁的，但是简介的代码不如干净利落的执行来的重要。低级语言通常优于高级语言，因为你可以更明确地知道计算机在执行你的代码时在做些什么（因此，你有更多的空间来进行优化）。执行：计算机如何执行你的代码是最重要的。不考虑执行的编程只是在为缓慢的性能添砖加瓦。正确性：如果一个程序在正常参数下以你期望的方式运行，那么它就是正确的。执行的优雅性比正确性更重要。如果一个理论上的问题由于机器的工作方式而无法在实践中发生，那么它就不是一个真正的错误。一个程序必须有快速的执行速度才能被认为是正确的。 UI：代码如何与人互动是与它的实现应该分开考虑。让硬件的限制来指导用户体验是可以的。举例： Poul-Henning Kamp, Michael Steil, The 8-Bit guy

这里的关键是要考虑到计算机和你的运行程序的整体性。按照此方阵营的说法，编写好软件的最佳（唯一）方法是全面考虑它将如何运行，以及我们的程序将如何与其他硬件和软件互动。做好这一点，就能达到硬件的共鸣，一切都像上好油的时钟一样运行。这种快乐就像驾驶一辆你能听到和理解的手波车一样。

任何混淆计算机如何执行你的程序的行为对执行方来说都是危险的 - 因为它增加了更多需要考虑的变量。因此，这个阵营的人经常嘲笑垃圾回收器，或者 JS 性能基准测试结果的大闹改变了我们编写代码的方式。C 语言编译器中的未定义行为是一个持续争论的焦点。

在现代应用开发中，我们的计算机速度已经足够快了，这种思维已经不那么重要。几十年前，你需要对计算机的工作原理有深刻的理解才能编写软件。但现在基本上你使用的任何语言都足够快了，所以为什么要费心学习 C 语言呢？我认识的大多数网络开发者都不懂 C 语言，也没有兴趣去学习指针或手动内存管理。

但是这类工作在很多领域仍然有很大的价值。游戏开发社区仍然用 C++ 编写大部分代码（尽管unity正在慢慢改变这种状况）。安全工程师需要一个系统的理解来寻找漏洞。嵌入式系统工程师不能浪费周期和内存，一旦后端系统变得足够大，性能又开始重要起来。

而且，即使它不实用，但被迫思考机器的问题也是非常有趣的! 例如，PICO-8 施加了专横的 “硬件 “限制，迫使你在设计游戏的时候变得聪明起来。

在这个社区中，我们的计算机几乎所有的性能改进都归功于此，超出了客户的要求。没有人像那些整天考虑硬件的人那样关心性能。但是，如果你把你的电脑当成一台机器，还有什么比无意义的工作更让你感到丑陋的呢？

我真的很好奇 Rust 是否会在这个社区中大火。Rust 本质上是一种由上述第一阵营的语言书呆子设计的语言，为那些关心运行时效率的人服务。他们会接受它吗？未来的游戏引擎会被移植到 Rust 上吗？

与第一个阵营的冲突：

可变性（内存从根本上说是可变的 / 但它使我们的程序更难理解）
GC （它使你的程序变得缓慢而笨拙 / 但错误较少！）
抽象（你使你的程序更难 / 更容易推理）

最喜欢的语言：C, C++, Assembly

居所：Hackerspaces, Game dev shops, database companies, CCC, Defcon.

Brett Victor making fun of this tribe.

编程即创造的工具

最后一组人把编程看作是达到美好目的的手段，而不是构建美好的东西。这个阵营的人描述自己的方式从根本上说是务实的。他们写软件是因为软件对其他人有用。

源代码：代码应该是简洁的，但只是因为简洁的代码更容易迭代。代码的简洁度没有其他大多数因素那么重要。
执行：程序只需要对用户来说足够快。如果你让它变得更快，你就会浪费掉增加人们更关心的功能中的时间。
正确性：Bugs 的坏处只与它们的影响成正比。程序应该按照用户期望的方式运行。
UI：UI 比其他任何东西都要重要。程序的其他部分都是为用户界面而存在的。我认为大多数专业的软件工程师都在这个阵营里 - 这很合理，因为这是写软件最容易赚钱的地方。

根据我的经验，这个阵营的人在社区方面更出色。他们似乎更积极，更鼓励新成员，并愿意提供帮助。我想这是因为你可以通过简单的观察自己来判断你在其他两个阵营中是否做得很好。如果你为其他人制作软件，满足感来自于让你周围的人感到快乐。

我不禁觉得这个地方有点儿没有灵魂。走到极端，这种世界观并不重视工程本身的美。尽管你可能会对其他团体提出相反的批评 - 他们不重视他们的软件如何影响世界。

在这个阵营和我谈到的其他两个阵营之间存在着很多冲突。而且这可能会变得有点刻薄。我知道很多做产品的人对他们缺乏传统数据结构和算法的知识感到自责。他们觉得被 “真正的” 程序员批判，因为他们不能实现晦涩的算法和二进制框架协议。在这个阵营的人看来，反正其他人已经实现了所有这些东西。所以，谁在乎呢？

这还算公平，但它也是事实，很多问题是由前端工程师缺乏技术能力造成的。这主要是自我纠正 - 如果你的程序太慢，你知道它并可以修复它。但是安全工程是真正的危险。如果你不知道如何保护你编写的软件不受黑客攻击，那么它可能就很危险。而且，即使你被黑了，你也可能不知道这是个问题。

“@jdan Well, then you’re not a very good programmer. Sorry but that’s how it is.” ~ Jonathan Blow (@Jonathan_Blow) June 12, 2015

就上面的言论而言，Jonathan Blow（著名的独立游戏开发者）说，如果你不能逆转二叉树，你就不是一个好的开发者，即使你每天都在写有用的软件。

他说的对吗？这取决于 “好的开发者” 是什么意思，而这又取决于你关心的是哪个阵营。我认为 Blow 是在第二阵营，评判标准是你知道多少。 @jdan在第三阵营，所以他的评判标准是他做了什么。Jonathan Blow 当然会写出有用的软件，但他的上一个游戏（The Witness）花了这么长时间，原因之一是他自己写的引擎，而不是使用现成的东西。当被问及这个问题时：

“ 我对Unity不是很了解。然而，很明显，如果不重写大部分Unity（或添加很多没有的东西，拒绝使用Unity提供的大部分东西），就无法在Unity中构建 The Witness。而我们反正已经有了一个简单的图形引擎。因此，在建立我们自己的系统时，我们可以确保它们确实是游戏所需要的最好的东西。 ”

我怀疑他对第一部分的看法是错误的。但我自己主要是在第二阵营，所以我理解无论如何要写自己的引擎这种想法。我可能也会做同样的事情。

最喜欢的语言：无论做什么都完成了工作。JS, Ruby, Python, Swift, C#.

居所：Twitter, SydJS, StackOverflow, 你附近的公司!

Gary Bernhardt making fun of this camp.

一场安静的战争

我认为我们社区中的很多冲突和分歧都可以用这些术语来表达。并且还有很多程序员之间的误解。

例如，当一个整数溢出时，你的编程语言应该怎么做？如果你认为编程就像数学诗一样，首先它应该给你一个数学上正确的结果。

Haskell (第一阵营):

λ: 23^23
20880467999847912034355032910567 :: Num a => a

Vs C (第二阵营):

printf("%llu\n", 1 << 100); // overflows. Prints 0.

而如果你只是想发布一个产品，你就不必须在乎了。在javascript中（第三阵营），根本就没有整数类型。JS只用浮点数来表示一切。如果它们溢出了，那就倒霉了。

Rust 试图在前两个阵营中各占一席之地 - 成为一门由编程语言书呆子创造的语言，但却能编译出高效的代码。不出所料，这个问题在 Rust 社区引起了长时间的争论。最后的解决方案是这样的：默认情况下，溢出导致的异常在调试模式下被抛出，但在生产模式下安静地工作。

Rob Pike（ Go 的作者）对他的语言想要吸引哪个阵营感到困惑。他在 Go 发布几年后写了这篇文章。

“ 几周前有人问我，“你在推出 Go 时遇到的最大惊喜是什么？” 我立刻就知道了答案。尽管我们期望 C++ 程序员将 Go 视为一种替代方案，但大多数Go程序员来自 Python 和Ruby 等语言。很少有来自 C++ 的人。 ”

为什么？好吧，C++ 程序员在很大程度上属于上述第二阵营。他们想知道他们的代码将如何运行。但是 Go 有一个垃圾收集器和一个快速编译器。真的，Go 关心的是如何摆脱你的束缚，让你可以直接做东西。它是为最后一个阵营的人设计的语言，他们想制造产品。那些关心这个问题的人目前使用什么语言呢？Python、Ruby 和 Javascript。所以 Go 的目标当然是他们。

闭幕

下一次，当你看到关于 Javascript 是我们行业的毒瘤还是福音的争论时，或者当你看到像我这样的人对现代应用程序是垃圾感到愤怒时，请问你自己是为哪个阵营说话。他们是在拥护美丽的代码吗？性能和 “深刻理解”？还是他们只想完成工作和发布产品？

归根结底，代码就是代码。即使我们有不同的理由来写软件，我们所写的东西（通常）是兼容的。即使不是这样（Haskell）- 也总是有很多我们可以学习和窃取的想法。

毕竟，我们都欠对方很多。没有语言书呆子，我们仍然在写汇编。没有系统程序员，我们就不会有操作系统，而 haskell 和 javascript 也会慢得不能再慢。如果没有产品工程师，其他人就会被迫写 CSS。相信我，没有人愿意这样。

格雷斯-霍珀海军少将（Rear Admiral Grace Hopper）成功地将机器理解和产品思维联系起来，并在此过程中发明了一种与机器无关的计算机语言的概念。如果不能同时考虑到计算机能做什么和我们希望计算机做什么，这就不可能实现。

但我个人认为，我们应该渴望成为 Alan Kay 那样的人，同时做到这三点。他和他的团队经常跨越多个阵营的界限。举个例子，他从观察儿童学习 Squeak 和 Logo 中发明了面向对象的编程。他认为有一些方法可以让吃到蛋糕 - 使用现代技术来设计更简单的系统，使其更快、更优雅、对人类更有用。如果你还没有这样做，你应该看看他的每一次演讲。慢慢地看吧。

这当然是我的目标。希望我在70岁以后还能让人们大吃一惊。

This is a version from josephg.

Why OO Sucks - 为什么面向对象糟透了？

Thu, 03 Jun 2021 00:00:00 +0000

当我第一次接触到 OOP（面向对象编程）思想的时候，我是持怀疑态度的，但我不知道是因为什么，只是感觉这是”错误“的。OOP 推出后变得非常流行（我稍后会解释为什么），现在批评 OOP 就好比在亵渎神明。OOness（面向对象性）成为任何一种受欢迎语言必须拥有的东西。

说到这里，我想起了在巴黎举行的第 7 届 IEEE Logic 编程大会上，法国 IBM 时任老板的主旨演讲。 IBM prolog 已经添加了很多 OO 扩展，当被问及为什么他回答：

“我们的客户想要 OO prolog，所以我们制作了 OO prolog”

Why OO Sucks - 为什么面向对象糟透了

我对 OOP （面向对象编程）的主要反对意见要追溯到其中涉及的基本思想，我将概述其中的一些思想以及我对它们的反对意见。

反对 1 - 数据结构和函数不应绑定在一起

对象以不可分割的单位将函数和数据结构绑定在一起。我认为这是一个基本错误，因为函数和数据结构属于完全不同的世界。为什么？

函数是功能的执行，是做什么，它们有输入和输出。输入和输出是数据结构，这些数据结构被函数改变。函数是由命令式序列构建的：“先做这个再做那个…”，要理解函数，你必须理解事情完成的顺序（在惰性 FPL 和逻辑语言中，这个限制是放松的）。

数据结构就只是数据结构，他们什么都不做。它们本质上是声明。 “理解”数据结构比“理解”函数容易得多。

函数被理解为将输入转换为输出的黑盒。如果我理解了输入和输出，那么我就理解了函数。但这并不意味着我可以编写该函数。

函数通常是通过观察它们是计算系统中的事物来“理解”的，该系统的工作是将类型 T1 的数据结构转换为类型 T2 的数据结构。

函数和数据结构是完全不同类型的事物，因此将它们锁在同一个笼子里从根本上是错误的。

反对 2 - 一切都必须是对象

想想 “time”。在面向对象语言中，“time” 必须是一个对象。但是在非 OO 语言中，“time” 只是数据类型的一个实例。例如，在 Erlang 中有很多不同种类的时间，这些可以使用类型声明清晰明确地指定，如下所示：

-deftype day() = 1..31.
-deftype month() = 1..12.
-deftype year() = int().
-deftype hour() = 1..24.
-deftype minute() = 1..60.
-deftype second() = 1..60.
-deftype abstime() = {abstime, year(), month(), day(), hour(), min(), sec()}.
-deftype hms() = {hms, hour(), min(), sec()}.
...

请注意，这些定义不属于任何特定对象。它们无处不在，表示时间的数据结构可以被系统中的任何函数操作。

没有关联的方法。

反对 3 - 在 OOPL（面向对象编程语言）中，数据类型定义是分散在各处的

在 OOPL 中，数据类型定义属于对象。所以我无法在一个地方找到所有的数据类型定义。在 Erlang 或 C 中，我可以在单个包含文件或数据字典中定义所有数据类型。在 OOPL 中我不能这么做：数据类型定义散布在各处。

让我举一个例子。假设我想定义一个无处不在的数据结构，在 OOPL 中会带来麻烦。

正如 lisp 程序员早就知道的那样，拥有少量普遍存在的数据类型和大量用于处理它们的小函数比拥有大量数据类型和少量起作用的函数要好。

无处不在的数据结构类似于链表、数组或哈希表，或者更高级的对象，如时间、日期或文件名。

在 OOPL 中，我必须选择一些基础对象，我将在其中定义普遍存在的数据结构，所有其他想要使用该数据结构的对象都必须继承该对象。假设现在我想创建一些“时间”对象，它属于哪里以及在哪个对象中……

反对 4 - 对象有私有状态

状态是万恶之源。特别是应该避免有副作用的函数。

虽然编程语言中的状态是不可取的，但在现实世界中状态比比皆是。我对我的银行账户状态非常关心，当我从银行存款或取款时，我希望我的银行账户状态能够正确更新。

鉴于现实世界中存在状态，编程语言应该提供哪些工具来处理状态？

OOPL说： “对程序员隐藏状态”。状态只有通过访问函数才能隐藏和可见。传统的编程语言（C、Pascal）说：状态变量的可见性是由语言的作用域规则控制的。纯声明式语言说：没有状态。系统的全局状态被带入到所有函数中并又从所有函数中带出来，诸如 monad（用于 FPL）和 DCG（逻辑语言）之类的机制用于向程序员隐藏状态，因此他们可以好像“状态无关紧要”的进行编程，但在必要时可以完全访问系统状态。

OOPL 的 “对程序员隐藏状态” 是最糟糕的选择。他们没有暴露状态并试图找到减少状态干扰的方法，而是将其隐藏起来。

为什么 OO 很受欢迎？

原因 1 - 它被认为很容易学习。
原因 2 - 它被认为使代码重用更容易。
原因 3 - 它被炒作了。
原因 4 - 它创造了一个新的软件产业。我看不到原因 1 和 2 的证据。原因 3 和 4 似乎是技术背后的驱动力。如果一种语言技术如此糟糕以至于它创造了一个新的行业来解决它自己制造的问题，那么对于从中获利的人来说，这一定是个好主意。

这才是 OOP 背后的真正驱动力。

Shadowsocks-libev 部署教程

Wed, 02 Jun 2021 00:00:00 +0000

https://sunbk201public.notion.site/sunbk201public/Shadowsocks-libev-f78f777f132b4caea67b38736cc3d662

ShellClash 加密防检测教程

Wed, 02 Jun 2021 00:00:00 +0000

https://sunbk201public.notion.site/sunbk201public/ShellClash-d199f43309e44ab4b4d4ece01dbac3bb

OpenWrt 编译与防检测部署教程

Tue, 01 Jun 2021 00:00:00 +0000

https://sunbk201public.notion.site/sunbk201public/OpenWrt-f59ae1a76741486092c27bc24dbadc59

全新方案-懒人福音-无需手动编译修改UA-校园网防检测

Sun, 30 May 2021 00:00:00 +0000

校园网防检测: UA3F - 新一代 UA 修改方法

关于某大学校园网共享上网检测机制的研究与解决方案

OpenWrt 编译与防检测部署教程

阅读过上面两篇文章的同学可以发现，手动编译OpenWrt是一件很痛苦的事。显然对于一些动手能力不强的同学来说，通过 UA2F 修改UA是比较困难的。而且，UA2F从设计层面上也存在一些问题，例如无法处理网卡分包等情况。

因此，我们需要一种更加简单的方案，既能无需编译OpenWrt，又能更好的满足我们的需求。

之前我曾经提到过我们可以通过加密流量来实现防检测，但我当时并没有采取这个策略，因为进行全局加密网络流畅度影响太大，而进行部分加密目前市面上还没有很好的解决方案（之前是这么认为），目前大多数加密软件都是基于规则的加密，但支持的多为针对域名的加密。

然而我们的需求是针对http应用层的加密，这类加密方案目前支持的不多。

经过我深入了解，Clash 中 DstPort 是我们最理想的规则选项，我们可以指定代理目标端口为http的80端口从而实现http应用层的加密。

此外，除了针对http的加密外，我们还可以通过支持Mitm的网络调试工具对http中UA进行重写以达到修改UA的目的。

基于上面的分析，我总结了以下方案：

Windows 用户

使用 Clash，添加规则：

- DST-PORT,80,proxy

加入以上规则即可实现针对 80 端口的加密

Andorid 用户

使用 Clash，添加规则：

- DST-PORT,80,proxy

加入以上规则即可实现针对80 端口的加密

iOS & Mac 用户

使用 Quantumult X/Surge 等支持重写的工具，添加重写规则：

# Quantumult X
^http:// url request-header (\r\n)User-[A|a]gent:.+(\r\n) request-header $1User-Agent: F$2

# Surge
^http:// header-replace User-Agent F

加入以上规则即可实现针对 UA 的重写

OpenWrt 配置

使用 OpenClash，添加规则：

- DST-PORT,80,proxy

如果在 OpenWrt 加入这条配置，那么就无需进行其他终端的配置了。

其他

对于 TTL 和 NTP 方面，我们无需进行手动编译，常见的 OpenWrt 固件都能够默认支持。对于 IPID，我认为无需关注，基于 IPID 的检测我认为是不现实且很少见的。

如果有疑问可以加讨论组：Telegram

关于某大学校园网共享上网检测机制的研究与解决方案

Sat, 13 Mar 2021 00:00:00 +0000

太长不看（写于 2025.11）

校园网共享检测有 4 种方式，检测力和难度依次加大：

针对 IP 数据包的 TTL 字段的检测
针对 HTTP User-Agent 字段的检测
针对 TCP 时间戳计算时钟偏移的检测
针对部分应用特征的 DPI 检测（例如微信）

⚠️注意：你的校园网不一定 4 种方式都会开启。

下面是针对这 4 种检测方式的解决方案总结：

修改 TTL 字段：在路由器防火墙添加。使用 UA3F 默认配置开箱即用，ipk 安装即可。
修改 User-Agent 字段：使用 UA3F，默认配置开箱即用，ipk 安装即可。
清除 TCP 时间戳选项：使用 UA3F 的清除 TCP 时间戳选项功能即可。
加密流量：使用科学代理加密（例如 Clash、Surge 等），将部分特征流量进行加密。UA3F 提供了 Clash 参考配置。

UA3F 的使用教程见：猴子也能看懂的 UA3F 使用教程

⚠️关于 IPID 的检测：现代网络设备 IPID 已经不再递增，因此不再需要修改 IPID。

前言

关于本校的校园网，相信大家都知道是禁止单一账号下多设备同时访问互联网的，具体表现为 1 个账号只能同时让 1 台有线设备和 1 台无线设备接入互联网，这给我们一些拥有多设备的同学带来了很大的不便，因此不少同学想到了使用家用路由器的方式来解决这个为问题，然而校园网会进行共享上网检测，一旦发现一个 IP 下有多个不同设备的流量，就会封禁账号 2-8 小时不等，害的同学们怨声载道。

然而奇怪的是本校内竟无应对此检测的方案，俗话说得好，道高一尺魔高一丈，肯定是有办法解决这个问题的。因此本人出于学术兴趣，针对本校校园网共享上网检测机制进行了研究分析，并针对该机制提出了一些解决方案。

对于本校校园网网络环境的说明

校园网网络硬件设备：锐捷三层交换机（目前已知）
校园网认证系统：Drcom Web Portal 认证
校园网网络防火墙安全方案：深信服

为什么本校要禁止多设备共享上网？

对于家用的上网资费，平均一年就要数百甚至上千元人民币，而校园网的资费一般都很低，如果一个宿舍只用一个账号一个路由器就可以实现全员上网的话，那 ISP 肯定要亏死，因此肯定会封禁像路由器这种设备的。

本校校园网共享上网检测机制的研究

目前已知的（可能）存在的有：

基于 IPv4 数据包包头内的 TTL 字段的检测
基于 HTTP 数据包请求头内的 User-Agent 字段的检测
DPI (Deep Packet Inspection) 深度包检测技术
基于 IPv4 数据包包头内的 Identification 字段的检测
基于网络协议栈时钟偏移的检测技术
Flash Cookie 检测技术

下面我会对这些技术的实现原理作出进一步说明。

基于 IPv4 数据包包头内的 TTL 字段的检测

存活时间（Time To Live，TTL），指一个数据包在经过一个路由器时，可传递的最长距离（跃点数）。每当数据包经过一个路由器时，其存活次数就会被减一。当其存活次数为0时，路由器便会取消该数据包转发，IP网络的话，会向原数据包的发出者发送一个ICMP TTL数据包以告知跃点数超限。其设计目的是防止数据包因不正确的路由表等原因造成的无限循环而无法送达及耗尽网络资源。

这是一个比较有效且合理的检测技术，IPv4数据包下存在 TTL（Time To Live）这一字段，数据包每经过一个路由器（即经过一个网段），该TTL值就会减一。

不同的操作系统的默认 TTL 值是不同的，Windows 是 128， macOS/iOS、Linux 是 64。

因此如果我们自己接入路由器到校园网，我们的通过路由器的数据包会变为 127 或 63，一旦校园网抓包检测到这种数据包TTL不是128或64，就会判定为用户接入了路由器。

基于 HTTP 数据包请求头内的 User-Agent 字段的检测

HTTP 数据包请求头存在一个叫做 User-Agent 的字段，该字段通常能够标识出操作系统类型，例如：

Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.72 Safari/537.36 Edg/89.0.774.45
Mozilla/5.0 (iPad; U; CPU OS 3_2_1 like Mac OS X; en-us) AppleWebKit/531.21.10 (KHTML, like Gecko) Mobile/7B405

校园网会通过多次抓包检测此字段，若发现同时出现例如Windows NT 10.0 iPad 的字段，则判定存在多设备上网。

DPI (Deep Packet Inspection) 深度包检测技术

这个检测方案比较先进，检测系统会抓包分析应用层的流量，根据不同应用程序的数据包的特征值来判断出是否存在多设备上网。

具体可参考：基于 DPI 技术的网络共享设备检测方法及系统

此种方式已确认在锐捷相关设备上应用，当由于此项功能极耗费性能，因此有些学校可能不会开启此项功能。

基于 IPv4 数据包包头内的 Identification 字段的检测

IP 报文首部存在一个叫做 Identification 的字段，此字段用来唯一标识一个 IP 报文，在实际的应用中通常把它当做一个计数器，一台主机依次发送的IP数据包内的 Identification 字段会对应的依次递增，同一时间段内，而不同设备的 Identification 字段的递增区间一般是不同的，因此校园网可以根据一段时间内递增区间的不同判断出是否存在多设备共享上网。具体可以参考此专利：基于 IPID 和概率统计模型的 NAT 主机个数检测方法

不过经过我的抓包分析，Windows 的 TCP/IP 协议栈对 Identification 字段的实现是递增，而 iOS 的实现是保持全 0，因此校园网是否使用了该检测机制有待商榷。

基于网络协议栈时钟偏移的检测技术

不同主机物理时钟偏移不同，网络协议栈时钟与物理时钟存在对应关系，不同主机发送报文频率与时钟存在统计对应关系，通过特定的频谱分析算法，发现不同的网络时钟偏移来确定不同主机。

具体可以参考此专利：一种基于时钟偏移的加密流量共享检测方法与装置

此种方式具有一定的实验性，因此我不认为此种方式投入了商用。

该技术已经用不到了，Flash 都凉了… 不过还是提一下。 Flash Cookie 会记录用户在访问 Flash 网页的时候保留的信息，只要当用户打开浏览器去上网，那么就能被 AC 记录到 Flash Cookie 的特征值，由于 Flash Cookie 不容易被清除，而且具有针对每个用户具有唯一，并且支持跨浏览器，所以被用于做防共享检测。

具体参考：深信服防共享测试指导书

防共享上网检测的解决方案

对于校园网重重的检测，我们似乎已经不可能从终端级提出一个完美的解决方案，因此，下面的解决方案都是基于网关级的。简单来说，我们需要在路由器上动手脚。

路由器固件我们选择 OpenWrt，这是一个开源的路由器系统，允许我们自定义其系统内核以及添加自定义插件。

针对基于 IPv4 数据包包头内的 TTL 字段的检测的解决方案

应对思路很简单：修改 TTL 为固定值。

# 在 OpenWrt 上安装必要的软件包
opkg update && opkg install iptables-mod-ipopt kmod-ipt-ipopt
# 加入以下防火墙规则
iptables -t mangle -A POSTROUTING -j TTL --ttl-set 64

针对基于 HTTP 数据包请求头内的 User-Agent 字段的检测的解决方案

应对思路：统一所有终端的 User-Agent 这一点实现起来有点困难，目前有四种解决方案。

方案一：通过 Privoxy 修改 User-Agent（此方案不再建议使用）

~~这个方案存在一个很大的缺点就是性能太差，会极大的拖慢我们的带宽，但也是最简单的方案。~~

# 安装 Privoxy 软件包
opkg update
opkg install privoxy luci-app-privoxy luci-i18n-privoxy-zh-cn

进入 Privoxy 管理页面设置，进入文件与目录，Action Files 中只保留 match-all.action，Filter Files 与 Trust Files 留空；进入访问控制，Listen Address 填写 0.0.0.0:8118，Permit Address 填写 192.168.0.0/16，勾选 Enable Action File Editor；进入杂项，勾选 Accept Intercepted Requests；进入日志，取消全部选项；点击保存并应用；进入 OpenWRT 防火墙设置，在自定义设置中填入以下内容：

# 将局域网内的 HTTP 请求转发到 Privoxy 代理服务器上
iptables -t nat -N http_ua_drop
iptables -t nat -I PREROUTING -p tcp --dport 80 -j http_ua_drop
iptables -t nat -A http_ua_drop -m mark --mark 1/1 -j RETURN
iptables -t nat -A http_ua_drop -d 0.0.0.0/8 -j RETURN
iptables -t nat -A http_ua_drop -d 127.0.0.0/8 -j RETURN
iptables -t nat -A http_ua_drop -d 192.168.0.0/16 -j RETURN
iptables -t nat -A http_ua_drop -p tcp -j REDIRECT --to-port 8118

打开 http://config.privoxy.org/edit-actions-list?f=0；点击 Edit，在 Action 那一列中，hide-user-agent 改选为 Enable - 在右侧 User Agent string to send 框中填写 Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.108 Safari/537.36，其它全部选择为 No Change；点击 Submit。

方案二：使用 XMURP-UA 修改 UA

这个方案需要手动交叉编译 OpenWrt，有能力的同学可以尝试。

优点：这是个内核模块，因此性能不错

缺点：因为是内核模块，因此稳定性欠佳，此外这个模块只能修改 80 端口的数据包，因此有些非 80 端口的数据包是修改不了的。

git clone https://github.com/CHN-beta/xmurp-ua.git package/xmurp-ua
make menuconfig
# 在 Kernel module -> Other modules 里勾选 kmod-xmurp-ua（按 y）。保存退出。
# 正常编译镜像，镜像中就会包含插件了。

如果要单独编译此模块，需运行：

make package/xmurp-ua/compile V=sc
cd /tmp
pkg install 改成对应的xmurp-ua文件名.ipk

# 安装压缩内存插件
opkg update
opkg install zram-swap

# 检测这两个插件是否均已安装成功
opkg list-installed | grep zram-swap
opkg list-installed | grep xmurp-ua

# 重启路由器
reboot

方案三：使用 UA2F 修改 UA

UA2F 可以修改所有端口的数据包，而且性能不错，不过依旧需要编译。具体参见：Zxilly/UA2F。

验证方式：UA 检测-HTTP

方案四：UA3F

校园网防检测: UA3F - 新一代 UA 修改方法

UA3F Github

方案五：使用代理客户端中的重写功能对 http-header 进行修改

这应该是最容易操作的方法，也可能是有效的方法。

以 Quantumult X 为例，只需在重写规则里面加入一条：

http:// url request-header (\r\n)User-[A|a]gent:.+(\r\n) request-header $1User-Agent: $2

iOS 客户端 Quantumult X、Shadowrocket、Surge 等都支持重写功能。

Android 的客户端可以使用 surfboard（或许现在不支持了）。

macOS 可以使用 Surge。

Clash 用户要失望了，Clash 不支持 URL 重写，不过可以使用 Clash 走规则匹配，把 HTTP 流量全都加密。

如果不想在自己的客户端上长时间开启代理，可以在 OpenWrt 中使用 OpenClash/ShellClash 进行网关级修改。

针对基于 IPv4 数据包包头内的 Identification 字段的检测的解决方案

应对思路：修改所有数据包的 ID 字段为递增。

我们使用 rkp-ipid 这一内核模块进行修改。

git clone https://github.com/CHN-beta/rkp-ipid.git package/rkp-ipid
make package/rkp-ipid/compile V=sc

# 设置所有发出的数据包的 IPID 为递增
iptables -t mangle -N IPID_MOD
iptables -t mangle -A FORWARD -j IPID_MOD
iptables -t mangle -A OUTPUT -j IPID_MOD
iptables -t mangle -A IPID_MOD -d 0.0.0.0/8 -j RETURN
iptables -t mangle -A IPID_MOD -d 127.0.0.0/8 -j RETURN
# iptables -t mangle -A IPID_MOD -d 10.0.0.0/8 -j RETURN
iptables -t mangle -A IPID_MOD -d 172.16.0.0/12 -j RETURN
iptables -t mangle -A IPID_MOD -d 192.168.0.0/16 -j RETURN
iptables -t mangle -A IPID_MOD -d 255.0.0.0/8 -j RETURN
iptables -t mangle -A IPID_MOD -j MARK --set-xmark 0x10/0x10

针对基于网络协议栈时钟偏移的检测技术的解决方案

应对思路：在局域网中建立 NTP 服务器统一时间戳

进入 OpenWrt 系统设置, 勾选 Enable NTP client（启用 NTP 客户端）和 Provide NTP server（作为 NTP 服务器提供服务）

NTP server candidates（候选 NTP 服务器）四个框框分别填写:

ntp1.aliyun.com, time1.cloud.tencent.com, stdtime.gov.hk, pool.ntp.org

进入 OpenWrt 防火墙设置，在自定义设置中填入以下内容:

# 防时钟偏移检测
iptables -t nat -N ntp_force_local
iptables -t nat -I PREROUTING -p udp --dport 123 -j ntp_force_local
iptables -t nat -A ntp_force_local -d 0.0.0.0/8 -j RETURN
iptables -t nat -A ntp_force_local -d 127.0.0.0/8 -j RETURN
iptables -t nat -A ntp_force_local -d 192.168.0.0/16 -j RETURN
iptables -t nat -A ntp_force_local -s 192.168.0.0/16 -j DNAT --to-destination 192.168.1.1
# 最后的 192.168.1.1 需要修改为路由器网关地址

确认效果：在 Windows 电脑上，打开控制面板，在右上角查看方式处选择小图标，然后点击“日期和时间”。点击 Internet 时间 -> 更改设置，点几次“立即更新”，直到提示“时钟在 xxx 与 xxx 同步成功”。这时，暂时地拔掉墙上接口与路由器之间的网线（断开了外网的连接），再点一次“立即更新”，应该仍然提示成功，这说明 NTP 请求已经被劫持到了路由器自身而不是外网。然后把网线插回。

应对思路：iptables 拒绝 AC 进行 Flash 检测

# iptables 拒绝 AC 进行 Flash 检测
iptables -I FORWARD -p tcp --sport 80 --tcp-flags ACK ACK -m string --algo bm --string " src=\"http://1.1.1." -j DROP

针对 DPI (Deep Packet Inspection) 深度包检测技术的解决方案

应对思路：加密数据包。

我们无法通过修改数据包来防止 DPI 检测，因此加密是最好的手段。

最后

对于认为修改 UA IPID 太过麻烦的同学，可以直接对自己的流量进行全加密，前提是你的有充足的解密代理服务器

下面我给出最终全部的配置脚本：

# @SunBK201 - https://blog.sunbk201.site
iptables -t nat -A PREROUTING -p udp --dport 53 -j REDIRECT --to-ports 53
iptables -t nat -A PREROUTING -p tcp --dport 53 -j REDIRECT --to-ports 53

# 通过 rkp-ipid 设置 IPID
iptables -t mangle -N IPID_MOD
iptables -t mangle -A FORWARD -j IPID_MOD
iptables -t mangle -A OUTPUT -j IPID_MOD
iptables -t mangle -A IPID_MOD -d 0.0.0.0/8 -j RETURN
iptables -t mangle -A IPID_MOD -d 127.0.0.0/8 -j RETURN
# 由于本校局域网是A类网，所以我将这一条注释掉了，具体要不要注释结合你所在的校园网
# iptables -t mangle -A IPID_MOD -d 10.0.0.0/8 -j RETURN
iptables -t mangle -A IPID_MOD -d 172.16.0.0/12 -j RETURN
iptables -t mangle -A IPID_MOD -d 192.168.0.0/16 -j RETURN
iptables -t mangle -A IPID_MOD -d 255.0.0.0/8 -j RETURN
iptables -t mangle -A IPID_MOD -j MARK --set-xmark 0x10/0x10

# ua2f 改UA
iptables -t mangle -N ua2f
# 由于本校局域网是A类网，所以我将这一条注释掉了，具体要不要注释结合你所在的校园网
# iptables -t mangle -A ua2f -d 10.0.0.0/8 -j RETURN
iptables -t mangle -A ua2f -d 127.0.0.0/8 -j RETURN
iptables -t mangle -A ua2f -d 192.168.0.0/16 -j RETURN # 不处理流向保留地址的包
iptables -t mangle -A ua2f -p tcp --dport 443 -j RETURN # 不处理 https
iptables -t mangle -A ua2f -p tcp --dport 22 -j RETURN # 不处理 SSH 
iptables -t mangle -A ua2f -p tcp --dport 80 -j CONNMARK --set-mark 44
iptables -t mangle -A ua2f -m connmark --mark 43 -j RETURN # 不处理标记为非 http 的流 (实验性)
iptables -t mangle -A ua2f -m set --set nohttp dst,dst -j RETURN
iptables -t mangle -A ua2f -j NFQUEUE --queue-num 10010
  
iptables -t mangle -A FORWARD -p tcp -m conntrack --ctdir ORIGINAL -j ua2f
iptables -t mangle -A FORWARD -p tcp -m conntrack --ctdir REPLY


# 防时钟偏移检测
iptables -t nat -N ntp_force_local
iptables -t nat -I PREROUTING -p udp --dport 123 -j ntp_force_local
iptables -t nat -A ntp_force_local -d 0.0.0.0/8 -j RETURN
iptables -t nat -A ntp_force_local -d 127.0.0.0/8 -j RETURN
iptables -t nat -A ntp_force_local -d 192.168.0.0/16 -j RETURN
iptables -t nat -A ntp_force_local -s 192.168.0.0/16 -j DNAT --to-destination 192.168.1.1

# 通过 iptables 修改 TTL 值
iptables -t mangle -A POSTROUTING -j TTL --ttl-set 64

# iptables 拒绝 AC 进行 Flash 检测
iptables -I FORWARD -p tcp --sport 80 --tcp-flags ACK ACK -m string --algo bm --string " src=\"http://1.1.1." -j DROP

对于防检测方案的可用性分析验证

为检测方案的可用性，我进行了抓包分析。

实验环境为：

一台路由器（模拟校园网提供接入互联网服务）（192.168.5.1）
一台抓包服务器(192.168.5.219)(模拟检测系统)，提供web访问服务，以供客户机访问。
一台路由器（模拟我们自己接入校园网的路由器）（192.168.5.190）
两台客户机：一台Win10（192.168.1.10）一台iOS（192.168.1.20）

两台客户机同时访问抓包服务器(192.168.5.219)进行抓包分析。

部署防检测方案前

TTL: 127 / 63

IPID: 64764-64779 / 0-0

UA: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.72 Safari/537.36 Edg/89.0.774.45

Mozilla/5.0 (iPad; U; CPU OS 3_2_1 like Mac OS X; en-us) AppleWebKit/531.21.10 (KHTML, like Gecko) Mobile/7B405

部署防检测方案后

TTL: 64 / 64

IPID: 2319-2504

UA: FFFFFFFFFFFFFFFFFFFFFFFFFFFF

最终结论：防共享检测有效！

实际使用

我已经使用此方案一周之久，这一周内没有过发生一次封禁，可以肯定，此解决方案实际使用是有效的！

写在最后

我在写这篇文章的时候已经大三了，其实早在我大一的时候就有过一段时间来试图解决这个问题，但是当时能力还不够，无法拿出完整的解决方案，现在能力够了，但是也快毕业了，说实话现在再使用这些防检测方案已经有些晚了，不过，我相信这些解决方案可以对我们以后一些大一大二的同学有所帮助，我所做的一些工作也是值得的。

具体操作见：OpenWrt 编译与防检测部署教程

如果大家有疑问可以加讨论组： Telegram

最后，感谢开发 OpenWrt 防检测模块的作者们 Zxilly、 CHN-beta ，是有了他们的无私奉献，才使我能够整理出这么一份解决方案。

hello, world

Sun, 01 Mar 2020 00:00:00 +0000

#include <stdio.h>

int main()
{
    printf("hello, world\n");
    return 0;
}

SunBK201's Blog

校园网防检测: UA3F - 新一代 UA 修改方法

太长不看（写于 2025.11）

前言

UA3F: 新一代 UA 修改方法

UA3F 使用

结束

命令行界面设计指南

About

正则表达式高阶使用：负向零宽度断言

多线程简介：走进并发世界

进程和线程：命名

进程与线程的不同

绿色线程：纤维

线程的用途

是什么让并发和并行成为可能

单核上的运行多线程应用：有意义吗？

越多线程，越多问题

线程安全的概念

数据竞争的根源

竞态条件

教会线程们如何相处：并发控制

1500 字节是如何成为互联网的 MTU 的？

神奇的数字

效率问题

关于 SSD，每一位开发者都应该知道的一些知识

驱动器（Drives）不是磁盘（Disks）

并行性

写入

Out-Of-Place 写入

写入放大与超额配置

总结

关于 iOS SSID 格式字符串 BUG 的快速分析

main 通常是个函数，那么什么时候不是呢？

String Hashing 如何工作？

String Hash 公式

什么是 /dev/null：介绍一下比特桶 (Bit Bucket)

为什么叫 “比特桶”？

/dev/null 文件

/dev/null 文件的使用

使用 /dev/null 抑制输出

使用 /dev/null 来输入 EOF（End of File）

使用 /dev/null 来清空一个文件

总结

3 Tribes of Programming - 3 大编程阵营

三大编程阵营

编程即数学的应用

编程即硬件 Hack

编程即创造的工具

一场安静的战争

闭幕

Why OO Sucks - 为什么面向对象糟透了？

Why OO Sucks - 为什么面向对象糟透了

反对 1 - 数据结构和函数不应绑定在一起

反对 2 - 一切都必须是对象

反对 3 - 在 OOPL（面向对象编程语言）中，数据类型定义是分散在各处的

反对 4 - 对象有私有状态

为什么 OO 很受欢迎？

Shadowsocks-libev 部署教程

ShellClash 加密防检测教程

OpenWrt 编译与防检测部署教程

全新方案-懒人福音-无需手动编译修改UA-校园网防检测

Windows 用户

Andorid 用户

iOS & Mac 用户

OpenWrt 配置

其他

关于某大学校园网共享上网检测机制的研究与解决方案

太长不看（写于 2025.11）

前言

对于本校校园网网络环境的说明

为什么本校要禁止多设备共享上网？

本校校园网共享上网检测机制的研究

基于 IPv4 数据包包头内的 TTL 字段的检测

基于 HTTP 数据包请求头内的 User-Agent 字段的检测

DPI (Deep Packet Inspection) 深度包检测技术

基于 IPv4 数据包包头内的 Identification 字段的检测

基于网络协议栈时钟偏移的检测技术

Flash Cookie 检测技术

防共享上网检测的解决方案