linux ipsec 实现

1. 前言

在Linux2.6内核中自带了IPSEC的实现,这样就不用象2.4那样打补丁来实现了。该实现包括以下几个部分: PF_KEY类型套接口, 用来提供和用户层空间进行

PF_KEY通信，代码在net/key目录下，前面已经介绍过；安全联盟SA和安全策略SP管理，是使用xfrm库来实现的，代码在net/xfrm/目录下定义；ESP，AH等协议实现，在net/ipv4(6)下定义；加密认证算法库，在crypto目录下定义，这些算法都是标准代码了。本系列文章主要描述XFRM库的实现以及在IPV4下相关协议的处理部分, IPV6的忽略。

本文Linux内核代码版本为2.6.19.2。xfrm是内核中变化比较大的部分,每个版本中都有不小的差异, 同时也说明了该模块的不成熟性。

在net/xfrm目录下的各文件大致功能说明如下:

xfrm_state.c: xfrm状态管理

xfrm_policy.c: xfrm策略管理

xfrm_algo.c: 算法管理

xfrm_hash.c: HASH计算函数

xfrm_input.c: 安全路径(sec_path)处理,用于进入的ipsec包

xfrm_user.c: netlink接口的SA和SP管理

在net/ipv4目录下的和ipsec相关各文件大致功能说明如下:

ah4.c: IPV4的AH协议处理

esp4.c: IPV4的ESP协议处理

ipcomp.c: IP压缩协议处理

xfrm4_input: 接收的IPV4的IPSEC包处理

xfrm4_output: 发出的IPV4的IPSEC包处理

xfrm4_state: IPV4的SA处理

xfrm4_policy: IPV4的策略处理

xfrm4_tunnel: IPV4的通道处理

xfrm4_mode_transport: 传输模式

xfrm4_mode_tunnel: 通道模式

xfrm4_mode_beet: BEET模式

2. 数据结构

内核SA的定义用xfrm_state结构定义，SP用xfrm_policy结构定义，在

include/net/xfrm.h中定义。

2.1 状态(SA)

xfrm_state状态结构用来描述SA在内核中的具体实现:

struct xfrm_state

{

/* Note: bydst is re-used during gc */

// 每个状态结构挂接到三个HASH链表中

struct hlist_node bydst; // 按目的地址HASH

struct hlist_node bysrc; // 按源地址HASH

struct hlist_node byspi; // 按SPI值HASH

atomic_t refcnt; // 所有使用计数

spinlock_t lock; // 状态锁

struct xfrm_id id; // ID结构，即目的地址，SPI，协议三元组struct xfrm_selector sel; // 状态选择子

u32 genid; // 状态的标志值, 防止发生碰撞

/* Key manger bits */

struct {

u8 state;

u8 dying;

u32 seq;

} km; // KEY回调管理处理结构参数

/* Parameters of this state. */

struct {

u32 reqid; // 请求ID

u8 mode; // 模式: 传输/通道

u8 replay_window; // 回放窗口

u8 aalgo, ealgo, calgo; // 认证,加密,压缩算法ID值

u8 flags; // 一些标准

u16 family; // 协议族

xfrm_address_t saddr; // 源地址

int header_len; // 添加的协议头长度

int trailer_len; //

} props; // SA相关参数结构

struct xfrm_lifetime_cfg lft; // 生存时间配置

/* Data for transformer */

struct xfrm_algo *aalg; // hash算法

struct xfrm_algo *ealg; // 加密算法

struct xfrm_algo *calg; // 压缩算法

/* Data for encapsulator */

struct xfrm_encap_tmpl *encap; // NAT-T封装信息

/* Data for care-of address */

xfrm_address_t *coaddr;

/* IPComp needs an IPIP tunnel for handling uncompressed packets */ struct xfrm_state *tunnel; // 通道, 实际是另一个SA

/* If a tunnel, number of users + 1 */

atomic_t tunnel_users; // 通道的使用数

/* State for replay detection */

struct xfrm_replay_state replay; // 回放检测结构,包含各种序列号掩码等信息/* Replay detection state at the time we sent the last notification */

struct xfrm_replay_state preplay; // 上次的回放记录值

/* internal flag that only holds state for delayed aevent at the

* moment

*/

u32 xflags; // 标志

/* Replay detection notification settings */

u32 replay_maxage; // 回放最大时间间隔

u32 replay_maxdiff; // 回放最大差值

/* Replay detection notification timer */

struct timer_list rtimer; // 回放检测定时器

/* Statistics */

struct xfrm_stats stats; // 统计值

struct xfrm_lifetime_cur curlft; // 当前时间计数器

struct timer_list timer; // SA定时器

/* Last used time */

u64 lastused; // 上次使用时间

/* Reference to data common to all the instances of this

* transformer. */

struct xfrm_type *type; // 协议, ESP/AH/IPCOMP

struct xfrm_mode *mode; // 模式, 通道或传输

/* Security context */

struct xfrm_sec_ctx *security; // 安全上下文, 加密时使用

/* Private data of this transformer, format is opaque,

* interpreted by xfrm_type methods. */

void *data; // 内部数据

};

2.2 安全策略(SP)

xfrm_policy结构用于描述SP在内核内部的具体实现:

struct xfrm_policy

{

struct xfrm_policy *next; // 下一个策略

struct hlist_node bydst; // 按目的地址HASH的链表

struct hlist_node byidx; // 按索引号HASH的链表

/* This lock only affects elements except for entry. */

rwlock_t lock; // 策略结构锁

atomic_t refcnt; // 引用次数

struct timer_list timer; // 策略定时器

u8 type; // 类型

u32 priority; // 策略优先级

u32 index; // 策略索引号

struct xfrm_selector selector; // 选择子

struct xfrm_lifetime_cfg lft; // 策略生命期

struct xfrm_lifetime_cur curlft; // 当前的生命期数据

struct dst_entry *bundles; // 路由链表

__u16 family; // 协议族

__u8 action; // 策略动作, 接受/加密/阻塞...

__u8 flags; // 标志

__u8 dead; // 策略死亡标志

__u8 xfrm_nr; // 使用的xfrm_vec的数量

struct xfrm_sec_ctx *security; // 安全上下文

struct xfrm_tmpl xfrm_vec[XFRM_MAX_DEPTH]; // 状态模板};

xfrm模板结构, 用于状态和策略的查询:

struct xfrm_tmpl

{

/* id in template is interpreted as:

* daddr - destination of tunnel, may be zero for transport mode.

* spi - zero to acquire spi. Not zero if spi is static, then

* daddr must be fixed too.

* proto - AH/ESP/IPCOMP

*/

// SA三元组, 目的地址, 协议, SOI

struct xfrm_id id;

/* Source address of tunnel. Ignored, if it is not a tunnel. */

// 源地址

xfrm_address_t saddr;

// 请求ID

__u32 reqid;

/* Mode: transport, tunnel etc. */

__u8 mode;

/* Sharing mode: unique, this session only, this user only etc. */

__u8 share;

/* May skip this transfomration if no SA is found */

__u8 optional;

/* Bit mask of algos allowed for acquisition */

__u32 aalgos;

__u32 ealgos;

__u32 calgos;

};

2.3 协议结构

对ESP, AH, IPCOMP等协议的描述是通过xfrm_type结构来描述的, 多个协议的封装就是靠多个协议结构形成的链表来实现:

struct xfrm_type

{

char *description; // 描述字符串

struct module *owner; // 协议模块

__u8 proto; // 协议值

__u8 flags; // 标志

#define XFRM_TYPE_NON_FRAGMENT 1

// 初始化状态

int (*init_state)(struct xfrm_state *x);

// 析构函数

void (*destructor)(struct xfrm_state *);

// 数据输入函数

int (*input)(struct xfrm_state *, struct sk_buff *skb);

// 数据输出函数

int (*output)(struct xfrm_state *, struct sk_buff *pskb);

// 拒绝函数

int (*reject)(struct xfrm_state *, struct sk_buff *, struct flowi *);

// 头部偏移

int (*hdr_offset)(struct xfrm_state *, struct sk_buff *, u8 **);

// 本地地址

xfrm_address_t *(*local_addr)(struct xfrm_state *, xfrm_address_t *);

// 远程地址

xfrm_address_t *(*remote_addr)(struct xfrm_state *, xfrm_address_t *);

/* Estimate maximal size of result of transformation of a dgram */

// 最大数据报长度

u32 (*get_max_size)(struct xfrm_state *, int size);

};

具体的协议结构定义如下, 通常只定义初始化,析构,输入和输出四个成员函数: AH协议定义

/* net/ipv4/ah4.c */

static struct xfrm_type ah_type =

{

.description = "AH4",

.owner = THIS_MODULE,

.proto = IPPROTO_AH,

.init_state = ah_init_state,

.destructor = ah_destroy,

.input = ah_input,

.output = ah_output

};

ESP协议定义:

/* net/ipv4/esp4.c */

static struct xfrm_type esp_type =

{

.description = "ESP4",

.owner = THIS_MODULE,

.proto = IPPROTO_ESP,

.init_state = esp_init_state,

.destructor = esp_destroy,

.get_max_size = esp4_get_max_size,

.input = esp_input,

.output = esp_output

};

IP压缩协议定义:

/* net/ipv4/ipcomp.c */

static struct xfrm_type ipcomp_type = {

.description = "IPCOMP4",

.owner = THIS_MODULE,

.proto = IPPROTO_COMP,

.init_state = ipcomp_init_state,

.destructor = ipcomp_destroy,

.input = ipcomp_input,

.output = ipcomp_output

};

IPIP协议定义:

/* net/ipv4/xfrm4_tunnel.c */

static struct xfrm_type ipip_type = {

.description = "IPIP",

.owner = THIS_MODULE,

.proto = IPPROTO_IPIP,

.init_state = ipip_init_state,

.destructor = ipip_destroy,

.input = ipip_xfrm_rcv,

.output = ipip_output

};

2.4 模式结构

模式结构用于描述IPSEC连接描述, 可为通道模式或传输模式两种: struct xfrm_mode {

// 数据输入函数

int (*input)(struct xfrm_state *x, struct sk_buff *skb);

// 数据输出函数

int (*output)(struct xfrm_state *x,struct sk_buff *skb); // 模块指针

struct module *owner;

// 封装

unsigned int encap;

};

通道模式结构定义:

/* net/ipv4/xfrm4_mode_tunnel.c */

static struct xfrm_mode xfrm4_tunnel_mode = {

.input = xfrm4_tunnel_input,

.output = xfrm4_tunnel_output,

.owner = THIS_MODULE,

.encap = XFRM_MODE_TUNNEL,

};

传输模式结构定义:

/* net/ipv4/xfrm4_mode_transport.c */

static struct xfrm_mode xfrm4_transport_mode = {

.input = xfrm4_transport_input,

.output = xfrm4_transport_output,

.owner = THIS_MODULE,

.encap = XFRM_MODE_TRANSPORT,

};

beet模式, 不知道在哪用

/* net/ipv4/xfrm4_mode_beet.c */

static struct xfrm_mode xfrm4_beet_mode = {

.input = xfrm4_beet_input,

.output = xfrm4_beet_output,

.owner = THIS_MODULE,

.encap = XFRM_MODE_BEET,

};

2.5 策略的相关协议处理结构

以下结构用于描述具体协议族下的的策略处理: struct xfrm_policy_afinfo {

// 协议族

unsigned short family;

// 协议类型

struct xfrm_type *type_map[IPPROTO_MAX];

// 模式

struct xfrm_mode *mode_map[XFRM_MODE_MAX]; // 目的操作结构

struct dst_ops *dst_ops;

// 垃圾搜集

void (*garbage_collect)(void);

// 路由选择

int (*dst_lookup)(struct xfrm_dst **dst, struct flowi *fl);

// 获取源地址

int (*get_saddr)(xfrm_address_t *saddr, xfrm_address_t *daddr);

// 查找路由项

struct dst_entry *(*find_bundle)(struct flowi *fl, struct xfrm_policy *policy); // 创建新路由项

int (*bundle_create)(struct xfrm_policy *policy,

struct xfrm_state **xfrm,

int nx,

struct flowi *fl,

struct dst_entry **dst_p);

// 解码会话

void (*decode_session)(struct sk_buff *skb,

struct flowi *fl);

};

IPV4的策略协议相关处理结构定义如下:

/* net/ipv4/xfrm4_policy.c */

static struct xfrm_policy_afinfo xfrm4_policy_afinfo = {

.family = AF_INET,

.dst_ops = &xfrm4_dst_ops,

.dst_lookup = xfrm4_dst_lookup,

.get_saddr = xfrm4_get_saddr,

.find_bundle = __xfrm4_find_bundle,

.bundle_create = __xfrm4_bundle_create,

.decode_session = _decode_session4,

2.5 状态的相关协议处理结构

以下结构用于描述具体协议族下的的状态处理:

struct xfrm_state_afinfo {

// 协议族

unsigned short family;

// 初始化标志

int (*init_flags)(struct xfrm_state *x);

// 初始化模板选择

void (*init_tempsel)(struct xfrm_state *x, struct flowi *fl,

struct xfrm_tmpl *tmpl,

xfrm_address_t *daddr, xfrm_address_t *saddr);

// 模板排序

int (*tmpl_sort)(struct xfrm_tmpl **dst, struct xfrm_tmpl **src, int n); // 状态排序

int (*state_sort)(struct xfrm_state **dst, struct xfrm_state **src, int n);

};

IPV4的状态相关协议处理结构

/* net/ipv4/xfrm4_state.c */

static struct xfrm_state_afinfo xfrm4_state_afinfo = {

.family = AF_INET,

.init_flags = xfrm4_init_flags,

.init_tempsel = __xfrm4_init_tempsel,

};

2.6 回调通知信息结构

struct xfrm_mgr

{

struct list_head list;

char *id;

// 状态通知

int (*notify)(struct xfrm_state *x, struct km_event *c);

// 获取, 如获取SA

int (*acquire)(struct xfrm_state *x, struct xfrm_tmpl *, struct xfrm_policy *xp, int dir);

// 编译策略

struct xfrm_policy *(*compile_policy)(struct sock *sk, int opt, u8 *data, int len, int *dir);

// 映射

int (*new_mapping)(struct xfrm_state *x, xfrm_address_t *ipaddr, u16 sport); // 策略通知

int (*notify_policy)(struct xfrm_policy *x, int dir, struct km_event *c);

// 报告

int (*report)(u8 proto, struct xfrm_selector *sel, xfrm_address_t *addr);

};

在net/key/pf_key.c中定义了pkeyv2_mgr结构:

static struct xfrm_mgr pfkeyv2_mgr =

{

.id = "pfkeyv2",

.notify = pfkey_send_notify,

.acquire = pfkey_send_acquire,

.compile_policy = pfkey_compile_policy,

.new_mapping = pfkey_send_new_mapping,

.notify_policy = pfkey_send_policy_notify,

};

3. 初始化

/* net/xfrm/xfrm_policy.c */

// xfrm初始化函数包括状态, 策略和输入处理的三初始化函数

// xfrm是不支持模块方式的

void __init xfrm_init(void)

{

xfrm_state_init();

xfrm_policy_init();

xfrm_input_init();

}

3.1 xfrm状态初始化

/* net/xfrm/xfrm_state.c */

void __init xfrm_state_init(void)

{

unsigned int sz;

// 初始HASH表不大, 每个HASH中初始化为8个链表, 但随着状态数量的增加// 会动态增加HASH表数量

sz = sizeof(struct hlist_head) * 8;

// 建立3组HASH, 分别按SA的源地址, 目的地址和SPI值

xfrm_state_bydst = xfrm_hash_alloc(sz);

xfrm_state_bysrc = xfrm_hash_alloc(sz);

xfrm_state_byspi = xfrm_hash_alloc(sz);

if (!xfrm_state_bydst || !xfrm_state_bysrc || !xfrm_state_byspi)

panic("XFRM: Cannot allocate bydst/bysrc/byspi hashes.");

// xfrm_state_hmask初始值为=7, 计算出的HASH值与该值与来得到链表号xfrm_state_hmask = ((sz / sizeof(struct hlist_head)) - 1);

// 初始化工作队列work_queue, 完成对状态垃圾的搜集和释放

INIT_WORK(&xfrm_state_gc_work, xfrm_state_gc_task, NULL);

}

3.2 策略初始化

static void __init xfrm_policy_init(void)

{

unsigned int hmask, sz;

int dir;

// 建立一个内核cache, 用于分配xfrm_dst结构()

xfrm_dst_cache = kmem_cache_create("xfrm_dst_cache",

sizeof(struct xfrm_dst),

0, SLAB_HWCACHE_ALIGN|SLAB_PANIC,

NULL, NULL);

// 分配状态HASH表, 初始是8个HASH链表,以后随着策略数量的增加

// 会动态增加HASH表的数量

hmask = 8 - 1;

sz = (hmask+1) * sizeof(struct hlist_head);

// 该HASH表是按策略的index参数进行索引的

xfrm_policy_byidx = xfrm_hash_alloc(sz);

xfrm_idx_hmask = hmask;

if (!xfrm_policy_byidx)

panic("XFRM: failed to allocate byidx hash\n");

// 输入, 输出, 转发三个处理点, 双向

for (dir = 0; dir < XFRM_POLICY_MAX * 2; dir++) {

struct xfrm_policy_hash *htab;

// 初始化inexact链表头, inexact处理选择子相关长度不是标准值的一些特别策略

INIT_HLIST_HEAD(&xfrm_policy_inexact[dir]);

// 分配按地址HASH的HASH表

htab = &xfrm_policy_bydst[dir];

htab->table = xfrm_hash_alloc(sz);

htab->hmask = hmask;

if (!htab->table)

panic("XFRM: failed to allocate bydst hash\n");

}

// 初始化策略垃圾搜集的工作队列, 完成对策略垃圾的搜集和释放

INIT_WORK(&xfrm_policy_gc_work, xfrm_policy_gc_task, NULL);

// 登记网卡通知

register_netdevice_notifier(&xfrm_dev_notifier);

}

xfrm的网卡通知回调结构

static struct notifier_block xfrm_dev_notifier = {

xfrm_dev_event,

NULL,

};

// 网卡通知回调函数

static int xfrm_dev_event(struct notifier_block *this, unsigned long event, void *ptr) {

switch (event) {

// 如果网卡down掉的话, 清除相关的所有的xfrm路由项

case NETDEV_DOWN:

xfrm_flush_bundles();

}

return NOTIFY_DONE;

}

// 清除相关的所有的xfrm路由项

static int xfrm_flush_bundles(void)

{

// 将不用的路由项删除

xfrm_prune_bundles(stale_bundle);

return 0;

}

3.3 输入初始化

/* net/xfrm/xfrm_input.c */

void __init xfrm_input_init(void)

{

// 建立一个内核cache, 用于分配sec_path结构(安全路径)

secpath_cachep = kmem_cache_create("secpath_cache",

sizeof(struct sec_path),

0, SLAB_HWCACHE_ALIGN|SLAB_PANIC,

NULL, NULL);

}

struct sec_path结构是对输入的加密包进行层层解包的处理, 在sk_buff中有该结构的指针sp, 如果sp非空表示这是个IPSEC解密后的包。

...... 待续......

5. 安全策略(xfrm_policy)处理

本节所介绍的函数都在net/xfrm/xfrm_policy.c中定义。

5.1 策略分配

策略分配函数为xfrm_policy_alloc(), 该函数被pfkey_spdadd()函数调用

struct xfrm_policy *xfrm_policy_alloc(gfp_t gfp)

{

struct xfrm_policy *policy;

// 分配struct xfrm_policy结构空间并清零

policy = kzalloc(sizeof(struct xfrm_policy), gfp);

if (policy) {

// 初始化链接节点

INIT_HLIST_NODE(&policy->bydst);

INIT_HLIST_NODE(&policy->byidx);

// 初始化锁

rwlock_init(&policy->lock);

// 策略引用计数初始化为1

atomic_set(&policy->refcnt, 1);

// 初始化定时器

init_timer(&policy->timer);

policy->timer.data = (unsigned long)policy;

policy->timer.function = xfrm_policy_timer;

}

return policy;

}

EXPORT_SYMBOL(xfrm_policy_alloc);

定时器函数:

static void xfrm_policy_timer(unsigned long data)

{

struct xfrm_policy *xp = (struct xfrm_policy*)data;

unsigned long now = (unsigned long)https://www.360docs.net/doc/a613910064.html,_sec;

long next = LONG_MAX;

int warn = 0;

int dir;

// 加锁

read_lock(&xp->lock);

// 如果策略已经是死的, 退出

if (xp->dead)

goto out;

// 根据策略索引号确定策略处理的数据的方向, 看索引号的后3位dir = xfrm_policy_id2dir(xp->index);

// 如果到期了还要强制要增加一些时间

if (xp->lft.hard_add_expires_seconds) {

// 计算强制增加的超时时间

long tmo = xp->lft.hard_add_expires_seconds +

xp->curlft.add_time - now;

// 没法增加超时了, 到期

if (tmo <= 0)

goto expired;

if (tmo < next)

next = tmo;

}

// 如果到期了还要强制要增加的使用时间

if (xp->lft.hard_use_expires_seconds) {

// 计算强制增加的使用时间

long tmo = xp->lft.hard_use_expires_seconds +

(xp->https://www.360docs.net/doc/a613910064.html,e_time ? : xp->curlft.add_time) - now;

// 没法增加超时了, 到期

if (tmo <= 0)

goto expired;

if (tmo < next)

next = tmo;

}

// 如果到期了还要软性要增加一些时间

if (xp->lft.soft_add_expires_seconds) {

// 计算软性增加的时间

long tmo = xp->lft.soft_add_expires_seconds +

xp->curlft.add_time - now;

// 软性增加超时小于0, 设置报警标志, 并将超时设置为XFRM_KM_TIMEOUT, 这点和其他不同

if (tmo <= 0) {

warn = 1;

tmo = XFRM_KM_TIMEOUT;

}

if (tmo < next)

next = tmo;

}

// 如果到期了还要软性要增加的使用时间

if (xp->lft.soft_use_expires_seconds) {

// 计算软性增加的使用时间

long tmo = xp->lft.soft_use_expires_seconds +

(xp->https://www.360docs.net/doc/a613910064.html,e_time ? : xp->curlft.add_time) - now;

// 软性增加超时小于0, 设置报警标志, 并将超时设置为XFRM_KM_TIMEOUT, 这点和其他不同

if (tmo <= 0) {

warn = 1;

tmo = XFRM_KM_TIMEOUT;

}

if (tmo < next)

next = tmo;

}

// 需要报警, 调用到期回调

if (warn)

km_policy_expired(xp, dir, 0, 0);

// 如果更新的超时值有效, 修改定时器超时, 增加策略使用计数

if (next != LONG_MAX &&

!mod_timer(&xp->timer, jiffies + make_jiffies(next)))

xfrm_pol_hold(xp);

out:

read_unlock(&xp->lock);

xfrm_pol_put(xp);

return;

expired:

read_unlock(&xp->lock);

// 如果确实到期, 删除策略

if (!xfrm_policy_delete(xp, dir))

// 1表示是硬性到期了

km_policy_expired(xp, dir, 1, 0);

xfrm_pol_put(xp);

}

5.2 策略插入

策略插入函数为xfrm_policy_insert(), 该函数被pfkey_spdadd()函数调用, 注意策略链表是按优先权大小进行排序的有序链表, 因此插入策略时要进行优先权比较后插入到合适的位置.

int xfrm_policy_insert(int dir, struct xfrm_policy *policy, int excl)

{

struct xfrm_policy *pol;

struct xfrm_policy *delpol;

struct hlist_head *chain;

struct hlist_node *entry, *newpos, *last;

struct dst_entry *gc_list;

write_lock_bh(&xfrm_policy_lock);

// 找到具体的hash链表

chain = policy_hash_bysel(&policy->selector, policy->family, dir);

delpol = NULL;

newpos = NULL;

last = NULL;

// 遍历链表, 该链表是以策略的优先级值进行排序的链表, 因此需要根据新策略的优先级大小

// 将新策略插到合适的位置

hlist_for_each_entry(pol, entry, chain, bydst) {

// delpol要为空

if (!delpol &&

// 策略类型比较

pol->type == policy->type &&

// 选择子比较

!selector_cmp(&pol->selector, &policy->selector) &&

// 安全上下文比较

xfrm_sec_ctx_match(pol->security, policy->security)) {

// 新策略和已有的某策略匹配

if (excl) {

// 如果是排他性添加操作, 要插入的策略在数据库中已经存在, 发生错误write_unlock_bh(&xfrm_policy_lock);

return -EEXIST;

}

// 保存好要删除的策略位置

delpol = pol;

// 要更新的策略优先级值大于原有的优先级值, 重新循环找到合适的插入位置// 因为这个链表是以优先级值进行排序的, 不能乱

// 现在delpol已经非空了, 前面的策略查找条件已经不可能满足了if (policy->priority > pol->priority)

continue;

} else if (policy->priority >= pol->priority) {

// 如果新的优先级不低于当前的优先级, 保存当前节点, 继续查找合适插入位置

last = &pol->bydst;

continue;

}

// 这里是根据新策略的优先级确定的插入位置

if (!newpos)

newpos = &pol->bydst;

// 如果已经找到要删除的策略, 中断

if (delpol)

break;

last = &pol->bydst;

}

if (!newpos)

newpos = last;

// 插入策略到按目的地址HASH的链表的指定位置

if (newpos)

hlist_add_after(newpos, &policy->bydst);

else

hlist_add_head(&policy->bydst, chain);

// 增加策略引用计数

xfrm_pol_hold(policy);

// 该方向的策略数增1

xfrm_policy_count[dir]++;

atomic_inc(&flow_cache_genid);

// 如果有相同的老策略, 要从目的地址HASH和索引号HASH这两个表中删除if (delpol) {

hlist_del(&delpol->bydst);

hlist_del(&delpol->byidx);

xfrm_policy_count[dir]--;

}

// 获取策略索引号, 插入索引HASH链表

policy->index = delpol ? delpol->index : xfrm_gen_index(policy->type, dir);

hlist_add_head(&policy->byidx, xfrm_policy_byidx+idx_hash(policy->index));

// 策略插入实际时间

policy->curlft.add_time = (unsigned long)https://www.360docs.net/doc/a613910064.html,_sec; policy->https://www.360docs.net/doc/a613910064.html,e_time = 0;

if (!mod_timer(&policy->timer, jiffies + HZ))

xfrm_pol_hold(policy);

write_unlock_bh(&xfrm_policy_lock);

// 释放老策略

if (delpol)

xfrm_policy_kill(delpol);

else if (xfrm_bydst_should_resize(dir, NULL)) schedule_work(&xfrm_hash_work);

// 下面释放所有策略当前的路由cache

read_lock_bh(&xfrm_policy_lock);

gc_list = NULL;

entry = &policy->bydst;

// 遍历链表, 搜集垃圾路由cache建立链表

hlist_for_each_entry_continue(policy, entry, bydst) { struct dst_entry *dst;

write_lock(&policy->lock);

// 策略的路由链表头

dst = policy->bundles;

if (dst) {

// 直接将整个策略路由链表加到垃圾链表前面struct dst_entry *tail = dst;

while (tail->next)

tail = tail->next;

tail->next = gc_list;

gc_list = dst;

// 当前策略的路由为空

policy->bundles = NULL;

}

write_unlock(&policy->lock);

}

read_unlock_bh(&xfrm_policy_lock);

// 释放垃圾路由cahce

while (gc_list) {

struct dst_entry *dst = gc_list;

gc_list = dst->next;

dst_free(dst);

}

return 0;

}

EXPORT_SYMBOL(xfrm_policy_insert);

5.3 删除某类型的全部安全策略

该函数被pfkey_spdflush()等函数调用

void xfrm_policy_flush(u8 type)

{

int dir;

write_lock_bh(&xfrm_policy_lock);

for (dir = 0; dir < XFRM_POLICY_MAX; dir++) {

struct xfrm_policy *pol;

struct hlist_node *entry;

int i, killed;

killed = 0;

again1:

// 遍历inexact HASH链表

hlist_for_each_entry(pol, entry,

&xfrm_policy_inexact[dir], bydst) {

// 判断类型

if (pol->type != type)

continue;

// 将策略从bydst链表中断开

hlist_del(&pol->bydst);

// 将策略从byidt链表中断开

hlist_del(&pol->byidx);

write_unlock_bh(&xfrm_policy_lock);

// 将策略状态置为dead, 并添加到系统的策略垃圾链表进行调度处理准备删除xfrm_policy_kill(pol);

killed++;

write_lock_bh(&xfrm_policy_lock);

goto again1;

}

// 遍历所有目的HASH链表

for (i = xfrm_policy_bydst[dir].hmask; i >= 0; i--) {

again2:

// 遍历按目的地址HASH的链表

hlist_for_each_entry(pol, entry,

xfrm_policy_bydst[dir].table + i,

bydst) {

if (pol->type != type)

continue;

// 将节点从链表中断开

hlist_del(&pol->bydst);

hlist_del(&pol->byidx);

write_unlock_bh(&xfrm_policy_lock);

// 释放节点

xfrm_policy_kill(pol);

killed++;

write_lock_bh(&xfrm_policy_lock);

goto again2;

}

}

xfrm_policy_count[dir] -= killed;

}

atomic_inc(&flow_cache_genid);

write_unlock_bh(&xfrm_policy_lock);

}

EXPORT_SYMBOL(xfrm_policy_flush);

/* Rule must be locked. Release descentant resources, announce * entry dead. The rule must be unlinked from lists to the moment. */

// 策略释放到垃圾链表

static void xfrm_policy_kill(struct xfrm_policy *policy)

{

int dead;

write_lock_bh(&policy->lock);

// 保留老的DEAD标志

dead = policy->dead;

// 设置策略DEAD标志

policy->dead = 1;

write_unlock_bh(&policy->lock);

// 为什么不在前面判断DEAD呢?

if (unlikely(dead)) {

WARN_ON(1);

return;

}

spin_lock(&xfrm_policy_gc_lock);

// 将该策略节点从当前链表断开, 插入策略垃圾链表

hlist_add_head(&policy->bydst, &xfrm_policy_gc_list);

spin_unlock(&xfrm_policy_gc_lock);

// 调度策略垃圾策略工作结构

schedule_work(&xfrm_policy_gc_work);

}

5.4 策略查找

5.4.1 策略查找并删除

根据选择子和安全上下文查找策略, 可查找策略并删除, 被pfkey_spddelete()函数调用

struct xfrm_policy *xfrm_policy_bysel_ctx(u8 type, int dir,

struct xfrm_selector *sel,

struct xfrm_sec_ctx *ctx, int delete)

{

struct xfrm_policy *pol, *ret;

struct hlist_head *chain;

struct hlist_node *entry;

write_lock_bh(&xfrm_policy_lock);

// 定位HASH表

chain = policy_hash_bysel(sel, sel->family, dir);

ret = NULL;

// 遍历链表

hlist_for_each_entry(pol, entry, chain, bydst) {

// 根据类型, 选择子和上下文进行匹配

if (pol->type == type &&

!selector_cmp(sel, &pol->selector) &&

xfrm_sec_ctx_match(ctx, pol->security)) {

xfrm_pol_hold(pol);

if (delete) {

// 要的删除话将策略节点从目的地址HASH链表和索引HASH链表中断开hlist_del(&pol->bydst);

hlist_del(&pol->byidx);

xfrm_policy_count[dir]--;

}

ret = pol;

break;

}

}

write_unlock_bh(&xfrm_policy_lock);

if (ret && delete) {

// 增加genid

atomic_inc(&flow_cache_genid);

// 将策略状态置为dead, 并添加到系统的策略垃圾链表进行调度处理准备删除xfrm_policy_kill(ret);

}

return ret;

}

EXPORT_SYMBOL(xfrm_policy_bysel_ctx);

5.4.2 按索引号查找并删除