乐于分享
好东西不私藏
当前位置：夜雨聆风 > 技术教程 > 软件教程 > 跨平台系统信息获取库libsigar源码分析系列(六)

跨平台系统信息获取库libsigar源码分析系列(六)

当前时间： 2026-03-17 15:09:48 分类：软件教程 评论(0)

跨平台系统信息获取库libsigar源码分析系列(六)

官网：http://securitytech.cc

源码分析mettle后门工具学习 所使用的依赖库

官网：http://securitytech.cc

OpenBSD 分支源码分析

概述

OpenBSD 是一个专注于安全性、代码正确性和可移植性的免费开源 UNIX 操作系统。libsigar 在 OpenBSD 平台的实现与 FreeBSD 有很高的相似性,主要使用 sysctl 系统调用和 kvm 库来获取系统信息,并提供了 /proc 文件系统的可选支持。

核心架构

1. sigar_t 结构体扩展

  1. structsigar_t{
  2.     SIGAR_T_BASE;// 基础结构
  3. int pagesize;// 页面大小
  4. time_t last_getprocs;// 最后一次获取进程信息的时间
  5. sigar_pid_t last_pid;// 最后查询的 PID
  6. bsd_pinfo_t*pinfo;// 进程信息缓存 (kinfo_proc)
  7. int lcpu;// 最后访问的 CPU
  8. size_t argmax;// 参数最大长度
  9. kvm_t*kmem;// kvm 库句柄
  10. unsignedlong koffsets[KOFFSET_MAX];// 内核符号偏移量
  11. int proc_mounted;// /proc 是否挂载
  12. };

2. 内核符号偏移量枚举

  1. enum{
  2.     KOFFSET_CPUINFO,// cp_time
  3.     KOFFSET_VMMETER,// cnt
  4.     KOFFSET_TCPSTAT,// tcpstat
  5.     KOFFSET_TCBTABLE,// tcbtable
  6.     KOFFSET_MAX
  7. };

这些偏移量通过 kvm_nlist 从内核符号表中解析,用于直接读取内核数据。

3. 核心数据类型

  1. typedefstruct kinfo_proc bsd_pinfo_t;

使用标准的 BSD 进程信息结构体。

核心技术

1. sysctl 系统调用

OpenBSD 主要通过 sysctl 获取系统信息:

  1. int mib[2];
  2. size_t len;
  4. // 获取 CPU 数量
  5. mib[0]= CTL_HW;
  6. mib[1]= HW_NCPU;
  7. sysctl(mib, NMIB(mib),&ncpu,&len, NULL,0);
  9. // 获取内存大小
  10. mib[1]= HW_PHYSMEM;
  11. sysctl(mib, NMIB(mib),&mem_total,&len, NULL,0);
  13. // 获取页面大小
  14. mib[1]= HW_PAGESIZE;
  15. sysctl(mib, NMIB(mib),&pagesize,&len, NULL,0);
  17. // 获取启动时间
  18. mib[0]= CTL_KERN;
  19. mib[1]= KERN_BOOTTIME;
  20. sysctl(mib, NMIB(mib),&boottime,&len, NULL,0);

2. kvm 库内核访问

用于访问内核内存和获取进程信息:

  1. kvm_t*kmem = kvm_openfiles(NULL, NULL, NULL, KVM_NO_FILES, NULL);
  3. // 获取所有进程
  4. struct kinfo_proc *proc = kvm_getprocs(kmem, KERN_PROC_ALL,0,
  5. sizeof(*proc),&num);
  7. // 读取内核数据
  8. kvm_read(kmem, offset, data, size);

3. 内核符号解析

  1. staticint get_koffsets(sigar_t*sigar)
  2. {
  3. struct nlist klist[]={
  4. {"_cp_time"},// CPU 时间
  5. {"_cnt"},// 虚拟内存统计
  6. {"_tcpstat"},// TCP 统计
  7. {"_tcbtable"},// TCP 控制块表
  8. { NULL }
  9. };
  11.     kvm_nlist(sigar->kmem, klist);
  13. for(i =0; i < KOFFSET_MAX; i++){
  14.         sigar->koffsets[i]= klist[i].n_value;
  15. }
  16. }

4. 内核数据读取

  1. staticint kread(sigar_t*sigar,void*data,int size,long offset)
  2. {
  3. if(!sigar->kmem){
  4. return SIGAR_EPERM_KMEM;
  5. }
  7. if(kvm_read(sigar->kmem, offset, data, size)!= size){
  8. return errno;
  9. }
  11. return SIGAR_OK;
  12. }

5. 进程信息缓存

  1. staticint sigar_get_pinfo(sigar_t*sigar,sigar_pid_t pid)
  2. {
  3. int mib[]={ CTL_KERN, KERN_PROC, KERN_PROC_PID,0,
  4. sizeof(*sigar->pinfo),1};
  5. size_t len =sizeof(*sigar->pinfo);
  6. time_t timenow = time(NULL);
  7.     mib[3]= pid;
  9. if(sigar->pinfo == NULL){
  10.         sigar->pinfo = malloc(len);
  11. }
  13. // 60 秒缓存
  14. if(sigar->last_pid == pid){
  15. if((timenow - sigar->last_getprocs)< SIGAR_LAST_PROC_EXPIRE){
  16. return SIGAR_OK;
  17. }
  18. }
  20.     sigar->last_pid = pid;
  21.     sigar->last_getprocs = timenow;
  23. return sysctl(mib, NMIB(mib), sigar->pinfo,&len, NULL,0);
  24. }

6. /proc 可选支持

  1. #define PROCFS_STATUS(status) \
  2. ((((status)!= SIGAR_OK)&&!sigar->proc_mounted)? \
  3.      SIGAR_ENOTIMPL : status)
  5. int sigar_os_open(sigar_t**sigar)
  6. {
  7. struct stat sb;
  9. if(stat("/proc/curproc",&sb)<0){
  10. (*sigar)->proc_mounted =0;
  11. }else{
  12. (*sigar)->proc_mounted =1;
  13. }
  14. }

核心功能模块

1. 内存监控

  1. int sigar_mem_get(sigar_t*sigar,sigar_mem_t*mem)
  2. {
  3. int mib[2];
  4. size_t len;
  5. struct uvmexp vmstat;
  6. sigar_uint64_t kern =0;
  8. // 页面大小
  9.     mib[0]= CTL_HW;
  10.     mib[1]= HW_PAGESIZE;
  11.     sysctl(mib, NMIB(mib),&sigar->pagesize,&len, NULL,0);
  13. // 物理内存总量
  14.     mib[1]= HW_PHYSMEM;
  15.     sysctl(mib, NMIB(mib),&mem_total,&len, NULL,0);
  16.     mem->total = mem_total;
  18. // 虚拟内存统计
  19.     sigar_vmstat(sigar,&vmstat);
  21.     mem->free = vmstat.free;
  22.     kern = vmstat.inactive;
  23.     kern += vmstat.vnodepages + vmstat.vtextpages;
  24.     kern *= sigar->pagesize;
  26.     mem->used = mem->total - mem->free;
  27.     mem->actual_free = mem->free + kern;
  28.     mem->actual_used = mem->used - kern;
  30.     sigar_mem_calc_ram(sigar, mem);
  31. }

2. 交换空间监控

  1. int sigar_swap_get(sigar_t*sigar,sigar_swap_t*swap)
  2. {
  3. struct uvmexp vmstat;
  5.     sigar_vmstat(sigar,&vmstat);
  7.     swap->total = vmstat.swpages * sigar->pagesize;
  8.     swap->used = vmstat.swpginuse * sigar->pagesize;
  9.     swap->free = swap->total - swap->used;
  10.     swap->page_in = vmstat.pageins;
  11.     swap->page_out = vmstat.pdpageouts;
  12. }

3. CPU 监控

总体 CPU 统计

  1. int sigar_cpu_get(sigar_t*sigar,sigar_cpu_t*cpu)
  2. {
  3. cp_time_t cp_time[CPUSTATES];
  4. int mib[]={ CTL_KERN, KERN_CPTIME };
  5. size_t size =sizeof(cp_time);
  7.     sysctl(mib, NMIB(mib),&cp_time,&size, NULL,0);
  9.     cpu->user = SIGAR_TICK2MSEC(cp_time[CP_USER]);
  10.     cpu->nice = SIGAR_TICK2MSEC(cp_time[CP_NICE]);
  11.     cpu->sys  = SIGAR_TICK2MSEC(cp_time[CP_SYS]);
  12.     cpu->idle = SIGAR_TICK2MSEC(cp_time[CP_IDLE]);
  13.     cpu->wait =0;// N/A
  14.     cpu->irq = SIGAR_TICK2MSEC(cp_time[CP_INTR]);
  15.     cpu->soft_irq =0;// N/A
  16.     cpu->stolen =0;// N/A
  17.     cpu->total = cpu->user + cpu->nice + cpu->sys + cpu->idle + cpu->irq;
  18. }

CPU 列表

  1. int sigar_cpu_list_get(sigar_t*sigar,sigar_cpu_list_t*cpulist)
  2. {
  3.     sigar_cpu_list_create(cpulist);
  5. #ifdef HAVE_KERN_CP_TIMES
  6. // 支持每个 CPU 的统计
  7. if(sigar_cp_times_get(sigar, cpulist)== SIGAR_OK){
  8. return SIGAR_OK;
  9. }
  10. #endif
  12. // 旧版本: 所有指标在第 1 个 CPU,其余为 0
  13.     sigar_cpu_get(sigar,&cpulist->data[cpulist->number++]);
  15. for(i =1; i < sigar->ncpu; i++){
  16.         SIGAR_CPU_LIST_GROW(cpulist);
  17.         cpu =&cpulist->data[cpulist->number++];
  18.         SIGAR_ZERO(cpu);
  19. }
  20. }

4. 进程监控

进程列表

  1. int sigar_os_proc_list_get(sigar_t*sigar,sigar_proc_list_t*proclist)
  2. {
  3. struct kinfo_proc *proc;
  4. int num;
  6. if(!sigar->kmem){
  7. return SIGAR_EPERM_KMEM;
  8. }
  10.     proc = kvm_getprocs(sigar->kmem, KERN_PROC_ALL,0,
  11. sizeof(*proc),&num);
  13. for(i =0; i < num; i++){
  14. // 跳过系统进程和 PID 0
  15. if(proc[i].KI_FLAG & P_SYSTEM){
  16. continue;
  17. }
  18. if(proc[i].KI_PID ==0){
  19. continue;
  20. }
  22.         SIGAR_PROC_LIST_GROW(proclist);
  23.         proclist->data[proclist->number++]= proc[i].KI_PID;
  24. }
  25. }

进程内存

  1. int sigar_proc_mem_get(sigar_t*sigar,sigar_pid_t pid,sigar_proc_mem_t*procmem)
  2. {
  3. bsd_pinfo_t*pinfo = sigar->pinfo;
  5.     sigar_get_pinfo(sigar, pid);
  7. // 虚拟内存大小 = text + data + stack
  8.     procmem->size =
  9. (pinfo->p_vm_tsize + pinfo->p_vm_dsize + pinfo->p_vm_ssize)*
  10.         sigar->pagesize;
  12.     procmem->resident = pinfo->p_vm_rssize * sigar->pagesize;
  13.     procmem->share = SIGAR_FIELD_NOTIMPL;
  15.     procmem->minor_faults = pinfo->p_uru_minflt;
  16.     procmem->major_faults = pinfo->p_uru_majflt;
  17.     procmem->page_faults = procmem->minor_faults + procmem->major_faults;
  18. }

进程凭据

  1. int sigar_proc_cred_get(sigar_t*sigar,sigar_pid_t pid,sigar_proc_cred_t*proccred)
  2. {
  3. bsd_pinfo_t*pinfo = sigar->pinfo;
  5.     sigar_get_pinfo(sigar, pid);
  7.     proccred->uid  = pinfo->p_ruid;
  8.     proccred->gid  = pinfo->p_rgid;
  9.     proccred->euid = pinfo->p_uid;
  10.     proccred->egid = pinfo->p_gid;
  11. }

进程时间

  1. #define tv2msec(tv) \
  2. (((sigar_uint64_t)tv.tv_sec * SIGAR_MSEC)+(((sigar_uint64_t)tv.tv_usec)/1000))
  4. int sigar_proc_time_get(sigar_t*sigar,sigar_pid_t pid,sigar_proc_time_t*proctime)
  5. {
  6. bsd_pinfo_t*pinfo = sigar->pinfo;
  8.     sigar_get_pinfo(sigar, pid);
  10.     proctime->user  = tv2msec(pinfo->p_uutime);
  11.     proctime->sys   = tv2msec(pinfo->p_stime);
  12.     proctime->total = proctime->user + proctime->sys;
  13.     proctime->start_time = tv2msec(pinfo->p_ustart);
  14. }

进程状态

  1. int sigar_proc_state_get(sigar_t*sigar,sigar_pid_t pid,sigar_proc_state_t*procstate)
  2. {
  3. bsd_pinfo_t*pinfo = sigar->pinfo;
  5.     sigar_get_pinfo(sigar, pid);
  7.     SIGAR_SSTRCPY(procstate->name, pinfo->p_comm);
  8.     procstate->ppid = pinfo->p_ppid;
  9.     procstate->priority = pinfo->p_priority;
  10.     procstate->nice = pinfo->p_nice;
  11.     procstate->processor = pinfo->p_cpuid;
  13. // 状态映射
  14. switch(pinfo->p_stat){
  15. case SIDL:    procstate->state ='D';break;
  16. case SRUN:    procstate->state ='R';break;
  17. case SSLEEP:  procstate->state ='S';break;
  18. case SSTOP:   procstate->state ='T';break;
  19. case SZOMB:   procstate->state ='Z';break;
  20. case SDEAD:   procstate->state ='Z';break;
  21. }
  22. }

进程参数

OpenBSD 使用自定义的 sigar_proc_args_get 实现来获取进程参数。

技术亮点

1. 统一的 sysctl 接口

  • 所有系统信息通过 sysctl 获取
  • 结构化的 mib 数组
  • 高效的二进制接口

2. kvm 库内核访问

  • 直接访问内核内存
  • 获取完整的进程信息
  • 内核符号解析支持

3. /proc 可选支持

  • 检测 /proc 是否挂载
  • 在失败时优雅降级
  • 适应不同系统配置

4. 进程信息缓存

  • 60 秒有效期
  • 减少 sysctl 调用
  • 提高性能

5. 版本兼容性

  • KERN_CPTIME vs KERN_CP_TIME
  • HAVE_KERN_CP_TIMES 检测
  • 新旧 API 兼容

6. 与 FreeBSD 共享头文件

  1. typedefstruct kinfo_proc bsd_pinfo_t;

大量复用 FreeBSD 的代码和结构定义。

错误处理

自定义错误码

  1. #define SIGAR_EPERM_KMEM (SIGAR_OS_START_ERROR+EACCES)
  2. #define SIGAR_EPROC_NOENT (SIGAR_OS_START_ERROR+2)

错误字符串

  1. char*sigar_os_error_string(sigar_t*sigar,int err)
  2. {
  3. switch(err){
  4. case SIGAR_EPERM_KMEM:
  5. return"Failed to open /dev/kmem for reading";
  6. case SIGAR_EPROC_NOENT:
  7. return"/proc filesystem is not mounted";
  8. default:
  9. return NULL;
  10. }
  11. }

未实现功能

以下功能在 OpenBSD 上未实现:

  • sigar_sys_info_get_uuid – 系统 UUID
  • sigar_system_stats_get – 系统统计
  • sigar_proc_cumulative_disk_io_get – 进程磁盘 I/O
  • sigar_proc_env_get – 进程环境变量
  • sigar_proc_fd_get – 进程文件描述符
  • sigar_proc_exe_get – 进程可执行文件

与 FreeBSD 的区别

特性
OpenBSD
FreeBSD
进程结构
kinfo_proc
kinfo_proc
内核访问
kvm
kvm
/proc 支持
可选
完整支持
sysctl 扩展
KERN_CPTIME
KERN_CPTIME
进程过滤
P_SYSTEM 标志
无特定过滤
共享内存
自定义实现
更完整

总结

OpenBSD 分支的实现特点:

  1. 安全导向 – 严格的访问控制和错误处理
  2. sysctl 为主 – 主要通过 sysctl 获取信息
  3. kvm 辅助 – 使用 kvm 获取进程信息
  4. 兼容性强 – 与 FreeBSD 共享大量代码
  5. /proc 可选 – 不依赖 /proc 文件系统
  6. 简洁设计 – 代码清晰,易于维护
  7. 性能优化 – 进程信息缓存减少系统调用

OpenBSD 的实现体现了该系统对安全性和代码正确性的重视,同时也保持了与其他 BSD 系统的高度兼容性。

AD：【资源若失效或者不可用，请留言评论或加老夜微信 al_tmen】>>点此前往<<
本站文章均为手工撰写未经允许谢绝转载：夜雨聆风 » 跨平台系统信息获取库libsigar源码分析系列(六)

wang

猜你喜欢

  • 暂无文章