IPVS之安全防御

最新推荐文章于 2023-07-28 15:58:16 发布

redwingz

最新推荐文章于 2023-07-28 15:58:16 发布

阅读量442

点赞数

分类专栏：负载均衡文章标签： ipvs

本文链接：https://blog.csdn.net/sinat_20184565/article/details/102670685

版权

负载均衡专栏收录该内容

42 篇文章 10 订阅

订阅专栏

初始化

IPVS在初始化时，使用内核delayed work机制启动一个处理任务。每1秒钟（DEFENSE_TIMER_PERIOD）执行一次。

/* Timer for checking the defense */
#define DEFENSE_TIMER_PERIOD    1*HZ

static int __net_init ip_vs_control_net_init_sysctl(struct netns_ipvs *ipvs)
{
    atomic_set(&ipvs->dropentry, 0);
	
	ipvs->sysctl_amemthresh = 1024;

    /* Schedule defense work */
    INIT_DELAYED_WORK(&ipvs->defense_work, defense_work_handler);
    schedule_delayed_work(&ipvs->defense_work, DEFENSE_TIMER_PERIOD);

防御处理

static void defense_work_handler(struct work_struct *work)
{
struct netns_ipvs *ipvs =
container_of(work, struct netns_ipvs, defense_work.work);

update_defense_level(ipvs);
if (atomic_read(&ipvs->dropentry))
    ip_vs_random_dropentry(ipvs);
schedule_delayed_work(&ipvs->defense_work, DEFENSE_TIMER_PERIOD);

}

PROC控制文件

可用内存阈值amemthresh

PROC文件：/proc/sys/net/ipv4/vs/amemthresh 用于设置可用内存的阈值，默认值为1024，单位是页面。如果系统可用内存值低于此阈值，IPVS系统即认为已无内存可用，其将尝试释放部分自身所占用的内存空间。

$ cat /proc/sys/net/ipv4/vs/amemthresh
1024

表项丢弃策略

PROC文件:/proc/sys/net/ipv4/vs/drop_entry用于设置处于无可用内存时IPVS丢弃表项的策略。默认值为0，表明关闭表项丢弃策略。将此值设置为3，表示总是开启此丢弃策略。值1和2为动态模式，当值设置为1时，一旦检测到内存不足，将进行表项丢弃，并将此值更改为2；否则，内存充足，不进行丢弃处理。当此值设置为2时，一旦检测到内存不足，同样将进行表项丢弃操作，反之如果内存充足，停止丢弃操作，并将drop_entry的值设置为1。

由以上描述可知，对于PROC文件drop_entry设置为1，2的情况，在内存不足时，drop_entry的值为2，当内存充足时，其值为1。

$ cat /proc/sys/net/ipv4/vs/drop_entry 
0

报文丢弃策略

PROC文件:/proc/sys/net/ipv4/vs/drop_packet用于设置处于可用内存不足时IPVS的报文丢弃策略，默认值为0，表明关闭报文丢弃策略。drop_packet的作用于上一节drop_entry类似，值1和2也是动态模式，值3表示总是开启报文丢弃策略。

对于PROC文件drop_packet设置为1，2的情况，在内存不足时，drop_packet的值为2，当内存充足时，其值为1。

$ cat /proc/sys/net/ipv4/vs/drop_packet 
0

和报文丢包丢弃相关的一个PROC文件为：/proc/sys/net/ipv4/vs/am_droprate，其定义了在drop_packet值为3时，所使用的的丢包率，默认为10，即丢弃十分之一的报文。

$ cat /proc/sys/net/ipv4/vs/am_droprate
10

当drop_packet的值为1或者2时，丢包率由以下公式计算而来：

rate = amemthresh / (amemthresh - available_memory)

安全TCP策略

PROC文件:/proc/sys/net/ipv4/vs/secure_tcp用于设置TCP使用一个不同的状态变迁表，对于NAT转发模式而言，可将TCP的Established状态延迟到三次握手完成之后。默认值为零，表明关闭secure_tcp功能。secure_tcp值的设置与上两节的drop_entry和drop_packet意义类似。值1和2也是动态模式，值3表示总是开启安全TCP策略。

对于PROC文件secure_tcp设置为1，2的情况，在内存不足时，secure_tcp的值为2，当内存充足时，其值为1。

$ cat /proc/sys/net/ipv4/vs/secure_tcp 
0

更新防御等级

函数update_defense_level负责防御等级的更新处理，其由delayed work每隔1秒钟调度一次。

可用内存计算

首先使用si_meminfo获得系统的空闲内存页面数量freeram和缓存页面数量bufferram，两者之和作为系统当前可用内存值（以页面为单位），此值如果小于PROC系统文件amemthresh指定的值，即认为内存已经不足。amemthresh默认值为1024。

static void update_defense_level(struct netns_ipvs *ipvs)
{
    struct sysinfo i;
    static int old_secure_tcp = 0;
    int to_change = -1;

    /* we only count free and buffered memory (in pages) */
    si_meminfo(&i);
    availmem = i.freeram + i.bufferram;

    nomem = (availmem < ipvs->sysctl_amemthresh);

drop_entry处理

以下逻辑根据PROC系统文件drop_entry和nomem来计算IPVS的dropentry值，dropentry表示是否执行连接表项丢弃操作。

    switch (ipvs->sysctl_drop_entry) {
    case 0:
        atomic_set(&ipvs->dropentry, 0);
        break;
    case 1:
        if (nomem) {
            atomic_set(&ipvs->dropentry, 1);
            ipvs->sysctl_drop_entry = 2;
        } else {
            atomic_set(&ipvs->dropentry, 0);
        }
        break;
    case 2:
        if (nomem) {
            atomic_set(&ipvs->dropentry, 1);
        } else {
            atomic_set(&ipvs->dropentry, 0);
            ipvs->sysctl_drop_entry = 1;
        };
        break;
    case 3:
        atomic_set(&ipvs->dropentry, 1);
        break;
    }

如下函数todrop_entry负责判断是否丢弃待定的连接表项。首先如果连接建立还未超过60秒，将不进行删除操作，以便保证正常的连接处理。

static inline int todrop_entry(struct ip_vs_conn *cp)
{
    /* The drop rate array needs tuning for real environments. Called from timer bh only => no locking
     */
    static const char todrop_rate[9] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
    static char todrop_counter[9] = {0};

    /* if the conn entry hasn't lasted for 60 seconds, don't drop it. This will leave enough time for normal connection to get through. */
    if (time_before(cp->timeout + jiffies, cp->timer.expires + 60*HZ))
        return 0;

如下示意图，

  create
   time           expires
                     |
    |     timeout    |  60s | 
    |----------------|------|
         |
         |----------------|
         |    timeout     |
        now
       jiffies
    |    |
    |<60s|

如果此连接接收到的报文数量不在[0， 8]之间，包括0和8，不执行丢弃，即没有接收到报文的连接与接收到大于8个报文的连接，可能在正常的使用不执行丢弃。反之，接下来将处理接收报文数量在[0,8]直接的连接。

以todrop_rate数组的第9个元素值8为例，如果连接接收的报文数量等于8个，在静态数组todrop_counter的第9个元素首次赋值为8之后，要一致等到执行8次之后，todrop_counter[8]才会再次小于等于零，返回1执行一次丢弃连接操作。

即对于连接的接收报文数量，数组todrop_rate指定了依据报文数量而定的丢弃速率。报文数量越多，丢弃率越低。

    /* Don't drop the entry if its number of incoming packets is not located in [0, 8] */
    i = atomic_read(&cp->in_pkts);
    if (i > 8 || i < 0) return 0;

    if (!todrop_rate[i]) return 0;
    if (--todrop_counter[i] > 0) return 0;

    todrop_counter[i] = todrop_rate[i];
    return 1;

drop_packet处理

以下逻辑根据PROC系统文件drop_packet和nomem来计算IPVS的drop_rate丢弃速率值。drop_rate值为空表示不执行报文丢弃操作。丢弃率drop_rate值的计算参考以上PROC文件am_droprate的介绍。

    switch (ipvs->sysctl_drop_packet) {
    case 0:
        ipvs->drop_rate = 0;
        break;
    case 1:
        if (nomem) {
            ipvs->drop_rate = ipvs->drop_counter 
                = ipvs->sysctl_amemthresh / (ipvs->sysctl_amemthresh-availmem);
            ipvs->sysctl_drop_packet = 2;
        } else {
            ipvs->drop_rate = 0;
        }
        break;
    case 2:
        if (nomem) {
            ipvs->drop_rate = ipvs->drop_counter
                = ipvs->sysctl_amemthresh / (ipvs->sysctl_amemthresh-availmem);
        } else {
            ipvs->drop_rate = 0;
            ipvs->sysctl_drop_packet = 1;
        }
        break;
    case 3:
        ipvs->drop_rate = ipvs->sysctl_am_droprate;
        break;
    }

报文丢弃的处理位于IPVS系统的各个协议的调度函数中，以UDP协议为例，其位于函数udp_conn_schedule中。如下的判断函数ip_vs_todrop。

static int udp_conn_schedule(struct netns_ipvs *ipvs, int af, struct sk_buff *skb,
          struct ip_vs_proto_data *pd, int *verdict, struct ip_vs_conn **cpp, struct ip_vs_iphdr *iph)
{
    if (svc) {
        if (ip_vs_todrop(ipvs)) {
            /* It seems that we are very loaded. We have to drop this packet :(
             */
            *verdict = NF_DROP;
            return 0;

当drop_rate不为零时，每当drop_counter小于等于零时，丢弃当前的报文。

static inline int ip_vs_todrop(struct netns_ipvs *ipvs)
{
    if (!ipvs->drop_rate)
        return 0;
    if (--ipvs->drop_counter > 0)
        return 0;
    ipvs->drop_counter = ipvs->drop_rate;
    return 1;

secure_tcp处理

以下逻辑根据PROC系统文件secure_tcp和nomem来计算IPVS的to_change值，to_change表示是否更改TCP所使用的状态迁移表。

    switch (ipvs->sysctl_secure_tcp) {
    case 0:
        if (old_secure_tcp >= 2)
            to_change = 0;
        break;
    case 1:
        if (nomem) {
            if (old_secure_tcp < 2)
                to_change = 1;
            ipvs->sysctl_secure_tcp = 2;
        } else {
            if (old_secure_tcp >= 2)
                to_change = 0;
        }
        break;
    case 2:
        if (nomem) {
            if (old_secure_tcp < 2)
                to_change = 1;
        } else {
            if (old_secure_tcp >= 2)
                to_change = 0;
            ipvs->sysctl_secure_tcp = 1;
        }
        break;
    case 3:
        if (old_secure_tcp < 2)
            to_change = 1;
        break;
    }
    old_secure_tcp = ipvs->sysctl_secure_tcp;
    if (to_change >= 0)
        ip_vs_protocol_timeout_change(ipvs, ipvs->sysctl_secure_tcp > 1);

函数ip_vs_protocol_timeout_change负责具体执行TCP状态转移表的切换。目前只有TCP协议注册了timeout_change指针函数。

void ip_vs_protocol_timeout_change(struct netns_ipvs *ipvs, int flags)
{
    struct ip_vs_proto_data *pd;

    for (i = 0; i < IP_VS_PROTO_TAB_SIZE; i++) {
        for (pd = ipvs->proto_data_table[i]; pd; pd = pd->next) {
            if (pd->pp->timeout_change)
                pd->pp->timeout_change(pd, flags);

TCP协议的timeout_change指针函数如下：tcp_timeout_change。如果开启，将TCP状态转换表设置为tcp_states_dos；否则，使用tcp_states表。

static void tcp_timeout_change(struct ip_vs_proto_data *pd, int flags)
{
    int on = (flags & 1);       /* secure_tcp */

    /*
    ** FIXME: change secure_tcp to independent sysctl var
    ** or make it per-service or per-app because it is valid
    ** for most if not for all of the applications. Something
    ** like "capabilities" (flags) for each object.
    */
    pd->tcp_state_table = (on ? tcp_states_dos : tcp_states);
}

连接表项丢弃处理

如在defense_work_handler函数中，如果update_defense_level函数将dropentry设置为非零值，将使用ip_vs_random_dropentry函数随机丢弃一定数量的连接表项。

static void defense_work_handler(struct work_struct *work)
{
    struct netns_ipvs *ipvs =
        container_of(work, struct netns_ipvs, defense_work.work);

    update_defense_level(ipvs);
    if (atomic_read(&ipvs->dropentry))
        ip_vs_random_dropentry(ipvs);

如下，在函数ip_vs_random_dropentry中，其随机选取1/32数量（ip_vs_conn_tab_size>>5）的哈希链表，随后遍历每个选定链表，获取候选丢弃表项。对于模板连接，如果存在子连接，或者其所属的虚拟服务未设置了OPS（One-Packet Scheduling），由于还在使用，不能丢弃此模板连接。否则，尝试进行丢弃操作。

/* Called from keventd and must protect itself from softirqs */
void ip_vs_random_dropentry(struct netns_ipvs *ipvs)
{
    struct ip_vs_conn *cp, *cp_c; 

    /* Randomly scan 1/32 of the whole table every second
     */
    for (idx = 0; idx < (ip_vs_conn_tab_size>>5); idx++) {
        unsigned int hash = prandom_u32() & ip_vs_conn_tab_mask;

        hlist_for_each_entry_rcu(cp, &ip_vs_conn_tab[hash], c_list) {
            if (cp->ipvs != ipvs)
                continue;
            if (cp->flags & IP_VS_CONN_F_TEMPLATE) {
                if (atomic_read(&cp->n_control) || !ip_vs_conn_ops_mode(cp))
                    continue;
                else
                    /* connection template of OPS */
                    goto try_drop;
            }

对于TCP协议，如果其状态为IP_VS_TCP_S_SYN_RECV或者IP_VS_TCP_S_SYNACK，表明TCP连接尚处在建立阶段，直接break出来进行丢弃。而对于处在IP_VS_TCP_S_ESTABLISHED状态的TCP协议类型的连接，使用函数todrop_entry判断是否可进行丢弃。另外对于其它TCP状态的连接，不进行处理，遍历下一个。

            if (cp->protocol == IPPROTO_TCP) {
                switch(cp->state) {
                case IP_VS_TCP_S_SYN_RECV:
                case IP_VS_TCP_S_SYNACK:
                    break;

                case IP_VS_TCP_S_ESTABLISHED:
                    if (todrop_entry(cp))
                        break;
                    continue;

                default:
                    continue;
                }

与以上的TCP协议类似，对于SCTP协议，如果其连接处于IP_VS_SCTP_S_INIT1或者IP_VS_SCTP_S_INIT状态，直接break出来进行丢弃处理。如果连接处于IP_VS_SCTP_S_ESTABLISHED状态，使用函数todrop_entry进行丢弃判断。其它SCTP协议状态的连接，不进行处理，遍历下一个。

            } else if (cp->protocol == IPPROTO_SCTP) {
                switch (cp->state) {
                case IP_VS_SCTP_S_INIT1:
                case IP_VS_SCTP_S_INIT:
                    break;
                case IP_VS_SCTP_S_ESTABLISHED:
                    if (todrop_entry(cp))
                        break;
                    continue;
                default:
                    continue;
                }

除了以上的TCP和SCTP协议之外，其它的协议统一使用函数todrop_entry进行丢弃判断。

            } else {
try_drop:
                if (!todrop_entry(cp))
                    continue;
            }

执行到此处的连接，表示要被进行丢弃。由函数ip_vs_conn_expire_now将连接的超时定时器更改为当下，最终由超时处理函数ip_vs_conn_expire执行连接的删除操作。

            IP_VS_DBG(4, "del connection\n");
            ip_vs_conn_expire_now(cp);
            cp_c = cp->control;
            /* cp->control is valid only with reference to cp */
            if (cp_c && __ip_vs_conn_get(cp)) {
                IP_VS_DBG(4, "del conn template\n");
                ip_vs_conn_expire_now(cp_c);
                __ip_vs_conn_put(cp);
            }

secure_tcp处理

static unsigned int ip_vs_in(struct netns_ipvs *ipvs, unsigned int hooknum, struct sk_buff *skb, int af)
{
    ip_vs_in_stats(cp, skb);
    ip_vs_set_state(cp, IP_VS_DIR_INPUT, skb, pd);
    if (cp->packet_xmit)
        ret = cp->packet_xmit(skb, cp, pp, &iph);
        /* do not touch skb anymore */

函数ip_vs_set_state封装了IPVS支持的各个协议所注册的状态转换函数指针state_transition。

static inline void ip_vs_set_state(struct ip_vs_conn *cp, int direction, const struct sk_buff *skb, struct ip_vs_proto_data *pd)
{
    if (likely(pd->pp->state_transition))
        pd->pp->state_transition(cp, direction, skb, pd);

对于TCP协议而言，其为tcp_state_transition函数，核心的子函数为set_tcp_state。

static void tcp_state_transition(struct ip_vs_conn *cp, int direction, const struct sk_buff *skb, struct ip_vs_proto_data *pd)
{
    struct tcphdr _tcph, *th;

#ifdef CONFIG_IP_VS_IPV6
    int ihl = cp->af == AF_INET ? ip_hdrlen(skb) : sizeof(struct ipv6hdr);
#else
    int ihl = ip_hdrlen(skb);
#endif

    th = skb_header_pointer(skb, ihl, sizeof(_tcph), &_tcph);

    set_tcp_state(pd, cp, direction, th);

如下的set_tcp_state函数，由TCP协议转换表tcp_state_table推导出当前连接的下一个状态new_state，如果此新状态不是活跃的TCP状态，并且此连接之前为设置inactive标志，将为其设置IP_VS_CONN_F_INACTIVE标志，递减目的服务器的activeconns活跃连接计数，增加inactconns非活跃连接计数。反之亦然。

static inline void set_tcp_state(struct ip_vs_proto_data *pd, struct ip_vs_conn *cp, int direction, struct tcphdr *th)
{
    int new_state = IP_VS_TCP_S_CLOSE;
    int state_off = tcp_state_off[direction];

    if ((state_idx = tcp_state_idx(th)) < 0) {
        IP_VS_DBG(8, "tcp_state_idx=%d!!!\n", state_idx);
        goto tcp_state_out;
    }
    new_state = pd->tcp_state_table[state_off+state_idx].next_state[cp->state];

tcp_state_out:
    if (new_state != cp->state) {
        struct ip_vs_dest *dest = cp->dest;

        if (dest) {
            if (!(cp->flags & IP_VS_CONN_F_INACTIVE) && !tcp_state_active(new_state)) {
                atomic_dec(&dest->activeconns);
                atomic_inc(&dest->inactconns);
                cp->flags |= IP_VS_CONN_F_INACTIVE;
            } else if ((cp->flags & IP_VS_CONN_F_INACTIVE) && tcp_state_active(new_state)) {
                atomic_inc(&dest->activeconns);
                atomic_dec(&dest->inactconns);
                cp->flags &= ~IP_VS_CONN_F_INACTIVE;

以下为正常情况下的TCP状态转换表tcp_states，以及开启secure_tcp之后所使用的tcp_states_dos转换表。例如，在输入方向（TCP_DIR_INPUT），对于正常的tcp_states转换表，如果当前连接状态为sSR（SYN_RECV），那么下一个状态根据报文类型（SYN，FIN，ACK和RST）分别为（sSR，sTW，sES和sSR）；而对于tcp_states_dos转换表，其下一个状态分别为（sSR，sTW，sSR和sSR），只有接收到FIN报文，其状态才会转换到sTW（TIME_WAIT），其它类型报文不引起状态变迁。目前还没有搞清楚这两张表的意义（…>_<…）。

static struct tcp_states_t tcp_states [] = {
/*  INPUT */
/*        sNO, sES, sSS, sSR, sFW, sTW, sCL, sCW, sLA, sLI, sSA */
/*syn*/ {{sSR, sES, sES, sSR, sSR, sSR, sSR, sSR, sSR, sSR, sSR }},
/*fin*/ {{sCL, sCW, sSS, sTW, sTW, sTW, sCL, sCW, sLA, sLI, sTW }},
/*ack*/ {{sES, sES, sSS, sES, sFW, sTW, sCL, sCW, sCL, sLI, sES }},
/*rst*/ {{sCL, sCL, sCL, sSR, sCL, sCL, sCL, sCL, sLA, sLI, sSR }},
...
};

static struct tcp_states_t tcp_states_dos [] = {
/*  INPUT */
/*        sNO, sES, sSS, sSR, sFW, sTW, sCL, sCW, sLA, sLI, sSA */
/*syn*/ {{sSR, sES, sES, sSR, sSR, sSR, sSR, sSR, sSR, sSR, sSA }},
/*fin*/ {{sCL, sCW, sSS, sTW, sTW, sTW, sCL, sCW, sLA, sLI, sSA }},
/*ack*/ {{sES, sES, sSS, sSR, sFW, sTW, sCL, sCW, sCL, sLI, sSA }},
/*rst*/ {{sCL, sCL, sCL, sSR, sCL, sCL, sCL, sCL, sLA, sLI, sCL }},

内核版本 4.15