开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
ipt_unclean.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：14k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

ipt_unclean.c：源码内容
  1. /* Kernel module to match suspect packets. */
  2. #include <linux/module.h>
  3. #include <linux/skbuff.h>
  4. #include <linux/ip.h>
  5. #include <linux/udp.h>
  6. #include <linux/tcp.h>
  7. #include <linux/icmp.h>
  8. #include <net/checksum.h>
  10. #include <linux/netfilter_ipv4/ip_tables.h>
  12. #define limpk(format, args...)  
  13. do {  
  14. if (net_ratelimit())  
  15. printk("ipt_unclean: %s" format,  
  16.        embedded ? "(embedded packet) " : "" , ## args);  
  17. } while(0)
  19. enum icmp_error_status
  20. {
  21. ICMP_MAY_BE_ERROR,
  22. ICMP_IS_ERROR,
  23. ICMP_NOT_ERROR
  24. };
  26. struct icmp_info
  27. {
  28. size_t min_len, max_len;
  29. enum icmp_error_status err;
  30. u_int8_t min_code, max_code;
  31. };
  33. static int
  34. check_ip(struct iphdr *iph, size_t length, int embedded);
  36. /* ICMP-specific checks. */
  37. static int
  38. check_icmp(const struct icmphdr *icmph,
  39.    u_int16_t datalen,
  40.    unsigned int offset,
  41.    int more_frags,
  42.    int embedded)
  43. {
  44. static struct icmp_info info[]
  45. = { [ICMP_ECHOREPLY]
  46.     = { 8, 65536, ICMP_NOT_ERROR, 0, 0 },
  47.     [ICMP_DEST_UNREACH]
  48.     = { 8 + 28, 65536, ICMP_IS_ERROR, 0, 15 },
  49.     [ICMP_SOURCE_QUENCH]
  50.     = { 8 + 28, 65536, ICMP_IS_ERROR, 0, 0 },
  51.     [ICMP_REDIRECT]
  52.     = { 8 + 28, 65536, ICMP_IS_ERROR, 0, 3 },
  53.     [ICMP_ECHO]
  54.     = { 8, 65536, ICMP_NOT_ERROR, 0, 0  },
  55.     /* Router advertisement. */
  56.     [9]
  57.     = { 8, 8 + 255 * 8, ICMP_NOT_ERROR, 0, 0 },
  58.     /* Router solicitation. */
  59.     [10]
  60.     = { 8, 8, ICMP_NOT_ERROR, 0, 0 },
  61.     [ICMP_TIME_EXCEEDED]
  62.     = { 8 + 28, 65536, ICMP_IS_ERROR, 0, 1  },
  63.     [ICMP_PARAMETERPROB]
  64.     = { 8 + 28, 65536, ICMP_IS_ERROR, 0, 1 },
  65.     [ICMP_TIMESTAMP]
  66.     = { 20, 20, ICMP_NOT_ERROR, 0, 0 },
  67.     [ICMP_TIMESTAMPREPLY]
  68.     = { 20, 20, ICMP_NOT_ERROR, 0, 0 },
  69.     [ICMP_INFO_REQUEST]
  70.     = { 8, 65536, ICMP_NOT_ERROR, 0, 0 },
  71.     [ICMP_INFO_REPLY]
  72.     = { 8, 65536, ICMP_NOT_ERROR, 0, 0 },
  73.     [ICMP_ADDRESS]
  74.     = { 12, 12, ICMP_NOT_ERROR, 0, 0 },
  75.     [ICMP_ADDRESSREPLY]
  76.     = { 12, 12, ICMP_NOT_ERROR, 0, 0 } };
  78. /* Can't do anything if it's a fragment. */
  79. if (offset)
  80. return 1;
  82. /* Must cover type and code. */
  83. if (datalen < 2) {
  84. limpk("ICMP len=%u too shortn", datalen);
  85. return 0;
  86. }
  88. /* If not embedded. */
  89. if (!embedded) {
  90. /* Bad checksum?  Don't print, just ignore. */
  91. if (!more_frags
  92.     && ip_compute_csum((unsigned char *) icmph, datalen) != 0)
  93. return 0;
  95. /* CHECK: Truncated ICMP (even if first fragment). */
  96. if (icmph->type < sizeof(info)/sizeof(struct icmp_info)
  97.     && info[icmph->type].min_len != 0
  98.     && datalen < info[icmph->type].min_len) {
  99. limpk("ICMP type %u len %u too shortn",
  100.       icmph->type, datalen);
  101. return 0;
  102. }
  104. /* CHECK: Check within known error ICMPs. */
  105. if (icmph->type < sizeof(info)/sizeof(struct icmp_info)
  106.     && info[icmph->type].err == ICMP_IS_ERROR) {
  107. /* CHECK: Embedded packet must be at least
  108.    length of iph + 8 bytes. */
  109. struct iphdr *inner = (void *)icmph + 8;
  111. /* datalen > 8 since all ICMP_IS_ERROR types
  112.                            have min length > 8 */
  113. if (datalen - 8 < sizeof(struct iphdr)) {
  114. limpk("ICMP error internal way too shortn");
  115. return 0;
  116. }
  117. if (datalen - 8 < inner->ihl*4 + 8) {
  118. limpk("ICMP error internal too shortn");
  119. return 0;
  120. }
  121. if (!check_ip(inner, datalen - 8, 1))
  122. return 0;
  123. }
  124. } else {
  125. /* CHECK: Can't embed ICMP unless known non-error. */
  126. if (icmph->type >= sizeof(info)/sizeof(struct icmp_info)
  127.     || info[icmph->type].err != ICMP_NOT_ERROR) {
  128. limpk("ICMP type %u not embeddablen",
  129.       icmph->type);
  130. return 0;
  131. }
  132. }
  134. /* CHECK: Invalid ICMP codes. */
  135. if (icmph->type < sizeof(info)/sizeof(struct icmp_info)
  136.     && (icmph->code < info[icmph->type].min_code
  137. || icmph->code > info[icmph->type].max_code)) {
  138. limpk("ICMP type=%u code=%un",
  139.       icmph->type, icmph->code);
  140. return 0;
  141. }
  143. /* CHECK: Above maximum length. */
  144. if (icmph->type < sizeof(info)/sizeof(struct icmp_info)
  145.     && info[icmph->type].max_len != 0
  146.     && datalen > info[icmph->type].max_len) {
  147. limpk("ICMP type=%u too long: %u bytesn",
  148.       icmph->type, datalen);
  149. return 0;
  150. }
  152. switch (icmph->type) {
  153. case ICMP_PARAMETERPROB: {
  154. /* CHECK: Problem param must be within error packet's
  155.  * IP header. */
  156. struct iphdr *iph = (void *)icmph + 8;
  157. u_int32_t arg = ntohl(icmph->un.gateway);
  159. if (icmph->code == 0) {
  160. /* Code 0 means that upper 8 bits is pointer
  161.                            to problem. */
  162. if ((arg >> 24) >= iph->ihl*4) {
  163. limpk("ICMP PARAMETERPROB ptr = %un",
  164.       ntohl(icmph->un.gateway) >> 24);
  165. return 0;
  166. }
  167. arg &= 0x00FFFFFF;
  168. }
  170. /* CHECK: Rest must be zero. */
  171. if (arg) {
  172. limpk("ICMP PARAMETERPROB nonzero arg = %un",
  173.       arg);
  174. return 0;
  175. }
  176. break;
  177. }
  179. case ICMP_TIME_EXCEEDED:
  180. case ICMP_SOURCE_QUENCH:
  181. /* CHECK: Unused must be zero. */
  182. if (icmph->un.gateway != 0) {
  183. limpk("ICMP type=%u unused = %un",
  184.       icmph->type, ntohl(icmph->un.gateway));
  185. return 0;
  186. }
  187. break;
  188. }
  190. return 1;
  191. }
  193. /* UDP-specific checks. */
  194. static int
  195. check_udp(const struct iphdr *iph,
  196.   const struct udphdr *udph,
  197.   u_int16_t datalen,
  198.   unsigned int offset,
  199.   int more_frags,
  200.   int embedded)
  201. {
  202. /* Can't do anything if it's a fragment. */
  203. if (offset)
  204. return 1;
  206. /* CHECK: Must cover UDP header. */
  207. if (datalen < sizeof(struct udphdr)) {
  208. limpk("UDP len=%u too shortn", datalen);
  209. return 0;
  210. }
  212. /* Bad checksum?  Don't print, just say it's unclean. */
  213. /* FIXME: SRC ROUTE packets won't match checksum --RR */
  214. if (!more_frags && !embedded && udph->check
  215.     && csum_tcpudp_magic(iph->saddr, iph->daddr, datalen, IPPROTO_UDP,
  216.  csum_partial((char *)udph, datalen, 0)) != 0)
  217. return 0;
  219. /* CHECK: Destination port can't be zero. */
  220. if (!udph->dest) {
  221. limpk("UDP zero destination portn");
  222. return 0;
  223. }
  225. if (!more_frags) {
  226. if (!embedded) {
  227. /* CHECK: UDP length must match. */
  228. if (ntohs(udph->len) != datalen) {
  229. limpk("UDP len too short %u vs %un",
  230.       ntohs(udph->len), datalen);
  231. return 0;
  232. }
  233. } else {
  234. /* CHECK: UDP length be >= this truncated pkt. */
  235. if (ntohs(udph->len) < datalen) {
  236. limpk("UDP len too long %u vs %un",
  237.       ntohs(udph->len), datalen);
  238. return 0;
  239. }
  240. }
  241. } else {
  242. /* CHECK: UDP length must be > this frag's length. */
  243. if (ntohs(udph->len) <= datalen) {
  244. limpk("UDP fragment len too short %u vs %un",
  245.       ntohs(udph->len), datalen);
  246. return 0;
  247. }
  248. }
  250. return 1;
  251. }
  253. #define TH_FIN 0x01
  254. #define TH_SYN 0x02
  255. #define TH_RST 0x04
  256. #define TH_PUSH 0x08
  257. #define TH_ACK 0x10
  258. #define TH_URG 0x20
  259. #define TH_ECE 0x40
  260. #define TH_CWR 0x80
  262. /* TCP-specific checks. */
  263. static int
  264. check_tcp(const struct iphdr *iph,
  265.   const struct tcphdr *tcph,
  266.   u_int16_t datalen,
  267.   unsigned int offset,
  268.   int more_frags,
  269.   int embedded)
  270. {
  271. u_int8_t *opt = (u_int8_t *)tcph;
  272. u_int8_t *endhdr = (u_int8_t *)tcph + tcph->doff * 4;
  273. u_int8_t tcpflags;
  274. int end_of_options = 0;
  275. size_t i;
  277. /* CHECK: Can't have offset=1: used to override TCP syn-checks. */
  278. /* In fact, this is caught below (offset < 516). */
  280. /* Can't do anything if it's a fragment. */
  281. if (offset)
  282. return 1;
  284. /* CHECK: Smaller than minimal TCP hdr. */
  285. if (datalen < sizeof(struct tcphdr)) {
  286. if (!embedded) {
  287. limpk("Packet length %u < TCP header.n", datalen);
  288. return 0;
  289. }
  290. /* Must have ports available (datalen >= 8), from
  291.                    check_icmp which set embedded = 1 */
  292. /* CHECK: TCP ports inside ICMP error */
  293. if (!tcph->source || !tcph->dest) {
  294. limpk("Zero TCP ports %u/%u.n",
  295.       htons(tcph->source), htons(tcph->dest));
  296. return 0;
  297. }
  298. return 1;
  299. }
  301. /* CHECK: Smaller than actual TCP hdr. */
  302. if (datalen < tcph->doff * 4) {
  303. if (!embedded) {
  304. limpk("Packet length %u < actual TCP header.n",
  305.       datalen);
  306. return 0;
  307. } else
  308. return 1;
  309. }
  311. /* Bad checksum?  Don't print, just say it's unclean. */
  312. /* FIXME: SRC ROUTE packets won't match checksum --RR */
  313. if (!more_frags && !embedded
  314.     && csum_tcpudp_magic(iph->saddr, iph->daddr, datalen, IPPROTO_TCP,
  315.  csum_partial((char *)tcph, datalen, 0)) != 0)
  316. return 0;
  318. /* CHECK: TCP ports non-zero */
  319. if (!tcph->source || !tcph->dest) {
  320. limpk("Zero TCP ports %u/%u.n",
  321.       htons(tcph->source), htons(tcph->dest));
  322. return 0;
  323. }
  325. /* CHECK: TCP reserved bits zero. */
  326. if(tcp_flag_word(tcph) & TCP_RESERVED_BITS) {
  327. limpk("TCP reserved bits not zeron");
  328. return 0;
  329. }
  331. /* CHECK: TCP flags. */
  332. tcpflags = (((u_int8_t *)tcph)[13] & ~(TH_ECE|TH_CWR));
  333. if (tcpflags != TH_SYN
  334.     && tcpflags != (TH_SYN|TH_ACK)
  335. && tcpflags != TH_RST
  336.     && tcpflags != (TH_RST|TH_ACK)
  337.     && tcpflags != (TH_RST|TH_ACK|TH_PUSH)
  338.     && tcpflags != (TH_FIN|TH_ACK)
  339.     && tcpflags != TH_ACK
  340.     && tcpflags != (TH_ACK|TH_PUSH)
  341.     && tcpflags != (TH_ACK|TH_URG)
  342.     && tcpflags != (TH_ACK|TH_URG|TH_PUSH)
  343.     && tcpflags != (TH_FIN|TH_ACK|TH_PUSH)
  344.     && tcpflags != (TH_FIN|TH_ACK|TH_URG)
  345.     && tcpflags != (TH_FIN|TH_ACK|TH_URG|TH_PUSH)) {
  346. limpk("TCP flags bad: %un", tcpflags);
  347. return 0;
  348. }
  350. for (i = sizeof(struct tcphdr); i < tcph->doff * 4; ) {
  351. switch (opt[i]) {
  352. case 0:
  353. end_of_options = 1;
  354. i++;
  355. break;
  356. case 1:
  357. i++;
  358. break;
  359. default:
  360. /* CHECK: options after EOO. */
  361. if (end_of_options) {
  362. limpk("TCP option %u after endn",
  363.       opt[i]);
  364. return 0;
  365. }
  366. /* CHECK: options at tail. */
  367. else if (i+1 >= tcph->doff * 4) {
  368. limpk("TCP option %u at tailn",
  369.       opt[i]);
  370. return 0;
  371. }
  372. /* CHECK: zero-length options. */
  373. else if (opt[i+1] == 0) {
  374. limpk("TCP option %u 0 lenn",
  375.       opt[i]);
  376. return 0;
  377. }
  378. /* CHECK: oversize options. */
  379. else if (&opt[i] + opt[i+1] > endhdr) {
  380. limpk("TCP option %u at %Zu too longn",
  381.       (unsigned int) opt[i], i);
  382. return 0;
  383. }
  384. /* Move to next option */
  385. i += opt[i+1];
  386. }
  387. }
  389. return 1;
  390. }
  392. /* Returns 1 if ok */
  393. /* Standard IP checks. */
  394. static int
  395. check_ip(struct iphdr *iph, size_t length, int embedded)
  396. {
  397. u_int8_t *opt = (u_int8_t *)iph;
  398. u_int8_t *endhdr = (u_int8_t *)iph + iph->ihl * 4;
  399. int end_of_options = 0;
  400. void *protoh;
  401. size_t datalen;
  402. unsigned int i;
  403. unsigned int offset;
  405. /* Should only happen for local outgoing raw-socket packets. */
  406. /* CHECK: length >= ip header. */
  407. if (length < sizeof(struct iphdr) || length < iph->ihl * 4) {
  408. limpk("Packet length %Zu < IP header.n", length);
  409. return 0;
  410. }
  412. offset = ntohs(iph->frag_off) & IP_OFFSET;
  413. protoh = (void *)iph + iph->ihl * 4;
  414. datalen = length - iph->ihl * 4;
  416. /* CHECK: Embedded fragment. */
  417. if (embedded && offset) {
  418. limpk("Embedded fragment.n");
  419. return 0;
  420. }
  422. for (i = sizeof(struct iphdr); i < iph->ihl * 4; ) {
  423. switch (opt[i]) {
  424. case 0:
  425. end_of_options = 1;
  426. i++;
  427. break;
  428. case 1:
  429. i++;
  430. break;
  431. default:
  432. /* CHECK: options after EOO. */
  433. if (end_of_options) {
  434. limpk("IP option %u after endn",
  435.       opt[i]);
  436. return 0;
  437. }
  438. /* CHECK: options at tail. */
  439. else if (i+1 >= iph->ihl * 4) {
  440. limpk("IP option %u at tailn",
  441.       opt[i]);
  442. return 0;
  443. }
  444. /* CHECK: zero-length or one-length options. */
  445. else if (opt[i+1] < 2) {
  446. limpk("IP option %u %u lenn",
  447.       opt[i], opt[i+1]);
  448. return 0;
  449. }
  450. /* CHECK: oversize options. */
  451. else if (&opt[i] + opt[i+1] > endhdr) {
  452. limpk("IP option %u at %u too longn",
  453.       opt[i], i);
  454. return 0;
  455. }
  456. /* Move to next option */
  457. i += opt[i+1];
  458. }
  459. }
  461. /* Fragment checks. */
  463. /* CHECK: More fragments, but doesn't fill 8-byte boundary. */
  464. if ((ntohs(iph->frag_off) & IP_MF)
  465.     && (ntohs(iph->tot_len) % 8) != 0) {
  466. limpk("Truncated fragment %u long.n", ntohs(iph->tot_len));
  467. return 0;
  468. }
  470. /* CHECK: Oversize fragment a-la Ping of Death. */
  471. if (offset * 8 + datalen > 65535) {
  472. limpk("Oversize fragment to %u.n", offset * 8);
  473. return 0;
  474. }
  476. /* CHECK: DF set and offset or MF set. */
  477. if ((ntohs(iph->frag_off) & IP_DF)
  478.     && (offset || (ntohs(iph->frag_off) & IP_MF))) {
  479. limpk("DF set and offset=%u, MF=%u.n",
  480.       offset, ntohs(iph->frag_off) & IP_MF);
  481. return 0;
  482. }
  484. /* CHECK: Zero-sized fragments. */
  485. if ((offset || (ntohs(iph->frag_off) & IP_MF))
  486.     && datalen == 0) {
  487. limpk("Zero size fragment offset=%un", offset);
  488. return 0;
  489. }
  491. /* Note: we can have even middle fragments smaller than this:
  492.    consider a large packet passing through a 600MTU then
  493.    576MTU link: this gives a fragment of 24 data bytes.  But
  494.    everyone packs fragments largest first, hence a fragment
  495.    can't START before 576 - MAX_IP_HEADER_LEN. */
  497. /* Used to be min-size 576: I recall Alan Cox saying ax25 goes
  498.    down to 128 (576 taken from RFC 791: All hosts must be
  499.    prepared to accept datagrams of up to 576 octets).  Use 128
  500.    here. */
  501. #define MIN_LIKELY_MTU 128
  502. /* CHECK: Min size of first frag = 128. */
  503. if ((ntohs(iph->frag_off) & IP_MF)
  504.     && offset == 0
  505.     && ntohs(iph->tot_len) < MIN_LIKELY_MTU) {
  506. limpk("First fragment size %u < %un", ntohs(iph->tot_len),
  507.       MIN_LIKELY_MTU);
  508. return 0;
  509. }
  511. /* CHECK: Min offset of frag = 128 - IP hdr len. */
  512. if (offset && offset * 8 < MIN_LIKELY_MTU - iph->ihl * 4) {
  513. limpk("Fragment starts at %u < %un", offset * 8,
  514.       MIN_LIKELY_MTU - iph->ihl * 4);
  515. return 0;
  516. }
  518. /* CHECK: Protocol specification non-zero. */
  519. if (iph->protocol == 0) {
  520. limpk("Zero protocoln");
  521. return 0;
  522. }
  524. /* Per-protocol checks. */
  525. switch (iph->protocol) {
  526. case IPPROTO_ICMP:
  527. return check_icmp(protoh, datalen, offset,
  528.   (ntohs(iph->frag_off) & IP_MF),
  529.   embedded);
  531. case IPPROTO_UDP:
  532. return check_udp(iph, protoh, datalen, offset,
  533.  (ntohs(iph->frag_off) & IP_MF),
  534.  embedded);
  536. case IPPROTO_TCP:
  537. return check_tcp(iph, protoh, datalen, offset,
  538.  (ntohs(iph->frag_off) & IP_MF),
  539.  embedded);
  540. default:
  541. /* Ignorance is bliss. */
  542. return 1;
  543. }
  544. }
  546. static int
  547. match(const struct sk_buff *skb,
  548.       const struct net_device *in,
  549.       const struct net_device *out,
  550.       const void *matchinfo,
  551.       int offset,
  552.       const void *hdr,
  553.       u_int16_t datalen,
  554.       int *hotdrop)
  555. {
  556. return !check_ip(skb->nh.iph, skb->len, 0);
  557. }
  559. /* Called when user tries to insert an entry of this type. */
  560. static int
  561. checkentry(const char *tablename,
  562.    const struct ipt_ip *ip,
  563.    void *matchinfo,
  564.    unsigned int matchsize,
  565.    unsigned int hook_mask)
  566. {
  567. if (matchsize != IPT_ALIGN(0))
  568. return 0;
  570. return 1;
  571. }
  573. static struct ipt_match unclean_match
  574. = { { NULL, NULL }, "unclean", &match, &checkentry, NULL, THIS_MODULE };
  576. static int __init init(void)
  577. {
  578. return ipt_register_match(&unclean_match);
  579. }
  581. static void __exit fini(void)
  582. {
  583. ipt_unregister_match(&unclean_match);
  584. }
  586. module_init(init);
  587. module_exit(fini);
  588. MODULE_LICENSE("GPL");