关于stac和clac的进一步细节及EFLAGS

一、背景

在之前的博客 内核态代码直接使用用户态数据的注意事项_内核态怎样打开用户态文件-CSDN博客 里，我们x86平台上在内核态里使用用户态数据的干系细节，即必要使用stac和clac函数来打开/关闭内核态访问用户态数据的权限，这里说是权限，实在指的是管控，也就是x86上SMAP特性，防止内核逻辑不测修改用户态数据，仅仅在copy_from_user/copy_to_user等一些地方临时答应内核态逻辑来访问用户态数据。在arm64下，也有类似的机制，如下图里的：

这里不睁开说arm64的，但是可以得知的是，不同的硬件平台一些紧张的特性都会覆盖的，如arm64的smap功能在armv8.4-A架构及更高版本中会引入。
回到x86平台，在之前的博客 内核态代码直接使用用户态数据的注意事项-CSDN博客 里，我们自己调用了stac和clac，在stac和clac的中心使用了memcpy使用到了用户态数据，但是实在会遇到一个warning的提示，我们在下面第二章里，睁开说明。然后我们在第三章里，把与stac和clac有关的在做上下文切换时怎样生存和规复的逻辑做说明。

二、stac和clac之间使用memcpy会导致编译warning

如下图，假如在stac和clac之间使用memcpy：

就会导致编译时如下的warning：

提示“call to fortify_panic() with UACCESS enabled”。
2.1 在编译时会使用objtool，在举行validate_call函数时会举行UACCESS使能的检查

如下图可以看到，在objtool的源码里，有对指令举行uaccess的验证，假如当前这条指令不是uaccess安全的话，会举行报错：

编译时是可以获悉当前是否在代码里使用了stac这样的打开内核态代码访问用户态数据的管控。
2.2 memcpy里会举行检查，假如检查不外会触发fortify_panic

在objdump -S导出的vmlinux.txt里，可以搜到如下判断和触发fortify_panic的逻辑：

上图里的代码：
if ((p_size != SIZE_MAX && p_size < size) ||
源码里就一处：

是在fortify-string.h里的fortify_memcpy_chk函数里：

而fortify_memcpy_chk函数是在__fortify_memcpy_chk里使用到：

是在fortify-string.h里定义了memcpy，使用到了上图里的__fortify_memcpy_chk宏：

三、stac和clac会写EFLAGS

我们知道x86下的EFLAGS在做上下文切换时会举行生存和规复。内核里是用pt_regs这个结构体来生存和规复上下文切换时所必要的prev和next的寄存器。有关pt_regs的更多的细节介绍，见之前的博客 监测各个核上cpu上的线程是内核线程还是用户线程，处于内核态还是用户态的方法_怎么查看线程是用户tai还是内核态-CSDN博客里的 3.1 一节。
下面 3.1 一节，我们先贴出测试源码和测试情况，在 3.2 一节里举行干系分析。
3.1 测试源码和测试结果

3.1.1 测试用的内核模块源码

这一节的内核模块源码是改写自 内核态代码直接使用用户态数据的注意事项-CSDN博客 博客里的 2.1 一节。

1. #include <linux/module.h>
2. #include <linux/capability.h>
3. #include <linux/sched.h>
4. #include <linux/uaccess.h>
5. #include <linux/proc_fs.h>
6. #include <linux/ctype.h>
7. #include <linux/seq_file.h>
8. #include <linux/poll.h>
9. #include <linux/types.h>
10. #include <linux/ioctl.h>
11. #include <linux/errno.h>
12. #include <linux/stddef.h>
13. #include <linux/lockdep.h>
14. #include <linux/kthread.h>
15. #include <linux/sched.h>
16. #include <linux/delay.h>
17. #include <linux/wait.h>
18. #include <linux/init.h>
19. #include <asm/atomic.h>
20. #include <trace/events/workqueue.h>
21. #include <linux/sched/clock.h>
22. #include <linux/string.h>
23. #include <linux/mm.h>
24. #include <linux/interrupt.h>
25. #include <linux/tracepoint.h>
26. #include <trace/events/osmonitor.h>
27. #include <trace/events/sched.h>
28. #include <trace/events/irq.h>
29. #include <trace/events/kmem.h>
30. #include <linux/ptrace.h>
31. #include <linux/uaccess.h>
32. #include <asm/processor.h>
33. #include <linux/sched/task_stack.h>
34. #include <linux/nmi.h>
35. #include <asm/apic.h>
36. #include <linux/version.h>
37. #include <linux/sched/mm.h>
38. #include <asm/irq_regs.h>
39. #include <linux/kallsyms.h>
40. #include <linux/kprobes.h>
42. #include <linux/stop_machine.h>
44. MODULE_LICENSE("GPL");
45. MODULE_AUTHOR("zhaoxin");
46. MODULE_DESCRIPTION("Module for debug pf error code tasks.");
47. MODULE_VERSION("1.0");
49. #define TESTPFERRORCODE_NODE_TYPEMAGIC    0x73
50. #define TESTPFERRORCODE_IO_BASE           0x10
52. char _testmem[102400];
54. typedef struct testpferrorcode_ioctl_memcpy {
55.     void* memstart;
56.     int memsize;
57. } testpferrorcode_ioctl_memcpy;
59. #define TESTPFERRORCODE_IOCTL_MEMCPY  \
60.     _IOWR(TESTPFERRORCODE_NODE_TYPEMAGIC, TESTPFERRORCODE_IO_BASE + 1, testpferrorcode_ioctl_memcpy)
62. unsigned long get_eflags(void) {
63.     unsigned long eflags;
64.     asm volatile (
65.         "pushf\n\t"         // 将 EFLAGS 压入栈
66.         "pop %0\n\t"        // 将 EFLAGS 弹出到 eflags 变量
67.         : "=r" (eflags)     // 输出约束，eflags 变量作为输出
68.         :                    // 没有输入
69.         :                    // 没有被修改的寄存器
70.     );
71.     return eflags;
72. }
74. static long testpferrorcode_proc_ioctl(struct file *i_pfile, u32 i_cmd, long unsigned int i_arg)
75. {
76.     switch (i_cmd) {
77.         case TESTPFERRORCODE_IOCTL_MEMCPY:
78.             {
79.                 void __user* parg = (void __user*)i_arg;
80.                 testpferrorcode_ioctl_memcpy mem;
81.                 if (copy_from_user(&mem, parg, sizeof(mem))) {
82.                     printk("copy_from_user failed\n");
83.                     return -EFAULT;
84.                 }
85.                
86.                 {
87.                     unsigned long eflags = get_eflags();
88.                     printk("before stac eflags=0x%llx\n", eflags);
89.                 }
90.                
91.                 stac();
93.                 {
94.                     unsigned long eflags = get_eflags();
95.                     printk("after stac eflags=0x%llx\n", eflags);
96.                 }
98.                 {
99.                     printk("before run memcpy\n");
100.                     for (int i = 0; i < mem.memsize; i++) {
101.                         *(_testmem + i) = *((char*)(mem.memstart + i));
102.                     }
103.                     printk("after run memcpy\n");
104.                 }
105.                 //memcpy(_testmem, mem.memstart, mem.memsize);
106.                
107.                 clac();
108.                 printk("after clac()\n");
109.                 return 0;
110.             }
111.         default:
112.             return -EINVAL;
113.     }
114.     return 0;
115. }
117. static int testpferrorcode_proc_open(struct inode *i_pinode, struct file *i_pfile)
118. {
119.         return 0;
120. }
122. static int testpferrorcode_proc_release(struct inode *i_inode, struct file *i_file)
123. {
124.     return 0;
125. }
127. typedef struct testpferrorcode_env {
128.     struct proc_dir_entry*      testpferrorcode;
129. } testpferrorcode_env;
131. static testpferrorcode_env _env;
133. static const struct proc_ops testpferrorcode_proc_ops = {
134.     .proc_read = NULL,
135.     .proc_write = NULL,
136.     .proc_open = testpferrorcode_proc_open,
137.     .proc_release = testpferrorcode_proc_release,
138.     .proc_ioctl = testpferrorcode_proc_ioctl,
139. };
141. #define PROC_TESTPFERRORCODE_NAME "testpferrorcode"
143. static int __init testpferrorcode_init(void)
144. {
145.     _env.testpferrorcode = proc_create(PROC_TESTPFERRORCODE_NAME, 0666, NULL, &testpferrorcode_proc_ops);
146.     return 0;
147. }
149. static void __exit testpferrorcode_exit(void)
150. {
151.     remove_proc_entry(PROC_TESTPFERRORCODE_NAME, NULL);
152. }
154. module_init(testpferrorcode_init);
155. module_exit(testpferrorcode_exit);

复制代码

3.1.2 上层的测试步伐

这一节的上层测试代码是改写自 内核态代码直接使用用户态数据的注意事项-CSDN博客 博客里的 2.2 一节。

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <unistd.h>
4. #include <sys/mman.h>
5. #include <sys/stat.h>
6. #include <fcntl.h>
7. #include <string.h>
8. #include <sys/types.h>
9. #include <sys/socket.h>
10. #include <sys/un.h>
11. #include <unistd.h>
12. #include <string.h>
13. #include <iostream>
14. #include <sys/types.h>
15. #include <sys/ioctl.h>
17. using namespace std;
19. #define TESTPFERRORCODE_NODE_TYPEMAGIC    0x73
20. #define TESTPFERRORCODE_IO_BASE           0x10
22. typedef struct testpferrorcode_ioctl_memcpy {
23.     void* memstart;
24.     int memsize;
25. } testpferrorcode_ioctl_memcpy;
27. #define TESTPFERRORCODE_IOCTL_MEMCPY  \
28.     _IOWR(TESTPFERRORCODE_NODE_TYPEMAGIC, TESTPFERRORCODE_IO_BASE + 1, testpferrorcode_ioctl_memcpy)
30. int main(int i_argc, char* i_argv[]) {
31.     if (i_argc != 2) {
32.         printf("should be two parameters!\n");
33.         return -1;
34.     }
35.     int convertfd = open("/proc/testpferrorcode", O_RDWR);
36.     testpferrorcode_ioctl_memcpy mem;
37.     int size = atoi(i_argv[1]);
38.     if (size == 4) {
39.         int testa = 3;
40.         int testsize = sizeof(testa);
41.         mem.memstart = &testa;
42.         mem.memsize = testsize;
43.     }
44.     else {
45.         printf("size=%d\n", size);
46.         mem.memstart = malloc(size);
47.         printf("memstart=0x%llx\n", mem.memstart);
48.         //memset(mem.memstart, 0, size);
49.         mem.memsize = size;
50.     }
51.     if (ioctl(convertfd, TESTPFERRORCODE_IOCTL_MEMCPY, &mem) < 0) {
52.         perror("ioctl");
53.         return 0;
54.     }
55.     return 1;
56. }

复制代码

3.1.3 测试步骤和测试结果

测试步骤是先insmod 3.1.1 里编出后的ko：

然后运行 3.1.2 里编出的步伐，执行方式如下：

看dmesg里的日志里下图里的赤色框里的部门：

可以看到在执行stac前后，eflags的值是有变更的。

3.2 原理分析

3.2.1 eflags的获取方法

eflags是x86下的一个寄存器，是状态标志寄存器。可以通过如下方法来获取eflags的值：

如上图，逻辑还是比较简单的，即通过pushf把eflags压入栈，然后再通过pop弹出它的值到一个寄存器里，作为函数返回值返回。
3.2.2 stac和clac会写EFLAGS的bit18

如下图的dmesg打印可以看到stac是写的EFLAGS的bit18（0x246->0x40246）：

改写的是下图里的赤色框出的bit位（下图是取自资源 https://download.csdn.net/download/weixin_42766184/90348566?spm=1001.2014.3001.5503 的文档）：

bit18也叫做EFLAGS.AC：

该EFLAGS.AC与SMAP功能的干系解释如下：

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。