xref: /linux/net/netfilter/nft_bitwise.c (revision 164666fa66669d437bdcc8d5f1744a2aee73be41) 
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (c) 2008-2009 Patrick McHardy <kaber@trash.net>
4  *
5  * Development of this code funded by Astaro AG (http://www.astaro.com/)
6  */
7 
8 #include <linux/kernel.h>
9 #include <linux/init.h>
10 #include <linux/module.h>
11 #include <linux/netlink.h>
12 #include <linux/netfilter.h>
13 #include <linux/netfilter/nf_tables.h>
14 #include <net/netfilter/nf_tables_core.h>
15 #include <net/netfilter/nf_tables.h>
16 #include <net/netfilter/nf_tables_offload.h>
17 
18 struct nft_bitwise {
19 	u8			sreg;
20 	u8			dreg;
21 	enum nft_bitwise_ops	op:8;
22 	u8			len;
23 	struct nft_data		mask;
24 	struct nft_data		xor;
25 	struct nft_data		data;
26 };
27 
28 static void nft_bitwise_eval_bool(u32 *dst, const u32 *src,
29 				  const struct nft_bitwise *priv)
30 {
31 	unsigned int i;
32 
33 	for (i = 0; i < DIV_ROUND_UP(priv->len, 4); i++)
34 		dst[i] = (src[i] & priv->mask.data[i]) ^ priv->xor.data[i];
35 }
36 
37 static void nft_bitwise_eval_lshift(u32 *dst, const u32 *src,
38 				    const struct nft_bitwise *priv)
39 {
40 	u32 shift = priv->data.data[0];
41 	unsigned int i;
42 	u32 carry = 0;
43 
44 	for (i = DIV_ROUND_UP(priv->len, sizeof(u32)); i > 0; i--) {
45 		dst[i - 1] = (src[i - 1] << shift) | carry;
46 		carry = src[i - 1] >> (BITS_PER_TYPE(u32) - shift);
47 	}
48 }
49 
50 static void nft_bitwise_eval_rshift(u32 *dst, const u32 *src,
51 				    const struct nft_bitwise *priv)
52 {
53 	u32 shift = priv->data.data[0];
54 	unsigned int i;
55 	u32 carry = 0;
56 
57 	for (i = 0; i < DIV_ROUND_UP(priv->len, sizeof(u32)); i++) {
58 		dst[i] = carry | (src[i] >> shift);
59 		carry = src[i] << (BITS_PER_TYPE(u32) - shift);
60 	}
61 }
62 
63 void nft_bitwise_eval(const struct nft_expr *expr,
64 		      struct nft_regs *regs, const struct nft_pktinfo *pkt)
65 {
66 	const struct nft_bitwise *priv = nft_expr_priv(expr);
67 	const u32 *src = &regs->data[priv->sreg];
68 	u32 *dst = &regs->data[priv->dreg];
69 
70 	switch (priv->op) {
71 	case NFT_BITWISE_BOOL:
72 		nft_bitwise_eval_bool(dst, src, priv);
73 		break;
74 	case NFT_BITWISE_LSHIFT:
75 		nft_bitwise_eval_lshift(dst, src, priv);
76 		break;
77 	case NFT_BITWISE_RSHIFT:
78 		nft_bitwise_eval_rshift(dst, src, priv);
79 		break;
80 	}
81 }
82 
83 static const struct nla_policy nft_bitwise_policy[NFTA_BITWISE_MAX + 1] = {
84 	[NFTA_BITWISE_SREG]	= { .type = NLA_U32 },
85 	[NFTA_BITWISE_DREG]	= { .type = NLA_U32 },
86 	[NFTA_BITWISE_LEN]	= { .type = NLA_U32 },
87 	[NFTA_BITWISE_MASK]	= { .type = NLA_NESTED },
88 	[NFTA_BITWISE_XOR]	= { .type = NLA_NESTED },
89 	[NFTA_BITWISE_OP]	= { .type = NLA_U32 },
90 	[NFTA_BITWISE_DATA]	= { .type = NLA_NESTED },
91 };
92 
93 static int nft_bitwise_init_bool(struct nft_bitwise *priv,
94 				 const struct nlattr *const tb[])
95 {
96 	struct nft_data_desc mask, xor;
97 	int err;
98 
99 	if (tb[NFTA_BITWISE_DATA])
100 		return -EINVAL;
101 
102 	if (!tb[NFTA_BITWISE_MASK] ||
103 	    !tb[NFTA_BITWISE_XOR])
104 		return -EINVAL;
105 
106 	err = nft_data_init(NULL, &priv->mask, sizeof(priv->mask), &mask,
107 			    tb[NFTA_BITWISE_MASK]);
108 	if (err < 0)
109 		return err;
110 	if (mask.type != NFT_DATA_VALUE || mask.len != priv->len) {
111 		err = -EINVAL;
112 		goto err1;
113 	}
114 
115 	err = nft_data_init(NULL, &priv->xor, sizeof(priv->xor), &xor,
116 			    tb[NFTA_BITWISE_XOR]);
117 	if (err < 0)
118 		goto err1;
119 	if (xor.type != NFT_DATA_VALUE || xor.len != priv->len) {
120 		err = -EINVAL;
121 		goto err2;
122 	}
123 
124 	return 0;
125 err2:
126 	nft_data_release(&priv->xor, xor.type);
127 err1:
128 	nft_data_release(&priv->mask, mask.type);
129 	return err;
130 }
131 
132 static int nft_bitwise_init_shift(struct nft_bitwise *priv,
133 				  const struct nlattr *const tb[])
134 {
135 	struct nft_data_desc d;
136 	int err;
137 
138 	if (tb[NFTA_BITWISE_MASK] ||
139 	    tb[NFTA_BITWISE_XOR])
140 		return -EINVAL;
141 
142 	if (!tb[NFTA_BITWISE_DATA])
143 		return -EINVAL;
144 
145 	err = nft_data_init(NULL, &priv->data, sizeof(priv->data), &d,
146 			    tb[NFTA_BITWISE_DATA]);
147 	if (err < 0)
148 		return err;
149 	if (d.type != NFT_DATA_VALUE || d.len != sizeof(u32) ||
150 	    priv->data.data[0] >= BITS_PER_TYPE(u32)) {
151 		nft_data_release(&priv->data, d.type);
152 		return -EINVAL;
153 	}
154 
155 	return 0;
156 }
157 
158 static int nft_bitwise_init(const struct nft_ctx *ctx,
159 			    const struct nft_expr *expr,
160 			    const struct nlattr * const tb[])
161 {
162 	struct nft_bitwise *priv = nft_expr_priv(expr);
163 	u32 len;
164 	int err;
165 
166 	err = nft_parse_u32_check(tb[NFTA_BITWISE_LEN], U8_MAX, &len);
167 	if (err < 0)
168 		return err;
169 
170 	priv->len = len;
171 
172 	err = nft_parse_register_load(tb[NFTA_BITWISE_SREG], &priv->sreg,
173 				      priv->len);
174 	if (err < 0)
175 		return err;
176 
177 	err = nft_parse_register_store(ctx, tb[NFTA_BITWISE_DREG],
178 				       &priv->dreg, NULL, NFT_DATA_VALUE,
179 				       priv->len);
180 	if (err < 0)
181 		return err;
182 
183 	if (tb[NFTA_BITWISE_OP]) {
184 		priv->op = ntohl(nla_get_be32(tb[NFTA_BITWISE_OP]));
185 		switch (priv->op) {
186 		case NFT_BITWISE_BOOL:
187 		case NFT_BITWISE_LSHIFT:
188 		case NFT_BITWISE_RSHIFT:
189 			break;
190 		default:
191 			return -EOPNOTSUPP;
192 		}
193 	} else {
194 		priv->op = NFT_BITWISE_BOOL;
195 	}
196 
197 	switch(priv->op) {
198 	case NFT_BITWISE_BOOL:
199 		err = nft_bitwise_init_bool(priv, tb);
200 		break;
201 	case NFT_BITWISE_LSHIFT:
202 	case NFT_BITWISE_RSHIFT:
203 		err = nft_bitwise_init_shift(priv, tb);
204 		break;
205 	}
206 
207 	return err;
208 }
209 
210 static int nft_bitwise_dump_bool(struct sk_buff *skb,
211 				 const struct nft_bitwise *priv)
212 {
213 	if (nft_data_dump(skb, NFTA_BITWISE_MASK, &priv->mask,
214 			  NFT_DATA_VALUE, priv->len) < 0)
215 		return -1;
216 
217 	if (nft_data_dump(skb, NFTA_BITWISE_XOR, &priv->xor,
218 			  NFT_DATA_VALUE, priv->len) < 0)
219 		return -1;
220 
221 	return 0;
222 }
223 
224 static int nft_bitwise_dump_shift(struct sk_buff *skb,
225 				  const struct nft_bitwise *priv)
226 {
227 	if (nft_data_dump(skb, NFTA_BITWISE_DATA, &priv->data,
228 			  NFT_DATA_VALUE, sizeof(u32)) < 0)
229 		return -1;
230 	return 0;
231 }
232 
233 static int nft_bitwise_dump(struct sk_buff *skb, const struct nft_expr *expr)
234 {
235 	const struct nft_bitwise *priv = nft_expr_priv(expr);
236 	int err = 0;
237 
238 	if (nft_dump_register(skb, NFTA_BITWISE_SREG, priv->sreg))
239 		return -1;
240 	if (nft_dump_register(skb, NFTA_BITWISE_DREG, priv->dreg))
241 		return -1;
242 	if (nla_put_be32(skb, NFTA_BITWISE_LEN, htonl(priv->len)))
243 		return -1;
244 	if (nla_put_be32(skb, NFTA_BITWISE_OP, htonl(priv->op)))
245 		return -1;
246 
247 	switch (priv->op) {
248 	case NFT_BITWISE_BOOL:
249 		err = nft_bitwise_dump_bool(skb, priv);
250 		break;
251 	case NFT_BITWISE_LSHIFT:
252 	case NFT_BITWISE_RSHIFT:
253 		err = nft_bitwise_dump_shift(skb, priv);
254 		break;
255 	}
256 
257 	return err;
258 }
259 
260 static struct nft_data zero;
261 
262 static int nft_bitwise_offload(struct nft_offload_ctx *ctx,
263 			       struct nft_flow_rule *flow,
264 			       const struct nft_expr *expr)
265 {
266 	const struct nft_bitwise *priv = nft_expr_priv(expr);
267 	struct nft_offload_reg *reg = &ctx->regs[priv->dreg];
268 
269 	if (priv->op != NFT_BITWISE_BOOL)
270 		return -EOPNOTSUPP;
271 
272 	if (memcmp(&priv->xor, &zero, sizeof(priv->xor)) ||
273 	    priv->sreg != priv->dreg || priv->len != reg->len)
274 		return -EOPNOTSUPP;
275 
276 	memcpy(&reg->mask, &priv->mask, sizeof(priv->mask));
277 
278 	return 0;
279 }
280 
281 static bool nft_bitwise_reduce(struct nft_regs_track *track,
282 			       const struct nft_expr *expr)
283 {
284 	const struct nft_bitwise *priv = nft_expr_priv(expr);
285 	const struct nft_bitwise *bitwise;
286 
287 	if (!track->regs[priv->sreg].selector)
288 		return false;
289 
290 	bitwise = nft_expr_priv(expr);
291 	if (track->regs[priv->sreg].selector == track->regs[priv->dreg].selector &&
292 	    track->regs[priv->dreg].bitwise &&
293 	    track->regs[priv->dreg].bitwise->ops == expr->ops &&
294 	    priv->sreg == bitwise->sreg &&
295 	    priv->dreg == bitwise->dreg &&
296 	    priv->op == bitwise->op &&
297 	    priv->len == bitwise->len &&
298 	    !memcmp(&priv->mask, &bitwise->mask, sizeof(priv->mask)) &&
299 	    !memcmp(&priv->xor, &bitwise->xor, sizeof(priv->xor)) &&
300 	    !memcmp(&priv->data, &bitwise->data, sizeof(priv->data))) {
301 		track->cur = expr;
302 		return true;
303 	}
304 
305 	if (track->regs[priv->sreg].bitwise) {
306 		track->regs[priv->dreg].selector = NULL;
307 		track->regs[priv->dreg].bitwise = NULL;
308 		return false;
309 	}
310 
311 	if (priv->sreg != priv->dreg) {
312 		track->regs[priv->dreg].selector =
313 			track->regs[priv->sreg].selector;
314 	}
315 	track->regs[priv->dreg].bitwise = expr;
316 
317 	return false;
318 }
319 
320 static const struct nft_expr_ops nft_bitwise_ops = {
321 	.type		= &nft_bitwise_type,
322 	.size		= NFT_EXPR_SIZE(sizeof(struct nft_bitwise)),
323 	.eval		= nft_bitwise_eval,
324 	.init		= nft_bitwise_init,
325 	.dump		= nft_bitwise_dump,
326 	.reduce		= nft_bitwise_reduce,
327 	.offload	= nft_bitwise_offload,
328 };
329 
330 static int
331 nft_bitwise_extract_u32_data(const struct nlattr * const tb, u32 *out)
332 {
333 	struct nft_data_desc desc;
334 	struct nft_data data;
335 	int err = 0;
336 
337 	err = nft_data_init(NULL, &data, sizeof(data), &desc, tb);
338 	if (err < 0)
339 		return err;
340 
341 	if (desc.type != NFT_DATA_VALUE || desc.len != sizeof(u32)) {
342 		err = -EINVAL;
343 		goto err;
344 	}
345 	*out = data.data[0];
346 err:
347 	nft_data_release(&data, desc.type);
348 	return err;
349 }
350 
351 static int nft_bitwise_fast_init(const struct nft_ctx *ctx,
352 				 const struct nft_expr *expr,
353 				 const struct nlattr * const tb[])
354 {
355 	struct nft_bitwise_fast_expr *priv = nft_expr_priv(expr);
356 	int err;
357 
358 	err = nft_parse_register_load(tb[NFTA_BITWISE_SREG], &priv->sreg,
359 				      sizeof(u32));
360 	if (err < 0)
361 		return err;
362 
363 	err = nft_parse_register_store(ctx, tb[NFTA_BITWISE_DREG], &priv->dreg,
364 				       NULL, NFT_DATA_VALUE, sizeof(u32));
365 	if (err < 0)
366 		return err;
367 
368 	if (tb[NFTA_BITWISE_DATA])
369 		return -EINVAL;
370 
371 	if (!tb[NFTA_BITWISE_MASK] ||
372 	    !tb[NFTA_BITWISE_XOR])
373 		return -EINVAL;
374 
375 	err = nft_bitwise_extract_u32_data(tb[NFTA_BITWISE_MASK], &priv->mask);
376 	if (err < 0)
377 		return err;
378 
379 	err = nft_bitwise_extract_u32_data(tb[NFTA_BITWISE_XOR], &priv->xor);
380 	if (err < 0)
381 		return err;
382 
383 	return 0;
384 }
385 
386 static int
387 nft_bitwise_fast_dump(struct sk_buff *skb, const struct nft_expr *expr)
388 {
389 	const struct nft_bitwise_fast_expr *priv = nft_expr_priv(expr);
390 	struct nft_data data;
391 
392 	if (nft_dump_register(skb, NFTA_BITWISE_SREG, priv->sreg))
393 		return -1;
394 	if (nft_dump_register(skb, NFTA_BITWISE_DREG, priv->dreg))
395 		return -1;
396 	if (nla_put_be32(skb, NFTA_BITWISE_LEN, htonl(sizeof(u32))))
397 		return -1;
398 	if (nla_put_be32(skb, NFTA_BITWISE_OP, htonl(NFT_BITWISE_BOOL)))
399 		return -1;
400 
401 	data.data[0] = priv->mask;
402 	if (nft_data_dump(skb, NFTA_BITWISE_MASK, &data,
403 			  NFT_DATA_VALUE, sizeof(u32)) < 0)
404 		return -1;
405 
406 	data.data[0] = priv->xor;
407 	if (nft_data_dump(skb, NFTA_BITWISE_XOR, &data,
408 			  NFT_DATA_VALUE, sizeof(u32)) < 0)
409 		return -1;
410 
411 	return 0;
412 }
413 
414 static int nft_bitwise_fast_offload(struct nft_offload_ctx *ctx,
415 				    struct nft_flow_rule *flow,
416 				    const struct nft_expr *expr)
417 {
418 	const struct nft_bitwise_fast_expr *priv = nft_expr_priv(expr);
419 	struct nft_offload_reg *reg = &ctx->regs[priv->dreg];
420 
421 	if (priv->xor || priv->sreg != priv->dreg || reg->len != sizeof(u32))
422 		return -EOPNOTSUPP;
423 
424 	reg->mask.data[0] = priv->mask;
425 	return 0;
426 }
427 
428 static bool nft_bitwise_fast_reduce(struct nft_regs_track *track,
429 				    const struct nft_expr *expr)
430 {
431 	const struct nft_bitwise_fast_expr *priv = nft_expr_priv(expr);
432 	const struct nft_bitwise_fast_expr *bitwise;
433 
434 	if (!track->regs[priv->sreg].selector)
435 		return false;
436 
437 	bitwise = nft_expr_priv(expr);
438 	if (track->regs[priv->sreg].selector == track->regs[priv->dreg].selector &&
439 	    track->regs[priv->dreg].bitwise &&
440 	    track->regs[priv->dreg].bitwise->ops == expr->ops &&
441 	    priv->sreg == bitwise->sreg &&
442 	    priv->dreg == bitwise->dreg &&
443 	    priv->mask == bitwise->mask &&
444 	    priv->xor == bitwise->xor) {
445 		track->cur = expr;
446 		return true;
447 	}
448 
449 	if (track->regs[priv->sreg].bitwise) {
450 		track->regs[priv->dreg].selector = NULL;
451 		track->regs[priv->dreg].bitwise = NULL;
452 		return false;
453 	}
454 
455 	if (priv->sreg != priv->dreg) {
456 		track->regs[priv->dreg].selector =
457 			track->regs[priv->sreg].selector;
458 	}
459 	track->regs[priv->dreg].bitwise = expr;
460 
461 	return false;
462 }
463 
464 const struct nft_expr_ops nft_bitwise_fast_ops = {
465 	.type		= &nft_bitwise_type,
466 	.size		= NFT_EXPR_SIZE(sizeof(struct nft_bitwise_fast_expr)),
467 	.eval		= NULL, /* inlined */
468 	.init		= nft_bitwise_fast_init,
469 	.dump		= nft_bitwise_fast_dump,
470 	.reduce		= nft_bitwise_fast_reduce,
471 	.offload	= nft_bitwise_fast_offload,
472 };
473 
474 static const struct nft_expr_ops *
475 nft_bitwise_select_ops(const struct nft_ctx *ctx,
476 		       const struct nlattr * const tb[])
477 {
478 	int err;
479 	u32 len;
480 
481 	if (!tb[NFTA_BITWISE_LEN] ||
482 	    !tb[NFTA_BITWISE_SREG] ||
483 	    !tb[NFTA_BITWISE_DREG])
484 		return ERR_PTR(-EINVAL);
485 
486 	err = nft_parse_u32_check(tb[NFTA_BITWISE_LEN], U8_MAX, &len);
487 	if (err < 0)
488 		return ERR_PTR(err);
489 
490 	if (len != sizeof(u32))
491 		return &nft_bitwise_ops;
492 
493 	if (tb[NFTA_BITWISE_OP] &&
494 	    ntohl(nla_get_be32(tb[NFTA_BITWISE_OP])) != NFT_BITWISE_BOOL)
495 		return &nft_bitwise_ops;
496 
497 	return &nft_bitwise_fast_ops;
498 }
499 
500 struct nft_expr_type nft_bitwise_type __read_mostly = {
501 	.name		= "bitwise",
502 	.select_ops	= nft_bitwise_select_ops,
503 	.policy		= nft_bitwise_policy,
504 	.maxattr	= NFTA_BITWISE_MAX,
505 	.owner		= THIS_MODULE,
506 };
507 
508 bool nft_expr_reduce_bitwise(struct nft_regs_track *track,
509 			     const struct nft_expr *expr)
510 {
511 	const struct nft_expr *last = track->last;
512 	const struct nft_expr *next;
513 
514 	if (expr == last)
515 		return false;
516 
517 	next = nft_expr_next(expr);
518 	if (next->ops == &nft_bitwise_ops)
519 		return nft_bitwise_reduce(track, next);
520 	else if (next->ops == &nft_bitwise_fast_ops)
521 		return nft_bitwise_fast_reduce(track, next);
522 
523 	return false;
524 }
525