4805529cf8
Set 31 is still special because rules belonging to it are not deleted by the "ipfw flush" command, but must be deleted explicitly with "ipfw delete set 31" or by individual rule numbers. This implement a flexible form of "persistent rules" which you might want to have available even after an "ipfw flush". Note that this change does not violate POLA, because you could not use set 31 in a ruleset before this change. sbin/ipfw changes to allow manipulation of set 31 will follow shortly. Suggested by: Paul Richards
427 lines
12 KiB
C
427 lines
12 KiB
C
/*
|
|
* Copyright (c) 2002 Luigi Rizzo, Universita` di Pisa
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*
|
|
* $FreeBSD$
|
|
*/
|
|
|
|
#ifndef _IPFW2_H
|
|
#define _IPFW2_H
|
|
#define IPFW2 1
|
|
/*
|
|
* The kernel representation of ipfw rules is made of a list of
|
|
* 'instructions' (for all practical purposes equivalent to BPF
|
|
* instructions), which specify which fields of the packet
|
|
* (or its metadata) should be analysed.
|
|
*
|
|
* Each instruction is stored in a structure which begins with
|
|
* "ipfw_insn", and can contain extra fields depending on the
|
|
* instruction type (listed below).
|
|
* Note that the code is written so that individual instructions
|
|
* have a size which is a multiple of 32 bits. This means that, if
|
|
* such structures contain pointers or other 64-bit entities,
|
|
* (there is just one instance now) they may end up unaligned on
|
|
* 64-bit architectures, so the must be handled with care.
|
|
*
|
|
* "enum ipfw_opcodes" are the opcodes supported. We can have up
|
|
* to 256 different opcodes.
|
|
*/
|
|
|
|
enum ipfw_opcodes { /* arguments (4 byte each) */
|
|
O_NOP,
|
|
|
|
O_IP_SRC, /* u32 = IP */
|
|
O_IP_SRC_MASK, /* ip = IP/mask */
|
|
O_IP_SRC_ME, /* none */
|
|
O_IP_SRC_SET, /* u32=base, arg1=len, bitmap */
|
|
|
|
O_IP_DST, /* u32 = IP */
|
|
O_IP_DST_MASK, /* ip = IP/mask */
|
|
O_IP_DST_ME, /* none */
|
|
O_IP_DST_SET, /* u32=base, arg1=len, bitmap */
|
|
|
|
O_IP_SRCPORT, /* (n)port list:mask 4 byte ea */
|
|
O_IP_DSTPORT, /* (n)port list:mask 4 byte ea */
|
|
O_PROTO, /* arg1=protocol */
|
|
|
|
O_MACADDR2, /* 2 mac addr:mask */
|
|
O_MAC_TYPE, /* same as srcport */
|
|
|
|
O_LAYER2, /* none */
|
|
O_IN, /* none */
|
|
O_FRAG, /* none */
|
|
|
|
O_RECV, /* none */
|
|
O_XMIT, /* none */
|
|
O_VIA, /* none */
|
|
|
|
O_IPOPT, /* arg1 = 2*u8 bitmap */
|
|
O_IPLEN, /* arg1 = len */
|
|
O_IPID, /* arg1 = id */
|
|
|
|
O_IPTOS, /* arg1 = id */
|
|
O_IPPRECEDENCE, /* arg1 = precedence << 5 */
|
|
O_IPTTL, /* arg1 = TTL */
|
|
|
|
O_IPVER, /* arg1 = version */
|
|
O_UID, /* u32 = id */
|
|
O_GID, /* u32 = id */
|
|
O_ESTAB, /* none (tcp established) */
|
|
O_TCPFLAGS, /* arg1 = 2*u8 bitmap */
|
|
O_TCPWIN, /* arg1 = desired win */
|
|
O_TCPSEQ, /* u32 = desired seq. */
|
|
O_TCPACK, /* u32 = desired seq. */
|
|
O_ICMPTYPE, /* u32 = icmp bitmap */
|
|
O_TCPOPTS, /* arg1 = 2*u8 bitmap */
|
|
|
|
O_VERREVPATH, /* none */
|
|
|
|
O_PROBE_STATE, /* none */
|
|
O_KEEP_STATE, /* none */
|
|
O_LIMIT, /* ipfw_insn_limit */
|
|
O_LIMIT_PARENT, /* dyn_type, not an opcode. */
|
|
|
|
/*
|
|
* These are really 'actions'.
|
|
*/
|
|
|
|
O_LOG, /* ipfw_insn_log */
|
|
O_PROB, /* u32 = match probability */
|
|
|
|
O_CHECK_STATE, /* none */
|
|
O_ACCEPT, /* none */
|
|
O_DENY, /* none */
|
|
O_REJECT, /* arg1=icmp arg (same as deny) */
|
|
O_COUNT, /* none */
|
|
O_SKIPTO, /* arg1=next rule number */
|
|
O_PIPE, /* arg1=pipe number */
|
|
O_QUEUE, /* arg1=queue number */
|
|
O_DIVERT, /* arg1=port number */
|
|
O_TEE, /* arg1=port number */
|
|
O_FORWARD_IP, /* fwd sockaddr */
|
|
O_FORWARD_MAC, /* fwd mac */
|
|
|
|
/*
|
|
* More opcodes.
|
|
*/
|
|
O_IPSEC, /* has ipsec history */
|
|
|
|
O_LAST_OPCODE /* not an opcode! */
|
|
};
|
|
|
|
/*
|
|
* Template for instructions.
|
|
*
|
|
* ipfw_insn is used for all instructions which require no operands,
|
|
* a single 16-bit value (arg1), or a couple of 8-bit values.
|
|
*
|
|
* For other instructions which require different/larger arguments
|
|
* we have derived structures, ipfw_insn_*.
|
|
*
|
|
* The size of the instruction (in 32-bit words) is in the low
|
|
* 6 bits of "len". The 2 remaining bits are used to implement
|
|
* NOT and OR on individual instructions. Given a type, you can
|
|
* compute the length to be put in "len" using F_INSN_SIZE(t)
|
|
*
|
|
* F_NOT negates the match result of the instruction.
|
|
*
|
|
* F_OR is used to build or blocks. By default, instructions
|
|
* are evaluated as part of a logical AND. An "or" block
|
|
* { X or Y or Z } contains F_OR set in all but the last
|
|
* instruction of the block. A match will cause the code
|
|
* to skip past the last instruction of the block.
|
|
*
|
|
* NOTA BENE: in a couple of places we assume that
|
|
* sizeof(ipfw_insn) == sizeof(u_int32_t)
|
|
* this needs to be fixed.
|
|
*
|
|
*/
|
|
typedef struct _ipfw_insn { /* template for instructions */
|
|
enum ipfw_opcodes opcode:8;
|
|
u_int8_t len; /* numer of 32-byte words */
|
|
#define F_NOT 0x80
|
|
#define F_OR 0x40
|
|
#define F_LEN_MASK 0x3f
|
|
#define F_LEN(cmd) ((cmd)->len & F_LEN_MASK)
|
|
|
|
u_int16_t arg1;
|
|
} ipfw_insn;
|
|
|
|
/*
|
|
* The F_INSN_SIZE(type) computes the size, in 4-byte words, of
|
|
* a given type.
|
|
*/
|
|
#define F_INSN_SIZE(t) ((sizeof (t))/sizeof(u_int32_t))
|
|
|
|
/*
|
|
* This is used to store an array of 16-bit entries (ports etc.)
|
|
*/
|
|
typedef struct _ipfw_insn_u16 {
|
|
ipfw_insn o;
|
|
u_int16_t ports[2]; /* there may be more */
|
|
} ipfw_insn_u16;
|
|
|
|
/*
|
|
* This is used to store an array of 32-bit entries
|
|
* (uid, single IPv4 addresses etc.)
|
|
*/
|
|
typedef struct _ipfw_insn_u32 {
|
|
ipfw_insn o;
|
|
u_int32_t d[1]; /* one or more */
|
|
} ipfw_insn_u32;
|
|
|
|
/*
|
|
* This is used to store IP addr-mask pairs.
|
|
*/
|
|
typedef struct _ipfw_insn_ip {
|
|
ipfw_insn o;
|
|
struct in_addr addr;
|
|
struct in_addr mask;
|
|
} ipfw_insn_ip;
|
|
|
|
/*
|
|
* This is used to forward to a given address (ip).
|
|
*/
|
|
typedef struct _ipfw_insn_sa {
|
|
ipfw_insn o;
|
|
struct sockaddr_in sa;
|
|
} ipfw_insn_sa;
|
|
|
|
/*
|
|
* This is used for MAC addr-mask pairs.
|
|
*/
|
|
typedef struct _ipfw_insn_mac {
|
|
ipfw_insn o;
|
|
u_char addr[12]; /* dst[6] + src[6] */
|
|
u_char mask[12]; /* dst[6] + src[6] */
|
|
} ipfw_insn_mac;
|
|
|
|
/*
|
|
* This is used for interface match rules (recv xx, xmit xx).
|
|
*/
|
|
typedef struct _ipfw_insn_if {
|
|
ipfw_insn o;
|
|
union {
|
|
struct in_addr ip;
|
|
int32_t unit;
|
|
} p;
|
|
char name[IFNAMSIZ];
|
|
} ipfw_insn_if;
|
|
|
|
/*
|
|
* This is used for pipe and queue actions, which need to store
|
|
* a single pointer (which can have different size on different
|
|
* architectures.
|
|
* Note that, because of previous instructions, pipe_ptr might
|
|
* be unaligned in the overall structure, so it needs to be
|
|
* manipulated with care.
|
|
*/
|
|
typedef struct _ipfw_insn_pipe {
|
|
ipfw_insn o;
|
|
void *pipe_ptr; /* XXX */
|
|
} ipfw_insn_pipe;
|
|
|
|
/*
|
|
* This is used for limit rules.
|
|
*/
|
|
typedef struct _ipfw_insn_limit {
|
|
ipfw_insn o;
|
|
u_int8_t _pad;
|
|
u_int8_t limit_mask; /* combination of DYN_* below */
|
|
#define DYN_SRC_ADDR 0x1
|
|
#define DYN_SRC_PORT 0x2
|
|
#define DYN_DST_ADDR 0x4
|
|
#define DYN_DST_PORT 0x8
|
|
|
|
u_int16_t conn_limit;
|
|
} ipfw_insn_limit;
|
|
|
|
/*
|
|
* This is used for log instructions.
|
|
*/
|
|
typedef struct _ipfw_insn_log {
|
|
ipfw_insn o;
|
|
u_int32_t max_log; /* how many do we log -- 0 = all */
|
|
u_int32_t log_left; /* how many left to log */
|
|
} ipfw_insn_log;
|
|
|
|
/*
|
|
* Here we have the structure representing an ipfw rule.
|
|
*
|
|
* It starts with a general area (with link fields and counters)
|
|
* followed by an array of one or more instructions, which the code
|
|
* accesses as an array of 32-bit values.
|
|
*
|
|
* Given a rule pointer r:
|
|
*
|
|
* r->cmd is the start of the first instruction.
|
|
* ACTION_PTR(r) is the start of the first action (things to do
|
|
* once a rule matched).
|
|
*
|
|
* When assembling instruction, remember the following:
|
|
*
|
|
* + if a rule has a "keep-state" (or "limit") option, then the
|
|
* first instruction (at r->cmd) MUST BE an O_PROBE_STATE
|
|
* + if a rule has a "log" option, then the first action
|
|
* (at ACTION_PTR(r)) MUST be O_LOG
|
|
*
|
|
* NOTE: we use a simple linked list of rules because we never need
|
|
* to delete a rule without scanning the list. We do not use
|
|
* queue(3) macros for portability and readability.
|
|
*/
|
|
|
|
struct ip_fw {
|
|
struct ip_fw *next; /* linked list of rules */
|
|
struct ip_fw *next_rule; /* ptr to next [skipto] rule */
|
|
/* 'next_rule' is used to pass up 'set_disable' status */
|
|
|
|
u_int16_t act_ofs; /* offset of action in 32-bit units */
|
|
u_int16_t cmd_len; /* # of 32-bit words in cmd */
|
|
u_int16_t rulenum; /* rule number */
|
|
u_int8_t set; /* rule set (0..31) */
|
|
#define RESVD_SET 31 /* set for default and persistent rules */
|
|
u_int8_t _pad; /* padding */
|
|
|
|
/* These fields are present in all rules. */
|
|
u_int64_t pcnt; /* Packet counter */
|
|
u_int64_t bcnt; /* Byte counter */
|
|
u_int32_t timestamp; /* tv_sec of last match */
|
|
|
|
ipfw_insn cmd[1]; /* storage for commands */
|
|
};
|
|
|
|
#define ACTION_PTR(rule) \
|
|
(ipfw_insn *)( (u_int32_t *)((rule)->cmd) + ((rule)->act_ofs) )
|
|
|
|
#define RULESIZE(rule) (sizeof(struct ip_fw) + \
|
|
((struct ip_fw *)(rule))->cmd_len * 4 - 4)
|
|
|
|
/*
|
|
* This structure is used as a flow mask and a flow id for various
|
|
* parts of the code.
|
|
*/
|
|
struct ipfw_flow_id {
|
|
u_int32_t dst_ip;
|
|
u_int32_t src_ip;
|
|
u_int16_t dst_port;
|
|
u_int16_t src_port;
|
|
u_int8_t proto;
|
|
u_int8_t flags; /* protocol-specific flags */
|
|
};
|
|
|
|
/*
|
|
* Dynamic ipfw rule.
|
|
*/
|
|
typedef struct _ipfw_dyn_rule ipfw_dyn_rule;
|
|
|
|
struct _ipfw_dyn_rule {
|
|
ipfw_dyn_rule *next; /* linked list of rules. */
|
|
struct ip_fw *rule; /* pointer to rule */
|
|
/* 'rule' is used to pass up the rule number (from the parent) */
|
|
|
|
ipfw_dyn_rule *parent; /* pointer to parent rule */
|
|
u_int64_t pcnt; /* packet match counter */
|
|
u_int64_t bcnt; /* byte match counter */
|
|
struct ipfw_flow_id id; /* (masked) flow id */
|
|
u_int32_t expire; /* expire time */
|
|
u_int32_t bucket; /* which bucket in hash table */
|
|
u_int32_t state; /* state of this rule (typically a
|
|
* combination of TCP flags)
|
|
*/
|
|
u_int32_t ack_fwd; /* most recent ACKs in forward */
|
|
u_int32_t ack_rev; /* and reverse directions (used */
|
|
/* to generate keepalives) */
|
|
u_int16_t dyn_type; /* rule type */
|
|
u_int16_t count; /* refcount */
|
|
};
|
|
|
|
/*
|
|
* Definitions for IP option names.
|
|
*/
|
|
#define IP_FW_IPOPT_LSRR 0x01
|
|
#define IP_FW_IPOPT_SSRR 0x02
|
|
#define IP_FW_IPOPT_RR 0x04
|
|
#define IP_FW_IPOPT_TS 0x08
|
|
|
|
/*
|
|
* Definitions for TCP option names.
|
|
*/
|
|
#define IP_FW_TCPOPT_MSS 0x01
|
|
#define IP_FW_TCPOPT_WINDOW 0x02
|
|
#define IP_FW_TCPOPT_SACK 0x04
|
|
#define IP_FW_TCPOPT_TS 0x08
|
|
#define IP_FW_TCPOPT_CC 0x10
|
|
|
|
#define ICMP_REJECT_RST 0x100 /* fake ICMP code (send a TCP RST) */
|
|
|
|
/*
|
|
* Main firewall chains definitions and global var's definitions.
|
|
*/
|
|
#ifdef _KERNEL
|
|
|
|
#define IP_FW_PORT_DYNT_FLAG 0x10000
|
|
#define IP_FW_PORT_TEE_FLAG 0x20000
|
|
#define IP_FW_PORT_DENY_FLAG 0x40000
|
|
|
|
/*
|
|
* Arguments for calling ipfw_chk() and dummynet_io(). We put them
|
|
* all into a structure because this way it is easier and more
|
|
* efficient to pass variables around and extend the interface.
|
|
*/
|
|
struct ip_fw_args {
|
|
struct mbuf *m; /* the mbuf chain */
|
|
struct ifnet *oif; /* output interface */
|
|
struct sockaddr_in *next_hop; /* forward address */
|
|
struct ip_fw *rule; /* matching rule */
|
|
struct ether_header *eh; /* for bridged packets */
|
|
|
|
struct route *ro; /* for dummynet */
|
|
struct sockaddr_in *dst; /* for dummynet */
|
|
int flags; /* for dummynet */
|
|
|
|
struct ipfw_flow_id f_id; /* grabbed from IP header */
|
|
u_int16_t divert_rule; /* divert cookie */
|
|
u_int32_t retval;
|
|
};
|
|
|
|
/*
|
|
* Function definitions.
|
|
*/
|
|
|
|
/* Firewall hooks */
|
|
struct sockopt;
|
|
struct dn_flow_set;
|
|
|
|
void flush_pipe_ptrs(struct dn_flow_set *match); /* used by dummynet */
|
|
|
|
typedef int ip_fw_chk_t (struct ip_fw_args *args);
|
|
typedef int ip_fw_ctl_t (struct sockopt *);
|
|
extern ip_fw_chk_t *ip_fw_chk_ptr;
|
|
extern ip_fw_ctl_t *ip_fw_ctl_ptr;
|
|
extern int fw_one_pass;
|
|
extern int fw_enable;
|
|
#define IPFW_LOADED (ip_fw_chk_ptr != NULL)
|
|
#endif /* _KERNEL */
|
|
|
|
#endif /* _IPFW2_H */
|