Kernel Bug-Vulnerability-Comment library

daemeon

after release lock, how to guarantee timer not  freed in other place.

sisi8408

you won ￥1, congratulation.

but how can i get timer, say through /dev/mem after lunch?

[ 本帖最后由 sisi8408 于 2007-8-19 09:49 编辑 ]

sisi8408

1. 
   
2. /*
   
3. * linux-2.6.20.7/kernel/time/clocksource.c
   
4. */
   
5. static ssize_t sysfs_show_available_clocksources(struct sys_device *dev, char *buf)
   
6. {
   
7.         struct list_head *tmp;
   
8.         char *curr = buf;
   
9. 
   
10.         spin_lock_irq(&clocksource_lock);
    
11.         list_for_each(tmp, &clocksource_list) {
    
12.                 struct clocksource *src;
    
13. 
    
14.                 src = list_entry(tmp, struct clocksource, list);
    
15.                 /*
    
16.                  * no check of buf overflow
    
17.                  */
    
18.                 curr += sprintf(curr, "%s ", src->name);
    
19.         }
    
20.         spin_unlock_irq(&clocksource_lock);
    
21.         curr += sprintf(curr, "\n");
    
22.         return curr - buf;
    
23. }
    

复制代码

sisi8408

1. 
   
2. /*
   
3. * linux-2.6.20.7/kernel/time/clocksource.c
   
4. */
   
5. static int __init init_clocksource_sysfs(void)
   
6. {
   
7.         int error = sysdev_class_register(&clocksource_sysclass);
   
8. 
   
9.         if (!error)
   
10.                 error = sysdev_register(&device_clocksource);
    
11.         if (!error)
    
12.                 error = sysdev_create_file(
    
13.                                 &device_clocksource,
    
14.                                 &attr_current_clocksource);
    
15.         /*
    
16.          * lack of xxx_unregister to clean trash
    
17.          */
    
18.         if (!error)
    
19.                 error = sysdev_create_file(
    
20.                                 &device_clocksource,
    
21.                                 &attr_available_clocksource);
    
22.         return error;
    
23. }
    

复制代码

Solaris12

原帖由 sisi8408 于 2007-8-18 13:49 发表
这里搜集/整理/讨论 linux 八哥/漏洞，和解决方案

贴八哥/漏洞，一次性获得￥1，最多￥2。


贴解决方案，一次性获得￥1，最多￥9。


1，如果要求任何版权，sisi8408只承诺 版权归地球人，与GPLvx无关 ...

不明白你们为什么要这样做，不如直接提交bug给Linux社区，这样即贡献了社区，如果你自己理解有误，自己又学习东西了。我并不反对大家交流，希望交流以后，能提交bug给社区，甚至是提交patch给社区。



到今天为之我提交了过不少bug给Solaris，其中大多数是驱动/tcp-ip/内核相关的。一开始提交bug只是简单描述下问题，或者重现步骤，但后来有些bug就可以给出一些自己的分析，甚至指出那里可能有问题。

提交bug能学到很多东西，尤其是从修bug的人那里。

所以说，大家不要放弃通过提交bug和那些内核开发者的交流机会。

[ 本帖最后由 Solaris12 于 2007-8-19 11:37 编辑 ]

sisi8408

1，敬仰 提交了不少bug给Solaris。
     如果能在CU分享，俺看就是美事。

2，提交和搜集不矛盾，也不冲突。
     表达自己的想法，在LKML、bugzila、CU，可能没有本质区别，都是社区吗。

3，￥表示致敬和鼓励干涩的眼睛，是俺的心意，俺很乐意。

[ 本帖最后由 sisi8408 于 2007-8-23 10:27 编辑 ]

sisi8408

1. 
   
2. /*
   
3. * linux-2.6.20.7/net/ipv4/netfilter/ip_conntrack_core.c
   
4. */
   
5. int __init ip_conntrack_init(void)
   
6. {
   
7.         unsigned int i;
   
8.         int ret;
   
9. 
   
10.         /* Idea from tcp.c: use 1/16384 of memory.  On i386: 32MB
    
11.          * machine has 256 buckets.  >= 1GB machines have 8192 buckets. */
    
12.         if (!ip_conntrack_htable_size) {
    
13.                 ip_conntrack_htable_size
    
14.                         = (((num_physpages << PAGE_SHIFT) / 16384)
    
15.                            / sizeof(struct list_head));
    
16.                 if (num_physpages > (1024 * 1024 * 1024 / PAGE_SIZE))
    
17.                         ip_conntrack_htable_size = 8192;
    
18.                 if (ip_conntrack_htable_size < 16)
    
19.                         ip_conntrack_htable_size = 16;
    
20.         }
    
21.         ip_conntrack_max = 8 * ip_conntrack_htable_size;
    
22. 
    
23.         printk("ip_conntrack version %s (%u buckets, %d max)"
    
24.                " - %Zd bytes per conntrack\n", IP_CONNTRACK_VERSION,
    
25.                ip_conntrack_htable_size, ip_conntrack_max,
    
26.                sizeof(struct ip_conntrack));
    
27. 
    
28.         ret = nf_register_sockopt(&so_getorigdst);
    
29.         if (ret != 0) {
    
30.                 printk(KERN_ERR "Unable to register netfilter socket option\n");
    
31.                 return ret;
    
32.         }
    
33. 
    
34.         ip_conntrack_hash = alloc_hashtable(ip_conntrack_htable_size,
    
35.                                             &ip_conntrack_vmalloc);
    
36.         if (!ip_conntrack_hash) {
    
37.                 printk(KERN_ERR "Unable to create ip_conntrack_hash\n");
    
38.                 goto err_unreg_sockopt;
    
39.         }
    
40. 
    
41.         ip_conntrack_cachep = kmem_cache_create("ip_conntrack",
    
42.                                                 sizeof(struct ip_conntrack), 0,
    
43.                                                 0, NULL, NULL);
    
44.         if (!ip_conntrack_cachep) {
    
45.                 printk(KERN_ERR "Unable to create ip_conntrack slab cache\n");
    
46.                 goto err_free_hash;
    
47.         }
    
48. 
    
49.         ip_conntrack_expect_cachep = kmem_cache_create("ip_conntrack_expect",
    
50.                                         sizeof(struct ip_conntrack_expect),
    
51.                                         0, 0, NULL, NULL);
    
52.         if (!ip_conntrack_expect_cachep) {
    
53.                 printk(KERN_ERR "Unable to create ip_expect slab cache\n");
    
54.                 goto err_free_conntrack_slab;
    
55.         }
    
56. 
    
57.         /* Don't NEED lock here, but good form anyway. */
    
58.         write_lock_bh(&ip_conntrack_lock);
    
59.         for (i = 0; i < MAX_IP_CT_PROTO; i++)
    
60.                 /*
    
61.                  * potential base upon which issue
    
62.                  * iph->protocol += 32 attack
    
63.                  */
    
64.                 ip_ct_protos[i] = &ip_conntrack_generic_protocol;
    
65.        
    
66.         /* Sew in builtin protocols. */
    
67.         ip_ct_protos[IPPROTO_TCP] = &ip_conntrack_protocol_tcp;
    
68.         ip_ct_protos[IPPROTO_UDP] = &ip_conntrack_protocol_udp;
    
69.         ip_ct_protos[IPPROTO_ICMP] = &ip_conntrack_protocol_icmp;
    
70.         write_unlock_bh(&ip_conntrack_lock);
    
71. 
    
72.         /* For use by ipt_REJECT */
    
73.         ip_ct_attach = ip_conntrack_attach;
    
74. 
    
75.         /* Set up fake conntrack:
    
76.             - to never be deleted, not in any hashes */
    
77.         atomic_set(&ip_conntrack_untracked.ct_general.use, 1);
    
78.         /*  - and look it like as a confirmed connection */
    
79.         set_bit(IPS_CONFIRMED_BIT, &ip_conntrack_untracked.status);
    
80. 
    
81.         return ret;
    
82. 
    
83. err_free_conntrack_slab:
    
84.         kmem_cache_destroy(ip_conntrack_cachep);
    
85. err_free_hash:
    
86.         free_conntrack_hash(ip_conntrack_hash, ip_conntrack_vmalloc,
    
87.                             ip_conntrack_htable_size);
    
88. err_unreg_sockopt:
    
89.         nf_unregister_sockopt(&so_getorigdst);
    
90. 
    
91.         return -ENOMEM;
    
92. }
    

复制代码

[ 本帖最后由 sisi8408 于 2007-8-19 14:33 编辑 ]

sisi8408

1. 
   
2. /*
   
3. * linux-2.6.20.7/net/ipv4/netfilter/ip_conntrack_core.c
   
4. *
   
5. * On success, returns conntrack ptr, sets skb->nfct and ctinfo
   
6. */
   
7. static inline struct ip_conntrack *
   
8. resolve_normal_ct(struct sk_buff *skb,
   
9.                   struct ip_conntrack_protocol *proto,
   
10.                   int *set_reply,
    
11.                   unsigned int hooknum,
    
12.                   enum ip_conntrack_info *ctinfo)
    
13. {
    
14.         struct ip_conntrack_tuple tuple;
    
15.         struct ip_conntrack_tuple_hash *h;
    
16.         struct ip_conntrack *ct;
    
17. 
    
18.         IP_NF_ASSERT((skb->nh.iph->frag_off & htons(IP_OFFSET)) == 0);
    
19. 
    
20.         if (!ip_ct_get_tuple(skb->nh.iph, skb, skb->nh.iph->ihl*4,
    
21.                                 &tuple,proto))
    
22.                 return NULL;
    
23. 
    
24.         /* look for tuple match */
    
25.         h = ip_conntrack_find_get(&tuple, NULL);
    
26.         if (!h) {
    
27.                 /*
    
28.                  * potential base upon which issue
    
29.                  * pure tcp ack attack
    
30.                  */
    
31.                 h = init_conntrack(&tuple, proto, skb);
    
32.                 if (!h)
    
33.                         return NULL;
    
34.                 if (IS_ERR(h))
    
35.                         return (void *)h;
    
36.         }
    
37.         ct = tuplehash_to_ctrack(h);
    
38. 
    
39.         /* It exists; we have (non-exclusive) reference. */
    
40.         if (DIRECTION(h) == IP_CT_DIR_REPLY) {
    
41.                 *ctinfo = IP_CT_ESTABLISHED + IP_CT_IS_REPLY;
    
42.                 /* Please set reply bit if this packet OK */
    
43.                 *set_reply = 1;
    
44.         } else {
    
45.                 /* Once we've had two way comms, always ESTABLISHED. */
    
46.                 if (test_bit(IPS_SEEN_REPLY_BIT, &ct->status)) {
    
47.                         DEBUGP("ip_conntrack_in: normal packet for %p\n",
    
48.                                ct);
    
49.                         *ctinfo = IP_CT_ESTABLISHED;
    
50.                 } else if (test_bit(IPS_EXPECTED_BIT, &ct->status)) {
    
51.                         DEBUGP("ip_conntrack_in: related packet for %p\n",
    
52.                                ct);
    
53.                         *ctinfo = IP_CT_RELATED;
    
54.                 } else {
    
55.                         DEBUGP("ip_conntrack_in: new packet for %p\n",
    
56.                                ct);
    
57.                         *ctinfo = IP_CT_NEW;
    
58.                 }
    
59.                 *set_reply = 0;
    
60.         }
    
61.         skb->nfct = &ct->ct_general;
    
62.         skb->nfctinfo = *ctinfo;
    
63.         return ct;
    
64. }
    

复制代码

sisi8408

1. 
   
2. /*
   
3. * linux-2.6.20.7/net/ipv4/netfilter/ip_conntrack_proto_tcp.c
   
4. */
   
5. static int tcp_in_window(struct ip_ct_tcp *state,
   
6.                          enum ip_conntrack_dir dir,
   
7.                          unsigned int index,
   
8.                          const struct sk_buff *skb,
   
9.                          struct iphdr *iph,
   
10.                          struct tcphdr *tcph)
    
11. {
    
12.         struct ip_ct_tcp_state *sender = &state->seen[dir];
    
13.         struct ip_ct_tcp_state *receiver = &state->seen[!dir];
    
14.         __u32 seq, ack, sack, end, win, swin;
    
15.         int res;
    
16.        
    
17.         /*
    
18.          * Get the required data from the packet.
    
19.          */
    
20.         seq = ntohl(tcph->seq);
    
21.         ack = sack = ntohl(tcph->ack_seq);
    
22.         win = ntohs(tcph->window);
    
23.         end = segment_seq_plus_len(seq, skb->len, iph, tcph);
    
24.        
    
25.         if (receiver->flags & IP_CT_TCP_FLAG_SACK_PERM)
    
26.                 tcp_sack(skb, iph, tcph, &sack);
    
27.                
    
28.         DEBUGP("tcp_in_window: START\n");
    
29.         DEBUGP("tcp_in_window: src=%u.%u.%u.%u:%hu dst=%u.%u.%u.%u:%hu "
    
30.                "seq=%u ack=%u sack=%u win=%u end=%u\n",
    
31.                 NIPQUAD(iph->saddr), ntohs(tcph->source),
    
32.                 NIPQUAD(iph->daddr), ntohs(tcph->dest),
    
33.                 seq, ack, sack, win, end);
    
34.         DEBUGP("tcp_in_window: sender end=%u maxend=%u maxwin=%u scale=%i "
    
35.                "receiver end=%u maxend=%u maxwin=%u scale=%i\n",
    
36.                 sender->td_end, sender->td_maxend, sender->td_maxwin,
    
37.                 sender->td_scale,
    
38.                 receiver->td_end, receiver->td_maxend, receiver->td_maxwin,
    
39.                 receiver->td_scale);
    
40.                
    
41.         if (sender->td_end == 0) {
    
42.                 /*
    
43.                  * Initialize sender data.
    
44.                  */
    
45.                 if (tcph->syn && tcph->ack) {
    
46.                         /*
    
47.                          * Outgoing SYN-ACK in reply to a SYN.
    
48.                          */
    
49.                         sender->td_end =
    
50.                         sender->td_maxend = end;
    
51.                         sender->td_maxwin = (win == 0 ? 1 : win);
    
52. 
    
53.                         tcp_options(skb, iph, tcph, sender);
    
54.                         /*
    
55.                          * RFC 1323:
    
56.                          * Both sides must send the Window Scale option
    
57.                          * to enable window scaling in either direction.
    
58.                          */
    
59.                         if (!(sender->flags & IP_CT_TCP_FLAG_WINDOW_SCALE
    
60.                               && receiver->flags & IP_CT_TCP_FLAG_WINDOW_SCALE))
    
61.                                 sender->td_scale =
    
62.                                 receiver->td_scale = 0;
    
63.                 } else {
    
64.                         /*
    
65.                          * We are in the middle of a connection,
    
66.                          * its history is lost for us.
    
67.                          * Let's try to use the data from the packet.
    
68.                           */
    
69.                          /*
    
70.                           * why not drop/reject pure tcp ack????
    
71.                           */
    
72.                         sender->td_end = end;
    
73.                         sender->td_maxwin = (win == 0 ? 1 : win);
    
74.                         sender->td_maxend = end + sender->td_maxwin;
    
75.                 }
    
76.         } else if (((state->state == TCP_CONNTRACK_SYN_SENT
    
77.                      && dir == IP_CT_DIR_ORIGINAL)
    
78.                     || (state->state == TCP_CONNTRACK_SYN_RECV
    
79.                         && dir == IP_CT_DIR_REPLY))
    
80.                     && after(end, sender->td_end)) {
    
81.                 /*
    
82.                  * RFC 793: "if a TCP is reinitialized ... then it need
    
83.                  * not wait at all; it must only be sure to use sequence
    
84.                  * numbers larger than those recently used."
    
85.                  */
    
86.                 sender->td_end =
    
87.                 sender->td_maxend = end;
    
88.                 sender->td_maxwin = (win == 0 ? 1 : win);
    
89. 
    
90.                 tcp_options(skb, iph, tcph, sender);
    
91.         }
    
92.        
    
93.         if (!(tcph->ack)) {
    
94.                 /*
    
95.                  * If there is no ACK, just pretend it was set and OK.
    
96.                  */
    
97.                 ack = sack = receiver->td_end;
    
98.         } else if (((tcp_flag_word(tcph) & (TCP_FLAG_ACK|TCP_FLAG_RST)) ==
    
99.                     (TCP_FLAG_ACK|TCP_FLAG_RST))
    
100.                    && (ack == 0)) {
     
101.                 /*
     
102.                  * Broken TCP stacks, that set ACK in RST packets as well
     
103.                  * with zero ack value.
     
104.                  */
     
105.                 ack = sack = receiver->td_end;
     
106.         }
     
107. 
     
108.         if (seq == end
     
109.             && (!tcph->rst
     
110.                 || (seq == 0 && state->state == TCP_CONNTRACK_SYN_SENT)))
     
111.                 /*
     
112.                  * Packets contains no data: we assume it is valid
     
113.                  * and check the ack value only.
     
114.                  * However RST segments are always validated by their
     
115.                  * SEQ number, except when seq == 0 (reset sent answering
     
116.                  * SYN.
     
117.                  */
     
118.                 seq = end = sender->td_end;
     
119.                
     
120.         DEBUGP("tcp_in_window: src=%u.%u.%u.%u:%hu dst=%u.%u.%u.%u:%hu "
     
121.                "seq=%u ack=%u sack =%u win=%u end=%u\n",
     
122.                 NIPQUAD(iph->saddr), ntohs(tcph->source),
     
123.                 NIPQUAD(iph->daddr), ntohs(tcph->dest),
     
124.                 seq, ack, sack, win, end);
     
125.         DEBUGP("tcp_in_window: sender end=%u maxend=%u maxwin=%u scale=%i "
     
126.                "receiver end=%u maxend=%u maxwin=%u scale=%i\n",
     
127.                 sender->td_end, sender->td_maxend, sender->td_maxwin,
     
128.                 sender->td_scale,
     
129.                 receiver->td_end, receiver->td_maxend, receiver->td_maxwin,
     
130.                 receiver->td_scale);
     
131.        
     
132.         DEBUGP("tcp_in_window: I=%i II=%i III=%i IV=%i\n",
     
133.                 before(seq, sender->td_maxend + 1),
     
134.                     after(end, sender->td_end - receiver->td_maxwin - 1),
     
135.                     before(sack, receiver->td_end + 1),
     
136.                     after(ack, receiver->td_end - MAXACKWINDOW(sender)));
     
137.        
     
138.         if (sender->loose || receiver->loose ||
     
139.             (before(seq, sender->td_maxend + 1) &&
     
140.              after(end, sender->td_end - receiver->td_maxwin - 1) &&
     
141.              before(sack, receiver->td_end + 1) &&
     
142.              after(ack, receiver->td_end - MAXACKWINDOW(sender)))) {
     
143.                     /*
     
144.                  * Take into account window scaling (RFC 1323).
     
145.                  */
     
146.                 if (!tcph->syn)
     
147.                         win <<= sender->td_scale;
     
148.                
     
149.                 /*
     
150.                  * Update sender data.
     
151.                  */
     
152.                 swin = win + (sack - ack);
     
153.                 if (sender->td_maxwin < swin)
     
154.                         sender->td_maxwin = swin;
     
155.                 if (after(end, sender->td_end))
     
156.                         sender->td_end = end;
     
157.                 /*
     
158.                  * Update receiver data.
     
159.                  */
     
160.                 if (after(end, sender->td_maxend))
     
161.                         receiver->td_maxwin += end - sender->td_maxend;
     
162.                 if (after(sack + win, receiver->td_maxend - 1)) {
     
163.                         receiver->td_maxend = sack + win;
     
164.                         if (win == 0)
     
165.                                 receiver->td_maxend++;
     
166.                 }
     
167. 
     
168.                 /*
     
169.                  * Check retransmissions.
     
170.                  */
     
171.                 if (index == TCP_ACK_SET) {
     
172.                         if (state->last_dir == dir
     
173.                             && state->last_seq == seq
     
174.                             && state->last_ack == ack
     
175.                             && state->last_end == end
     
176.                             && state->last_win == win)
     
177.                                 state->retrans++;
     
178.                         else {
     
179.                                 state->last_dir = dir;
     
180.                                 state->last_seq = seq;
     
181.                                 state->last_ack = ack;
     
182.                                 state->last_end = end;
     
183.                                 state->last_win = win;
     
184.                                 state->retrans = 0;
     
185.                         }
     
186.                 }
     
187.                 /*
     
188.                  * Close the window of disabled window tracking :-)
     
189.                  */
     
190.                 if (sender->loose)
     
191.                         sender->loose--;
     
192.                
     
193.                 res = 1;
     
194.         } else {
     
195.                 if (LOG_INVALID(IPPROTO_TCP))
     
196.                         nf_log_packet(PF_INET, 0, skb, NULL, NULL, NULL,
     
197.                         "ip_ct_tcp: %s ",
     
198.                         before(seq, sender->td_maxend + 1) ?
     
199.                         after(end, sender->td_end - receiver->td_maxwin - 1) ?
     
200.                         before(sack, receiver->td_end + 1) ?
     
201.                         after(ack, receiver->td_end - MAXACKWINDOW(sender)) ? "BUG"
     
202.                         : "ACK is under the lower bound (possible overly delayed ACK)"
     
203.                         : "ACK is over the upper bound (ACKed data not seen yet)"
     
204.                         : "SEQ is under the lower bound (already ACKed data retransmitted)"
     
205.                         : "SEQ is over the upper bound (over the window of the receiver)");
     
206. 
     
207.                 res = ip_ct_tcp_be_liberal;
     
208.           }
     
209.   
     
210.         DEBUGP("tcp_in_window: res=%i sender end=%u maxend=%u maxwin=%u "
     
211.                "receiver end=%u maxend=%u maxwin=%u\n",
     
212.                 res, sender->td_end, sender->td_maxend, sender->td_maxwin,
     
213.                 receiver->td_end, receiver->td_maxend, receiver->td_maxwin);
     
214. 
     
215.         return res;
     
216. }
     

复制代码

mingyanguo

原帖由 sisi8408 于 2007-8-19 11:59 发表
1，敬仰 提交了不少bug给Solaris。
     如果能在CU分享，俺看就是美事。
     还是那句话，您能来发贴，俺就欢迎、知足。呵呵，满意的笑容。

2，提交和搜集不矛盾，也不冲突。 区别只在于GPL。
     想贴 ...

如果对licence有异议，可以考虑换个kernel，这样做，给人的感觉不是太好。