Linux系统 2023-06-30

探究URLHook和Linux的独特关系 (urlhook linux)

近年来，随着互联网的快速发展，我们的日常生活中已离不开各种软件和操作系统。其中，Linux作为一种非常流行的开源操作系统，其适用性和稳定性受到了众多用户的青睐。而在Linux操作系统中，URLHook技术的应用正成为越来越多开发者关注的焦点。那么，什么是URLHook技术？它在Linux操作系统中的应用有何特殊之处？接下来，本文将深入探究URLHook技术与Linux操作系统之间的独特关系。

URLHook技术是一种应用于网络安全领域的技术。它通过钩子机制，在访问URL时对请求进行拦截和处理，以对网络传输数据进行加密、解密和请求过滤等操作。目前，该技术在常见的网络安全产品如防火墙、杀毒软件、Web安全等系统中得到广泛应用。

基于Linux操作系统的开放性和自由性，许多开发者也开始关注并使用URLHook技术。在Linux操作系统中，钩子技术是非常普遍的，因为它可以让开发者通过修改某些系统内核代码，实现特定的功能增强。而因为Linux的开源性，用户可以自由地修改和自定义内核代码，将自己的概念变成现实。

在Linux中使用URLHook技术，开发者可以根据自己的需求，进行各种类型的URL拦截和处理。例如，可以对URL请求进行分类，对于网络上的一些恶意URL可以拦截和过滤；也可以将URL请求进行可靠的加密传输，提高网络传输的安全性。

此外，Linux操作系统的特殊性质还为URLHook技术的运用提供了其他的优势。在Linux操作系统中，内核代码的规模很小，使得其运行速度非常快，并且系统具有很高的稳定性和可靠性。这使得钩子机制可以更加快速、准确地进行拦截和处理，从而有效提升用户体验。此外，Linux操作系统的开放性还使得开发者可以根据自己的需要定制自己的系统内核，达到更好的功能拓展和性能提升。

然而，与此同时，Linux操作系统的开源性也带来了一定的风险，其中就包括针对操作系统本身的攻击。当黑客攻击系统内核时，利用URLHook技术可以对攻击行为进行分析和拦截，从而提高系统的安全性。但是，如果黑客攻击的是钩子机制本身，可能会使URLHook技术反而会影响系统的安全性。因此，在钩子机制的使用过程中，开发者必须非常小心，加强钩子机制的保护，增强系统的鲁棒性。

综上所述，通过URLHook技术，可以有效地提升Linux操作系统的安全性和性能表现。其威力不仅在于它的拦截和处理能力，也在于它的灵活性和系统可定制性。然而，开发者需要注意保护系统钩子的安全性，以达到更佳的网络安全效果。在未来，我们可以预见到，随着网络安全形势的不断变化，URLHook技术一定会得到更广泛的应用和发展。

相关问题拓展阅读：

linux内核态，在L框架中的文件操作hook接口中如何获取一个正在作的文件的内容？（linux4.4版本）

linux内核态，在L框架中的文件操作hook接口中如何获取一个正在作的文件的内容？（linux4.4版本）

L是Linux Secrity Module的简称，即linux安全模块。其是一种轻量级通用访

问控制框架，适合于多种访问控制模型在它上面以内核可加载模块的形实现。用

户可以根据自己的需求选择合适的安全模块加载到内核上实现。

L设计思想：

L的设计思想：在最少改变内核代码的情况下，提供一个能够成功实现强制访

问控制模块需要的结构或者接口。L避免了利用如在systrace系统调用中的出

现过的系统调用干预，因为它不能扩展到多处理器内核，并且它受制于参数替换

攻击。还有L在设计时做了两点考虑：对不使用的人来说尽量少引入麻烦，对

使用的人来说要带来效率。以

Linus Torvalds

为代表的内核开发人员对Linux安

全模块（L）提出了三点要求：

1、真正的通用，当使用一个不同的安全模型的时候，只需要加载一个不同的内

核模块。

2、概念上简单，对

Linux内核

影响最小，高效，并且。

3、能够支持现存的POSIX.1e capabilities逻辑，作为一个可选的安全模块。

还有，针对linux上提出的各种不同的Linux安全增强系统对Linux安全模块（L

）提出的要求是：能够允许他们以可加载内核模块的形式重新实现其安全功能，

并且不会在安全性方面带来明显的损失，也不会带来做渣额外的系统开销。

L框架结构：

L框架主要由五部分构成：

1、在特定的内核

数据结构

中加入安全域。

2、在内核

源代码

中不同的关键点插入对安全钩子函数的调用。

3、加入一个通用的安全系统调用。

4、提供了函数允许内核模块注册为安全模块或者注销。

5、5、将capabilities逻辑的大部分移植为一个可选的安全模块。

安全域是一个void*类型的指针，它使得安全模块把安全信息和内核内部对象联

系起来。下面列出被修改加入了安全域的内核数据结构，以及各自所代表的内核

内部对象：

task_struct结构：代表任务（进程）

linux_binprm结构：代表程序

super_block结构：代表

文件系统

inode结构：代表管道，文件，或者Socket

套接字

file结构：代表打开的文件

sk_buff结构：代表网络缓冲区（包）

net_device结构：代表

网络设备

kern_ipc_perm结构：代表Semaphore信号，共享内存段，或者

消息队列

msg_msg：代表单个的消息

Linux安全模块（L）提供了两类对安全钩子函数的调用：一类管理内核对象的

安全域，另一类仲裁对这些内核对象的访问。对安全钩子函数的调用通过钩子来

实现，钩子是全局表security_ops中的

函数指针

，这个全局表的类型是

security_operations结构，这个结构定义在include/linux/security.h这个头

文件中。

L接没尘口的核心是security_ops，当系统启动时，他们被初始化为传统的DAC策略

。传统DAC访问控制是指控制系统中的主体（如进程）对系统中的客体（如文件

目录、文件）的访问（读、写和执行等）。自主访问控制DAC 是指主体（进程，

用户）对客体（文件、目录、特殊设备文件、IPC等）的访问权限是由客体的属

主或超级用户决定的，而且此权限一旦确定，将作为以后判断主体对客体是否有

访问权限的依据。

在加载安全模块时，我们必需先对模块进行注册，我们可以使用

register_security()函数向L注册一个安全模块。在我们的模块被加载成

功后，就可以进行访问控制操作。如果此时还有一个安全模块要使用

register_security()函数进行加载，则会出现错误，直到使用

unregister_security()函数向框架注销后，下一个模块才可以载入枯胡禅。当然LS

M还提供了mod_reg_security()函数和mod_unreg_security()函数，可以连续注

册多个安全模块。如果有其他后来的模块需要载入，可以通过mod_reg_security

（）向之一个模块注册，形成支持不同策略的模块栈。

注：以上出现的函数均基于2.6.22以前的版本，对于后续的版本，出现了

register_security()函数未被导出或者取消掉了unregister_security()函数。

L执行过程：

根据下图的执行步骤：用户在执行系统调用时，先通过原有的内核接口依次执行

功能性的错误检查，接着进行传统的DAC检查，并在即将访问内核的内部对象之

前，通过L钩子函数调用L。L再调用具体的访问控制策略来决定访问的合

法性。图三显示了L钩子的调用：

图三：基于L的内核对象访问过程

Lilinux安全模块（L）主要支持”限制型”的访问控制决策：当Linux内核授予

文件或目录访问权限时，Linux安全模块（L）可能会拒绝，而当 Linux内核拒

绝访问时，可以跳过L。

========

使用L实现自己的访问控制

首先对L 进行简单介绍。虽然linux下的各位基本都知道一些，但是还要罗嗦

一下。

L中文全称是linux安全模块。英文全称：linux security module.

L是一种轻量级、通用的访问控制框架，适合多种访问控制模型以内核模块的

形式实现。其特点是通用、简单、高效、支持POSIX。1e能力机制。

L的架构图如下：

通过系统调用进入内核之后，系统首先进行传统的权限检查（传统权限检查主要

是基于用户的，用户通过验证之后就可以访问资源），通过之后才会进行强制访

问控制。（强制访问控制是不允许主体干涉的一种访问控制，其采用

安全标识

、

信息分级等信息敏感性进行访问控制。并且通过比较主体的级别和资源的敏感性

来确定是否允许访问。比如说系统设置A用户不允许访问文件B，即便A是文件B的

所有者，访问也是受限制的。）从图上看来，L实现访问控制主要通过安全模

块的钩子函数实现。

L框架主要由五部分组成：这个网上资料很多。

在关键的特定内核数据结构中加入了安全域；

在内核源码中不同的关键点处插入对安全钩子函数的调用；

提供了一个通用的安全系统调用；

提供了注册和注销函数，使得访问控制策略可以以内核模块方式实现；

将capabilities逻辑的大部分功能移植为一个可选的安全模块。

我们这里重点结合源码对L框架进行解释。我使用的源码是3.5.4

首先介绍安全域字段，它是一个空类型的指针，在内核中的很多内核结构中都存

在，比如inode、superblock、dentry、file等等。类型字段为void *

security;

那么安全域怎么和安全模块中的信息关联起来？

当安全模块加载之后，安全域中的指针便指向安全模块中的安全信息。这里以

selinux为例进行介绍。

内核里面security/selinux/include/objsec.h中定义了不同对象的安全信息，

格式为XXX_security_strut.

上面的文件的安全信息里面包含打开

文件描述符

时的安全ID、文件所有者的安全

ID等等。

要联系安全模块中安全信息和安全域需要几个控制钩子函数。这些钩子函数实现

了对内核关键信息的设置和管理。这里主要介绍alloc_security、

free_security。

selinux里面通过实现安全信息空间分配实现关联。比如以文件安全信息为例

这里分配空间成功之后，通过file->f_security = fsec实现了关联。

撤销关联是在安全模块卸载之后调用file_free_security.

这里具体通过设置file->f_secrity为NULL，然后释放安全信息结构实现。

现在来看看内核如何实现selinux的访问控制。这里主要就是实现L里面的钩子

函数了。L里面给出了

结构体

security_operations，里面给出了很多钩子函数

，实现了相关钩子函数就可以实现访问控制了。

上面的函数就实现了file_permission钩子函数。可以看下inode结构体的获得，

感受内核是通过文件->目录项->inode。该函数主要实现自己的访问控制策略就

OK 了。

哪selinux来说，在获得文件安全ID之后，主要对

掩码

和文件打开时相关的安全

信息进行检测，符合就通过访问控制。

selinux基本实现了L里面的所有钩子函数，待钩子函数实现后，对L里面钩

子域进行填充就OK了。

做完以上这些还需要注册安全模块到L，这里注册和注销使用了

register_security和unregister_security。

比如selinux在注册时使用语句register_security(&selinux_ops)实现。

接下来通过上面的分析我们可以实现简单的基于L的访问控制。

#include

static int l_test_file_permission(struct file *file,int mask)

{

int path=0;

struct file *filp;

struct nameidata nd;

path = path_lookup(FILENAME,LOOKUP_FOLLOW,&nd);

if(!mask)

return 0;

if(path)

{

printk(“lookup file failed!\n”);

return -1;

}

filp = filp_open(“/home/yuyunchao/code/.c”,O_RDON,0);

{

printk(“open failed!\n”);

}

return 0;

}

static struct security_operations l_test_security_ops = {

.file_permission = l_test_file_permission,

};

static int __init l_file_init(void)

{

if(register_security(&l_test_security_ops)){

printk(“register error ……….\n”);

return -1;

}

printk(“l_file init..\n “);

return 0;

}

static void __exit l_file_exit(void)

{

if(unregister_security(&l_test_security_ops)){

printk(“unregister error…………….\n”);

return ;

}

printk(“module exit…….\n”);

}

MODULE_LICENSE(“GPL”);

module_init(l_file_init);

module_exit(l_file_exit);

========

L(Linux Security Module)应用方法（简单例子）

L在内核中很多地方已经插入了hook函数，并且在security.c函数中声明了

security_ops结构，要实现你自己的安全模块，只需要定义你自己的struct

security_operations，并且用register_security注册即可，下面举个简单例子

：

test.c代码如下：

* Test Linux Security Module

* Author: penghuan

* This program is free software; you can redistribute it and/or modify

* it under the terms of the GNU General Public License version 2, as

* published by the Free Software Foundation.

#include

int test_file_permission(struct file *file, int mask)

{

char *name = file->f_path.dentry->d_name.name;

if(!strcmp(name, “test.txt”))

{

file->f_flags |= O_RDON;

printk(“you can have your control code here!\n”);

}

return 0;

}

static struct security_operations test_security_ops = {

.name = “test”,

.file_permission = test_file_permission,

};

static __init int test_init(void)

{

printk(“enter test init!\n”);

printk(KERN_INFO “Test: becoming……\n”)

if (register_security(&test_security_ops))

panic(“Test: kernel registration failed.\n”);

return 0;

}

security_initcall(test_init);

将该文件以模块的形式放到security/下编译进内核，启用新的内核后，当你操

作文件test.txt时，通过dmesg命令就能再终端看到”you can have your

control code here!“输出

所以一般的做法是：定义你自己的struct security_operations，实现你自己的

hook函数，具体有哪些hook函数可以查询include/linux/security.h文件，然后

调用register_security来用你的test_security_ops初始化全局的security_ops

指针

楼主，我刚开始研究L，但网上资料太少，您这个代码，我编译成ko文件老是

有警告，并且inod时，说Unknown symbol register_security。我最近看了看

内核模块变成，没有对内核进行太深入的了解。不知能否把L的实验步骤给出

的再详细点，谢谢。

你需要把代码编进内核

是需要把那段源码拷到内核目录下，然后重新编译内核？。。没有不编译内核的

方法吗？。。直接按照模块进行编译。另外那个test.txt放在哪个文件夹里？。

是需要把那段源码拷到内核目录下，然后重新编译内核？。。没有不编译内核的

方法吗？。。直接按照模块进行 …

是的，你去网上找下怎么把模块编进内核，l模块不能以模块方式加载，涉及

安全；test.txt是测试文件，当你把代码编进内核后，用新内核启动，然后操作

test.txt文件，就会有输出，test.txt随便放哪里

楼主，您好，我刚开始学习l模块，把您的模块编译进内核，新的内核加载后

，register_security总是失败，请问下可能是什么原因导致的。我的内核版本

是3.13.11。

register＿security的返回值是-11

========

L在Linux中的实现方式

L(Linux Secure Model)一种轻量级访问控制机制.

其实现方式有如在系统调用中加入一个后门….

方式如下:

static struct file *__dentry_open(struct dentry *dentry, struct

vfount *mnt,

struct file *f,

int (*open)(struct inode *, struct file *),

const struct cred *cred)

{

struct inode *inode;

int error;

………………………………………………………

error = security_dentry_open(f, cred); //L机制实现方式,在此加入了

一个L函数.

//security_dentry_open的实现如下,相当于一个接口,对一个函数指针再

//封装一下.

//只返回是与否,这样的控制信息.

if (error)

goto cleanup_all;

……………………………………………………….

return f;

cleanup_all:

………………………………………………………..

return ERR_PTR(error);

}

//========简单封装一个指针结构体===========================

int security_dentry_open(struct file *file, const struct cred *cred)

{

int ret;

ret = security_ops->dentry_open(file, cred);

if (ret)

return ret;

return fsnotify_perm(file, MAY_OPEN);

}

========

利用L实现更安全的linux

L的全称是Linux Security Modules，它是linux内核中用来支持更灵活的

安全策略的一个底层框架，虽然听起来比较复杂，但是可以就把它理解成一组安

插在linux内核的钩子函数和一些预留的被称为安全域的数据结构，下面先说说

这个框架的由来吧。

linux本身的机制就保证了linux拥有更好的安全机制，但是在这个机制下面

，还是隐藏了许多的问题：

1、权限粒度太大。用过linux的人应该对0644这样的访问权限设置不陌生，

它对能够操作这个文件的用户做了限制，但是这个只是限制到了组，而没有更进

一步的细分，当然，如果L只是用来限制这个的话，那么也就太没意思了，因

为实现文件更细的控制粒度，ACL就能够很出色的完成，顺便提一下，ACL有一个

分配的限制，如果哪位朋友需要用ACL进行粒度更细的访问权限控制的话，可能

需要注意一下这方面的东西。

2、root用户的权限太大。在linux中，root用户就是至高无上的，他拥有对

机器的完全控制权限，可以做他想做的一切事情。但是很多时候，我们可能并不

希望有root有这么大的权限，比如在现在比较流行的云存储中，用户肯定不希望

服务提供商能够随意访问我们的文件，那么这个时候，就需要对root用户进行一

定的设置了。

由于这些问题的存在，所以出现了像SE Linux(Securiy Enhanced Linux )

这样的增强补丁。但是每个系统对于具体安全细节的控制不尽相同，所以Linus

Tovalds 提出应该要有一个 Linux 内核所能接受的安全框架来支持这些安全策

略，这个安全框架应该提供包含内核数据结构中的透明安全域以及用来控制、维

护安全域操作的安全钩子，于是就有了L。

L在内核中的位置，可以用下图来表示：

当用户态程序调用某些操作系统提供的函数的时候，比如read()函数，其会

对应于内核中的一个系统调用，然后该首先会进行一些常规的错误检测，接着进

行DAC（Discretionary Access Control）检测，再接着它会进行L检测。从上

图中能够看出来，L其实是一个非常底层的安全策略框架，利用L，可以接管

所有的系统调用，这样，我们就能对包括root在内的所有用户的权限进行控制，

并且实现粒度更细的访问权限控制。

当系统初始化的时候，L就是一个空的框架，它不提供任何的检测，其所

做的全部工作几乎就是返回0，当然，有些不带返回值的函数除外。而我们则可

以针对自己特定的需求来编写L，然后将我们编写的L钩子函数，通过其数据

结构struct security_operations注册到系统中去，这样，我们的L检测就开

始起作用了。

更多信息可参考《Linux就该这么学》

urlhook linux的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于urlhook linux,探究URLHook和Linux的独特关系,linux内核态，在L框架中的文件操作hook接口中如何获取一个正在作的文件的内容？（linux4.4版本）的信息别忘了在本站进行查找喔。

数据运维技术 » 探究URLHook和Linux的独特关系 (urlhook linux)

分享到：

linux内核态，在L框架中的文件操作hook接口中如何获取一个正在作的文件的内容？（linux4.4版本）

相关推荐