前段时间用claude+glm4.7整了个使用nginx+lua脚本实现的个人图床方案，很简洁啊，主要逻辑都集中在一个nginx配置文件内，不到120行，兼具性能（nginx特性）和访问速度（套cdn）。

然而这种部署方式绕不开一个问题：得有一台服务器。专门搞一台服务器做个人图床多少是有点大材小用了，个人使用又能存多少东西呢？不如先薅大厂羊毛，等到羊毛不够用了再换不迟。

于是这个轮子(项目)诞生了，在codex+gpt5.4和本人的努力下，花了一晚上时间。

项目简介

curl-powered image hosting for hackers. One-click deploy on Cloudflare, or integrate with existing nginx server.

该项目qspidy/imgng的设计理念是，能在身边任何一台联网的机器上传图片到图床并获取链接，只要记住这条几乎不能再短的curl命令：

1

curl -u user:pass --data-binary @photo.jpg https://example.com/upload

之所以说是“几乎”不能再短，是因为还可以使用alias或者shell函数给它设置别名，然后像使用一个普通linux命令一样使用它：

1
2
3
4
5

imgng() {
  curl -s -u user:pass --data-binary @"$1" https://example.com/upload
}

imgng photo.jpg

这次相比上一篇博客使用Nginx搭建个人图床，让链接永远有效！的主要变化是，提供一个零成本的服务端部署方案，使用Cloudflare+R2。当然还有很多其它薅羊毛（免费部署）方案，参考文末的外部链接，相信各路大神都能找到适合自己的方案。

从某种程度上而言，它更像是提供了一个相较传统S3 API而言更简洁的接口，在客户端做到了极致的简洁（命令行爱好者狂喜！）。

结合当前CLI越来越热的趋势，这小项目还有更多存在和参考的意义，后续或许可以进一步发展成一整套图床命令行增删改查(接口方案)。再者可以通过Skills/MCP等方式和Agent无缝集成，成为Agent工作流的一部分。

要长期使用的话，它目前还缺少一些关键的功能：图片展示列表，重复图片处理等。接下来会继续完善这些关键的功能。

另外还有些可选功能：支持多用户，备份恢复等。因为它当前的定位是个人使用，所以支持多用户暂不考虑，而文件存储在R2上也基本不用担心文件丢失的问题，所以目前不急（备份也就一条命令的事，考虑到前段时间Cloudflare还崩了一次，备份还是有必要的）。

碎碎念

用了codex+gpt5.4才知道原来不是Agent不好用，而是钱没到位（选错了模型和Agent），回想当初用 claude+glm4.7，那真是改了又改，5小时额度用完了都没跑通。这次几乎是首次提示词一下去出来的东西就能用，后面只需做些功能完善和文档生成的工作。

心情很复杂。很兴奋，在AI有加持下个人能力边界得到了极大的扩张，很悲伤，AI对程序员群体造成了很大的冲击，许多知识与技能似乎都没有了意义。

虽然如此，技术在发展，时代在进步，拥抱未来是唯一能走的路。

外部链接

类似项目（更适合广大人类GUI用户食用）

• https://github.com/MarSeventh/CloudFlare-ImgBed
• https://github.com/Molunerfinn/picgo

其它基于CF的薅羊毛项目

这周发生了很多有意思的事情。

Clawdbot改名成Moltbot，然后某个B站UP发了条动态：

做个opencode desktop的视频，第二天就爆火Clawdbot，Clawdbot要发了把名字改成了moltbot。这个时代不要为难老人家好不好~

前天一看又把名字改成了OpenClaw，想蹭个热点真不容易啊2333。

CloudCone机房罕见的出故障了，因为虚拟机WEB控制面板 Virtualizor 上存在一个严重漏洞，本来还准备在周末在CC服务器上整个mjl-/mox，结果什么也干不了。

周末要结束了还没修复：

于是在用Memos记录这些事情的时候，发现Memos不能直接在post里上传图片，只能用图床。

既然现在没法部署mjl-/mox，那就整(shui)个(pian)图(bo)床(ke)好了。

这次主要用的是Claude + GLM-4.7，体验下Claude和OpenCode的区别。

为什么要自建

没怎么用图床，相关的工具倒是收藏了不少。

其中杀手级的App当属Molunerfinn/PicGo，功能非常全面，支持各种存储服务，还能和常见的文本编辑器交互：

虽然有很多免费的存储服务可以用，但这些都逃不开一个最大的问题：很难保证链接长期有效。

比如把文件上传到OneDrive，得到一个链接，但如果哪天想要把图床迁移到另一个服务，那就不得不修改原来使用的链接，而用到这个链接的地方可能很多，emmm…

更不用说有些免费图床用着用着就跑路的。

而如果是用自己的域名访问的话，就能解决这个痛点。只在域名还在，做好备份恢复，就完全可以保证链接一直有效。

搭建思路

图床这种算是静态网站服务，有很多平台可以提供免费部署，比如Vercel，Github等，也能自定义域名。但这里用的是服务器+Nginx，毕竟现在的服务器很便宜了，这样也更方便备份迁移。

如果追求极致精简，直接把图片放在Nginx的静态文件目录就好。但这样服务器端是简单，客户端操作就有点复杂了，得用rsync, scp之类的工具把文件传上去，不方便也不安全。

所以设计原则是：客户端操作尽可能简单，无论在哪都能轻松上传图片。

于是我选择使用curl，通过http请求的方式上传图片，这命令是个电脑都应该会有吧，而且命令也不会很长，很容易就能记住。

开始干活

当然不是我干活，而是指挥AI干活。

要实现的功能也不多，需求一描述，用Claude和GLM-4.7生成的代码直接就能跑起来。

然后不出意外的出意外了，在首次生成的代码上继续改进时，上传图片的权限突然从一开始的600变成了666：

这可不是什么好事。

让Claude定位原因把图片权限改回去，但Claude并不知道是什么导致的权限改变，虽然加上了改变文件权限的代码，但最后图片权限依旧是666。

眼看Claude解决不了，只好亲自出手了。

扫了一眼本就不多的Lua脚本，唯一对图片有修改是调用ImagicMagick压缩图片这段

1
2
3
4
5

-- Optimize images (requires ImageMagick)
local image_extensions = {jpg=true, jpeg=true, png=true, webp=true, gif=true, avif=true}
if image_extensions[ext:lower()] then
os.execute(string.format("/usr/bin/mogrify -quality 85 -strip %s", target, target))
end

于是把这段lua注掉一试，果然，就是用/usr/bin/mogrify压缩图片后图片文件的权限从600变成了666 。

而虽然Claude加上了改变文件权限的代码

1

os.execute("/bin/chmod 600 " .. target .. " 2>/dev/null")

但因这段代码放在ImagicMagick压缩图片之前，所以没能发挥任何效果。

收尾

最后照例生成了Git项目，把代码传到了Github上：qspidy/imgng。

不得不夸一下OpenCode生成的README了。相比Claude，OpenCode生成的又有图标又有Badge，看起来很现代。

最后让Claude参考之前的项目才生成的现在这么现代的README：

结语

不得不感慨AI写代码之神速啊，虽然就目前看来还有一定的局限，有些问题还是得有人的配合才能解决。

但是，如果这次AI可以在本地调试，它应该能很快定位问题吧。

如果调试也被AI完全掌握，那或许真的就是程序员的末日了。

感觉也快了啊。

前不久在网上找到一张喜欢的壁纸，但是查了半天没找着高清原图，只好先将就用着。而最近看着这略显模糊的壁纸实在是受不了了，就想着给它upscale一下。很自然的想起了以前用过的xinntao/Real-ESRGAN，当时就觉得这东西巨好用，只是一直没有使用的场景，现在是时候给用起来了。

ComfyUI vs Script

虽然说想到要用Real-ESRGAN来让图像更清晰，一开始并没打算直接用它原有的命令行工具，而是准备用stable-diffusion-webui或者是ComfyUI这类功能更丰富的项目。

花一上午的时间在本地装好了ComfyUI：

用RealESRGAN_x4plus_anime_6B.pth试着增强下壁纸，结果让人哭笑不得：

或许是我的处理方式不对，也或许是因为没有照安装文档说的用最适配的python13/12版本导致。

不过这个模型在ComfyUI里确实有点水土不服，参考zentrocdot/ComfyUI-RealESRGAN_Upscaler和Reproduce A1111 hires fix with R-ESRGAN in Comfyui?。

不得已只好用xinntao/Real-ESRGAN本身提供的安装包和脚本了，好在虽然已经2年多没更新了，它的功能还能正常使用，生成的图也没有问题。

OpenCode开始发力

在对比生成前和生成后的壁纸时突然有了个想法，要是有工具可以直观的对比两张图的区别就好了。

查了一圈发现这个功能基本都是在线网站在提供，没找着离线工具。

那就自己做一个好了，正好试试OpenCode + GLM-4.7的本事。

于是差不多快晚上的时候，我开始用OpenCode生成代码，先是生成了一个可以让两图片通过滑块对比的单html页面，然后在此基础上让它支持上传文件、后台命令调用、文件下载等功能。

很快啊，这些个小功能它很快就完成了，而且运行得很完美。

OpenCode开始吃力

事情发生了转机。

我让它修改代码以支持在公网上安全部署，它咔咔生成完，结果没法上传文件了。

我把现象告诉它让它自己找出问题，它整了半天没把问题给找出来，最后我不得不打开了前端控制台：

1

(index):309 Executing inline script violates the following Content Security Policy directive 'script-src 'self' https://unpkg.com'. Either the 'unsafe-inline' keyword, a hash ('sha256-b6+B5SDP+VwnXrplXir/gTF5QsRBt5n146EYh701WGM='), or a nonce ('nonce-...') is required to enable inline execution. The action has been blocked.

好嘛，原来是安全策略把自己给限了，把错误信息交给它后，终于是把问题修复了。

之后又用最近流行起来的ui-ux-pro-max-skill给项目的前端页面升了个级：

已经是个有模有样的工具了。

OpenCode完美结算

最后截了几张图，直接让它生成README.md这些上传GitHub需要准备的东西，一气呵成，项目传送门：realesrgan-web-ui。

结语

不得不承认现在的AI发展神速啊，以后这种小工具完全可以用AI直接生成，再也不怕这些冷门的小需求无处安放。不管是让AI基于已有的东西开发新功能，还是直接生成一个小工具用完就扔，简直…

NNG, like its predecessors nanomsg (and to some extent ZeroMQ), is a lightweight, broker-less library, offering a simple API to solve common recurring messaging problems, such as publish/subscribe, RPC-style request/reply, or service discovery. – nng

NNGPP, C++ wrapper around the nanomsg NNG API. – nngpp
Instead of Kafaka and DDS, NNG is broker-less and less compleicated but full featured with messaging patterns such as publish/subscribe, RPC-style request/reply, or service discovery.

Using NNG with NNGPP

Actually gpt is more good at demostrating usage cases of nng, but notice that nngpp’s last commit is 6 years ago, gpt can’t tell the right usage case of nngpp in my case and there are few problems with this old repository.

Let’s go straight, when using nngpp for sub/pub case, code like this:

sub.cpp:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#include <iostream>
#include <nngpp/nngpp.h>
#include <nngpp/protocol/sub0.h>
#include <string>

int main (int argc, char *argv[]) {
  nng::socket sub_sock = nng::sub::open();

  nng::sub::set_opt_subscribe(sub_sock, "");

  sub_sock.dial("tcp://127.0.0.1:5000");

  while (true) {
    auto msg = sub_sock.recv_msg();
    std::string s(
        reinterpret_cast<char*>(msg.body().data()),
        msg.body().size()
    );
    std::cout << "recv: " << s << std::endl;
  }

  return 0;
}

pub.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#include <chrono>
#include <nngpp/nngpp.h>
#include <nngpp/protocol/pub0.h>
#include <string>
#include <thread>
#include <iostream>

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

  nng::socket pub = nng::pub::open();
  pub.listen("tcp://127.0.0.1:5000");

  int i = 0;
  while (true) {
    pub.send(nng::view("ping", 4));
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
  }
  return 0;
}

The SUB can’t receive the message from the PUB even if the SUB subscribes all topics by set_opt_subscribe(sub_sock, "");, and when I review the source of nngpp, everything looks ok.

Then I tried using bearly nng for sub/pub, it works can’t be more right. So it’s clearly that there is a problem with nngpp. It’s reasonalbe since it’s last commit has been so long.

Digging into code with gdb, finally caught the bug: when calling set_opt_subscribe in nngpp, it finally calls the nng api nng_socket_set, but pass the wrong parameter “topic string size”.

set_opt_subscribe:

1
2
3

inline void set_opt_subscribe( socket_view s, view v ) {
s.set_opt( to_name(option::subscribe), v );
}

set_opt:

1
2
3
4
5
6

void set_opt( const char* name, view v ) const {
    int r = nng_socket_set(s,name,v.data(),v.size());
    if( r != 0 ) {
        throw exception(r,"nng_socket_set");
    }
}

Check the code above, it pass the v.size() as the parameter “topic string size”. When the string is "", the size should be 0.

But in fact the v.size()(nngpp’s custom class view for data manage) returns 1 while v.data() is "", since it allocated buffer for \0.

I’m not sure if it’s because of the update of nng that make nngpp doesn’t work as expected any more, or the sub/pub is never tested in nngpp, but it’s indeed a bug which make pub/sub in nngpp doesn’t work any more.

Here is the correct version of set_opt:

1
2
3
4
5
6

void set_opt( const char* name, view v ) const {
    int r = nng_socket_set(s,name,v.data(),v.size() - 1);
    if( r != 0 ) {
        throw exception(r,"nng_socket_set");
    }
}

The end

I may fork nngpp and maintain it as long as I am using it for my project.

Transport types supported by nng, awesome!

Enjoy!

See also

• NNG: Lightweight Messaging Library

References

• nanomsg/nng
• cwzx/nngpp

First of all, though it’s from SCRATCH, I suppose the reader know basic Linux concepts and commands and is able to use basic tools for os installation such as Vectory. Of course this is mainly based on my walk through, so remember using google to finish what is not mentioned for you.

I fell in love with Nix for the first I have it installed cause it is definitely what I am searching for after more than three years of Arch usage. I have reinstalled my Arch many times, and each time I have to reinstall the packages manually and spend time to change the configurations, it’s fun and I enjoy it. But recently I don’t have much time left for it, so NixOS is definitely what I want.

As for Hyprland, I found it very popular recently and it’s written in cpp, so I tried it with Arch from scratch and found it a fancy wm.

Download and boot from image

Get NixOS image here, I chose Minimal ISO image in my case.

To begin the installation, you have to boot your computer from the install drive.

1. Plug in the install drive. Then turn on or restart your computer.
2. Open the boot menu by pressing the appropriate key, which is usually shown on the display on early boot. Select the USB flash drive (the option usually contains the word “USB”). If you choose the incorrect drive, your computer will likely continue to boot as normal. In that case restart your computer and pick a different drive.

Setup WIFI (Optional)

There is no iwd preinstalled in NixOS like Arch, so use wpa_supplicant instead.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# Bring the interface up
sudo ip link set wlan0 up

# Scan avaiable networks
sudo iw wlan0 scan | grep SSID

# Generate a wpa_supplicant config
wpa_passphrase "YourSSID" "YourPassword" | sudo tee /etc/wpa_supplicant.conf

# Start wpa_supplicant
sudo wpa_supplicant -B -i wlan0 -c /etc/wpa_supplicant.conf

# Get an IP address
sudo dhcpcd wlan0

# Check connectivity
ping -c 4 8.8.8.8

# Optional: Stop wpa_supplicant
# sudo pkill wpa_supplicant

Try installing new packages

Before installing a new package, you may want to check if the package exists and how to install from here.

Most of the time, install a package like this:

1

nix-shell -p cmatrix

Partitioning and formatting

Run lsblk to see where you gonna install NixOS into, the output may looks like this:

1
2
3
4
5

NAME                         MAJ:MIN RM   SIZE RO TYPE MOUNTPOINTS
nvme1n1                      259:0    0   3.7T  0 disk
├─nvme1n1p1                  259:1    0    16M  0 part
├─nvme1n1p2                  259:2    0 515.4G  0 part
└─nvme1n1p3                  259:3    0   300G  0 part

Suppose the nvme1n1p3 is what you want and you are SURE to format it:

1

sudo mkfs.ext4 -L nixos /dev/nvme1n1p3

Install NixOS

1
2
3
4
5
6
7
8
9
10
11
12

# Mount the target file system on which NixOS should be installed on `/mnt`
mount /dev/disk/by-label/nixos /mnt

# Suppose you UEFI partition is /dev/nvme1n1p1
mkdir -p /mnt/boot
mount /dev/nvme1n1p1 /mnt/boot

# Generate default configuration file
nixos-generate-config --root /mnt

# Edit configuration file
vim /mnt/etc/nixos/configuration.nix

(Optinal) 将清华源做为默认源，添加以下内容到配置文件大括号内

1

nix.settings.substituters = [ "https://mirrors.tuna.tsinghua.edu.cn/nix-channels/store" ];

在安装 NixOS 时临时使用清华源

1

nixos-install --option substituters "https://mirrors.tuna.tsinghua.edu.cn/nix-channels/store"

For more detailed processes, check this

Start NixOS

Reboot and choose the NixOS just installed. Setup wifi following the same procedure above, and this time you can make it start automatically via systemctl enable --now wpa_supplicant.

Or you can use NetworkManager instead, procedure will not be presented here.

Install Hyprland

Edit /etc/nixos/configuration.nix and add following:

1
2
3
4
5
6
7

{
  programs.hyprland = {
    enable = true;
    withUWSM = true; # recommended for most users
    xwayland.enable = true; # Xwayland can be disabled.
  };
}

Then install necessary packages, I use alacritty as my default terminal on Hyprland:

1
2
3
4
5

{
  environment.systemPackages = with pkgs; [
    alacritty
  ];
}

Rebuild NixOS:

1

sudo nixos-rebuild switch

Edit Hyprland’s config file ~/.config/hypr/hyprland.conf:

1
2
3

# change the default terminal from kitty to alacritty
# $terminal = kitty
$terminal = alacrityy

Start Hyprland.

1

uwsm start select

The end

The most basic setup has been done, you can now walk around the Hyprland and NixOS’s wiki and forums for more useful configurations and build up the final system that you want.

Enjoy!

See also

• Screenshots on hyprland on nixos

References

• NixOS Manual
• 清华源 Nix Channels
• Hyprland NixOS Wiki

I got the board several days ago, and now it’s time to get it to work. However I got stuck on WiFi configuration again though I did it many times before. So I write this post to make the steps more clear in my mind.

About the board

It’s Orange Pi Zero 3, a really small and powerful single-board computer! Here is its introduction from official:

Orange Pi Zero 3 is powered by Allwinner H618 quad-core Cortex-A53 processor, Arm Mali-G31 MP2 GPU, supports OpenGL ES 1.0/2.0/3.2, OpenCL 2.0, Vulkan 1.1, etc.,with 1GB/1.5GB/2GB/4GB memory options, decoding of multiple video formats is supported, and the Micro-HDMI output supports 4K display. In addition, Orange Pi Zero 3 can also be extended with headphones, TVout, USB2.0, IR reception and other functions via 13Pin expansion ports with an adapter board, in addition to the 26Pin expansion function port on the board, further enriching the functional interface of the motherboard.

In my case, it has 4GB LPDDR4 which makes it sufficient for my various services.

Here is what I got:

It’s easy to setup, and here is finally what I got:

Burn the image

There are several images on official site:

• Orange Pi OS(Arch)
• Ubuntu Image
• Debian Image
• Android Image
• OpenWRT

I chose debian as it’s one of my most familiar distros, there are also imaging tools on official site:

Burning…

Insert sd card and power on:

Finally got to the shell (BTW, the default password for orangepi is orangepi):

Basic setup

WiFi

The first thing to do about this new sever must be setting up wifi connection cause I don’t have another net cable.

There are generally three choices or tools on command line to manage wifi connections: iwconfig, wpa_supplicant and nmcli. After asking chatgpt for assistance, I finally decide to leave all of them behind and just edit /etc/network/interfaces to setup the wifi.

Actually when I asked chatgpt about how to setup wifi connection on linux, it didn’t mention editing /etc/network/interfaces. I happened to know it when I was configuring network for pve, and it is really a simple and basic way to setup wifi connections. And this time, I happened to know that I can setup a roaming wifi, so it can auto connect to different wifi if the current wifi connection corrupts, it’s useful but I don’t need it for the moment.

Edit /etc/network/interfaces and add following like this

1
2
3
4

auto wlan0
iface wlan0 inet dhcp
wpa-ssid <wifi-name>
wpa-psk <password>

Save and then restart, then the wifi will automatic be connected and got an ip:

Mirror source

The default mirror source is rather slow, so I change /etc/apt/sources.list to the following:

1
2
3
4
5
6
7
8
9
10
11

deb http://mirrors.ustc.edu.cn/debian bookworm main contrib non-free non-free-firmware
#deb http://repo.huaweicloud.com/debian bookworm main contrib non-free non-free-firmware
#deb-src http://repo.huaweicloud.com/debian bookworm main contrib non-free non-free-firmware

deb http://mirrors.ustc.edu.cn/debian bookworm-updates main contrib non-free non-free-firmware
#deb http://repo.huaweicloud.com/debian bookworm-updates main contrib non-free non-free-firmware
#deb-src http://repo.huaweicloud.com/debian bookworm-updates main contrib non-free non-free-firmware

deb http://mirrors.ustc.edu.cn/debian bookworm-backports main contrib non-free non-free-firmware
#deb http://repo.huaweicloud.com/debian bookworm-backports main contrib non-free non-free-firmware
#deb-src http://repo.huaweicloud.com/debian bookworm-backports main contrib non-free non-free-firmware

and remove the useless source in /etc/apt/sources.list.d/docker.list.

Shell

It surprised me that the image preinstalled zsh and oh-my-zsh, also tools like tmux, git, docker. here is the default .zshrc file:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

# If you come from bash you might have to change your $PATH.
# export PATH=$HOME/bin:$HOME/.local/bin:/usr/local/bin:$PATH

# Path to your Oh My Zsh installation.
export ZSH=/etc/oh-my-zsh
export ZSH_CACHE_DIR=~/.oh-my-zsh/cache

# Set name of the theme to load --- if set to "random", it will
# load a random theme each time Oh My Zsh is loaded, in which case,
# to know which specific one was loaded, run: echo $RANDOM_THEME
# See https://github.com/ohmyzsh/ohmyzsh/wiki/Themes
ZSH_THEME="mrtazz"

# Set list of themes to pick from when loading at random
# Setting this variable when ZSH_THEME=random will cause zsh to load
# a theme from this variable instead of looking in $ZSH/themes/
# If set to an empty array, this variable will have no effect.
# ZSH_THEME_RANDOM_CANDIDATES=( "robbyrussell" "agnoster" )

# Uncomment the following line to use case-sensitive completion.
# CASE_SENSITIVE="true"

# Uncomment the following line to use hyphen-insensitive completion.
# Case-sensitive completion must be off. _ and - will be interchangeable.
# HYPHEN_INSENSITIVE="true"

# Uncomment one of the following lines to change the auto-update behavior
# zstyle ':omz:update' mode disabled  # disable automatic updates
# zstyle ':omz:update' mode auto      # update automatically without asking
# zstyle ':omz:update' mode reminder  # just remind me to update when it's time

# Uncomment the following line to change how often to auto-update (in days).
# zstyle ':omz:update' frequency 13

# Uncomment the following line if pasting URLs and other text is messed up.
# DISABLE_MAGIC_FUNCTIONS="true"

# Uncomment the following line to disable colors in ls.
# DISABLE_LS_COLORS="true"

# Uncomment the following line to disable auto-setting terminal title.
# DISABLE_AUTO_TITLE="true"

# Uncomment the following line to enable command auto-correction.
# ENABLE_CORRECTION="true"

# Uncomment the following line to display red dots whilst waiting for completion.
# You can also set it to another string to have that shown instead of the default red dots.
# e.g. COMPLETION_WAITING_DOTS="%F{yellow}waiting...%f"
# Caution: this setting can cause issues with multiline prompts in zsh < 5.7.1 (see #5765)
# COMPLETION_WAITING_DOTS="true"

# Uncomment the following line if you want to disable marking untracked files
# under VCS as dirty. This makes repository status check for large repositories
# much, much faster.
# DISABLE_UNTRACKED_FILES_DIRTY="true"

# Uncomment the following line if you want to change the command execution time
# stamp shown in the history command output.
# You can set one of the optional three formats:
# "mm/dd/yyyy"|"dd.mm.yyyy"|"yyyy-mm-dd"
# or set a custom format using the strftime function format specifications,
# see 'man strftime' for details.
# HIST_STAMPS="mm/dd/yyyy"

# Would you like to use another custom folder than $ZSH/custom?
# ZSH_CUSTOM=/path/to/new-custom-folder

# Which plugins would you like to load?
# Standard plugins can be found in $ZSH/plugins/
# Custom plugins may be added to $ZSH_CUSTOM/plugins/
# Example format: plugins=(rails git textmate ruby lighthouse)
# Add wisely, as too many plugins slow down shell startup.
plugins=(evalcache git git-extras debian tmux screen history extract colorize web-search docker)

source $ZSH/oh-my-zsh.sh

# User configuration

# export MANPATH="/usr/local/man:$MANPATH"

# You may need to manually set your language environment
# export LANG=en_US.UTF-8

# Preferred editor for local and remote sessions
# if [[ -n $SSH_CONNECTION ]]; then
#   export EDITOR='vim'
# else
#   export EDITOR='mvim'
# fi

# Compilation flags
# export ARCHFLAGS="-arch x86_64"

# Set personal aliases, overriding those provided by Oh My Zsh libs,
# plugins, and themes. Aliases can be placed here, though Oh My Zsh
# users are encouraged to define aliases within a top-level file in
# the $ZSH_CUSTOM folder, with .zsh extension. Examples:
# - $ZSH_CUSTOM/aliases.zsh
# - $ZSH_CUSTOM/macos.zsh
# For a full list of active aliases, run `alias`.
#
# Example aliases
# alias zshconfig="mate ~/.zshrc"
# alias ohmyzsh="mate ~/.oh-my-zsh"

I leave the shell configurations be cause it is well enough.

Docker

Note that it’s defaultly installed docker, however, I can’t use docker compose to start a container from compose file cause it said docker: 'compose' is not a docker command..

I have to reinstall the docker. It’s rather easy, just run:

1

curl -fsSL https://get.docker.com | sh

After waiting for a while, it’s done. Now I can use docker compose to start a container from compose file.

Disable auto login (optional)

By default, when I’m use the tty to start a session, it will automaticly logs in to the terminal as orangepi. But I don’t want it to be like this after I setted it up so that it is necessary to disable it. There is document on official doc site on How to set automatic terminal login in linux system, the url is at the end of the post.

Use the following command to set the root user to automatically log in to the terminal
orangepi@orangepi:~$ sudo auto_login_cli.sh root

Use the following command to disable automatic login terminal
orangepi@orangepi:~$ sudo auto_login_cli.sh -d

Use the following command to set the orangepi user to automatically log in to the terminal again
orangepi@orangepi:~$ sudo auto_login_cli.sh orangepi

Summary

Orange Pi Zero 3 is small, powerful and flexible. I can burn different images to different sd cards to achieve easily switching to different operating systems and performing various expriments which would be a quite fancy journey.

In this blog post, I just present the most basic use case for the Orange Pi Zero 3 and explore its capabilities and there are a lot more to be explored. Wish it can help those who are new to Orange Pi Zero 3.

Feel free to leave comments below! :)

References

• Orange Pi Zero3 Introduction
• Orange Pi Zero 3 Downloads
• How to set automatic terminal login in linux system

今年早些时候入手了巡天AX3000Pro+，本以为可以一步到位，结果发现它没法刷OpenWrt，无法配置DHCP分配固定IP以及配置DNS解析，使的我只能使用IP来访问内网设备，设备IP甚至还会不停的变，买之前还是功课做少了啊。所以又看了一圈，相中了BPI-R3mini，虽然有点贵，但鉴于我喜欢折腾，且BPI-R3mini有官方提供OpenWrt镜像支持，就咬牙入手了。

硬件组装

到手后的东西如下：

安装方法参考：Banana Pi BPI-R3 Mini 迷你开源路由器开发板外壳安装教学视频

组装完的效果长这样：

BPI-R3mini有两种启动方式，分别是从Nand启动和从eMMC启动，一般来说是把Nand当成外插SD卡，所以Nand启动一般只是用来做特殊操作时候用，比如手动更新eMMC里的镜像的时候。切换方式是拨动板上面的一个开关：

因为eMMC和Nand里面正常都是默认装有镜像的，所以只用把开关调到左边eMMC位置再通电启动就好（与图中相反）。如果没有的话请参考官方Wiki的镜像烧录手册

装好通上电后，风扇就开始转了，默认镜像里有配置风扇PWM (Pulse Width Modulation/脉宽调制)，所以不用再做其它修改，如果要修改的话可参考Wiki：PWM FAN Control

不得不说这玩意发热量还是有点大的，难怪要整成全金属的外壳，只要它在跑，那金属外壳就烫手。风扇效果大不大，不好说，没感受到这小风扇的作用。

软件配置

通过eMMC启动，里面默认配置了WiFi，分别是MTK_MT7986_AP_AX4200_5G和MTK_MT7986_AP_AX4200_2.4G，直接连上，访问默认网关192.168.1.1，默认密码是bananapi，登录成功后界面如下图：

在System->Aministration下可以修改网关密码，在MTK->WiFi configuration下可以修改WiFi的SSID以及添加WiFi密码，下图是WiFi配置页：

可配置的东西有不少，我这只要加个WiFi密码改个WiFi名就够用了。

另外它还能配置许多有用的工具，比如Xray等。可以在System->Software->Installed下看到已经安装的软件包，也可以在这里安装新的软件包：

可玩性还是很高的，只是可选的包似乎不是很多，大概是因为这玩意用的人少吧。

使用SSH远程访问

BPI-R3mini默认有启用SSH Server（Dropbear SSH），所以可以通过SSH连上去，使用之前配置的密码，或者是在System->Aministration配置SSH公钥。连上后查看系统信息：

里面用的包管理器是opkg，官方介绍在这里，比起常见的apt, pacman还是有点不太好使。

可以在/etc/opkg.conf里给opkg配置代理，执行vim /etc/opkg.conf在文件末添加下面两行：

1
2

option http_proxy http://your.proxy.server:port
option https_proxy https://your.proxy.server:port

通过端口扫描可以看到它默认开了445端口，也就是SMB服务，所以可以直接使用Windows访问它的共享目录：

也就是说可以把它当成一个小NAS来用，但这默认配置似乎是只读的（也可能是我登录用户的原因），所以想往里放东西的话还得再配置一下，我这里还没用到这功能就不详说了。不过有件事不得不提，我专门买了个美光P310 2230 SSD，2T，结果插上后它无法识别（可以通过fdisk -l看到它的信息，但这信息里的设备路径事实上不存在，也就挂载不了），是因为2T容量太大了还是驱动啥的问题，还没整明白。

这玩意似乎并不能桥接WiFi，也就是不能当我的手机热点信号中继放大器，因为它似乎不支持作为AP Client去连WiFi：

这点我的巡天都可以做到。是我的操作有问题？还是少了什么驱动啥的？这已经到我的知识盲区了，也找不着相关资料😔。

最后

作为一个软路由它还是合格的，另外我准备给它安上5G模块，这样就可以直接插SIM卡连网，不用再拿手机当热点了，如果能再把NAS功能，Xray配置好的话，就算大功告成，这样它就能完全顶替我的巡天了。所以之后应该还会记录安装这些功能的过程和效果，这样就可以再水一篇博客了😆。

参考/引用

1. Getting Started with BPI-R3 MINI
2. Banana Pi BPI-R3 Mini
3. Banana Pi BPI-R3 Mini 迷你开源路由器开发板外壳安装教学视频]

最近用国补买了台MiniPC，整了个PVE丢家里当小服务器使，在上面跑了几个docker服务，以及ollama，8854H + 32g 内存跑llama3.1基本没有压力。由于平时上班不在家，也就有了远程管理这MiniPC的想法，正好以前瞎整的IRC服务器SSL证书过期提醒了我，以及最近在整些Python脚本，于是就有了现在这个项目：

Python实现简单IRC聊天机器人(A Simple IRC BOT Written in Python)

关于IRC + Python

作为一名命令行爱好者，我曾试图使用命令行实现所有我在电脑上要做的事，比如便捷的浏览文件、多终端同时运行、浏览网页、作为IDE写代码和即时通讯等，于是就找到了ranger、tmux、w3m、NvChad和Irssi等优秀的开源工具。

其中IRC终端客户端Irssi是我入门终端聊天的工具，让我对这个古老又相对简洁的通讯协议产生了兴趣，是时候基于它做点有意思的事了。

至于Python，众所周知：人生苦短，我用Python。如果后续对性能有需求，再用Go重构吧。

Albot

我给这聊天机器人取名Albot，不是AI，似是AI。它实现的功能有：

• 从后台ollama接口生成AI回复
• 针对不同的关键字触发不同的响应，比如收到bilibili后在服务器后台执行相应的脚本
• 同时响应多个请求，即同时与多个对象，在不同频道中聊天对话

通过设计不同的关键字和实现不同的脚本，我就可以通过和albot聊天的形式来灵活管理MiniPC了。

项目特点

简单，简单，还是简单。使用最小的成本实现想要的效果，适合用来入门Python多线程和网络编程。

• 网络模型参考的IOCP模型，主线程监听，监听到的连接分配给线程池中的线程去处理
• 由于MiniPC性能有限，通过加锁限制了同时只能有一个对话可以请求后台ollama
• ollama每生成一行，albot会立即发出，而非等到AI回复全部生成
• 仅使用Python默认库
• 对于ollama的HTTP响应做了相对健壮的处理，同时以性能优先

最后

项目地址：https://github.com/qspidy/albot

后续还会根据需要对其进行改进以及功能的添加和完善，比如使用数据库存聊天记录和AI对话的Prompt、设置不同的命令来灵活控制和ollama的交互、使用Docker打包成镜像等。主要以学习为目的，顺带让其产生点实际价值，只有实践才能知道以前以为很简单的功能实现起来也有不少细节啊。

还在努力适应PDB中…

拥有一台服务器

• 首先，当然是有一台已经装好Debian的服务器（1Mbps带宽大概对应2~4人，一个存档2核就够，棱镜+勋章至少得3G内存），不建议Ubuntu，一些依赖似乎无法安装。
• 安装之后可能用到的包：

1
2

sudo apt update
sudo apt install tmux btop htop fish ranger git

配置基础环境（steamcmd, dst服务器）：

• 一行行复制运行，注意是否报错

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

sudo dpkg --add-architecture i386 # If running a 64bit OS
sudo apt-get update
sudo apt-get install lib32gcc1    # If running a 64bit OS

sudo apt-get install lib32stdc++6 # If running a 64bit OS
sudo apt-get install libgcc1      # If running a 32bit OS
sudo apt-get install libcurl4-gnutls-dev:i386
sudo useradd -m steam
sudo su - steam
mkdir ~/steamcmd
cd ~/steamcmd
wget <https://steamcdn-a.akamaihd.net/client/installer/steamcmd_linux.tar.gz>
tar -xvzf steamcmd_linux.tar.gz
./steamcmd.sh
force_install_dir /home/steam/steamapps/DST (or whatever absolute path is wanted)
login anonymous
app_update 343050 validate
quit
cd /home/steam/steamapps/DST/bin/
./dontstarve_dedicated_server_nullrenderer

• 最后一句尝试启动服务器，会生成一些简单的配置，如无报错则基本环境已经配置好。

克隆MrOrange的服务器管理脚本，给予执行权限：

1
2
3

cd ~
git clone https://github.com/qspidy/dst-dedicated-server-admin-scripts.git
chmod +x dst-dedicated-server-admin-scripts/dst*

生成并上传cluster_token.txt

• 本地DST控制台运行TheNet:GenerateClusterToken()生成令牌文件cluster_token.txt，位置在C:/Users/<yourusername>/Documents/Klei/DoNotStarveTogether（大概，也可能在某个子文件夹），然后上传至服务器/home/steam/.klei/DoNotStarveTogether/目录。该文件相当于身份认证，即只有买了这游戏的人才能创服务器（当然也可以白嫖其它人的）。

常规开服步骤

创建新世界

• 在本地DST游戏中创建新世界，配置想要的模组，世界类型等等。

上传存档文件夹

• 找到新世界的存档文件夹（游戏里存档设置页有“打开世界文件夹”选项），通常叫Cluster_xx，把Cluster_xx文件夹上传到服务器的存档目录/home/steam/.klei/DoNotStarveTogether/。

修改相应配置（主要是cluster.ini）

• 打开服务器新世界存档文件夹Cluster_xx里的cluster.ini文件，修改相应的配置，主要是修改人数。
• [可选]直连端口在Cluster_xx/Master/server.ini里可以查看和修改。同时开不同的存档需要修改Cluster_xx/Master/server.ini和Cluster_xx/Caves/server.ini里的server_port，以及cluster.ini里的master_port，以避免端口冲突。

启动和维护

启动dst服务器(这里假设存档文件夹为Cluster_12 )：

1
2
3

./dst-dedicated-server-admin-scripts/dst_start.sh -C 12
# 如要进行服务器交互和查看输出（默认 dst-12 为对应的tmux会话名）
tmux attach -t dst-12

完全关闭dst服务器：

1

./dst-dedicated-server-admin-scripts/dst_shutdown.sh -C 12

生成备份文件：

1

./dst-dedicated-server-admin-scripts/dst_backup_cluster.sh -C 12

单独更新dst服务器和mods：

1
2

./dst-dedicated-server-admin-scripts/dst_update_modlist.sh 12
./dst-dedicated-server-admin-scripts/dst_update.sh

(更新中)发送服务器指令（如保存世界、踢出某人）：

1
2
3
4
5

# 保存世界
./dst-dedicated-server-admin-scripts/albin/tmux_send.al dst-12 c_save()

# 踢出某人
./dst-dedicated-server-admin-scripts/albin/tmux_send.al dst-12 c_kill("player_id")

• 常用指令（大概）：c_save() , c_shutdown() , c_announce("message") , c_regenerateworld() , c_rollback() , c_listallplayers() , c_kill("player_id") .
• 打印当前世界信息（天数、季节、时段）指令： TheNet:Announce("Current day: "..TheWorld.state.cycles.." Season: "..TheWorld.state.season..", Phase: "..TheWorld.state.phase)

查看跟踪日志：

• 查看跟踪当前服务器日志：tail -f ~/.klei/DoNotStarveTogether/Cluster_12/Master/server_log.txt
• 查看跟踪当前服务器聊天日志：tail -f ~/.klei/DoNotStarveTogether/Cluster_12/Master/server_chat_log.txt

参考链接：

1. Guides/Don’t Starve Together Dedicated Servers - FANDOM
2. Dedicated Server Quick Setup Guide - Linux
3. DEDICATED SERVER QUICK SETUP (Windows) | Don’t Starve Together
4. Dedicated Server配置项和命令行参数详解

在使用了很长一段时间（大概 6-7 个月）的 VirtualBox 之后，我决定使用 Qemu 替代它。事实上我使用 VirtualBox 的体验非常好，尤其是它提供的 Host 和 Guest 之间的文件传输，剪切板共享功能，它对于网络的配置也非常的方便。

但对于一些复杂点的网络配置则需要用到命令行工具 vboxmanage，比如启用虚拟网卡的 dhcp 服务。

让我毅然决定放弃 VirtualBox 选择 Qemu 的原因是我在油管上看到的一则发表于 2022 年 1 月视频：Stop using Virtualbox, Here’s how to use QEMU instead

油管博主 Chris Titus 在视频里展示了相同的虚拟机 Guest 在 Qemu 下和在 VirtualBox 下的启动时间，结论是 11.17s 比 35.28s！

我震惊了。如果说只是快个百分之二三十，我还可以认为只是简单的因为 VirtualBox 提供了更多的管理功能而导致的性能下降，但事实摆在我面前，速度提升 68.3%！

什么概念，要知道实际性能的提升和启动速度的提升并不是成正比的，通常来说实际性能的提升的比例会高于启动速度的提升比例，也就是说使用 Qemu 的虚拟机性能效果比 VirtualBox 的虚拟机性能效果提升超过一倍甚至更多。

这让我没有理由不选择使用 Qemu。

实际使用

Qemu 本身只提供了命令行工具来管理虚拟机，也不会保存虚拟机的相关配置信息。实际使用时通常是同时安装 Libvert（一套用于管理硬件虚拟化的开源API、守护进程与管理工具）配合 Libvert clients 来实现使用图形界面管理 Qemu 虚拟机。

Libvert clients 是 Libvert 的前端，常用的 Libvert clients 在这里。我使用的是 Virt-Manager 来管理 Qemu 虚拟机，因为在使用过程中 Virt-Manager 提供的管理功能和 VirtualBox 比较接近。使用教程参考 Derek Taylor 的 Virt-Manager Is The Better Way To Manage VMs。

使用 Virt-Manager 创建虚拟机的过程和 VirtualBox 类似，通常（对我来说）只需要改一下内存大小、CPU 数量和磁盘容量，其它无脑下一步就行。

与 VirtualBox 不同的是 Virt-Manager 还提供了通过网络安装（HTTP, HTTPS or FTP），安装过程要提供操作系统安装 URL，估计进行大规模安装的时候会用到，一般来说还是使用镜像文件来安装。

运行效果

不得不承认，Qemu 虚拟机的启动速度是肉眼可见的提升了，对 CPU 的占用也比 VirtualBox 少。除了没有剪切板共享功能有点不方便之外，其它使用体验和 VirtualBox 基本一致。

我主要使用虚拟机来调试一些应用程序，比如在 Windows 上运行 IDA，在 Linux 上运行 GDB。另外也会在 Linux 上运行些有意思的 Github 项目，比如 QQ Bot。

顺便提一嘴文件共享的问题。我不喜欢使用虚拟机软件提供的文件共享服务，一个是麻烦，有时还得重启配置才能生效；另一个是不灵活，不方便配置多个共享文件夹和控制权限。

我使用网络来实现文件共享，因为对这方面比较熟。

对于 Windows 虚拟机，只要开启网络文件共享，然后把想要共享的文件夹设置为对指定用户共享，就可以在宿主机（我这里用的 Linux，Windows 类似）使用 smb 协议连上 Windows 虚拟机，访问共享文件。

对于 Linux 虚拟机就更简单了，在 Linux 虚拟机里开启 SSHD/SSH 服务，使用 SSHFS 挂载 Linux 的文件系统或者直接 SCP，又或者使用 VS Code 的远程连接来直接编辑 Linux 虚拟机里的文件。

这个过程在 Qemu 下更加方便，因为 Qemu 直接虚拟出一个主机层面的虚拟网卡，也就不需要像 VirtualBox 那样使用 NAT 时还得配置端口转发才能从主机连上虚拟机。

实际使用中的问题

使用 Docker 和部署 Github 项目就不得不考虑配置代理的问题。

因为我在宿主机使用的是透明代理，所以在 VirtualBox 虚拟机里就不需要考虑配置网络代理的问题，网络数据自动由主机代理接管。

而 Qemu 虚拟的是主机层面的网卡，导致它的网络数据不由透明代理接管。（也可能是 iptables 配置的问题，弄了好久也没搞清楚是什么原因在开了 cgproxy 后 Qemu 虚拟机就连不上网，似乎可以对外请求，但返回的数据包没能回到虚拟机）

为了让虚拟机流量走主机代理，就只能是在虚拟机内使用配置 http_proxy 和 https_proxy 环境变量来试图让流量走主机代理了，但很多应用却并不使用 http_proxy 和 https_proxy 环境变量，搞自己的代理配置那一套。其中就包括 apt、docker 和 Python 脚本。

好在找到了一篇比较全的代理配置博文：UbuntuのProxy設定備忘録。里面包含了对 http_proxy 和 https_proxy 环境变量、apt、git、docker 和 wget 的代理配置方法。

关于 Python 的代理配置我参考的是 Stack Overflow 中的 How to pass all Python’s traffics through a http proxy?

结语

当需要考虑虚拟机性能时，毫无疑问应该选择 Qemu/KVM，这也是现在许多云服务厂商在使用的主流虚拟化方案。

但如果只是简单的虚拟需求如尝试各种 Linux 发行版啥的，那选择 VirtualBox 还是要更方便的，毕竟 VirtualBox 对虚拟机的管理配置很全，大部分需求都可以在 VirtualBox 的配置面板动动鼠标解决，这对新手非常友好。

折腾网络配置说实话挺烦的，尤其是还没深入研究过 Netfilter 和 Iptables。一些配置出问题虽然知道大概是哪有问题，但却不会修复。网上也不一定找得到答案，只能是论坛求助。

但折腾的好处则是我可以在解决问题的过程中学到不少新的东西，而这些经验会在未来不经意间发挥意想不到的作用。

最近终于把鸽了近一年多的 BinaryBomb 给做完了，花了一天时间，内力修炼的还不够啊。这里记录一下解题思路，方便以后回顾，同时也疏理一下解题用到的技术点。

Note：
本文主要记录解题的过程和思路，相关的基础知识可在 Binary-Bomb’s Readme 中查看。

BinaryBomb 简介

BinaryBomb 是 Carnegie Mellon University (卡内基·梅隆大学) CS 课上发布的一道作业，在 “Lab Assignments” page of Bryant and O’Hallaron’s website 中可以找到以下对 BinaryBomb 的介绍:

A "binary bomb" is a program provided to students as an object code file. When run, it prompts the user to type in 6 different strings. If any of these is incorrect, the bomb ``explodes,'' printing an error message and logging the event on a grading server. Students must ``defuse'' their own unique bomb by disassembling and reverse engineering the program to determine what the 6 strings should be. The lab teaches students to understand assembly language, and also forces them to learn how to use a debugger. It's also great fun. A legendary lab among the CMU undergrads.

译文：

“二进制炸弹”是一个以目标代码文件形式提供给学生的程序。运行后，它会提示用户输入 6 个不同的字符串。如果其中任何一个字符串错误，炸弹就会“爆炸”，打印错误信息并将事件记录到评分服务器上。学生必须通过反汇编和逆向工程程序来确定这 6 个字符串应该是什么，从而“拆除”他们自己独特的“炸弹”。这个实验旨在帮助学生理解汇编语言，并迫使他们学习如何使用调试器。它也充满乐趣，是卡内基梅隆大学本科生中一个传奇的实验。

正如介绍所说，BinaryBomb 非常有趣，虽然这作业是 2013 年发布的，但时至今日，仍能从中学到许多有用的东西。毕竟我们现在用的计算机除了从 32 位变成了 64 位外，寄存器种类，栈结构，函数调用机制等程序执行原理基本没有变化。

gdb + pwndbg 简介

• gdb 即 GNU Debugger，是 GNU 软件系统中的标准调试器，此外 gdb 也是个具有移携性的调试器，经过移携需求的调修与重新编译，如今许多的类 UNIX 操作系统上都可以使用 gdb，而现有 gdb 所能支持调试的编程语言有 C、C++、Pascal 以及 FORTRAN。

• pwndbg 是一个 GDB 和 LLDB 插件，可以减少调试工作，重点关注低级软件开发人员、硬件黑客、逆向工程和漏洞开发人员所需的功能。

简单来说，本文使用 Linux 自带的古老而又强大的调试器搭配上一个现代而又好用的插件，在鸽了一年后终于解决了差不多十年前发布的 CS 课作业。也许单用 gdb 才是这个作业的初衷，但裸 gdb 用起来非常的麻烦，每次查看状态信息时都得重新输一次命令，等到作业做完，手都起茧喽。人生苦短，用 gdb 前记得上 pwndbg。

运行环境

• OS: Arch Linux x86_64
• Shell: zsh 5.8.1
• Debuger: GNU gdb (gdb) 11.2 + pwndbg 1.0.3

关于 pwndbg 的安装，在 github-pwndbg 有详细描述；大部分桌面版 Linux 都有自带 gdb，没有的话可以使用对应包管理器安装，比如在 Ubuntu 运行 apt install gdb 进行安装。如果是 Windows 也可以用 WSL、MinGW 或者是虚拟机来搭建运行环境。具体操作教程网上很多，这里不再赘述。

BinaryBomb 二进制文件在 github-qspidy-BinaryBomb 下载，里面有许多答案不同的 BinaryBomb，但解答的过程基本一致。懒人命令：git clone https://github.com/qspidy/BinaryBomb

同时附上官方 bomb 下载链接。下载完成后在文件目录执行 tar xvf bomb.tar 解压。

gdb 常用命令表

开始调试 BinaryBomb

• 在 BinaryBomb 二进制文件目录下执行 gdb bomb 开始调试：
• 个人习惯先把所有的 phases 给反汇编出来复制到记事本，方便之后查看和相关地址的复制。执行 disas phase_1 显示 phase_1 的反汇编：

phase_1

1. 进入正题，一切准备就绪后，在 phase_1 函数入口处下断点：b phase_1，执行程序 r：
2. 因为还不知道正确答案，这里随便输入一串字符 helloworld，继续执行 c，这时 pwndbg 的作用就开始体现了，每次运行到断点停下，都会默认显示以下信息：

• Registers，寄存器信息，与 gdb 中运行 info r 输出类似：
• Disasm，反汇编信息，与 gdb 中运行 disas 输出类似：
• Stack，当前活动记录的栈信息，与 gdb 中运行 stack 输出类似：
• Backtrack，堆栈回溯，显示线程的函数调用堆栈，与 gdb 中运行 bt 输出类似

3. 注意这句：0x400e96 <phase_1+9> call strings_not_equal，从函数名能看出是调用了一个比较字符串是否相等的函数，那比较的是哪两个字符串呢？上一句指令是 0x400e91 <phase_1+4> mov esi, 0x402490，可以合理怀疑地址 0x402490 是其中一个字符串首地址，且作为参数传入该函数。执行 x/s 0x402490 尝试以字符串格式输出该地址信息：好家伙，看来这个就是答案了。
4. 但假如没有经验，不知道应该看地址 0x402490 的信息呢？那只能一步步运行看看了，连续执行 si 直到 strings_not_equal 函数，可以注意到下面这一段：很明显，参与比较的两个字符串分别是 rdi 指向的 helloworld 和 rsi 指向的 Why make trillions when we could make... billions?，前者是之前随便输的，后者是程序里写好的。
5. 后面的几句汇编是判断 eax 即 strings_not_equal 函数的返回值是否为 0，为 0 则说明两字符串相等，phase_1 退出，否则执行到 explode_bomb 函数，BOOM!!!

phase_2

1. phase_1 顶多算是热身，接下来的才是真正的 puzzle。先看一眼 phase_2 的反汇编：

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

   Dump of assembler code for function phase_2: 0x0000000000400ea9 <+0>: push rbp 0x0000000000400eaa <+1>: push rbx 0x0000000000400eab <+2>: sub rsp,0x28 0x0000000000400eaf <+6>: mov rax,QWORD PTR fs:0x28 0x0000000000400eb8 <+15>: mov QWORD PTR [rsp+0x18],rax 0x0000000000400ebd <+20>: xor eax,eax 0x0000000000400ebf <+22>: mov rsi,rsp 0x0000000000400ec2 <+25>: call 0x40152b <read_six_numbers> 0x0000000000400ec7 <+30>: cmp DWORD PTR [rsp],0x0 0x0000000000400ecb <+34>: jne 0x400ed4 <phase_2+43> 0x0000000000400ecd <+36>: cmp DWORD PTR [rsp+0x4],0x1 0x0000000000400ed2 <+41>: je 0x400ed9 <phase_2+48> 0x0000000000400ed4 <+43>: call 0x401509 <explode_bomb> 0x0000000000400ed9 <+48>: mov rbx,rsp 0x0000000000400edc <+51>: lea rbp,[rsp+0x10] 0x0000000000400ee1 <+56>: mov eax,DWORD PTR [rbx+0x4] 0x0000000000400ee4 <+59>: add eax,DWORD PTR [rbx] 0x0000000000400ee6 <+61>: cmp DWORD PTR [rbx+0x8],eax 0x0000000000400ee9 <+64>: je 0x400ef0 <phase_2+71> 0x0000000000400eeb <+66>: call 0x401509 <explode_bomb> 0x0000000000400ef0 <+71>: add rbx,0x4 0x0000000000400ef4 <+75>: cmp rbx,rbp 0x0000000000400ef7 <+78>: jne 0x400ee1 <phase_2+56> 0x0000000000400ef9 <+80>: mov rax,QWORD PTR [rsp+0x18] 0x0000000000400efe <+85>: xor rax,QWORD PTR fs:0x28 0x0000000000400f07 <+94>: je 0x400f0e <phase_2+101> 0x0000000000400f09 <+96>: call 0x400b00 <__stack_chk_fail@plt> 0x0000000000400f0e <+101>: add rsp,0x28 0x0000000000400f12 <+105>: pop rbx 0x0000000000400f13 <+106>: pop rbp 0x0000000000400f14 <+107>: ret End of assembler dump.

   同样，在 phase_2 函数入口下断点 b phase_2，继续执行 c，因为注意到 phase_2 的反汇编中有调用一个叫 read_six_numbers 的函数，所以输入的应该是六个数字，这里输入了 1 2 3 4 5 6，因为计算机内通常不会有这种简单的数字，所以这样输可以帮助我们观察哪些指令对输入的哪些参数进行了处理，更方便观察程序逻辑。

2. 多次执行命令 si 或直接 ni 8 (执行 8次 ni) 到 read_six_numbers 函数结束：

   

   cmp dword ptr [rsp], 0 一句表示将 rsp 寄存器指向的内容以 4字节 (dword) 格式解释，相当于 int 型，再与右边的 0 相减 (sub)，并改变相应的标志位。看一下当前的栈信息：

   

   可以看到当前的栈里存的是之前输入的 1 2 3 4 5 6，这样看可能不是很直观，输入 x/10wx $rsp 显示 10 个、地址从 rsp 开始连续的长度为 4字节 的内存信息：

   

   这里就能直观的看到栈里存储的数据格式了，其中 dword ptr [rsp] 是第一个参数即 0x00000001，dword ptr [rsp+4] 是第二个参数 0x00000002，dword ptr [rsp+8] 是第三个参数 0x00000003，以此类推。而 dword ptr [rsp] 指的正是栈顶的 4字节，也即之前输入的第一个参数。它和 0 一比较，不相等，便跳到了 explode_bomb 函数。所以推出第一个参数应该为 0。

3. 知道了第一个参数，可以选择重新运行，把输入参数的第一个改为 0，也可以先不管它，手动跳过 explode_bomb 函数继续运行。找到 jne phase_2+43 下一条指令地址为 0x400ecd，然后执行 set $rip=0x400ecd 设置 rip 寄存器值为该地址，因为 rip (指令指针寄存器) 始终存的是下一条即将执行的指令地址：

   

   发现这一段与上一段代码类似，可知第二个参数应该为 1。

4. 同样的方法跳过 explode_bomb 函数，从这里开始就有对参数进行计算的操作了，之前全是将参数和某个字符或数字比较，很容易很获得答案。继续一步步执行，发现这样一段：

   

   既然有条件跳转，就存在分支，这里 pwndbg 的输出默认只显示将会运行的指令，也就是说它预先执行了一下，帮你预测好了接下来几步的指令。为查看 pwndbg 省略掉的反汇编代码，执行 disas 输出当前函数反汇编，当前指令位置会有箭头标注：

   

   很明显 cmp DWORD PTR [rbx+0x8],eax 的结果应该为相等，其中前者 DWORD PTR [rbx+0x8] 是第三个参数，eax 存的是前几行指令的结果，再看前几行指令：

   

   对 rbp 和 rbx 进行赋值，然后计算第一参数与第二参数的和并赋于 eax，所以 eax 的值应该为 1，即第三个参数应该为 1。
   这里有一个小细节，因为 rbp 和 rbx 的旧值在这里被覆盖了，所以在函数开头有这样一句将 rbp 和 rbx 的旧值保存在栈里：

   

   并在函数返回前进行恢复：

   

   经典的保存现场和恢复现场操作，这在之后也会经常看到。

5. 继续向下执行，发现有这样三行指令：

   

   rbp 和 rbx 分别是之前赋的 rsp+0x10 和 rsp，即第五个参数和第一个参数的地址，对 rbx 加 4 即让 rbx 指向第下一个参数，然后比较一下看 rbx 是不是已经到了第五个参数，不是则跳到之前的 0x400ee1 <phase_2+56> mov eax, dword ptr [rbx + 4] 位置执行，否则退出循环。循环里执行的即是上一步的内容：检查第 x 个参数与第 x+1 个参数的和是否等于第 x+2 个参数，x 值为 1 到 5。至此，phase_2 已解决。

phase_3

1. 到这里基本上已经上手了，不同于 phase_2 的数学计算，phase_3 的重点在于理清程序执行逻辑，找出关键代码。同样附上 phase_3 的反汇编：

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77

   Dump of assembler code for function phase_3: 0x0000000000400f15 <+0>: sub rsp,0x28 0x0000000000400f19 <+4>: mov rax,QWORD PTR fs:0x28 0x0000000000400f22 <+13>: mov QWORD PTR [rsp+0x18],rax 0x0000000000400f27 <+18>: xor eax,eax 0x0000000000400f29 <+20>: lea r8,[rsp+0x14] 0x0000000000400f2e <+25>: lea rcx,[rsp+0xf] 0x0000000000400f33 <+30>: lea rdx,[rsp+0x10] 0x0000000000400f38 <+35>: mov esi,0x4024ee 0x0000000000400f3d <+40>: call 0x400bb0 <__isoc99_sscanf@plt> 0x0000000000400f42 <+45>: cmp eax,0x2 0x0000000000400f45 <+48>: jg 0x400f4c <phase_3+55> 0x0000000000400f47 <+50>: call 0x401509 <explode_bomb> 0x0000000000400f4c <+55>: cmp DWORD PTR [rsp+0x10],0x7 0x0000000000400f51 <+60>: ja 0x401053 <phase_3+318> 0x0000000000400f57 <+66>: mov eax,DWORD PTR [rsp+0x10] => 0x0000000000400f5b <+70>: jmp QWORD PTR [rax*8+0x402500] 0x0000000000400f62 <+77>: mov eax,0x69 0x0000000000400f67 <+82>: cmp DWORD PTR [rsp+0x14],0x33c 0x0000000000400f6f <+90>: je 0x40105d <phase_3+328> 0x0000000000400f75 <+96>: call 0x401509 <explode_bomb> 0x0000000000400f7a <+101>: mov eax,0x69 0x0000000000400f7f <+106>: jmp 0x40105d <phase_3+328> 0x0000000000400f84 <+111>: mov eax,0x66 0x0000000000400f89 <+116>: cmp DWORD PTR [rsp+0x14],0x30b 0x0000000000400f91 <+124>: je 0x40105d <phase_3+328> 0x0000000000400f97 <+130>: call 0x401509 <explode_bomb> 0x0000000000400f9c <+135>: mov eax,0x66 0x0000000000400fa1 <+140>: jmp 0x40105d <phase_3+328> 0x0000000000400fa6 <+145>: mov eax,0x71 0x0000000000400fab <+150>: cmp DWORD PTR [rsp+0x14],0x2d5 0x0000000000400fb3 <+158>: je 0x40105d <phase_3+328> 0x0000000000400fb9 <+164>: call 0x401509 <explode_bomb> 0x0000000000400fbe <+169>: mov eax,0x71 0x0000000000400fc3 <+174>: jmp 0x40105d <phase_3+328> 0x0000000000400fc8 <+179>: mov eax,0x7a 0x0000000000400fcd <+184>: cmp DWORD PTR [rsp+0x14],0x235 0x0000000000400fd5 <+192>: je 0x40105d <phase_3+328> 0x0000000000400fdb <+198>: call 0x401509 <explode_bomb> 0x0000000000400fe0 <+203>: mov eax,0x7a 0x0000000000400fe5 <+208>: jmp 0x40105d <phase_3+328> 0x0000000000400fe7 <+210>: mov eax,0x6c 0x0000000000400fec <+215>: cmp DWORD PTR [rsp+0x14],0x192 0x0000000000400ff4 <+223>: je 0x40105d <phase_3+328> 0x0000000000400ff6 <+225>: call 0x401509 <explode_bomb> 0x0000000000400ffb <+230>: mov eax,0x6c 0x0000000000401000 <+235>: jmp 0x40105d <phase_3+328> 0x0000000000401002 <+237>: mov eax,0x70 0x0000000000401007 <+242>: cmp DWORD PTR [rsp+0x14],0x1a6 0x000000000040100f <+250>: je 0x40105d <phase_3+328> 0x0000000000401011 <+252>: call 0x401509 <explode_bomb> 0x0000000000401016 <+257>: mov eax,0x70 0x000000000040101b <+262>: jmp 0x40105d <phase_3+328> 0x000000000040101d <+264>: mov eax,0x73 0x0000000000401022 <+269>: cmp DWORD PTR [rsp+0x14],0x325 0x000000000040102a <+277>: je 0x40105d <phase_3+328> 0x000000000040102c <+279>: call 0x401509 <explode_bomb> 0x0000000000401031 <+284>: mov eax,0x73 0x0000000000401036 <+289>: jmp 0x40105d <phase_3+328> 0x0000000000401038 <+291>: mov eax,0x6d 0x000000000040103d <+296>: cmp DWORD PTR [rsp+0x14],0x217 0x0000000000401045 <+304>: je 0x40105d <phase_3+328> 0x0000000000401047 <+306>: call 0x401509 <explode_bomb> 0x000000000040104c <+311>: mov eax,0x6d 0x0000000000401051 <+316>: jmp 0x40105d <phase_3+328> 0x0000000000401053 <+318>: call 0x401509 <explode_bomb> 0x0000000000401058 <+323>: mov eax,0x79 0x000000000040105d <+328>: cmp al,BYTE PTR [rsp+0xf] 0x0000000000401061 <+332>: je 0x401068 <phase_3+339> 0x0000000000401063 <+334>: call 0x401509 <explode_bomb> 0x0000000000401068 <+339>: mov rax,QWORD PTR [rsp+0x18] 0x000000000040106d <+344>: xor rax,QWORD PTR fs:0x28 0x0000000000401076 <+353>: je 0x40107d <phase_3+360> 0x0000000000401078 <+355>: call 0x400b00 <__stack_chk_fail@plt> 0x000000000040107d <+360>: add rsp,0x28 0x0000000000401081 <+364>: ret End of assembler dump.

   不像 phase_2 中有 read_six_numbers，phase_3 没法直接从反汇编中窥见输入的参数格式，那就暂时输 mrorange 好了，然后一步步执行，并观察 pwndbg 输出的 registers 信息，直到 scanf 函数：

   

   pwndbg 直接将传入 scanf 的参数展示出来，很容易能注意到 ‘%d %c %d‘ 就是 phase_3 正解的输入格式。有经验的话就可以直接 x/s 0x4024ee 查看输入格式了，因为 call scanf 的上一句指令即是用格式字符串地址赋值 rsi 寄存器，再作为参数传给 scanf 函数。

2. 确定了输入格式，重新运行输入 1 o 1 开始进一步分析：

   

   代码在 scanf 之后判断了输入参数个数是否大于 2 个，又判断了第一个参数是否小于等于 7，都通过则跳转到 第一个参数 * 8 + 0x402500 处，先不管这是哪，继续往下执行。注意到这句 cmp dword ptr [rsp + 0x14], 0x30b，看似是在判断一个参数是否为 0x30b，但是哪一个参数呢？之前输入的 1 o 1 不是很合适，因为第一个参数和第三个参数一样，在栈里就看不出哪个位置对应哪个参数，我这里又将输入改成了 1 o 2，再看一下栈区：

   

   dword ptr [rsp + 0x14] 的值是 2，所以 dword ptr [rsp + 0x14] 对应的是第三个参数。因此，第三个参数应该为 0x30b，但注意这个数是十六进制，而输入格式是 %d 即十进制，所以真正的第三参数是 779。

3. 继续向下，跳转到了 phase_3+3280x40105d <phase_3+328> cmp al, byte ptr [rsp + 0xf]，byte ptr [rsp + 0xf] 的值可以在栈里看到是 0x6f，也即第二个参数 o 的 ASCII 码，可以输入 x/bc $rsp+0xf 验证。将第二个参数和 al 即 rax 的最后一字节比较，那现在 rax 里存的又是什么呢？可以注意到是在比较第三个参数前有不显眼的一行 mov eax, 0x66，0x66 对应的字母是 f。至此，可以确定一组正确的答案为 1 f 779。

• Tip: 在 Python 命令行中，输入十六进制数会输出它的十进制；使用 print('{:c}'.format(0x66)) 可以输出 0x66 对应的 ASCII 字符。

4. 之所以说得到的只是其中一组正确答案，是因为第一个参数的值会决定跳转到的 第一个参数 * 8 + 0x402500 位置，而第一个参数值又小于等于 7，不能为负，所以对应不同的第一参数，一共会有八个不同的答案。得出答案的步骤完全一样，就不再赘述。

phase_4

1. 先附上 phase_4 和内部函数 func4 的反汇编：

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

   Dump of assembler code for function phase_4: 0x00000000004010b5 <+0>: sub rsp,0x18 0x00000000004010b9 <+4>: mov rax,QWORD PTR fs:0x28 0x00000000004010c2 <+13>: mov QWORD PTR [rsp+0x8],rax 0x00000000004010c7 <+18>: xor eax,eax 0x00000000004010c9 <+20>: lea rcx,[rsp+0x4] 0x00000000004010ce <+25>: mov rdx,rsp 0x00000000004010d1 <+28>: mov esi,0x40268f 0x00000000004010d6 <+33>: call 0x400bb0 <__isoc99_sscanf@plt> 0x00000000004010db <+38>: cmp eax,0x2 0x00000000004010de <+41>: jne 0x4010e6 <phase_4+49> 0x00000000004010e0 <+43>: cmp DWORD PTR [rsp],0xe 0x00000000004010e4 <+47>: jbe 0x4010eb <phase_4+54> 0x00000000004010e6 <+49>: call 0x401509 <explode_bomb> 0x00000000004010eb <+54>: mov edx,0xe 0x00000000004010f0 <+59>: mov esi,0x0 0x00000000004010f5 <+64>: mov edi,DWORD PTR [rsp] 0x00000000004010f8 <+67>: call 0x401082 <func4> 0x00000000004010fd <+72>: cmp eax,0x13 0x0000000000401100 <+75>: jne 0x401109 <phase_4+84> 0x0000000000401102 <+77>: cmp DWORD PTR [rsp+0x4],0x13 0x0000000000401107 <+82>: je 0x40110e <phase_4+89> 0x0000000000401109 <+84>: call 0x401509 <explode_bomb> 0x000000000040110e <+89>: mov rax,QWORD PTR [rsp+0x8] 0x0000000000401113 <+94>: xor rax,QWORD PTR fs:0x28 0x000000000040111c <+103>: je 0x401123 <phase_4+110> 0x000000000040111e <+105>: call 0x400b00 <__stack_chk_fail@plt> 0x0000000000401123 <+110>: add rsp,0x18 0x0000000000401127 <+114>: ret End of assembler dump.

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

   Dump of assembler code for function func4: 0x0000000000401082 <+0>: push rbx 0x0000000000401083 <+1>: mov eax,edx 0x0000000000401085 <+3>: sub eax,esi 0x0000000000401087 <+5>: mov ebx,eax 0x0000000000401089 <+7>: shr ebx,0x1f 0x000000000040108c <+10>: add eax,ebx 0x000000000040108e <+12>: sar eax,1 0x0000000000401090 <+14>: lea ebx,[rax+rsi*1] 0x0000000000401093 <+17>: cmp ebx,edi 0x0000000000401095 <+19>: jle 0x4010a3 <func4+33> 0x0000000000401097 <+21>: lea edx,[rbx-0x1] 0x000000000040109a <+24>: call 0x401082 <func4> 0x000000000040109f <+29>: add eax,ebx 0x00000000004010a1 <+31>: jmp 0x4010b3 <func4+49> 0x00000000004010a3 <+33>: mov eax,ebx 0x00000000004010a5 <+35>: cmp ebx,edi 0x00000000004010a7 <+37>: jge 0x4010b3 <func4+49> 0x00000000004010a9 <+39>: lea esi,[rbx+0x1] 0x00000000004010ac <+42>: call 0x401082 <func4> 0x00000000004010b1 <+47>: add eax,ebx 0x00000000004010b3 <+49>: pop rbx 0x00000000004010b4 <+50>: ret End of assembler dump.

   首先仍然是确定输入的格式。找到 scanf 函数，从其上一行中得到格式字符串地址，执行 x/s 0x40268f，得到格式字符串为 "%d %d"。

2. phase_4 的主函数部分的逻辑很简单，有了前三个 phase 的热身，应该可以轻松从反汇编中看出其逻辑：先判断输入参数个数是否为 2，再判断第一个参数是否小于 14，通过则调用函数 func4，并判断返回值是否为 19，最后判断初始输入的第二个参数是否为 19，均为是则顺利过关。

3. 光从第二步就能得知第一个参数是小于等于 14 的自然数，第二个参数是 19，通过暴力枚举 15 个可能的输入就能得到答案，甚至不用分析 func4 函数。但是前提是 func4 函数里没有改动最初输入的参数，也没有调用 explode_bomb 函数。前者在这种级别的题应该不会有，后者通过反汇编发现也满足。赶时间的话就可以开始试答案了，这里不再分析 func4 函数，附上伪代码（仅供参考，源自 IDA，其中参数 a1 = 输入的第一参数, a2 = 0, a3 = 14）:

   1 2 3 4 5 6 7 8 9 10 11 12 13

   __int64 func4(__int64 a1, __int64 a2, int a3) { int v3; // ebx __int64 result; // rax v3 = (a3 - (int)a2) / 2 + a2; if ( v3 > (int)a1 ) return v3 + (unsigned int)func4(a1, a2); result = (unsigned int)v3; if ( v3 < (int)a1 ) result = v3 + (unsigned int)func4(a1, (unsigned int)(v3 + 1)); return result; }

phase_5

1. 先附上 phase_5 的反汇编:

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

   Dump of assembler code for function phase_5: => 0x0000000000401128 <+0>: sub rsp,0x18 0x000000000040112c <+4>: mov rax,QWORD PTR fs:0x28 0x0000000000401135 <+13>: mov QWORD PTR [rsp+0x8],rax 0x000000000040113a <+18>: xor eax,eax 0x000000000040113c <+20>: lea rcx,[rsp+0x4] 0x0000000000401141 <+25>: mov rdx,rsp 0x0000000000401144 <+28>: mov esi,0x40268f 0x0000000000401149 <+33>: call 0x400bb0 <__isoc99_sscanf@plt> 0x000000000040114e <+38>: cmp eax,0x1 0x0000000000401151 <+41>: jg 0x401158 <phase_5+48> 0x0000000000401153 <+43>: call 0x401509 <explode_bomb> 0x0000000000401158 <+48>: mov eax,DWORD PTR [rsp] 0x000000000040115b <+51>: and eax,0xf 0x000000000040115e <+54>: mov DWORD PTR [rsp],eax 0x0000000000401161 <+57>: cmp eax,0xf 0x0000000000401164 <+60>: je 0x401195 <phase_5+109> 0x0000000000401166 <+62>: mov ecx,0x0 0x000000000040116b <+67>: mov edx,0x0 0x0000000000401170 <+72>: add edx,0x1 0x0000000000401173 <+75>: cdqe 0x0000000000401175 <+77>: mov eax,DWORD PTR [rax*4+0x402540] 0x000000000040117c <+84>: add ecx,eax 0x000000000040117e <+86>: cmp eax,0xf 0x0000000000401181 <+89>: jne 0x401170 <phase_5+72> 0x0000000000401183 <+91>: mov DWORD PTR [rsp],0xf 0x000000000040118a <+98>: cmp edx,0xf 0x000000000040118d <+101>: jne 0x401195 <phase_5+109> 0x000000000040118f <+103>: cmp ecx,DWORD PTR [rsp+0x4] 0x0000000000401193 <+107>: je 0x40119a <phase_5+114> 0x0000000000401195 <+109>: call 0x401509 <explode_bomb> 0x000000000040119a <+114>: mov rax,QWORD PTR [rsp+0x8] 0x000000000040119f <+119>: xor rax,QWORD PTR fs:0x28 0x00000000004011a8 <+128>: je 0x4011af <phase_5+135> 0x00000000004011aa <+130>: call 0x400b00 <__stack_chk_fail@plt> 0x00000000004011af <+135>: add rsp,0x18 0x00000000004011b3 <+139>: ret End of assembler dump.

   同样，通过观察反汇编得到格式字符串地址为 0x40268f，执行 x/s 0x40268f 得到格式字符串为 "%d %d"，这里输入 5 10 后继续分析。

2. 从 scanf 函数下一行开始一步步执行：判断输入参数个数是否大于 1，是则继续；取第一参数的后四位，并覆盖原来的参数，且第一参数的后四位不全为 1；这时第一参数的值转化成为 0～14 之间一个数；从 0x0000000000401170 <+72>: add edx,0x1 开始进入循环：

   

• 其中 cdqe 是使用 eax 的最高位拓展 rax 高 32 位的所有位。

2. 注意到这一行 mov eax, dword ptr [rax*4 + 0x402540]，不禁好奇地址 0x402540 里存了什么，执行 x/20wx 0x402540 查看内存：

   

   果然是一个数组，每个元素长度为 4字节，所以 dword ptr [rax*4 + 0x402540] 值为该数组的第 rax 个元素。再来看这段循环，它不断的将数组的第 rax 个元素再次赋予 rax，同时将 rax 的值累加到 ecx 寄存器。edx 记录循环的次数，直到 rax 值为 0xf 时退出循环：

   

3. 退出循环后，判断 edx 的值是否为 0xf，然后判断 ecx 和第二参数是否相等，均为是则过关。edx 值为 0xf 即循环次数为 15 次，数组长度为 16，所以很有可能 ecx 最后就是数组所有元素的和（除下标为 0xf 的元素）。再观察数组，发现通过不断的将数组下标对应元素作为新的数组下标，可以遍历完整个数组，因此在 15 次循环中必然完成了数组的一次遍历，ecx 值即所有元素和（除下标为 0xf 的元素）为 115。因此第二个参数应该为 115。

4. 那么第一个参数呢？第一个参数是 eax 的初值，也就是第一个下标，然后需要让 eax 遍历数组的时候正好在最后才被赋值 0xf，并退出循环。可以暴力枚举，也可以用逆推的方法：最后 eax 值为 0xf，那么 eax 前一个值为元素 0xf 的下标 0x6，再前一个值为元素 0x6 的下标 0xe，以此类推，得到最初下标应该为 0x5。或者直接正推，下标为 0xf 的元素 0x5 即为所求值。故第一个参数应该为 0x5。

phase_6

1. 先附上 phase_6 的反汇编：

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91

   Dump of assembler code for function phase_6: 0x00000000004011b4 <+0>: push r14 0x00000000004011b6 <+2>: push r13 0x00000000004011b8 <+4>: push r12 0x00000000004011ba <+6>: push rbp 0x00000000004011bb <+7>: push rbx 0x00000000004011bc <+8>: sub rsp,0x60 0x00000000004011c0 <+12>: mov rax,QWORD PTR fs:0x28 0x00000000004011c9 <+21>: mov QWORD PTR [rsp+0x58],rax 0x00000000004011ce <+26>: xor eax,eax 0x00000000004011d0 <+28>: mov rsi,rsp 0x00000000004011d3 <+31>: call 0x40152b <read_six_numbers> 0x00000000004011d8 <+36>: mov r12,rsp 0x00000000004011db <+39>: mov r13,rsp 0x00000000004011de <+42>: mov r14d,0x0 0x00000000004011e4 <+48>: mov rbp,r13 0x00000000004011e7 <+51>: mov eax,DWORD PTR [r13+0x0] 0x00000000004011eb <+55>: sub eax,0x1 0x00000000004011ee <+58>: cmp eax,0x5 0x00000000004011f1 <+61>: jbe 0x4011f8 <phase_6+68> 0x00000000004011f3 <+63>: call 0x401509 <explode_bomb> 0x00000000004011f8 <+68>: add r14d,0x1 0x00000000004011fc <+72>: cmp r14d,0x6 0x0000000000401200 <+76>: je 0x401223 <phase_6+111> 0x0000000000401202 <+78>: mov ebx,r14d 0x0000000000401205 <+81>: movsxd rax,ebx 0x0000000000401208 <+84>: mov eax,DWORD PTR [rsp+rax*4] 0x000000000040120b <+87>: cmp DWORD PTR [rbp+0x0],eax 0x000000000040120e <+90>: jne 0x401215 <phase_6+97> 0x0000000000401210 <+92>: call 0x401509 <explode_bomb> 0x0000000000401215 <+97>: add ebx,0x1 0x0000000000401218 <+100>: cmp ebx,0x5 0x000000000040121b <+103>: jle 0x401205 <phase_6+81> 0x000000000040121d <+105>: add r13,0x4 0x0000000000401221 <+109>: jmp 0x4011e4 <phase_6+48> 0x0000000000401223 <+111>: lea rcx,[rsp+0x18] 0x0000000000401228 <+116>: mov edx,0x7 0x000000000040122d <+121>: mov eax,edx 0x000000000040122f <+123>: sub eax,DWORD PTR [r12] 0x0000000000401233 <+127>: mov DWORD PTR [r12],eax 0x0000000000401237 <+131>: add r12,0x4 0x000000000040123b <+135>: cmp rcx,r12 0x000000000040123e <+138>: jne 0x40122d <phase_6+121> 0x0000000000401240 <+140>: mov esi,0x0 0x0000000000401245 <+145>: jmp 0x401261 <phase_6+173> 0x0000000000401247 <+147>: mov rdx,QWORD PTR [rdx+0x8] 0x000000000040124b <+151>: add eax,0x1 0x000000000040124e <+154>: cmp eax,ecx 0x0000000000401250 <+156>: jne 0x401247 <phase_6+147> 0x0000000000401252 <+158>: mov QWORD PTR [rsp+rsi*2+0x20],rdx 0x0000000000401257 <+163>: add rsi,0x4 0x000000000040125b <+167>: cmp rsi,0x18 0x000000000040125f <+171>: je 0x401275 <phase_6+193> 0x0000000000401261 <+173>: mov ecx,DWORD PTR [rsp+rsi*1] 0x0000000000401264 <+176>: mov eax,0x1 0x0000000000401269 <+181>: mov edx,0x6042f0 0x000000000040126e <+186>: cmp ecx,0x1 0x0000000000401271 <+189>: jg 0x401247 <phase_6+147> 0x0000000000401273 <+191>: jmp 0x401252 <phase_6+158> 0x0000000000401275 <+193>: mov rbx,QWORD PTR [rsp+0x20] 0x000000000040127a <+198>: lea rax,[rsp+0x20] 0x000000000040127f <+203>: lea rsi,[rsp+0x48] 0x0000000000401284 <+208>: mov rcx,rbx 0x0000000000401287 <+211>: mov rdx,QWORD PTR [rax+0x8] 0x000000000040128b <+215>: mov QWORD PTR [rcx+0x8],rdx 0x000000000040128f <+219>: add rax,0x8 0x0000000000401293 <+223>: mov rcx,rdx 0x0000000000401296 <+226>: cmp rsi,rax 0x0000000000401299 <+229>: jne 0x401287 <phase_6+211> 0x000000000040129b <+231>: mov QWORD PTR [rdx+0x8],0x0 0x00000000004012a3 <+239>: mov ebp,0x5 0x00000000004012a8 <+244>: mov rax,QWORD PTR [rbx+0x8] 0x00000000004012ac <+248>: mov eax,DWORD PTR [rax] 0x00000000004012ae <+250>: cmp DWORD PTR [rbx],eax 0x00000000004012b0 <+252>: jge 0x4012b7 <phase_6+259> 0x00000000004012b2 <+254>: call 0x401509 <explode_bomb> 0x00000000004012b7 <+259>: mov rbx,QWORD PTR [rbx+0x8] 0x00000000004012bb <+263>: sub ebp,0x1 0x00000000004012be <+266>: jne 0x4012a8 <phase_6+244> 0x00000000004012c0 <+268>: mov rax,QWORD PTR [rsp+0x58] 0x00000000004012c5 <+273>: xor rax,QWORD PTR fs:0x28 0x00000000004012ce <+282>: je 0x4012d5 <phase_6+289> 0x00000000004012d0 <+284>: call 0x400b00 <__stack_chk_fail@plt> 0x00000000004012d5 <+289>: add rsp,0x60 0x00000000004012d9 <+293>: pop rbx 0x00000000004012da <+294>: pop rbp 0x00000000004012db <+295>: pop r12 0x00000000004012dd <+297>: pop r13 0x00000000004012df <+299>: pop r14 0x00000000004012e1 <+301>: ret End of assembler dump.

   作为最后一个 phase，上来就给了个下马威，这反汇编在 6 个 phase 中最长，逻辑也是最复杂的。看一下反汇编，注意到 phase_6 调用了 read_six_numbers 函数，所以输入格式是和 phase_2 相同的六个数字。这里输入 1 2 3 4 5 6 继续分析。

2. 直接看不容易看出程序的规律，那就从 read_six_numbers 函数下一行开始一步步运行：

   

   上面这第一段代码主要判断第一个参数是否小于 6，再往下执行：

   

   从这段可基本判断现在位于一个循环中，r14d 中存循环变量，且这个循环要执行 6 次，继续向下执行：

   

   这段将当前第 ebx 个参数即第二个参数赋予 eax，并判断和第一个参数是否不相等，是则继续，接下来似乎是这个循环的最后一段：

   

   出现了另一个循环变量 ebx，且其控制的循环要执行 5 次。

3. 再往下，程序跳转到了 0x401205 <phase_6+81> movsxd rax, ebx，从之前的分析看，这一段是判断第 ebx 个参数是否和第一个参数不相等，所以 ebx 控制的循环功能是判断 6 个参数中其它 5 个参数是否和第 1 个参数相等。

4. 继续运行到 ebx 控制的循环结束：

   

   这里对 r13 加 4 后直接一个大跳转，继续跟进，发现继续执行的是第二步分析的判断参数是否小于 6，只不过这次判断的是第二个参数。分析到这，基本可以确定，以上这一整段是个双重循环，用于判断输入的六个数是不是为 1～6，且互不相等。

5. 检验完输入后就快进入关键逻辑了，循环结束继续向下执行：

   

   这又是一个小循环，但比起之前那个要简单得多。其功能是对每个参数 x 进行处理，使每个参数 x 都变为 7-x，比如第一个参数为 1，处理后变成 6。

6. 继续向下执行，程序跳转到了 0x401261 <phase_6+173> mov ecx, dword ptr [rsp + rsi]：

   

   这里开始又是一个循环，注意到出现了 node1 <0x6042f0>，不防看一眼里面都有什么，执行 x/25wx 0x6042f0：

   

   很明显这是一个单链表，node1 指向 node2，node2 指向 node3，依次类推。继续向下执行：

   

   令当前第 x 个参数为 a(x)，x 为 1～6。结合上一个片段看，可以判断这一段是遍历到第 a(1) 个节点，将其地址存入 rsp + rsi*2 + 0x20 位置，最后更改循环变量 rsi，判断是否要退出循环。

7. 上一步在 rsi 控制下一共执行了六次，功能是将第 a(x) 个节点放入 rsp + x*4*2 + 0x20 位置，结果如下图：

   

   继续向下执行，又是一个小循环：

   

   令节点 n 的下一节点指针为 flink(n)。这个小循环的功能为将节点 a(x) 的 flink(a(x)) 置为节点 a(x+1) 的地址。比如当前参数为 6 5 4 3 2 1，则循环处理后六个节点就会变成 node6 -> node5 -> node4 -> node3 -> node2 -> node1。

8. 退出循环后继续向下执行：

   

   这段先将最末节点的 flink 置 0，然后比较链表中第一个节点的值和第二个节点的值，如果前者大于后者则跳转：

   

   这里让 rbx 指向下一个节点，然后循环变量 ebp 减 1，继续上一步，即比较 rbx 指向的当前节点和下一节点的值，前者大于后者则跳转，否则 BOOM！

9. 上一步循环顺利退出即可过关。前提是当前链表中前一个节点中的数据始终大于后一个节点的数据，根据第六步中的节点信息，可以知道节点最后的顺序应该为 node2 -> node5 -> node4 -> node3 -> node6 -> node1。所以经第五步处理后的参数应该为 2 5 4 3 6 1。即最初输入的参数应该为 5 2 3 4 1 6。

结语

总的来说，这个作业难度不高，代码用到的都是最基本的逻辑和计算。但想要顺利的解出答案，除了要对 gdb 的操作和命令熟练外，还要对程序的基本运行原理和相关汇编指令有一定程度的掌握。

我认为这 6 个 Phase 中唯一棘手的是最后一个，几乎全是循环逻辑，甚至是双重循环，对这种逻辑的处理没太多经验的话很容易望而却步，哪怕是硬着头皮上，也会身心俱疲。但总之，程序的运行逻辑无非几种：顺序、分支、循环。基本逻辑搞定了，分析解决再复杂的逻辑也不过是时间问题。

当然，问题通常都不会只有一种解法，比如 phase_4 可以还能配合暴力枚举找出答案，节省大量时间。灵活运用工具，善于思考，尝试用不同的角度去审视难题，可以让思维更加开阔。

该篇是本博客第一个技术长篇，或许还有许多表述不周的地方，欢迎在下方评论，我们一起，变得更强！

Welcome to Orangeの小窝!!!

This is my first blog in the site, mainly for testing and will be removed when the site is fully built.

If you are new here and like this blog site, feel free to fav the website and leave your opinions of the site below as comments, anyway, it’s free, and you can always change your mind.

Enjoy the Orangeの小窝!!!