Lab2-system calls && MIT6.1810操作系统工程【持续更新】

Lab: system calls

​        在这个lab当中6.1810 / Fall 2025 它要求你在xv6当中添加一个新的系统调用，以此来帮助你理解在操作系统当中，系统调用的底层实现逻辑和调用链条；
​        之后该lab当中会告诉你一个故意留下来的系统漏洞，要求你利用该漏洞获取之前的进程（已经被清理的进程）的私有数据，通过此lab你可以学到操作系统是如何隔离每个进程的，同时也会告诉你在回收进程的资源时如果处理不当会导致原本应该被清理的进程，它的私有数据可能会被其他进程窃取，从而打破了操作系统的进程隔离机制。
1.Using gdb

​        这一部分涉及gdb的调试，所以我们暂时跳过，更多GDB的调试技巧可以去网上搜索一下，这里就不再阐述了。
2.Sandbox a command(中等难度)

​        在这一小节当中，我们需要给xv6操作系统引入一种进程级系统调用限制机制（sandbox）。具体而言，允许用户进程通过一个新的系统调用 interpose(mask, path)，为当前进程及其子进程设置一组“被禁止的系统调用”，使得后续执行中一旦触发这些系统调用，就会被内核拒绝。官网当中告诉我们interpose接收两个参数，一个是是屏蔽掩码mask，另一个是路径path （当前用不到）。
​        来自官网的提示（个人解析版）：

• 在 Makefile 中向 UPROGS 添加 $U/_sandbox，以保证编译器会编译该源文件。
  
• 由于interpose没有任何声明和实现，所以要在user/user.h 中添加一个 interpose 原型（不要遗漏参数） 。
  
• 在user/usys.pl当中增加一个新的项，该文件是用户态系统调用接口的生成脚本，它会帮助生成一个汇编文件user/usys.S，该文件中指定了每一个系统调用的参数，陷入指令和返回指令。
  
• 因为interpose是一个新的系统调用，所以我们要在kernel/syscall.h当中添加一个新的系统调用码，用于之后syscall函数的使用。
  
• 因为要添加一个新的系统调用，所以我们要严格按照xv6关于系统调用函数声明的规范进行命名，我们可以参考xv6当中已有的函数声明，所以我们在kernel/sysproc.c 当中实现一个名为：sys_interpose(void)的函数，它就是最终的调用实现。
  
• 按照官网的要求，我们的屏蔽掩码需要父进程传递给子进程（或者说是子进程继承了父进程的屏蔽掩码），所以这就代表了这个屏蔽掩码需要被持久存储于进程中，于是我们需要在进程的结构体当中添加一个字段，用于记录屏蔽掩码，同时因为子进程是父进程通过调用fork创造出来的，所以一定存在一个函数用于将父进程当中某些状态/属性纹丝不动地赋值给子进程当中对应的字段，因此根据官网的提示，我们可以在kernel/proc.c当中找到一个名为：kfork的函数，这里就是父子进行状态/属性继承的地方，我们需要在这里修改一下，使得其可以将父进程新添加的“屏蔽掩码”字段同样赋值给子进程。
  
• 因为每个系统调用都是一个函数指针，所以在kernel/syscall.c当中，有一个数组： syscalls，里面存放的是每一个系统调用的入口地址，我们需要在该数组当中添加一项新的数据，同时需要在此文件中添加sys_interpose的声明（可以参考已有的xv6代码，照葫芦画瓢）。
  
• 因为我们要实现的是系统调用的屏蔽机制，所以在xv6当中，任何系统调用最终都会通过内核态函数syscall进行调用号的识别和分发调用，所以我们可以在此函数当中添加某些判断逻辑，通过将当前请求系统调用的进程当中的屏蔽掩码与当前进程请求的系统调用的调用码向比对来得到是否要屏蔽该系统调用。
  

以下是代码相关内容：

1. ##user/user.h中新增的内容（用户态函数声明）：
2. int interpose(int,char *path);
4. ##user/usys.pl中新增的内容：
5. entry("interpose");
7. ##kernel/syscall.h中新增的内容（系统调用号）：
8. #define SYS_interpose 22  //interpose的系统调用码
10. ##kernel/proc.c/kfork函数体内，中新增的内容（子进程继承父进程的mask）：
11. ... ...
12. /*修改点，父进程的状态mask传递给子进程
13.   * 父进程的mask已经被修改，此时若创建新
14.   * 的子进程则mask也要一并传递。
15.   */
16.   np->mask = p->mask;
17. ... ...
19. ##kernel/syscall.c中新增/修改的内容（系统调用声明，添加新的的项到函数指针数组，修改syscall函数）：
20. extern uint64 sys_interpose(void); //新添加的系统调用声明
21. // An array mapping syscall numbers from syscall.h
22. // to the function that handles the system call.
23. static uint64 (*syscalls[])(void) = {
24. [SYS_fork]    sys_fork,
25. [SYS_exit]    sys_exit,
26. [SYS_wait]    sys_wait,
27. [SYS_pipe]    sys_pipe,
28. [SYS_read]    sys_read,
29. [SYS_kill]    sys_kill,
30. [SYS_exec]    sys_exec,
31. [SYS_fstat]   sys_fstat,
32. [SYS_chdir]   sys_chdir,
33. [SYS_dup]     sys_dup,
34. [SYS_getpid]  sys_getpid,
35. [SYS_sbrk]    sys_sbrk,
36. [SYS_pause]   sys_pause,
37. [SYS_uptime]  sys_uptime,
38. [SYS_open]    sys_open,
39. [SYS_write]   sys_write,
40. [SYS_mknod]   sys_mknod,
41. [SYS_unlink]  sys_unlink,
42. [SYS_link]    sys_link,
43. [SYS_mkdir]   sys_mkdir,
44. [SYS_close]   sys_close,
45. [SYS_interpose]   sys_interpose, //新添加的系统调用
46. };
48. //这里是syscall函数修改后的样子：
49. void
50. syscall(void)
51. {
52.   int num;
53.   struct proc *p = myproc();
54.   // 取出在a7中存放的调用号
55.   num = p->trapframe->a7;
56.   if(num > 0 && num < NELEM(syscalls) && syscalls[num]) {
57.     //将调用屏蔽掩码和系统调用码进行相与的操作，判断当前调用是否被屏蔽/禁止
58.     if(p->mask & (1 << num) ){
59.       p->trapframe->a0 = -1;
60.       return;
61.     }
63.     // Use num to lookup the system call function for num, call it,
64.     // and store its return value in p->trapframe->a0
65.     p->trapframe->a0 = syscalls[num]();
66.   } else {
67.     printf("%d %s: unknown sys call %d\n",
68.             p->pid, p->name, num);
69.     p->trapframe->a0 = -1;
70.   }
71. }
74. ##kernel/proc.h当中修改和新增的内容（屏蔽掩码）：
75. / Per-process state
76. struct proc {
77.   struct spinlock lock;
79.   // p->lock must be held when using these:
80.   enum procstate state;        // Process state
81.   void *chan;                  // If non-zero, sleeping on chan
82.   int killed;                  // If non-zero, have been killed
83.   int xstate;                  // Exit status to be returned to parent's wait
84.   int pid;                     // Process ID
85.   int mask;                    // （新）进程的系统调用屏蔽掩码
86.   ... ...
88. ##kernel/syscall.c当中新增的内容（sys_interpose的实现）：
89. uint64
90. sys_interpose(void){
91.   //获取参数
92.   int n;
93.   argint(0, &n);
95.   //修改状态
96.   struct proc *p = myproc();
97.   p->mask = n;
98.   return 0;
99. }

复制代码

验收成果：

• 按照官网给出的输入进行输入，如果输出的和官网结果一致则代表成功。
  
• 在ubuntu的shell当中（xv6目录下）输入 ./grade-lab-syscall sandbox_mask后，如果出现以下提示则代表成功！
  

1. == Test sandbox_mask == sandbox_mask: OK (1.5s)

复制代码

3.Sandbox with allowed pathnames(简单难度)

​        这一小节是对上一阶段 系统调用屏蔽 的扩展，上一小节只是简单粗暴地屏蔽了某个系统调用（一棒子打死的那种），在本小节，我们用到了interpose的第二个参数Path，这个参数的具体意思是：“允许访问的路径”。
​        假设我们的屏蔽掩码屏蔽了 open 和 exec 这个两个系统调用，但是这两个系统调用在调用时都需要向其传入一个路径（我们假设该路径的名字为：pathA），当我们调用 open 和 exec时，如果向其传入的路径 pathA和之前的Path一致，则代表 open 和 exec正常进行，不会被屏蔽，反之则直接返回，不再执行 open 和 exec。
​        个人的一些解析：

• 由于用到了interpose的第二次参数，因此我们需要在进程结构体当中添加新的字段用于存放允许访问的路径。
  
• 由于在进程结构体当中添加了新成员，因此父子进程继承状态/属性时需要传递刚才添加的新成员。
  
• 官网说了，如果屏蔽码屏蔽的是 open 和 exec，则会继续判断PathA和进程结构体当中的特点字段是否一致，一致则代表 open 和 exec可以正常执行，所以结合前面的例子，屏蔽掩码具体屏蔽了谁，应该在syscall当中进行判断，而进一步地判断需要在 sys_open 和 sys_exec两个调用的具体实现当中。
  

以下是代码相关内容：

1. ##kernel/proc.h当中修改和新增的内容（屏蔽掩码）：
2. // Per-process state
3. struct proc {
4.   struct spinlock lock;
6.   // p->lock must be held when using these:
7.   enum procstate state;        // Process state
8.   void *chan;                  // If non-zero, sleeping on chan
9.   int killed;                  // If non-zero, have been killed
10.   int xstate;                  // Exit status to be returned to parent's wait
11.   int pid;                     // Process ID
12.   int mask;                    // 进程的系统调用屏蔽字
13.   char allowPathName[MAXPATH];         // 被允许的路径名
14.   ... ...
16. ##kernel/proc.c/kfork函数体内，中新增的内容（子进程继承父进程的mask）：
17. ... ...
18. /*修改点，父进程的状态mask传递给子进程
19.   * 父进程的mask已经被修改，此时若创建新
20.   * 的子进程则mask也要一并传递。
21.   * 子进程也要继承父进程的allowPathName。
22.   */
23.   np->mask = p->mask;
24.   strncpy(np->allowPathName,p->allowPathName,MAXPATH);
25. ... ...
27. ##kernel/syscall.c当中修改的内容（遇到open和exec则“放行”，在open和exec中再次判断）：
28. void
29. syscall(void)
30. {
31.   int num;
32.   struct proc *p = myproc();
33.   // 取出在a7中存放的调用号
34.   num = p->trapframe->a7;
35.   if(num > 0 && num < NELEM(syscalls) && syscalls[num]) {
36.     //修改前：将调用屏蔽掩码和系统调用码进行相与的操作，判断当前调用是否被屏蔽/禁止
37.     //修改后：如果屏蔽的是open和exec则在open或者exec当中再次判断
38.     if(p->mask & (1 << num) ){
39.       if(num == SYS_open || num == SYS_exec){
40.         p->trapframe->a0 = syscalls[num]();
41.         return;
42.       }
43.       p->trapframe->a0 = -1;
44.       return;
45.     }
47.     // Use num to lookup the system call function for num, call it,
48.     // and store its return value in p->trapframe->a0
49.     p->trapframe->a0 = syscalls[num]();
50.   } else {
51.     printf("%d %s: unknown sys call %d\n",
52.             p->pid, p->name, num);
53.     p->trapframe->a0 = -1;
54.   }
55. }
57. ##kernel/sysfile.c/sys_open函数体内，新增的内容（添加判断逻辑）：
58.   ... ...
59.   // 只有当 open 被 mask 掉时，才检查路径
60.   if(p->mask & (1 << SYS_open)){
61.     if(strncmp(path,p->allowPathName,MAXPATH) != 0){
62.       return -1;
63.     }
64.   }
65.   ... ...
66.       
67. ##kernel/sysfile.c/sys_exec函数体内，新增的内容（添加判断逻辑）：   
68. ... ...
69. // 只有当 exec 被 mask 掉时，才检查路径
70.   if(p->mask & (1 << SYS_exec)){
71.     if(strncmp(path, p->allowPathName,MAXPATH) != 0){
72.       return -1;
73.     }
74.   }
75.   ... ...

复制代码

验收成果：

• 按照官网给出的输入进行输入，如果输出的和官网结果一致则代表成功。
  
• 在ubuntu的shell当中（xv6目录下）输入 make grade后，如果出现以下提示则代表成功！
  

1. == Test sandbox_mask ==
2. $ make qemu-gdb
3. sandbox_mask: OK (3.0s)
4. == Test sandbox_fork ==
5. $ make qemu-gdb
6. sandbox_fork: OK (1.1s)
7. == Test sandbox_path ==
8. $ make qemu-gdb
9. sandbox_path: OK (1.2s)
10. == Test sandbox_most ==
11. $ make qemu-gdb
12. sandbox_most: OK (0.7s)
13. == Test sandbox_minus ==
14. $ make qemu-gdb
15. sandbox_minus: OK (1.0s)
16. == Test attack ==
17. $ make qemu-gdb
18. attack: OK (1.1s)

复制代码

4、Attack xv6 (中等难度)

​        这一小节，我们将利用系统漏洞打破进程之间的屏障，从而中进程B当中访问到进程A（已被回收但未彻底重置该进程使用过的内存）当中的私有数据。
​        xv6 通过虚拟内存和系统调用机制实现了进程之间、用户态与内核态之间的隔离，在正常情况下，一个用户进程不可能直接访问另一个进程的内存数据。正常情况下进程在被销毁时，其使用过的内存空间也要被清理一下（例如全部置为0或者其他值），但是xv6当中负责回收进程内存的逻辑没有对进程使用过的内存进行清理，这就导致新的进程被创建后，其私有的内存空间很可能与之前的进程相重叠（方便理解先这么说，后面会给出具体的解释），导致新进程可能访问到旧进程的私有数据。
​        所以，在本次小节，xv6会先通过secret程序创建进程，并且向该进程的私有内存空间当中存放一些数据，最后销毁进程（注意：存放的数据没有被销毁），之后我们通过实现attack这个程序，来让一个新的进程尝试从自己的私有内存空间当中寻找secret进程遗留下来的蛛丝马迹，找到后输出它。
​        官网的一些提示和本人的解析：

• user/secret.c是secret的源文件。
  
• 我们在user/attack.c当中实现本小节让我们做的内容。
  
• 官网说通过sbrk()这个系统调用来请求分配一块内存空间（堆区），然后在该堆区当中寻找蛛丝马迹。
  
• 因为secret会向内存当从存放字符串，所以我们在遍历堆区时需要判断当前访问的内存当中存放的内容是否符合字符串的特征，同时字符串的字符应该是大于等于2个字符，连续并且以'\0'结尾。
  
• 要为进程分配合适大小的堆区，并且检测字符串时，存放字符串的容器长度也要设计合理。
  

相关代码：
[code]##user/attack.c#include "kernel/types.h"#include "kernel/fcntl.h"#include "user/user.h"#include "kernel/riscv.h"#define DATASIZE (8*4096)  //heap的大小为8页，共32k，一页4kBintmain(int argc, char *argv[]){  // Your code here.  //分配heap  char* buf = sbrk(DATASIZE);  //堆的大小为8页  char ch[DATASIZE/4];  //字符串大小为8k  int j = 0;//  for(int i = 0; i < DATASIZE; i++){    char c = buf;    if(c == '\0' && (j >= 2 && j < DATASIZE/4)){      //遇到/0,并且j大于2且在合法范围内则代表可能找到了想要的东西，截断字符串      ch[j++] = '\0';      //打印      printf("%s",ch);      printf("\n");      //j置为0继续找剩余符合条件的字符串（假设还没有扫码到heap的尽头的情况下）      j = 0;    }    //符合字符条件并且j的范围合理    if( ((c >='a' && c = 'A' && c = '0' && c

收藏一下   不知道什么时候能用到

谢谢分享，试用一下

前排留名，哈哈哈