struct tcphdr {
        __be16        source;
        __be16        dest;
        __be32        seq;
        __be32        ack_seq;
#if defined(__LITTLE_ENDIAN_BITFIELD)
        __u16        res1:4,
                doff:4,        /* 正解 doff *4 <= 60, 逗你玩 */
                fin:1,
                syn:1,
                rst:1,
                psh:1,
                ack:1,
                urg:1,
                ece:1,
                cwr:1;
#elif defined(__BIG_ENDIAN_BITFIELD)
        __u16        doff:4,
                res1:4,
                cwr:1,
                ece:1,
                urg:1,
                ack:1,
                psh:1,
                rst:1,
                syn:1,
                fin:1;
#else
#error        "Adjust your <asm/byteorder.h> defines"
#endif       
        __be16        window;
        __sum16        check;
        __be16        urg_ptr;
};

/* 2007-12-22 20:47 */
static void tcp_options(const struct sk_buff *skb,
                        unsigned int dataoff,
                        struct tcphdr *tcph,
                        struct ip_ct_tcp_state *state)
{
        unsigned char buff[(15 * 4) - sizeof(struct tcphdr)];
        unsigned char *ptr;
        int length = (tcph->doff*4) - sizeof(struct tcphdr);
        /*
         * sizeof(buff) = 40
         * length 只能 <= 40 ;)
         */
        if (!length)
                return;

        ptr = skb_header_pointer(skb, dataoff + sizeof(struct tcphdr),
                                 length, buff);
       
        /*108byte(20byte<IP>  +
         *          20byte<TCP>  +
         *          40byte<TCP opt> +
         *          28byte<trash>)SYN 包拆成两个碎片:
         * 第一个包：20byte<IP> + 20byte<TCP> + 24byte<TCP opt>
         *           and tcp->doff = 0xf
         * 第二个包：20byte<IP> + 16byte<TCP opt> + 28byte<trash>
         *
         * 这样会迫使 ptr = buff ;/
         * =========================
         * 40byte<TCP opt>这样填充，使得：
         * buff[0 ... 38] = TCPOPT_NOP ;
         * buff[39] = 非 TCPOPT_NOP and TCPOPT_EOL
         */
        BUG_ON(ptr == NULL);

        state->td_scale = state->flags = 0;

        while (length > 0) {
                /*
                 * when length = 1, ptr = &buff[39], and
                 * while-loop progress...
                 */
                int opcode = *ptr++;
                /*
                 * after opcode is read,
                 * ptr = &buff[40]
                 * still ok,
                 */
                int opsize;

                switch (opcode) {
                case TCPOPT_EOL:
                        return;
                case TCPOPT_NOP:        /* Ref: RFC 793 section 3.1 */
                        length--;
                        continue;
                default:
                        /*
                         * but when opsize is reading,
                         * buff overflow :?/
                         */
                        opsize = *ptr++;
                       
                        if (opsize < 2) /* "silly options" */
                                return;
                       
                        if (opsize > length)
                                break;        /* don't parse partial options */

                        if (opcode == TCPOPT_SACK_PERM
                            && opsize == TCPOLEN_SACK_PERM) {
                                state->flags |= IP_CT_TCP_FLAG_SACK_PERM;
                        }
                        else if (opcode == TCPOPT_WINDOW
                                 && opsize == TCPOLEN_WINDOW) {
                                state->td_scale = *(u_int8_t *)ptr;

                                if (state->td_scale > 14) {
                                        /* See RFC1323 */
                                        state->td_scale = 14;
                                }
                                state->flags |= IP_CT_TCP_FLAG_WINDOW_SCALE;
                        }
                        ptr += opsize - 2;
                        length -= opsize;
                }
        }
}

/* Print out the private part of the conntrack. */
static int tcp_print_conntrack(struct seq_file *s,
                               const struct ip_conntrack *conntrack)
{
        enum tcp_conntrack state;
        read_lock_bh(&tcp_lock);

        /* 这里 state 可能取到很多值 */
        state = conntrack->proto.tcp.state;
        read_unlock_bh(&tcp_lock);

        /* 这里显示具体的 state */
        return seq_printf(s, "%s ", tcp_conntrack_names[state]);
}

static const char *tcp_conntrack_names[] = {
        "NONE",
        "SYN_SENT",
        "SYN_RECV",
        "ESTABLISHED",
        "FIN_WAIT",
        "CLOSE_WAIT",
        "LAST_ACK",
        "TIME_WAIT",
        "CLOSE",
        "LISTEN"
};

/* This is exposed to userspace (ctnetlink) */
enum tcp_conntrack {
        TCP_CONNTRACK_NONE,
        TCP_CONNTRACK_SYN_SENT,
        TCP_CONNTRACK_SYN_RECV,
        TCP_CONNTRACK_ESTABLISHED,
        TCP_CONNTRACK_FIN_WAIT,
        TCP_CONNTRACK_CLOSE_WAIT,
        TCP_CONNTRACK_LAST_ACK,
        TCP_CONNTRACK_TIME_WAIT,
        TCP_CONNTRACK_CLOSE,
        TCP_CONNTRACK_LISTEN,
        TCP_CONNTRACK_MAX,          /* 这个没有出现在 tcp_conntrack_names 中 */
        TCP_CONNTRACK_IGNORE     /* 同上 */
};

struct ip_ct_tcp
{
        struct ip_ct_tcp_state seen[2]; /* connection parameters per direction */
        u_int8_t        state;          /* state of the connection (enum tcp_conntrack) */
                                                /* 这里取的可是 enum tcp_conntrack 的值啊？ */
        /* For detecting stale connections */
        u_int8_t        last_dir;       /* Direction of the last packet (enum ip_conntrack_dir) */
        u_int8_t        retrans;        /* Number of retransmitted packets */
        u_int8_t        last_index;     /* Index of the last packet */
        u_int32_t       last_seq;       /* Last sequence number seen in dir */
        u_int32_t       last_ack;       /* Last sequence number seen in opposite dir */
        u_int32_t       last_end;       /* Last seq + len */
        u_int16_t       last_win;       /* Last window advertisement seen in dir */
};

#include <net/snmp.h>
#include <net/ip.h>
#include <net/protocol.h>
#include <net/route.h>
#include <net/xfrm.h>
#include <linux/skbuff.h>
#include <net/sock.h>
#include <net/arp.h>
#include <net/icmp.h>
/* why so much men? linux-2.6.22.5/net/ipv4/ip_output.c
#include <net/checksum.h> */
#include <net/inetpeer.h>
#include <net/checksum.h>
#include <linux/igmp.h>

Hi, Jozsef

Though functions in nf_conntrack_proto_tcp.c never see fragmented packets,
the implementation of the function, ip_frag_reasm() in linux/net/ipv4/ip_fragment.c,
does not make sure that the skb seen in nf_conntrack_proto_tcp.c is linearized,
at least in the case of linux-2.6.22.5 from kernel.org.

Therefore buff overflow is still a problem, if not a vulnerability,
in the function of tcp_options(),
as shown in the following code,

static struct sk_buff *ip_frag_reasm(struct ipq *qp, struct net_device *dev)
{
[...]
    /*
     * head is not linearized,
     * 2008-1-11 22:48 by sisi
     */
    skb_shinfo(head)->frag_list = head->next;

    skb_push(head, head->data - skb_network_header(head));
    atomic_sub(head->truesize, &ip_frag_mem);

    for (fp=head->next; fp; fp = fp->next) {
        head->data_len += fp->len;
        head->len += fp->len;
        if (head->ip_summed != fp->ip_summed)
            head->ip_summed = CHECKSUM_NONE;
        else if (head->ip_summed == CHECKSUM_COMPLETE)
            head->csum = csum_add(head->csum, fp->csum);
        head->truesize += fp->truesize;
        atomic_sub(fp->truesize, &ip_frag_mem);
    }

    head->next = NULL;
    head->dev = dev;
    head->tstamp = qp->stamp;

    iph = ip_hdr(head);
    iph->frag_off = 0;
    iph->tot_len = htons(len);
    IP_INC_STATS_BH(IPSTATS_MIB_REASMOKS);
    qp->fragments = NULL;
    return head;
[...]
}


Best regards,
Jing



2008/1/4, Jozsef Kadlecsik <[email]kadlec@blackhole.kfki.hu[/email]>:

    Hi,

    On Mon, 24 Dec 2007, jing zhang wrote:

    > buffer overflow is discovered in parsing TCP options,
    > in both tcp_sack() and tcp_options() functions,
    > implemented in nf_conntrack_proto_tcp.c of linux-2.6.22/23.x
    >
    > I think it is possible to crash a netfilter-based firewall box with simply
    > constructed TCP SYN packet.
    [...]
    > /*
    >   If 108-byte TCP SYN packet is received in
    >   the manner of two frags:
    >   farg-I,  20-byte-IP + 20-byte-TCP + 24-byte-TCP_OPT
    >             and tcp->doff assigned to 0xf
    >
    >   farg-II,  20-byte-IP + 16-byte-TCP_OPT + 28-byte-TRASH
    >
    >   then the `ptr' is forcedly assigned to `buff',
    >   and sizeof(buff) is 40-byte.
    > */
    [...]

    Please note, defragmenting happens before conntrack is called. In other
    words these functions never see fragmented packets. Therefore I think
    there is no such problem in nf_conntrack_proto_tcp.c.

    Best regards,
    Jozsef
    -
    E-mail  : [email]kadlec@blackhole.kfki.hu[/email], [email]kadlec@sunserv.kfki.hu[/email]
    PGP key : [url]http://www.kfki.hu/~kadlec/pgp_public_key.txt[/url]
    Address : KFKI Research Institute for Particle and Nuclear Physics
              H-1525 Budapest 114, POB. 49, Hungary

static int ksoftirqd(void * __bind_cpu)
{
        set_current_state(TASK_INTERRUPTIBLE);
        /*
         * linux-2.6.23.12
         * set_user_nice(current, 1);
         */
[...]
}

$
$ mkdir /home/platin
$ vim /home/platin/show_buflow.c

#include <linux/module.h>
#include <linux/kernel.h>

#define SHOW_BUF_MAX 3
static char *buff[] = {
        [0 ... SHOW_BUF_MAX -2] = "aaa",
        [SHOW_BUF_MAX -1] = "and what?",
};

static int __init show_buflow_start(void)
{
        int j;
        for (j = 0; j < SHOW_BUF_MAX; j++)
                printk("%s\n", buff[j]);
        printk("%s\n", buff[j+3]);
        return 0;
}
static void __exit show_buflow_finish(void) {}
module_init(show_buflow_start);
module_exit(show_buflow_finish);

$ echo obj-m=show_buflow.o >>  /home/platin/Makefile
$ make -C /usr/src/linux-2.6.23.12 M=/home/platin modules
$ insmod  /home/platin/show_buflow.ko
$