/proc/kallsyms#

/proc/kallsyms是一个符号表，它包含了内核中所有的符号信息，包括函数、变量、常量等等。这些符号信息可以被内核模块和其他程序使用，这些符号类型可以帮助开发人员更好地理解内核中的符号信息，从而更好地进行内核开发和调试。

与 System.map 相比，/proc/kallsyms 是动态的，其包含了内核模块的符号地址

格式为 addr | type | symbol | [module name]

type的定义

T：表示该符号是一个函数，可以被其他代码调用。

t：表示该符号是一个局部函数，只能在当前文件中使用。

D：表示该符号是一个全局变量，可以被其他代码访问和修改。

d：表示该符号是一个局部变量，只能在当前文件中使用。

R：表示该符号是一个只读变量，不能被修改。

r：表示该符号是一个只读局部变量，只能在当前文件中使用。

A：表示该符号是一个可读写的变量，可以被其他代码访问和修改。

a：表示该符号是一个可读写的局部变量，只能在当前文件中使用。

B：表示该符号是一个未初始化的全局变量，它的值在程序启动时被初始化为0。

b：表示该符号是一个未初始化的局部变量，它的值在程序启动时被初始化为0。

G：表示该符号是一个全局变量，但是它的值在程序运行时可能会被修改。

C：表示该符号是一个常量，它的值在程序运行时不能被修改。

W：表示该符号是一个弱符号，

?: 表示该符号的类型未知。

/proc/sys/kernel/kptr_restrict#

linux-kernel/Documentation/sysctl/kernel.txt at master · tinganho/linux-kernel

kptr_restrict:

This toggle indicates whether restrictions are placed on
exposing kernel addresses via /proc and other interfaces. When
kptr_restrict is set to (0), there are no restrictions. When
kptr_restrict is set to (1), the default, kernel pointers
printed using the %pK format specifier will be replaced with 0’s
unless the user has CAP_SYSLOG. When kptr_restrict is set to
(2), kernel pointers printed using %pK will be replaced with 0’s
regardless of privileges.

kptr_restrict	输出(在能访问/proc/kallsyms的前提下)
0	任何用户读取kallsyms都输出addr
1	拥有`CAP_SYSLOG` 权能的用户可以输出addr
2	任何用户读取kallsyms输出的addr均为0

上文中的截图 addr 输出为0就是因为 kptr_restrict 的值被设置为2

设置为1或0即可读取addr

ksuinit#

KernelSU/userspace/ksuinit/src/loader.rs at main · tiann/KernelSU

1
use anyhow::{Context, Result};
2
use goblin::elf::{Elf, section_header, sym::Sym};
3
use rustix::{cstr, system::init_module};
4
use scroll::{Pwrite, ctx::SizeWith};
5
use std::collections::HashMap;
6
use std::fs;
7

8
struct Kptr {
9
    value: String,
10
}
11

12
impl Kptr {
13
    pub fn new() -> Result<Self> {
14
        let value = fs::read_to_string("/proc/sys/kernel/kptr_restrict")?;
15
        fs::write("/proc/sys/kernel/kptr_restrict", "1")?;
16
        Ok(Kptr { value })
17
    }
18
}
19

20
impl Drop for Kptr {
21
    fn drop(&mut self) {
22
        let _ = fs::write("/proc/sys/kernel/kptr_restrict", self.value.as_bytes());
23
    }
24
}
25

26
fn parse_kallsyms() -> Result<HashMap<String, u64>> {
27
    let _dontdrop = Kptr::new()?;
28

29
    let allsyms = fs::read_to_string("/proc/kallsyms")?
30
        .lines()
31
        .map(|line| line.split_whitespace())
32
        .filter_map(|mut splits| {
33
            splits
34
                .next()
35
                .and_then(|addr| u64::from_str_radix(addr, 16).ok())
36
                .and_then(|addr| splits.nth(1).map(|symbol| (symbol, addr)))
37
        })
38
        .map(|(symbol, addr)| {
39
            (
40
                symbol
41
                    .find("$")
42
                    .or_else(|| symbol.find(".llvm."))
43
                    .map_or(symbol, |pos| &symbol[0..pos])
44
                    .to_owned(),
45
                addr,
46
            )
47
        })
48
        .collect::<HashMap<_, _>>();
49

50
    Ok(allsyms)
51
}
52

53
pub fn load_module(path: &str) -> Result<()> {
54
    // check if self is init process(pid == 1)
55
    if !rustix::process::getpid().is_init() {
56
        anyhow::bail!("{}", "Invalid process");
57
    }
58

59
    let mut buffer = fs::read(path).with_context(|| format!("Cannot read file {}", path))?;
60
    let elf = Elf::parse(&buffer)?;
61

62
    let kernel_symbols = parse_kallsyms().context("Cannot parse kallsyms")?;
63

64
    let mut modifications = Vec::new();
65
    for (index, mut sym) in elf.syms.iter().enumerate() {
66
        if index == 0 {
67
            continue;
68
        }
69

70
        if sym.st_shndx != section_header::SHN_UNDEF as usize {
71
            continue;
72
        }
73

74
        let Some(name) = elf.strtab.get_at(sym.st_name) else {
75
            continue;
76
        };
77

78
        let offset = elf.syms.offset() + index * Sym::size_with(elf.syms.ctx());
79
        let Some(real_addr) = kernel_symbols.get(name) else {
80
            log::warn!("Cannot find symbol: {}", &name);
81
            continue;
82
        };
83
        sym.st_shndx = section_header::SHN_ABS as usize;
84
        sym.st_value = *real_addr;
85
        modifications.push((sym, offset));
86
    }
87

88
    let ctx = *elf.syms.ctx();
89
    for ele in modifications {
90
        buffer.pwrite_with(ele.0, ele.1, ctx)?;
91
    }
92
    init_module(&buffer, cstr!("")).context("init_module failed.")?;
93
    Ok(())
94
}