nft_chain_filter.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445
  1. #include <linux/init.h>
  2. #include <linux/kernel.h>
  3. #include <linux/netdevice.h>
  4. #include <net/net_namespace.h>
  5. #include <net/netfilter/nf_tables.h>
  6. #include <linux/netfilter_ipv4.h>
  7. #include <linux/netfilter_ipv6.h>
  8. #include <linux/netfilter_bridge.h>
  9. #include <linux/netfilter_arp.h>
  10. #include <net/netfilter/nf_tables_ipv4.h>
  11. #include <net/netfilter/nf_tables_ipv6.h>
  12. #ifdef CONFIG_NF_TABLES_IPV4
  13. static unsigned int nft_do_chain_ipv4(void *priv,
  14. struct sk_buff *skb,
  15. const struct nf_hook_state *state)
  16. {
  17. struct nft_pktinfo pkt;
  18. nft_set_pktinfo(&pkt, skb, state);
  19. nft_set_pktinfo_ipv4(&pkt, skb);
  20. return nft_do_chain(&pkt, priv);
  21. }
  22. static const struct nft_chain_type nft_chain_filter_ipv4 = {
  23. .name = "filter",
  24. .type = NFT_CHAIN_T_DEFAULT,
  25. .family = NFPROTO_IPV4,
  26. .hook_mask = (1 << NF_INET_LOCAL_IN) |
  27. (1 << NF_INET_LOCAL_OUT) |
  28. (1 << NF_INET_FORWARD) |
  29. (1 << NF_INET_PRE_ROUTING) |
  30. (1 << NF_INET_POST_ROUTING),
  31. .hooks = {
  32. [NF_INET_LOCAL_IN] = nft_do_chain_ipv4,
  33. [NF_INET_LOCAL_OUT] = nft_do_chain_ipv4,
  34. [NF_INET_FORWARD] = nft_do_chain_ipv4,
  35. [NF_INET_PRE_ROUTING] = nft_do_chain_ipv4,
  36. [NF_INET_POST_ROUTING] = nft_do_chain_ipv4,
  37. },
  38. };
  39. static void nft_chain_filter_ipv4_init(void)
  40. {
  41. nft_register_chain_type(&nft_chain_filter_ipv4);
  42. }
  43. static void nft_chain_filter_ipv4_fini(void)
  44. {
  45. nft_unregister_chain_type(&nft_chain_filter_ipv4);
  46. }
  47. #else
  48. static inline void nft_chain_filter_ipv4_init(void) {}
  49. static inline void nft_chain_filter_ipv4_fini(void) {}
  50. #endif /* CONFIG_NF_TABLES_IPV4 */
  51. #ifdef CONFIG_NF_TABLES_ARP
  52. static unsigned int nft_do_chain_arp(void *priv, struct sk_buff *skb,
  53. const struct nf_hook_state *state)
  54. {
  55. struct nft_pktinfo pkt;
  56. nft_set_pktinfo(&pkt, skb, state);
  57. nft_set_pktinfo_unspec(&pkt, skb);
  58. return nft_do_chain(&pkt, priv);
  59. }
  60. static const struct nft_chain_type nft_chain_filter_arp = {
  61. .name = "filter",
  62. .type = NFT_CHAIN_T_DEFAULT,
  63. .family = NFPROTO_ARP,
  64. .owner = THIS_MODULE,
  65. .hook_mask = (1 << NF_ARP_IN) |
  66. (1 << NF_ARP_OUT),
  67. .hooks = {
  68. [NF_ARP_IN] = nft_do_chain_arp,
  69. [NF_ARP_OUT] = nft_do_chain_arp,
  70. },
  71. };
  72. static void nft_chain_filter_arp_init(void)
  73. {
  74. nft_register_chain_type(&nft_chain_filter_arp);
  75. }
  76. static void nft_chain_filter_arp_fini(void)
  77. {
  78. nft_unregister_chain_type(&nft_chain_filter_arp);
  79. }
  80. #else
  81. static inline void nft_chain_filter_arp_init(void) {}
  82. static inline void nft_chain_filter_arp_fini(void) {}
  83. #endif /* CONFIG_NF_TABLES_ARP */
  84. #ifdef CONFIG_NF_TABLES_IPV6
  85. static unsigned int nft_do_chain_ipv6(void *priv,
  86. struct sk_buff *skb,
  87. const struct nf_hook_state *state)
  88. {
  89. struct nft_pktinfo pkt;
  90. nft_set_pktinfo(&pkt, skb, state);
  91. nft_set_pktinfo_ipv6(&pkt, skb);
  92. return nft_do_chain(&pkt, priv);
  93. }
  94. static const struct nft_chain_type nft_chain_filter_ipv6 = {
  95. .name = "filter",
  96. .type = NFT_CHAIN_T_DEFAULT,
  97. .family = NFPROTO_IPV6,
  98. .hook_mask = (1 << NF_INET_LOCAL_IN) |
  99. (1 << NF_INET_LOCAL_OUT) |
  100. (1 << NF_INET_FORWARD) |
  101. (1 << NF_INET_PRE_ROUTING) |
  102. (1 << NF_INET_POST_ROUTING),
  103. .hooks = {
  104. [NF_INET_LOCAL_IN] = nft_do_chain_ipv6,
  105. [NF_INET_LOCAL_OUT] = nft_do_chain_ipv6,
  106. [NF_INET_FORWARD] = nft_do_chain_ipv6,
  107. [NF_INET_PRE_ROUTING] = nft_do_chain_ipv6,
  108. [NF_INET_POST_ROUTING] = nft_do_chain_ipv6,
  109. },
  110. };
  111. static void nft_chain_filter_ipv6_init(void)
  112. {
  113. nft_register_chain_type(&nft_chain_filter_ipv6);
  114. }
  115. static void nft_chain_filter_ipv6_fini(void)
  116. {
  117. nft_unregister_chain_type(&nft_chain_filter_ipv6);
  118. }
  119. #else
  120. static inline void nft_chain_filter_ipv6_init(void) {}
  121. static inline void nft_chain_filter_ipv6_fini(void) {}
  122. #endif /* CONFIG_NF_TABLES_IPV6 */
  123. #ifdef CONFIG_NF_TABLES_INET
  124. static unsigned int nft_do_chain_inet(void *priv, struct sk_buff *skb,
  125. const struct nf_hook_state *state)
  126. {
  127. struct nft_pktinfo pkt;
  128. nft_set_pktinfo(&pkt, skb, state);
  129. switch (state->pf) {
  130. case NFPROTO_IPV4:
  131. nft_set_pktinfo_ipv4(&pkt, skb);
  132. break;
  133. case NFPROTO_IPV6:
  134. nft_set_pktinfo_ipv6(&pkt, skb);
  135. break;
  136. default:
  137. break;
  138. }
  139. return nft_do_chain(&pkt, priv);
  140. }
  141. static unsigned int nft_do_chain_inet_ingress(void *priv, struct sk_buff *skb,
  142. const struct nf_hook_state *state)
  143. {
  144. struct nf_hook_state ingress_state = *state;
  145. struct nft_pktinfo pkt;
  146. switch (skb->protocol) {
  147. case htons(ETH_P_IP):
  148. /* Original hook is NFPROTO_NETDEV and NF_NETDEV_INGRESS. */
  149. ingress_state.pf = NFPROTO_IPV4;
  150. ingress_state.hook = NF_INET_INGRESS;
  151. nft_set_pktinfo(&pkt, skb, &ingress_state);
  152. if (nft_set_pktinfo_ipv4_ingress(&pkt, skb) < 0)
  153. return NF_DROP;
  154. break;
  155. case htons(ETH_P_IPV6):
  156. ingress_state.pf = NFPROTO_IPV6;
  157. ingress_state.hook = NF_INET_INGRESS;
  158. nft_set_pktinfo(&pkt, skb, &ingress_state);
  159. if (nft_set_pktinfo_ipv6_ingress(&pkt, skb) < 0)
  160. return NF_DROP;
  161. break;
  162. default:
  163. return NF_ACCEPT;
  164. }
  165. return nft_do_chain(&pkt, priv);
  166. }
  167. static const struct nft_chain_type nft_chain_filter_inet = {
  168. .name = "filter",
  169. .type = NFT_CHAIN_T_DEFAULT,
  170. .family = NFPROTO_INET,
  171. .hook_mask = (1 << NF_INET_INGRESS) |
  172. (1 << NF_INET_LOCAL_IN) |
  173. (1 << NF_INET_LOCAL_OUT) |
  174. (1 << NF_INET_FORWARD) |
  175. (1 << NF_INET_PRE_ROUTING) |
  176. (1 << NF_INET_POST_ROUTING),
  177. .hooks = {
  178. [NF_INET_INGRESS] = nft_do_chain_inet_ingress,
  179. [NF_INET_LOCAL_IN] = nft_do_chain_inet,
  180. [NF_INET_LOCAL_OUT] = nft_do_chain_inet,
  181. [NF_INET_FORWARD] = nft_do_chain_inet,
  182. [NF_INET_PRE_ROUTING] = nft_do_chain_inet,
  183. [NF_INET_POST_ROUTING] = nft_do_chain_inet,
  184. },
  185. };
  186. static void nft_chain_filter_inet_init(void)
  187. {
  188. nft_register_chain_type(&nft_chain_filter_inet);
  189. }
  190. static void nft_chain_filter_inet_fini(void)
  191. {
  192. nft_unregister_chain_type(&nft_chain_filter_inet);
  193. }
  194. #else
  195. static inline void nft_chain_filter_inet_init(void) {}
  196. static inline void nft_chain_filter_inet_fini(void) {}
  197. #endif /* CONFIG_NF_TABLES_IPV6 */
  198. #if IS_ENABLED(CONFIG_NF_TABLES_BRIDGE)
  199. static unsigned int
  200. nft_do_chain_bridge(void *priv,
  201. struct sk_buff *skb,
  202. const struct nf_hook_state *state)
  203. {
  204. struct nft_pktinfo pkt;
  205. nft_set_pktinfo(&pkt, skb, state);
  206. switch (eth_hdr(skb)->h_proto) {
  207. case htons(ETH_P_IP):
  208. nft_set_pktinfo_ipv4_validate(&pkt, skb);
  209. break;
  210. case htons(ETH_P_IPV6):
  211. nft_set_pktinfo_ipv6_validate(&pkt, skb);
  212. break;
  213. default:
  214. nft_set_pktinfo_unspec(&pkt, skb);
  215. break;
  216. }
  217. return nft_do_chain(&pkt, priv);
  218. }
  219. static const struct nft_chain_type nft_chain_filter_bridge = {
  220. .name = "filter",
  221. .type = NFT_CHAIN_T_DEFAULT,
  222. .family = NFPROTO_BRIDGE,
  223. .hook_mask = (1 << NF_BR_PRE_ROUTING) |
  224. (1 << NF_BR_LOCAL_IN) |
  225. (1 << NF_BR_FORWARD) |
  226. (1 << NF_BR_LOCAL_OUT) |
  227. (1 << NF_BR_POST_ROUTING),
  228. .hooks = {
  229. [NF_BR_PRE_ROUTING] = nft_do_chain_bridge,
  230. [NF_BR_LOCAL_IN] = nft_do_chain_bridge,
  231. [NF_BR_FORWARD] = nft_do_chain_bridge,
  232. [NF_BR_LOCAL_OUT] = nft_do_chain_bridge,
  233. [NF_BR_POST_ROUTING] = nft_do_chain_bridge,
  234. },
  235. };
  236. static void nft_chain_filter_bridge_init(void)
  237. {
  238. nft_register_chain_type(&nft_chain_filter_bridge);
  239. }
  240. static void nft_chain_filter_bridge_fini(void)
  241. {
  242. nft_unregister_chain_type(&nft_chain_filter_bridge);
  243. }
  244. #else
  245. static inline void nft_chain_filter_bridge_init(void) {}
  246. static inline void nft_chain_filter_bridge_fini(void) {}
  247. #endif /* CONFIG_NF_TABLES_BRIDGE */
  248. #ifdef CONFIG_NF_TABLES_NETDEV
  249. static unsigned int nft_do_chain_netdev(void *priv, struct sk_buff *skb,
  250. const struct nf_hook_state *state)
  251. {
  252. struct nft_pktinfo pkt;
  253. nft_set_pktinfo(&pkt, skb, state);
  254. switch (skb->protocol) {
  255. case htons(ETH_P_IP):
  256. nft_set_pktinfo_ipv4_validate(&pkt, skb);
  257. break;
  258. case htons(ETH_P_IPV6):
  259. nft_set_pktinfo_ipv6_validate(&pkt, skb);
  260. break;
  261. default:
  262. nft_set_pktinfo_unspec(&pkt, skb);
  263. break;
  264. }
  265. return nft_do_chain(&pkt, priv);
  266. }
  267. static const struct nft_chain_type nft_chain_filter_netdev = {
  268. .name = "filter",
  269. .type = NFT_CHAIN_T_DEFAULT,
  270. .family = NFPROTO_NETDEV,
  271. .hook_mask = (1 << NF_NETDEV_INGRESS),
  272. .hooks = {
  273. [NF_NETDEV_INGRESS] = nft_do_chain_netdev,
  274. },
  275. };
  276. static void nft_netdev_event(unsigned long event, struct net_device *dev,
  277. struct nft_ctx *ctx)
  278. {
  279. struct nft_base_chain *basechain = nft_base_chain(ctx->chain);
  280. struct nft_hook *hook, *found = NULL;
  281. int n = 0;
  282. if (event != NETDEV_UNREGISTER)
  283. return;
  284. list_for_each_entry(hook, &basechain->hook_list, list) {
  285. if (hook->ops.dev == dev)
  286. found = hook;
  287. n++;
  288. }
  289. if (!found)
  290. return;
  291. if (n > 1) {
  292. nf_unregister_net_hook(ctx->net, &found->ops);
  293. list_del_rcu(&found->list);
  294. kfree_rcu(found, rcu);
  295. return;
  296. }
  297. /* UNREGISTER events are also happening on netns exit.
  298. *
  299. * Although nf_tables core releases all tables/chains, only this event
  300. * handler provides guarantee that hook->ops.dev is still accessible,
  301. * so we cannot skip exiting net namespaces.
  302. */
  303. __nft_release_basechain(ctx);
  304. }
  305. static int nf_tables_netdev_event(struct notifier_block *this,
  306. unsigned long event, void *ptr)
  307. {
  308. struct net_device *dev = netdev_notifier_info_to_dev(ptr);
  309. struct nft_table *table;
  310. struct nft_chain *chain, *nr;
  311. struct nft_ctx ctx = {
  312. .net = dev_net(dev),
  313. };
  314. if (event != NETDEV_UNREGISTER &&
  315. event != NETDEV_CHANGENAME)
  316. return NOTIFY_DONE;
  317. mutex_lock(&ctx.net->nft.commit_mutex);
  318. list_for_each_entry(table, &ctx.net->nft.tables, list) {
  319. if (table->family != NFPROTO_NETDEV)
  320. continue;
  321. ctx.family = table->family;
  322. ctx.table = table;
  323. list_for_each_entry_safe(chain, nr, &table->chains, list) {
  324. if (!nft_is_base_chain(chain))
  325. continue;
  326. ctx.chain = chain;
  327. nft_netdev_event(event, dev, &ctx);
  328. }
  329. }
  330. mutex_unlock(&ctx.net->nft.commit_mutex);
  331. return NOTIFY_DONE;
  332. }
  333. static struct notifier_block nf_tables_netdev_notifier = {
  334. .notifier_call = nf_tables_netdev_event,
  335. };
  336. static int nft_chain_filter_netdev_init(void)
  337. {
  338. int err;
  339. nft_register_chain_type(&nft_chain_filter_netdev);
  340. err = register_netdevice_notifier(&nf_tables_netdev_notifier);
  341. if (err)
  342. goto err_register_netdevice_notifier;
  343. return 0;
  344. err_register_netdevice_notifier:
  345. nft_unregister_chain_type(&nft_chain_filter_netdev);
  346. return err;
  347. }
  348. static void nft_chain_filter_netdev_fini(void)
  349. {
  350. nft_unregister_chain_type(&nft_chain_filter_netdev);
  351. unregister_netdevice_notifier(&nf_tables_netdev_notifier);
  352. }
  353. #else
  354. static inline int nft_chain_filter_netdev_init(void) { return 0; }
  355. static inline void nft_chain_filter_netdev_fini(void) {}
  356. #endif /* CONFIG_NF_TABLES_NETDEV */
  357. int __init nft_chain_filter_init(void)
  358. {
  359. int err;
  360. err = nft_chain_filter_netdev_init();
  361. if (err < 0)
  362. return err;
  363. nft_chain_filter_ipv4_init();
  364. nft_chain_filter_ipv6_init();
  365. nft_chain_filter_arp_init();
  366. nft_chain_filter_inet_init();
  367. nft_chain_filter_bridge_init();
  368. return 0;
  369. }
  370. void nft_chain_filter_fini(void)
  371. {
  372. nft_chain_filter_bridge_fini();
  373. nft_chain_filter_inet_fini();
  374. nft_chain_filter_arp_fini();
  375. nft_chain_filter_ipv6_fini();
  376. nft_chain_filter_ipv4_fini();
  377. nft_chain_filter_netdev_fini();
  378. }