Linux Security模块

asmlinkage void __init start_kernel(void)
{
    char * command_line;
    extern const struct kernel_param __start___param[], __stop___param[];
    ...
    thread_info_cache_init();
    cred_init();
    fork_init(totalram_pages);
    proc_caches_init();
    buffer_init();
    key_init();
    security_init();
    dbg_late_init();
    vfs_caches_init(totalram_pages);
    signals_init();
    /* rootfs populating might need page-writeback */
    page_writeback_init();
#ifdef CONFIG_PROC_FS
    proc_root_init();
#endif
    cgroup_init();
    cpuset_init();
    taskstats_init_early();
    delayacct_init();

    check_bugs();

    acpi_early_init(); /* before LAPIC and SMP init */
    sfi_init_late();

    ftrace_init();

    /* Do the rest non-__init‘ed, we‘re now alive */
    rest_init();
}

/**
 * security_init - initializes the security framework
 *
 * This should be called early in the kernel initialization sequence.
 */
int __init security_init(void)
{
    printk(KERN_INFO "Security Framework initialized\n");

    security_fixup_ops(&default_security_ops);
    security_ops = &default_security_ops;
    do_security_initcalls();

    return 0;
}

static void __init do_security_initcalls(void)
{
    initcall_t *call;
    call = __security_initcall_start;
    while (call < __security_initcall_end) {
        (*call) ();
        call++;
    }
}

#define SECURITY_INITCALL \
    VMLINUX_SYMBOL(__security_initcall_start) = .;         *(.security_initcall.init)         VMLINUX_SYMBOL(__security_initcall_end) = .;

#define security_initcall(fn)     static initcall_t __initcall_##fn     __used __section(.security_initcall.init) = fn

static __init int selinux_init(void)
{
    //判断SELinux是否为配置的默认安全模块
    if (!security_module_enable(&selinux_ops)) {
        selinux_enabled = 0;
        return 0;
    }

    //如果没有配置SELinux为默认安全模块，则退出
    if (!selinux_enabled) {
        printk(KERN_INFO "SELinux:  Disabled at boot.\n");
        return 0;
    }


    printk(KERN_INFO "SELinux:  Initializing.\n");

    // 设置当前进程的安全状态
    cred_init_security();

    default_noexec = !(VM_DATA_DEFAULT_FLAGS & VM_EXEC);

    // 给inode安全属性对象sel_inode_cache分配空间    
    sel_inode_cache = kmem_cache_create("selinux_inode_security",
                                       sizeof(struct inode_security_struct),    
                                       0, SLAB_PANIC, NULL);
    //初始化访问向量缓存（AVC）
    avc_init();

        //将SELinux注册到LSM中
    if (register_security(&selinux_ops))
        panic("SELinux: Unable to register with kernel.\n");

       // 显示SE Linux的强制模式
    if (selinux_enforcing)
        printk(KERN_DEBUG "SELinux:  Starting in enforcing mode\n");
    else
        printk(KERN_DEBUG "SELinux:  Starting in permissive mode\n");

    return 0;
}

// 确保可以尽早启动，以便在创建进程和对象时对其进行标识
// 该宏在include/linux/init.h文件中定义
security_initcall(selinux_init);    

struct task_security_struct {
    u32 osid;            // 最后一次execve前的SID
    u32 sid;            // 当前SID
    u32 exec_sid;        // exec的SID
    u32 create_sid;        // 创建文件系统的SID
    u32 keycreate_sid;        // 创建密钥的SID
    u32 sockcreate_sid;        // 创建套接字的SID
};

/*
 * initialise the security for the init task
 */
static void cred_init_security(void)
{
    struct cred *cred = (struct cred *) current->real_cred;
    struct task_security_struct *tsec;
    
    // 创建描述进程安全属性的数据结构
    tsec = kzalloc(sizeof(struct task_security_struct), GFP_KERNEL);
    if (!tsec)
        panic("SELinux:  Failed to initialize initial task.\n");

    // 设置当前进程的安全属性
    tsec->osid = tsec->sid = SECINITSID_KERNEL;
    cred->security = tsec;
}

#define AVC_CACHE_SLOTS 512
void __init avc_init(void)
{
    int i;

    // 初始化每一个缓存槽
    for (i = 0; i < AVC_CACHE_SLOTS; i++) {
        INIT_LIST_HEAD(&avc_cache.slots[i]);
        spin_lock_init(&avc_cache.slots_lock[i]);    // 写时加锁

    }
    atomic_set(&avc_cache.active_nodes, 0);
    atomic_set(&avc_cache.lru_hint, 0);

    // 给AVC缓存记录分配空间
    avc_node_cachep = kmem_cache_create("avc_node", sizeof(struct avc_node),
                0, SLAB_PANIC, NULL, NULL);

    // 记录AVC初始化
    audit_log(current->audit_context, GFP_KERNEL, AUDIT_KERNEL, "AVC INITIALIZED\n");
}

struct avc_cache {
    struct list_head slots[AVC_CACHE_SLOTS];
    spinlock_t slots_lock[AVC_CACHE_SLOTS];    // 用以在写入时加锁

    atomic_t lru_hint;            // 在reclaim搜索时的LRU提示

    atomic_t active_nodes;
    u32 latest_notif;            // 最近撤销提醒

};

/**
 * register_security - registers a security framework with the kernel
 * @ops: a pointer to the struct security_options that is to be registered
 *
 * This function allows a security module to register itself with the
 * kernel security subsystem.  Some rudimentary checking is done on the @ops
 * value passed to this function. You‘ll need to check first if your LSM
 * is allowed to register its @ops by calling security_module_enable(@ops).
 *
 * If there is already a security module registered with the kernel,
 * an error will be returned.  Otherwise %0 is returned on success.
 */
int __init register_security(struct security_operations *ops)
{
    if (verify(ops)) {
        printk(KERN_DEBUG "%s could not verify "
               "security_operations structure.\n", __func__);
        return -EINVAL;
    }

    if (security_ops != &default_security_ops)
        return -EAGAIN;

    security_ops = ops;

    return 0;
}

static struct file_system_type sel_fs_type = {
    .name        = "selinuxfs",
    .mount        = sel_mount,
    .kill_sb    = kill_litter_super,
};

struct vfsmount *selinuxfs_mount;

static int __init init_sel_fs(void)
{
    int err;

    if (!selinux_enabled)
        return 0;
    err = register_filesystem(&sel_fs_type);
    if (!err) {
        selinuxfs_mount = kern_mount(&sel_fs_type);
        if (IS_ERR(selinuxfs_mount)) {
            printk(KERN_ERR "selinuxfs:  could not mount!\n");
            err = PTR_ERR(selinuxfs_mount);
            selinuxfs_mount = NULL;
        }
    }
    return err;
}

__initcall(init_sel_fs);

    static struct tree_descr selinux_files[] = {
        [SEL_LOAD] = {"load", &sel_load_ops, S_IRUSR|S_IWUSR},
        [SEL_ENFORCE] = {"enforce", &sel_enforce_ops, S_IRUGO|S_IWUSR},
        [SEL_CONTEXT] = {"context", &transaction_ops, S_IRUGO|S_IWUGO},
        [SEL_ACCESS] = {"access", &transaction_ops, S_IRUGO|S_IWUGO},
        [SEL_CREATE] = {"create", &transaction_ops, S_IRUGO|S_IWUGO},
        [SEL_RELABEL] = {"relabel", &transaction_ops, S_IRUGO|S_IWUGO},
        [SEL_USER] = {"user", &transaction_ops, S_IRUGO|S_IWUGO},
        [SEL_POLICYVERS] = {"policyvers", &sel_policyvers_ops, S_IRUGO},
        [SEL_COMMIT_BOOLS] = {"commit_pending_bools", &sel_commit_bools_ops, S_IWUSR},
        [SEL_MLS] = {"mls", &sel_mls_ops, S_IRUGO},
        [SEL_DISABLE] = {"disable", &sel_disable_ops, S_IWUSR},
        [SEL_MEMBER] = {"member", &transaction_ops, S_IRUGO|S_IWUGO},
        [SEL_CHECKREQPROT] = {"checkreqprot", &sel_checkreqprot_ops, S_IRUGO|S_IWUSR},
        [SEL_REJECT_UNKNOWN] = {"reject_unknown", &sel_handle_unknown_ops, S_IRUGO},
        [SEL_DENY_UNKNOWN] = {"deny_unknown", &sel_handle_unknown_ops, S_IRUGO},
        [SEL_STATUS] = {"status", &sel_handle_status_ops, S_IRUGO},
        [SEL_POLICY] = {"policy", &sel_policy_ops, S_IRUSR},
        /* last one */ {""}
    };