编写字符设备驱动时不可忽视的内核态与用户态数据拷贝的安全风险

Wu QiangFei 2026-08-05 12:36

一、编写字符设备驱动的基础认知

1.1 什么是字符设备驱动

在操作系统里，设备驱动就像是设备和操作系统之间的桥梁。字符设备驱动呢，主要负责和那些按字符流方式处理数据的设备打交道，像键盘、鼠标、串口这些。简单来说，它就是让操作系统能够和这些设备顺畅交流的程序。

1.2 内核态与用户态

操作系统有内核态和用户态这两种运行模式。内核态就像是系统的“大管家”，拥有最高的权限，可以访问系统的所有资源，执行一些关键的操作。而用户态权限就比较小，只能访问自己的资源。编写字符设备驱动时，经常要在这两个状态之间进行数据拷贝。

1.3 为什么需要数据拷贝

举个例子，当我们在键盘上敲入一个字符时，键盘设备通过字符设备驱动把数据从硬件传输到内核态。但是我们运行的应用程序是在用户态，这就需要把内核态的数据拷贝到用户态，这样应用程序才能使用这些数据。反过来，应用程序要向设备发送数据时，也要把用户态的数据拷贝到内核态。

二、数据拷贝的方式及原理

2.1 copy_to_user 函数

在 Linux 内核中，copy_to_user 函数用于把内核态的数据拷贝到用户态。下面是一个简单的示例：

#include <linux/module.h>
#include <linux/fs.h>
#include <asm/uaccess.h>

static ssize_t my_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
{
    char kernel_data[] = "Hello from kernel!";
    size_t len = sizeof(kernel_data);

    // 将内核数据复制到用户空间
    if (copy_to_user(buf, kernel_data, len)) {
        return -EFAULT;
    }

    return len;
}

static struct file_operations my_fops = {
    .read = my_read,
};

static int __init my_init(void)
{
    register_chrdev(77, "my_device", &my_fops);
    return 0;
}

static void __exit my_exit(void)
{
    unregister_chrdev(77, "my_device");
}

module_init(my_init);
module_exit(my_exit);
MODULE_LICENSE("GPL");

这个示例里，copy_to_user 函数尝试把内核中的 kernel_data 数组复制到用户空间的 buf 中。如果拷贝失败，函数会返回非零值，这里就返回 -EFAULT 表示出错。

2.2 copy_from_user 函数

copy_from_user 函数则是把用户态的数据拷贝到内核态。看下面这个例子：

#include <linux/module.h>
#include <linux/fs.h>
#include <asm/uaccess.h>

static ssize_t my_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos)
{
    char kernel_buf[100];

    // 从用户空间复制数据到内核空间
    if (copy_from_user(kernel_buf, buf, count)) {
        return -EFAULT;
    }

    printk(KERN_INFO "Received data from user: %s\n", kernel_buf);

    return count;
}

static struct file_operations my_fops = {
    .write = my_write,
};

static int __init my_init(void)
{
    register_chrdev(78, "my_device", &my_fops);
    return 0;
}

static void __exit my_exit(void)
{
    unregister_chrdev(78, "my_device");
}

module_init(my_init);
module_exit(my_exit);
MODULE_LICENSE("GPL");

这里，copy_from_user 函数把用户空间的 buf 中的数据复制到内核空间的 kernel_buf 中。如果拷贝失败，同样返回 -EFAULT。

三、数据拷贝的安全风险及案例分析

3.1 越界访问风险

在数据拷贝时，如果没有正确检查用户传递的数据长度，就可能发生越界访问。比如：

#include <linux/module.h>
#include <linux/fs.h>
#include <asm/uaccess.h>

#define BUFFER_SIZE 10

static ssize_t my_bad_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos)
{
    char kernel_buf[BUFFER_SIZE];

    // 未检查长度，可能越界
    copy_from_user(kernel_buf, buf, count);

    printk(KERN_INFO "Received data from user: %s\n", kernel_buf);

    return count;
}

static struct file_operations my_fops = {
    .write = my_bad_write,
};

static int __init my_init(void)
{
    register_chrdev(79, "my_device", &my_fops);
    return 0;
}

static void __exit my_exit(void)
{
    unregister_chrdev(79, "my_device");
}

module_init(my_init);
module_exit(my_exit);
MODULE_LICENSE("GPL");

当用户传递的数据长度超过 BUFFER_SIZE 时，就会导致越界访问，可能破坏内核中的其他数据，引发系统崩溃。

3.2 空指针风险

如果用户传递的指针为空，而在进行数据拷贝时没有检查，也会出现问题。示例如下：

#include <linux/module.h>
#include <linux/fs.h>
#include <asm/uaccess.h>

static ssize_t my_null_ptr_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos)
{
    char kernel_buf[100];

    // 未检查指针是否为空
    copy_from_user(kernel_buf, buf, count);

    printk(KERN_INFO "Received data from user: %s\n", kernel_buf);

    return count;
}

static struct file_operations my_fops = {
    .write = my_null_ptr_write,
};

static int __init my_init(void)
{
    register_chrdev(80, "my_device", &my_fops);
    return 0;
}

static void __exit my_exit(void)
{
    unregister_chrdev(80, "my_device");
}

module_init(my_init);
module_exit(my_exit);
MODULE_LICENSE("GPL");

当 buf 为空指针时，copy_from_user 函数会尝试从空指针处拷贝数据，这会导致内核崩溃。

3.3 竞争条件风险

在多线程或者多进程环境下，数据拷贝可能会出现竞争条件。比如多个线程同时对同一个内核缓冲区进行读写操作。看下面的例子：

#include <linux/module.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
#include <linux/semaphore.h>

static char kernel_buf[100];
static struct semaphore sem;

static ssize_t my_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos)
{
    // 未加锁保护
    copy_from_user(kernel_buf, buf, count);

    printk(KERN_INFO "Received data from user: %s\n", kernel_buf);

    return count;
}

static ssize_t my_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
{
    // 未加锁保护
    copy_to_user(buf, kernel_buf, sizeof(kernel_buf));

    return sizeof(kernel_buf);
}

static struct file_operations my_fops = {
    .write = my_write,
    .read = my_read,
};

static int __init my_init(void)
{
    sema_init(&sem, 1);
    register_chrdev(81, "my_device", &my_fops);
    return 0;
}

static void __exit my_exit(void)
{
    unregister_chrdev(81, "my_device");
}

module_init(my_init);
module_exit(my_exit);
MODULE_LICENSE("GPL");

这里没有对 kernel_buf 进行加锁保护，当多个线程同时进行读写操作时，可能会导致数据混乱。

四、应对安全风险的措施

4.1 长度检查

在进行数据拷贝前，要检查用户传递的数据长度是否合法。修改前面的越界访问示例代码如下：

#include <linux/module.h>
#include <linux/fs.h>
#include <asm/uaccess.h>

#define BUFFER_SIZE 10

static ssize_t my_safe_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos)
{
    char kernel_buf[BUFFER_SIZE];

    if (count > BUFFER_SIZE) {
        count = BUFFER_SIZE;
    }

    if (copy_from_user(kernel_buf, buf, count)) {
        return -EFAULT;
    }

    printk(KERN_INFO "Received data from user: %s\n", kernel_buf);

    return count;
}

static struct file_operations my_fops = {
    .write = my_safe_write,
};

static int __init my_init(void)
{
    register_chrdev(82, "my_device", &my_fops);
    return 0;
}

static void __exit my_exit(void)
{
    unregister_chrdev(82, "my_device");
}

module_init(my_init);
module_exit(my_exit);
MODULE_LICENSE("GPL");

这样，当用户传递的数据长度超过 BUFFER_SIZE 时，会把长度截断为 BUFFER_SIZE，避免越界访问。

4.2 指针检查

在进行数据拷贝前，要检查用户传递的指针是否为空。修改前面的空指针示例代码如下：

#include <linux/module.h>
#include <linux/fs.h>
#include <asm/uaccess.h>

static ssize_t my_safe_null_ptr_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos)
{
    char kernel_buf[100];

    if (buf == NULL) {
        return -EINVAL;
    }

    if (copy_from_user(kernel_buf, buf, count)) {
        return -EFAULT;
    }

    printk(KERN_INFO "Received data from user: %s\n", kernel_buf);

    return count;
}

static struct file_operations my_fops = {
    .write = my_safe_null_ptr_write,
};

static int __init my_init(void)
{
    register_chrdev(83, "my_device", &my_fops);
    return 0;
}

static void __exit my_exit(void)
{
    unregister_chrdev(83, "my_device");
}

module_init(my_init);
module_exit(my_exit);
MODULE_LICENSE("GPL");

当 buf 为空指针时，直接返回 -EINVAL，避免内核崩溃。

4.3 同步机制

在多线程或者多进程环境下，要使用同步机制来避免竞争条件。修改前面的竞争条件示例代码如下：

#include <linux/module.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
#include <linux/semaphore.h>

static char kernel_buf[100];
static struct semaphore sem;

static ssize_t my_safe_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos)
{
    if (down_interruptible(&sem)) {
        return -ERESTARTSYS;
    }

    if (copy_from_user(kernel_buf, buf, count)) {
        up(&sem);
        return -EFAULT;
    }

    printk(KERN_INFO "Received data from user: %s\n", kernel_buf);

    up(&sem);
    return count;
}

static ssize_t my_safe_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
{
    if (down_interruptible(&sem)) {
        return -ERESTARTSYS;
    }

    if (copy_to_user(buf, kernel_buf, sizeof(kernel_buf))) {
        up(&sem);
        return -EFAULT;
    }

    up(&sem);
    return sizeof(kernel_buf);
}

static struct file_operations my_fops = {
    .write = my_safe_write,
    .read = my_safe_read,
};

static int __init my_init(void)
{
    sema_init(&sem, 1);
    register_chrdev(84, "my_device", &my_fops);
    return 0;
}

static void __exit my_exit(void)
{
    unregister_chrdev(84, "my_device");
}

module_init(my_init);
module_exit(my_exit);
MODULE_LICENSE("GPL");

这里使用了信号量 sem 来保护 kernel_buf，保证同一时间只有一个线程可以对其进行读写操作。

五、应用场景

5.1 嵌入式系统

在嵌入式系统中，常常需要和各种外设进行交互，比如传感器、显示屏等。字符设备驱动在其中起着关键作用，通过数据拷贝实现用户程序和外设之间的数据传输。例如，一个温度传感器通过字符设备驱动把采集到的温度数据从内核态传输到用户态的应用程序中，供用户查看。

5.2 网络设备

网络设备驱动也会涉及到内核态和用户态的数据拷贝。当网络设备接收到数据包时，数据首先进入内核态，然后通过字符设备驱动把数据拷贝到用户态的网络应用程序中进行处理。

六、技术优缺点

6.1 优点

灵活性高：通过数据拷贝，可以方便地实现用户态和内核态之间的数据交互，让应用程序能够使用内核中的数据，也可以让内核处理用户程序传递的数据。
兼容性好：copy_to_user 和 copy_from_user 函数是 Linux 内核提供的标准接口，具有很好的兼容性，不同的设备驱动都可以使用。

6.2 缺点

性能开销：数据拷贝需要在内核态和用户态之间进行数据的复制，会有一定的性能开销，尤其是在频繁进行数据拷贝的场景下。
安全风险：如果没有正确处理，就会存在越界访问、空指针引用、竞争条件等安全风险，可能导致系统崩溃或者数据泄露。

七、注意事项

7.1 错误处理

在使用 copy_to_user 和 copy_from_user 函数时，一定要处理好返回值。当函数返回非零值时，表示拷贝失败，要进行相应的错误处理。

7.2 内存管理

在使用内核缓冲区时，要注意内存管理，避免内存泄漏。当不再使用缓冲区时，要及时释放内存。

八、文章总结

编写字符设备驱动时，内核态与用户态的数据拷贝是非常重要的一个环节，但也存在着各种安全风险，比如越界访问、空指针引用和竞争条件等。为了确保系统的安全稳定运行，我们需要采取一系列的措施，如进行长度检查、指针检查和使用同步机制等。在实际应用中，要根据具体的场景选择合适的方法，同时要注意错误处理和内存管理等问题。只有这样，才能编写出安全可靠的字符设备驱动程序。

围绕“编写字符设备驱动时不可忽视的内核态与用户态数据拷贝的安全风险”参与讨论

0 条

编写字符设备驱动时不可忽视的内核态与用户态数据拷贝的安全风险

一、编写字符设备驱动的基础认知

1.1 什么是字符设备驱动

1.2 内核态与用户态

1.3 为什么需要数据拷贝

二、数据拷贝的方式及原理

2.1 copy_to_user 函数

2.2 copy_from_user 函数

三、数据拷贝的安全风险及案例分析

3.1 越界访问风险

3.2 空指针风险

3.3 竞争条件风险

四、应对安全风险的措施

4.1 长度检查

4.2 指针检查

4.3 同步机制

五、应用场景

5.1 嵌入式系统

5.2 网络设备

六、技术优缺点

6.1 优点

6.2 缺点

七、注意事项

7.1 错误处理

7.2 内存管理

八、文章总结

评论

关联文章

AI助手

一、编写字符设备驱动的基础认知

1.1 什么是字符设备驱动

1.2 内核态与用户态

1.3 为什么需要数据拷贝

二、数据拷贝的方式及原理

2.1 copy_to_user 函数

2.2 copy_from_user 函数

三、数据拷贝的安全风险及案例分析

3.1 越界访问风险

3.2 空指针风险

3.3 竞争条件风险

四、应对安全风险的措施

4.1 长度检查

4.2 指针检查

4.3 同步机制

五、应用场景

5.1 嵌入式系统

5.2 网络设备

六、技术优缺点

6.1 优点

6.2 缺点

七、注意事项

7.1 错误处理

7.2 内存管理

八、文章总结

同分类面试题

关联文章

AI助手