Project

General

Profile

Security #9425 ยป 0001-ipfw-reinject-with-the-packets-own-sockaddr.diff

Adam Barnard, 11/14/2026 03:35 PM

View differences:

src/source-ipfw.c
static TmEcode DecodeIPFWThreadDeinit(ThreadVars *tv, void *data);
static TmEcode DecodeIPFW(ThreadVars *, Packet *, void *);
#ifdef UNITTESTS
static void SourceIPFWRegisterTests(void);
#endif
/**
* \brief Registration Function for RecieveIPFW.
* \todo Unit tests are needed for this module.
*/
void TmModuleReceiveIPFWRegister (void)
{
......
SC_CAP_NET_BIND_SERVICE |
SC_CAP_NET_BROADCAST; /** \todo untested */
tmm_modules[TMM_RECEIVEIPFW].flags = TM_FLAG_RECEIVE_TM;
#ifdef UNITTESTS
tmm_modules[TMM_RECEIVEIPFW].RegisterTests = SourceIPFWRegisterTests;
#endif
}
/**
* \brief Registration Function for VerdictIPFW.
* \todo Unit tests are needed for this module.
*/
void TmModuleVerdictIPFWRegister (void)
{
......
#define IP_MAXPACKET 65535
#endif
/**
* \brief Read one packet from a divert socket
*
* \param fd the divert socket
* \param pkt buffer for the packet
* \param size size of the buffer
* \param sin set to the divert sockaddr of this packet. The packet has to be
* reinjected with it, so it is kept with the packet, see
* IPFWSetVerdict()
*
* \retval the length of the packet, or -1 with errno set by recvfrom()
*/
static ssize_t IPFWRecv(int fd, uint8_t *pkt, size_t size, struct sockaddr_in *sin)
{
socklen_t sinlen = sizeof(*sin);
memset(sin, 0, sizeof(*sin));
return recvfrom(fd, pkt, size, 0, (struct sockaddr *)sin, &sinlen);
}
/**
* \brief Set up a packet that was read from a divert socket
*
* \param p the packet
* \param ptv thread vars of the receive thread
* \param sin the divert sockaddr the packet was received with. It is kept in
* the packet for IPFWSetVerdict()
* \param pkt the packet as read from the socket
* \param pktlen its length
*/
static void IPFWPacketSetup(Packet *p, const IPFWThreadVars *ptv, const struct sockaddr_in *sin,
const uint8_t *pkt, uint32_t pktlen)
{
PKT_SET_SRC(p, PKT_SRC_WIRE);
p->datalink = ptv->datalink;
p->ipfw_v.ipfw_index = ptv->ipfw_index;
p->ipfw_v.ipfw_sin = *sin;
PacketCopyData(p, pkt, pktlen);
}
TmEcode ReceiveIPFWLoop(ThreadVars *tv, void *data, void *slot)
{
SCEnter();
......
IPFWThreadVars *ptv = (IPFWThreadVars *)data;
IPFWQueueVars *nq = NULL;
uint8_t pkt[IP_MAXPACKET];
struct sockaddr_in sin;
int pktlen=0;
struct pollfd IPFWpoll;
struct timeval IPFWts;
......
continue;
}
if ((pktlen = recvfrom(nq->fd, pkt, sizeof(pkt), 0,
(struct sockaddr *)&nq->ipfw_sin,
&nq->ipfw_sinlen)) == -1) {
if ((pktlen = IPFWRecv(nq->fd, pkt, sizeof(pkt), &sin)) == -1) {
/* We received an error on socket read */
if (errno == EINTR || errno == EWOULDBLOCK) {
/* Nothing for us to process */
......
if (p == NULL) {
SCReturnInt(TM_ECODE_FAILED);
}
PKT_SET_SRC(p, PKT_SRC_WIRE);
SCLogDebug("Received Packet Len: %d", pktlen);
......
ptv->pkts++;
ptv->bytes += pktlen;
p->datalink = ptv->datalink;
p->ipfw_v.ipfw_index = ptv->ipfw_index;
PacketCopyData(p, pkt, pktlen);
IPFWPacketSetup(p, ptv, &sin, pkt, pktlen);
SCLogDebug("Packet info: pkt_len: %" PRIu32 " (pkt %02x, pkt_data %02x)",
GET_PKT_LEN(p), *pkt, *(GET_PKT_DATA(p)));
......
TmEcode ReceiveIPFWThreadInit(ThreadVars *tv, const void *initdata, void **data)
{
struct timeval timev;
struct sockaddr_in sin;
IPFWThreadVars *ntv = (IPFWThreadVars *) initdata;
IPFWQueueVars *nq = IPFWGetQueue(ntv->ipfw_index);
......
SCReturnInt(TM_ECODE_FAILED);
}
nq->ipfw_sinlen=sizeof(nq->ipfw_sin);
memset(&nq->ipfw_sin, 0, nq->ipfw_sinlen);
nq->ipfw_sin.sin_family = PF_INET;
nq->ipfw_sin.sin_addr.s_addr = INADDR_ANY;
nq->ipfw_sin.sin_port = htons(nq->port_num);
memset(&sin, 0, sizeof(sin));
sin.sin_family = PF_INET;
sin.sin_addr.s_addr = INADDR_ANY;
sin.sin_port = htons(nq->port_num);
/* Bind that SOB */
if (bind(nq->fd, (struct sockaddr *)&nq->ipfw_sin, nq->ipfw_sinlen) == -1) {
if (bind(nq->fd, (struct sockaddr *)&sin, sizeof(sin)) == -1) {
SCLogError("Can't bind divert socket on port %d: %s", nq->port_num, strerror(errno));
SCReturnInt(TM_ECODE_FAILED);
}
......
}
#endif
/* Reinject with the sockaddr this packet came with. In autofp the
* receive thread has read other packets from the socket by now. */
IPFWMutexLock(nq);
if (sendto(nq->fd, GET_PKT_DATA(p), GET_PKT_LEN(p), 0,(struct sockaddr *)&nq->ipfw_sin, nq->ipfw_sinlen) == -1) {
if (sendto(nq->fd, GET_PKT_DATA(p), GET_PKT_LEN(p), 0,
(struct sockaddr *)&p->ipfw_v.ipfw_sin, sizeof(p->ipfw_v.ipfw_sin)) == -1) {
int r = errno;
switch (r) {
default:
......
/**
* \brief This function handles the Verdict processing
* \todo Unit tests are needed for this module.
*
*
* \param tv pointer to ThreadVars
......
SCReturnInt(TM_ECODE_OK);
}
/* This came from NFQ.
* If this is a tunnel packet we check if we are ready to verdict already. */
/* If this is a tunnel packet we check if we are ready to verdict already. */
if (PacketIsTunnel(p)) {
bool verdict = VerdictTunnelPacket(p);
......
return (void *)&ipfw_t[number];
}
#ifdef UNITTESTS
/* The tests use UDP sockets on the loopback address in place of a divert
* socket. On a UDP socket sendto() delivers a "reinjected" packet to the
* address in the sockaddr, so the peer that gets a packet shows which
* sockaddr the verdict used. */
/** sockets of a test: q stands in for the divert socket of queue 0, a and b
* are two peers that send packets to it */
typedef struct IPFWTestSockets_ {
int q;
int a;
int b;
struct sockaddr_in q_addr;
struct sockaddr_in b_addr;
/* queue 0's socket and the number of queues before the test */
int saved_fd;
uint16_t saved_port_num;
} IPFWTestSockets;
/**
* \brief Whether a failed socket() means this host has no IPv4 socket to test on
*
* \param err errno of the failed socket() call
*/
static bool IPFWTestNoSocket(int err)
{
return err == EAFNOSUPPORT || err == EPROTONOSUPPORT || err == EPERM || err == EACCES;
}
/**
* \brief UDP socket bound to the loopback address, with a receive timeout
*
* \param fd set to the socket, or to -1
* \param addr set to the address the socket is bound to
*
* \retval 1 ready
* \retval 0 this host has no IPv4 socket to test on
* \retval -1 failed
*/
static int IPFWTestSocket(int *fd, struct sockaddr_in *addr)
{
const struct timeval timev = { .tv_sec = 2, .tv_usec = 0 };
socklen_t len = sizeof(*addr);
struct sockaddr_in sin;
*fd = socket(AF_INET, SOCK_DGRAM, 0);
if (*fd == -1) {
const int err = errno;
if (!IPFWTestNoSocket(err)) {
SCLogWarning("can't create an AF_INET socket: %s", strerror(err));
return -1;
}
SCLogInfo("can't create an AF_INET socket: %s; nothing to test", strerror(err));
return 0;
}
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
if (bind(*fd, (struct sockaddr *)&sin, sizeof(sin)) == -1 ||
getsockname(*fd, (struct sockaddr *)addr, &len) == -1 ||
setsockopt(*fd, SOL_SOCKET, SO_RCVTIMEO, &timev, sizeof(timev)) == -1) {
SCLogWarning("can't set up a UDP socket on the loopback address: %s", strerror(errno));
close(*fd);
*fd = -1;
return -1;
}
return 1;
}
static void IPFWTestTeardown(IPFWTestSockets *s)
{
ipfw_q[0].fd = s->saved_fd;
receive_port_num = s->saved_port_num;
if (s->q != -1)
close(s->q);
if (s->a != -1)
close(s->a);
if (s->b != -1)
close(s->b);
}
/**
* \brief Open the sockets of a test and make q the socket of queue 0
*
* \retval 1 ready
* \retval 0 this host has no IPv4 socket to test on
* \retval -1 failed
*/
static int IPFWTestSetup(IPFWTestSockets *s)
{
struct sockaddr_in a_addr;
s->saved_fd = ipfw_q[0].fd;
s->saved_port_num = receive_port_num;
s->q = s->a = s->b = -1;
int r = IPFWTestSocket(&s->q, &s->q_addr);
if (r == 1)
r = IPFWTestSocket(&s->a, &a_addr);
if (r == 1)
r = IPFWTestSocket(&s->b, &s->b_addr);
if (r != 1) {
IPFWTestTeardown(s);
return r;
}
ipfw_q[0].fd = s->q;
receive_port_num = 1;
return 1;
}
/**
* \brief Send the one-byte packet \a c from \a from to the queue's socket and
* receive it into a new packet of queue 0, as ReceiveIPFWLoop() does
*/
static Packet *IPFWTestReceive(const IPFWTestSockets *s, int from, uint8_t c)
{
/* queue 0's receive thread */
const IPFWThreadVars ptv = { .datalink = DLT_RAW, .ipfw_index = 0 };
struct sockaddr_in sin;
uint8_t buf[8];
if (sendto(from, &c, 1, 0, (const struct sockaddr *)&s->q_addr, sizeof(s->q_addr)) != 1)
return NULL;
if (IPFWRecv(s->q, buf, sizeof(buf), &sin) != 1)
return NULL;
Packet *p = PacketGetFromAlloc();
if (p == NULL)
return NULL;
IPFWPacketSetup(p, &ptv, &sin, buf, 1);
if (GET_PKT_LEN(p) != 1 || *GET_PKT_DATA(p) != c) {
PacketFree(p);
return NULL;
}
return p;
}
/** true if the next packet \a fd receives is the one-byte packet \a c */
static bool IPFWTestGot(int fd, uint8_t c)
{
uint8_t buf[8];
return recv(fd, buf, sizeof(buf), 0) == 1 && buf[0] == c;
}
/**
* \test A verdict reinjects a packet with the sockaddr that packet was
* received with, not with the one of the packet received last. In the
* autofp runmode the verdict runs in another thread, after the receive
* thread has read more packets from the socket.
*/
static int IPFWSetVerdictTest01(void)
{
IPFWTestSockets s;
IPFWThreadVars ptv;
memset(&ptv, 0, sizeof(ptv));
const int ready = IPFWTestSetup(&s);
FAIL_IF(ready < 0);
if (ready == 0) {
PASS;
}
/* a packet from a, then one from b; the verdicts follow both */
Packet *pa = IPFWTestReceive(&s, s.a, 'a');
FAIL_IF_NULL(pa);
Packet *pb = IPFWTestReceive(&s, s.b, 'b');
FAIL_IF_NULL(pb);
FAIL_IF(IPFWSetVerdict(NULL, &ptv, pa) != TM_ECODE_OK);
FAIL_IF(IPFWSetVerdict(NULL, &ptv, pb) != TM_ECODE_OK);
FAIL_IF(ptv.accepted != 2);
FAIL_IF(ptv.dropped != 0);
/* each one went back to the peer it came from */
FAIL_IF_NOT(IPFWTestGot(s.a, 'a'));
FAIL_IF_NOT(IPFWTestGot(s.b, 'b'));
PacketFree(pa);
PacketFree(pb);
IPFWTestTeardown(&s);
PASS;
}
/**
* \test A dropped packet is not reinjected.
*/
static int IPFWSetVerdictTest02(void)
{
IPFWTestSockets s;
IPFWThreadVars ptv;
memset(&ptv, 0, sizeof(ptv));
const int ready = IPFWTestSetup(&s);
FAIL_IF(ready < 0);
if (ready == 0) {
PASS;
}
/* drop the first packet from a and accept the second */
Packet *pd = IPFWTestReceive(&s, s.a, 'd');
FAIL_IF_NULL(pd);
Packet *pe = IPFWTestReceive(&s, s.a, 'e');
FAIL_IF_NULL(pe);
PacketDrop(pd, ACTION_DROP, PKT_DROP_REASON_RULES);
FAIL_IF(IPFWSetVerdict(NULL, &ptv, pd) != TM_ECODE_OK);
FAIL_IF(IPFWSetVerdict(NULL, &ptv, pe) != TM_ECODE_OK);
FAIL_IF(ptv.accepted != 1);
FAIL_IF(ptv.dropped != 1);
/* the first packet a gets back is the second one */
FAIL_IF_NOT(IPFWTestGot(s.a, 'e'));
PacketFree(pd);
PacketFree(pe);
IPFWTestTeardown(&s);
PASS;
}
/**
* \test The verdict of a tunnel packet reinjects the root packet, the one
* that was read from the socket, with the root's sockaddr.
*/
static int IPFWSetVerdictTest03(void)
{
IPFWTestSockets s;
IPFWThreadVars ptv;
memset(&ptv, 0, sizeof(ptv));
const int ready = IPFWTestSetup(&s);
FAIL_IF(ready < 0);
if (ready == 0) {
PASS;
}
/* the root came from a. Its child was never on the socket; give it b's
* sockaddr to show that it is not used. */
Packet *root = IPFWTestReceive(&s, s.a, 'r');
FAIL_IF_NULL(root);
Packet *child = PacketGetFromAlloc();
FAIL_IF_NULL(child);
child->ipfw_v.ipfw_index = 0;
child->ipfw_v.ipfw_sin = s.b_addr;
child->root = root;
child->ttype = PacketTunnelChild;
root->ttype = PacketTunnelRoot;
TUNNEL_INCR_PKT_TPR(child);
/* no verdict for the root while its child is outstanding */
FAIL_IF(VerdictIPFW(NULL, root, &ptv) != TM_ECODE_OK);
FAIL_IF(ptv.accepted != 0);
/* the root is done, the verdict comes with the child */
PacketTunnelSetVerdicted(root);
FAIL_IF(VerdictIPFW(NULL, child, &ptv) != TM_ECODE_OK);
FAIL_IF(ptv.accepted != 1);
FAIL_IF_NOT(IPFWTestGot(s.a, 'r'));
PacketFree(child);
PacketFree(root);
IPFWTestTeardown(&s);
PASS;
}
static void SourceIPFWRegisterTests(void)
{
UtRegisterTest("IPFWSetVerdictTest01", IPFWSetVerdictTest01);
UtRegisterTest("IPFWSetVerdictTest02", IPFWSetVerdictTest02);
UtRegisterTest("IPFWSetVerdictTest03", IPFWSetVerdictTest03);
}
#endif /* UNITTESTS */
#endif /* End ifdef IPFW */
/* eof */
src/source-ipfw.h
#define IPFW_MAX_QUEUE 16
/* per packet IPFW vars (Not used) */
/* per packet IPFW vars */
typedef struct IPFWPacketVars_
{
int ipfw_index;
/* divert sockaddr the packet was received with. The packet is reinjected
* with it: it tells the kernel the direction, the interface and where in
* the ruleset to resume. */
struct sockaddr_in ipfw_sin;
} IPFWPacketVars;
typedef struct IPFWQueueVars_
......
uint16_t port_num;
/* position into the ipfw queue var array */
uint16_t ipfw_index;
struct sockaddr_in ipfw_sin;
socklen_t ipfw_sinlen;
#ifdef DBG_PERF
int dbg_maxreadsize;
    (1-1/1)