[mirror_ubuntu-bionic-kernel.git] / net / netfilter / xt_tcpudp.c

#include <linux/types.h>
#include <linux/module.h>
#include <net/ip.h>
#include <linux/ipv6.h>
#include <net/ipv6.h>
#include <net/tcp.h>
#include <net/udp.h>
#include <linux/netfilter/x_tables.h>
#include <linux/netfilter/xt_tcpudp.h>
#include <linux/netfilter_ipv4/ip_tables.h>
#include <linux/netfilter_ipv6/ip6_tables.h>

MODULE_DESCRIPTION("x_tables match for TCP and UDP, supports IPv4 and IPv6");
MODULE_LICENSE("GPL");
MODULE_ALIAS("xt_tcp");
MODULE_ALIAS("xt_udp");
MODULE_ALIAS("ipt_udp");
MODULE_ALIAS("ipt_tcp");
MODULE_ALIAS("ip6t_udp");
MODULE_ALIAS("ip6t_tcp");

#ifdef DEBUG_IP_FIREWALL_USER
#define duprintf(format, args...) printk(format , ## args)
#else
#define duprintf(format, args...)
#endif


/* Returns 1 if the port is matched by the range, 0 otherwise */
static inline int
port_match(u_int16_t min, u_int16_t max, u_int16_t port, int invert)
{
	int ret;

	ret = (port >= min && port <= max) ^ invert;
	return ret;
}

static int
tcp_find_option(u_int8_t option,
		const struct sk_buff *skb,
		unsigned int protoff,
		unsigned int optlen,
		int invert,
		int *hotdrop)
{
	/* tcp.doff is only 4 bits, ie. max 15 * 4 bytes */
	u_int8_t _opt[60 - sizeof(struct tcphdr)], *op;
	unsigned int i;

	duprintf("tcp_match: finding option\n");

	if (!optlen)
		return invert;

	/* If we don't have the whole header, drop packet. */
	op = skb_header_pointer(skb, protoff + sizeof(struct tcphdr),
				optlen, _opt);
	if (op == NULL) {
		*hotdrop = 1;
		return 0;
	}

	for (i = 0; i < optlen; ) {
		if (op[i] == option) return !invert;
		if (op[i] < 2) i++;
		else i += op[i+1]?:1;
	}

	return invert;
}

static int
tcp_match(const struct sk_buff *skb,
	  const struct net_device *in,
	  const struct net_device *out,
	  const struct xt_match *match,
	  const void *matchinfo,
	  int offset,
	  unsigned int protoff,
	  int *hotdrop)
{
	struct tcphdr _tcph, *th;
	const struct xt_tcp *tcpinfo = matchinfo;

	if (offset) {
		/* To quote Alan:

		   Don't allow a fragment of TCP 8 bytes in. Nobody normal
		   causes this. Its a cracker trying to break in by doing a
		   flag overwrite to pass the direction checks.
		*/
		if (offset == 1) {
			duprintf("Dropping evil TCP offset=1 frag.\n");
			*hotdrop = 1;
		}
		/* Must not be a fragment. */
		return 0;
	}

#define FWINVTCP(bool,invflg) ((bool) ^ !!(tcpinfo->invflags & invflg))

	th = skb_header_pointer(skb, protoff, sizeof(_tcph), &_tcph);
	if (th == NULL) {
		/* We've been asked to examine this packet, and we
		   can't.  Hence, no choice but to drop. */
		duprintf("Dropping evil TCP offset=0 tinygram.\n");
		*hotdrop = 1;
		return 0;
	}

	if (!port_match(tcpinfo->spts[0], tcpinfo->spts[1],
			ntohs(th->source),
			!!(tcpinfo->invflags & XT_TCP_INV_SRCPT)))
		return 0;
	if (!port_match(tcpinfo->dpts[0], tcpinfo->dpts[1],
			ntohs(th->dest),
			!!(tcpinfo->invflags & XT_TCP_INV_DSTPT)))
		return 0;
	if (!FWINVTCP((((unsigned char *)th)[13] & tcpinfo->flg_mask)
		      == tcpinfo->flg_cmp,
		      XT_TCP_INV_FLAGS))
		return 0;
	if (tcpinfo->option) {
		if (th->doff * 4 < sizeof(_tcph)) {
			*hotdrop = 1;
			return 0;
		}
		if (!tcp_find_option(tcpinfo->option, skb, protoff,
				     th->doff*4 - sizeof(_tcph),
				     tcpinfo->invflags & XT_TCP_INV_OPTION,
				     hotdrop))
			return 0;
	}
	return 1;
}

/* Called when user tries to insert an entry of this type. */
static int
tcp_checkentry(const char *tablename,
	       const void *info,
	       const struct xt_match *match,
	       void *matchinfo,
	       unsigned int matchsize,
	       unsigned int hook_mask)
{
	const struct xt_tcp *tcpinfo = matchinfo;

	/* Must specify no unknown invflags */
	return !(tcpinfo->invflags & ~XT_TCP_INV_MASK);
}

static int
udp_match(const struct sk_buff *skb,
	  const struct net_device *in,
	  const struct net_device *out,
	  const struct xt_match *match,
	  const void *matchinfo,
	  int offset,
	  unsigned int protoff,
	  int *hotdrop)
{
	struct udphdr _udph, *uh;
	const struct xt_udp *udpinfo = matchinfo;

	/* Must not be a fragment. */
	if (offset)
		return 0;

	uh = skb_header_pointer(skb, protoff, sizeof(_udph), &_udph);
	if (uh == NULL) {
		/* We've been asked to examine this packet, and we
		   can't.  Hence, no choice but to drop. */
		duprintf("Dropping evil UDP tinygram.\n");
		*hotdrop = 1;
		return 0;
	}

	return port_match(udpinfo->spts[0], udpinfo->spts[1],
			  ntohs(uh->source),
			  !!(udpinfo->invflags & XT_UDP_INV_SRCPT))
		&& port_match(udpinfo->dpts[0], udpinfo->dpts[1],
			      ntohs(uh->dest),
			      !!(udpinfo->invflags & XT_UDP_INV_DSTPT));
}

/* Called when user tries to insert an entry of this type. */
static int
udp_checkentry(const char *tablename,
	       const void *info,
	       const struct xt_match *match,
	       void *matchinfo,
	       unsigned int matchsize,
	       unsigned int hook_mask)
{
	const struct xt_tcp *udpinfo = matchinfo;

	/* Must specify no unknown invflags */
	return !(udpinfo->invflags & ~XT_UDP_INV_MASK);
}

static struct xt_match tcp_matchstruct = {
	.name		= "tcp",
	.match		= tcp_match,
	.matchsize	= sizeof(struct xt_tcp),
	.proto		= IPPROTO_TCP,
	.family		= AF_INET,
	.checkentry	= tcp_checkentry,
	.me		= THIS_MODULE,
};

static struct xt_match tcp6_matchstruct = {
	.name		= "tcp",
	.match		= tcp_match,
	.matchsize	= sizeof(struct xt_tcp),
	.proto		= IPPROTO_TCP,
	.family		= AF_INET6,
	.checkentry	= tcp_checkentry,
	.me		= THIS_MODULE,
};

static struct xt_match udp_matchstruct = {
	.name		= "udp",
	.match		= udp_match,
	.matchsize	= sizeof(struct xt_udp),
	.proto		= IPPROTO_UDP,
	.family		= AF_INET,
	.checkentry	= udp_checkentry,
	.me		= THIS_MODULE,
};
static struct xt_match udp6_matchstruct = {
	.name		= "udp",
	.match		= udp_match,
	.matchsize	= sizeof(struct xt_udp),
	.proto		= IPPROTO_UDP,
	.family		= AF_INET6,
	.checkentry	= udp_checkentry,
	.me		= THIS_MODULE,
};

static int __init xt_tcpudp_init(void)
{
	int ret;
	ret = xt_register_match(&tcp_matchstruct);
	if (ret)
		return ret;

	ret = xt_register_match(&tcp6_matchstruct);
	if (ret)
		goto out_unreg_tcp;

	ret = xt_register_match(&udp_matchstruct);
	if (ret)
		goto out_unreg_tcp6;
	
	ret = xt_register_match(&udp6_matchstruct);
	if (ret)
		goto out_unreg_udp;

	return ret;

out_unreg_udp:
	xt_unregister_match(&tcp_matchstruct);
out_unreg_tcp6:
	xt_unregister_match(&tcp6_matchstruct);
out_unreg_tcp:
	xt_unregister_match(&tcp_matchstruct);
	return ret;
}

static void __exit xt_tcpudp_fini(void)
{
	xt_unregister_match(&udp6_matchstruct);
	xt_unregister_match(&udp_matchstruct);
	xt_unregister_match(&tcp6_matchstruct);
	xt_unregister_match(&tcp_matchstruct);
}

module_init(xt_tcpudp_init);
module_exit(xt_tcpudp_fini);
Commit	Line	Data
2e4e6a17 HW	1	#include <linux/types.h>
	2	#include <linux/module.h>
	3	#include <net/ip.h>
37d8dc82	4	#include <linux/ipv6.h>
2e4e6a17 HW	5	#include <net/ipv6.h>
	6	#include <net/tcp.h>
	7	#include <net/udp.h>
	8	#include <linux/netfilter/x_tables.h>
	9	#include <linux/netfilter/xt_tcpudp.h>
	10	#include <linux/netfilter_ipv4/ip_tables.h>
	11	#include <linux/netfilter_ipv6/ip6_tables.h>
	12
	13	MODULE_DESCRIPTION("x_tables match for TCP and UDP, supports IPv4 and IPv6");
	14	MODULE_LICENSE("GPL");
	15	MODULE_ALIAS("xt_tcp");
	16	MODULE_ALIAS("xt_udp");
	17	MODULE_ALIAS("ipt_udp");
	18	MODULE_ALIAS("ipt_tcp");
	19	MODULE_ALIAS("ip6t_udp");
	20	MODULE_ALIAS("ip6t_tcp");
	21
	22	#ifdef DEBUG_IP_FIREWALL_USER
	23	#define duprintf(format, args...) printk(format , ## args)
	24	#else
	25	#define duprintf(format, args...)
	26	#endif
	27
	28
	29	/* Returns 1 if the port is matched by the range, 0 otherwise */
	30	static inline int
	31	port_match(u_int16_t min, u_int16_t max, u_int16_t port, int invert)
	32	{
	33	int ret;
	34
	35	ret = (port >= min && port <= max) ^ invert;
	36	return ret;
	37	}
	38
	39	static int
	40	tcp_find_option(u_int8_t option,
	41	const struct sk_buff *skb,
	42	unsigned int protoff,
	43	unsigned int optlen,
	44	int invert,
	45	int *hotdrop)
	46	{
	47	/* tcp.doff is only 4 bits, ie. max 15 * 4 bytes */
	48	u_int8_t _opt[60 - sizeof(struct tcphdr)], *op;
	49	unsigned int i;
	50
	51	duprintf("tcp_match: finding option\n");
	52
	53	if (!optlen)
	54	return invert;
	55
	56	/* If we don't have the whole header, drop packet. */
	57	op = skb_header_pointer(skb, protoff + sizeof(struct tcphdr),
	58	optlen, _opt);
	59	if (op == NULL) {
	60	*hotdrop = 1;
	61	return 0;
	62	}
	63
	64	for (i = 0; i < optlen; ) {
	65	if (op[i] == option) return !invert;
	66	if (op[i] < 2) i++;
	67	else i += op[i+1]?:1;
	68	}
69
70	return invert;
71	}
72
73	static int
74	tcp_match(const struct sk_buff *skb,
75	const struct net_device *in,
76	const struct net_device *out,
c4986734	77	const struct xt_match *match,
2e4e6a17 HW	78	const void *matchinfo,
	79	int offset,
	80	unsigned int protoff,
	81	int *hotdrop)
	82	{
	83	struct tcphdr _tcph, *th;
	84	const struct xt_tcp *tcpinfo = matchinfo;
	85
	86	if (offset) {
	87	/* To quote Alan:
	88
	89	Don't allow a fragment of TCP 8 bytes in. Nobody normal
	90	causes this. Its a cracker trying to break in by doing a
	91	flag overwrite to pass the direction checks.
	92	*/
	93	if (offset == 1) {
	94	duprintf("Dropping evil TCP offset=1 frag.\n");
	95	*hotdrop = 1;
	96	}
	97	/* Must not be a fragment. */
	98	return 0;
	99	}
	100
	101	#define FWINVTCP(bool,invflg) ((bool) ^ !!(tcpinfo->invflags & invflg))
	102
	103	th = skb_header_pointer(skb, protoff, sizeof(_tcph), &_tcph);
	104	if (th == NULL) {
	105	/* We've been asked to examine this packet, and we
	106	can't. Hence, no choice but to drop. */
	107	duprintf("Dropping evil TCP offset=0 tinygram.\n");
	108	*hotdrop = 1;
	109	return 0;
	110	}
	111
	112	if (!port_match(tcpinfo->spts[0], tcpinfo->spts[1],
	113	ntohs(th->source),
	114	!!(tcpinfo->invflags & XT_TCP_INV_SRCPT)))
	115	return 0;
	116	if (!port_match(tcpinfo->dpts[0], tcpinfo->dpts[1],
	117	ntohs(th->dest),
	118	!!(tcpinfo->invflags & XT_TCP_INV_DSTPT)))
	119	return 0;
	120	if (!FWINVTCP((((unsigned char *)th)[13] & tcpinfo->flg_mask)
	121	== tcpinfo->flg_cmp,
	122	XT_TCP_INV_FLAGS))
	123	return 0;
	124	if (tcpinfo->option) {
	125	if (th->doff * 4 < sizeof(_tcph)) {
	126	*hotdrop = 1;
	127	return 0;
	128	}
	129	if (!tcp_find_option(tcpinfo->option, skb, protoff,
	130	th->doff*4 - sizeof(_tcph),
	131	tcpinfo->invflags & XT_TCP_INV_OPTION,
	132	hotdrop))
	133	return 0;
	134	}
	135	return 1;
	136	}
	137
	138	/* Called when user tries to insert an entry of this type. */
	139	static int
	140	tcp_checkentry(const char *tablename,
	141	const void *info,
c4986734	142	const struct xt_match *match,
2e4e6a17 HW	143	void *matchinfo,
	144	unsigned int matchsize,
	145	unsigned int hook_mask)
	146	{
2e4e6a17 HW	147	const struct xt_tcp *tcpinfo = matchinfo;
2e4e6a17 HW	148
5d04bff0 PM	149	/* Must specify no unknown invflags */
5d04bff0 PM	150	return !(tcpinfo->invflags & ~XT_TCP_INV_MASK);
2e4e6a17 HW	151	}
2e4e6a17 HW	152
2e4e6a17 HW	153	static int
	154	udp_match(const struct sk_buff *skb,
	155	const struct net_device *in,
	156	const struct net_device *out,
c4986734	157	const struct xt_match *match,
2e4e6a17 HW	158	const void *matchinfo,
	159	int offset,
	160	unsigned int protoff,
	161	int *hotdrop)
	162	{
	163	struct udphdr _udph, *uh;
	164	const struct xt_udp *udpinfo = matchinfo;
	165
	166	/* Must not be a fragment. */
	167	if (offset)
	168	return 0;
	169
	170	uh = skb_header_pointer(skb, protoff, sizeof(_udph), &_udph);
	171	if (uh == NULL) {
	172	/* We've been asked to examine this packet, and we
	173	can't. Hence, no choice but to drop. */
	174	duprintf("Dropping evil UDP tinygram.\n");
	175	*hotdrop = 1;
	176	return 0;
	177	}
	178
	179	return port_match(udpinfo->spts[0], udpinfo->spts[1],
	180	ntohs(uh->source),
	181	!!(udpinfo->invflags & XT_UDP_INV_SRCPT))
	182	&& port_match(udpinfo->dpts[0], udpinfo->dpts[1],
	183	ntohs(uh->dest),
	184	!!(udpinfo->invflags & XT_UDP_INV_DSTPT));
	185	}
	186
	187	/* Called when user tries to insert an entry of this type. */
	188	static int
	189	udp_checkentry(const char *tablename,
	190	const void *info,
c4986734	191	const struct xt_match *match,
2e4e6a17	192	void *matchinfo,
5d04bff0	193	unsigned int matchsize,
2e4e6a17 HW	194	unsigned int hook_mask)
2e4e6a17 HW	195	{
5d04bff0	196	const struct xt_tcp *udpinfo = matchinfo;
2e4e6a17	197
5d04bff0 PM	198	/* Must specify no unknown invflags */
5d04bff0 PM	199	return !(udpinfo->invflags & ~XT_UDP_INV_MASK);
2e4e6a17 HW	200	}
	201
	202	static struct xt_match tcp_matchstruct = {
	203	.name = "tcp",
5d04bff0 PM	204	.match = tcp_match,
	205	.matchsize = sizeof(struct xt_tcp),
	206	.proto = IPPROTO_TCP,
a45049c5	207	.family = AF_INET,
5d04bff0	208	.checkentry = tcp_checkentry,
2e4e6a17 HW	209	.me = THIS_MODULE,
2e4e6a17 HW	210	};
5d04bff0	211
2e4e6a17 HW	212	static struct xt_match tcp6_matchstruct = {
2e4e6a17 HW	213	.name = "tcp",
5d04bff0 PM	214	.match = tcp_match,
	215	.matchsize = sizeof(struct xt_tcp),
	216	.proto = IPPROTO_TCP,
a45049c5	217	.family = AF_INET6,
5d04bff0	218	.checkentry = tcp_checkentry,
2e4e6a17 HW	219	.me = THIS_MODULE,
	220	};
	221
	222	static struct xt_match udp_matchstruct = {
	223	.name = "udp",
5d04bff0 PM	224	.match = udp_match,
	225	.matchsize = sizeof(struct xt_udp),
	226	.proto = IPPROTO_UDP,
a45049c5	227	.family = AF_INET,
5d04bff0	228	.checkentry = udp_checkentry,
2e4e6a17 HW	229	.me = THIS_MODULE,
	230	};
	231	static struct xt_match udp6_matchstruct = {
	232	.name = "udp",
5d04bff0 PM	233	.match = udp_match,
	234	.matchsize = sizeof(struct xt_udp),
	235	.proto = IPPROTO_UDP,
a45049c5	236	.family = AF_INET6,
5d04bff0	237	.checkentry = udp_checkentry,
2e4e6a17 HW	238	.me = THIS_MODULE,
	239	};
	240
65b4b4e8	241	static int __init xt_tcpudp_init(void)
2e4e6a17 HW	242	{
2e4e6a17 HW	243	int ret;
a45049c5	244	ret = xt_register_match(&tcp_matchstruct);
2e4e6a17 HW	245	if (ret)
	246	return ret;
	247
a45049c5	248	ret = xt_register_match(&tcp6_matchstruct);
2e4e6a17 HW	249	if (ret)
	250	goto out_unreg_tcp;
	251
a45049c5	252	ret = xt_register_match(&udp_matchstruct);
2e4e6a17 HW	253	if (ret)
	254	goto out_unreg_tcp6;
	255
a45049c5	256	ret = xt_register_match(&udp6_matchstruct);
2e4e6a17 HW	257	if (ret)
	258	goto out_unreg_udp;
	259
	260	return ret;
	261
	262	out_unreg_udp:
a45049c5	263	xt_unregister_match(&tcp_matchstruct);
2e4e6a17	264	out_unreg_tcp6:
a45049c5	265	xt_unregister_match(&tcp6_matchstruct);
2e4e6a17	266	out_unreg_tcp:
a45049c5	267	xt_unregister_match(&tcp_matchstruct);
2e4e6a17 HW	268	return ret;
	269	}
	270
65b4b4e8	271	static void __exit xt_tcpudp_fini(void)
2e4e6a17	272	{
a45049c5 PNA	273	xt_unregister_match(&udp6_matchstruct);
	274	xt_unregister_match(&udp_matchstruct);
	275	xt_unregister_match(&tcp6_matchstruct);
	276	xt_unregister_match(&tcp_matchstruct);
2e4e6a17 HW	277	}
2e4e6a17 HW	278
65b4b4e8 AM	279	module_init(xt_tcpudp_init);
65b4b4e8 AM	280	module_exit(xt_tcpudp_fini);