Update sysutils/rsyslog to 8.2610.0 including upstream patches fixing
multiple CVEs. I'm not familiar w/ the rsyslog release cycle, so i don't
know why only source patches instead of new versions have been released
(or if a new version comes soon).

Release notes:
https://github.com/rsyslog/rsyslog/releases


Updates to the port:
- needs yaml (alternative configuration format)

- new 'impstats' module which uses archivers/snappy for compression

- needs protobuf-c (native protobuf encoding)

- build process needs USE_GMAKE=yes now

- multiple patches fixing CVEs have been added (as found on the
  osssec ml)

Lightly tested (i'm not using rsyslog).



Index: Makefile
===================================================================
RCS file: /cvs/ports/sysutils/rsyslog/Makefile,v
retrieving revision 1.60
diff -u -p -r1.60 Makefile
--- Makefile    26 Aug 2025 16:08:32 -0000      1.60
+++ Makefile    18 Nov 2026 16:17:00 -0000
@@ -6,14 +6,13 @@ COMMENT-elasticsearch =       Elasticsearch pl
 
 MULTI_PACKAGES =       -main -mysql -normalize -pgsql -elasticsearch
 
-V =                    8.2404.0
+V =                    8.2610.0
 DISTNAME =             rsyslog-$V
 PKGNAME-main =         rsyslog-$V
 PKGNAME-mysql =                rsyslog-mysql-$V
 PKGNAME-normalize =    rsyslog-normalize-$V
 PKGNAME-pgsql =                rsyslog-pgsql-$V
 PKGNAME-elasticsearch =        rsyslog-elasticsearch-$V
-REVISION =             1
 
 CATEGORIES =           sysutils
 
@@ -29,6 +28,7 @@ WANTLIB-main +=               c crypto curl estr fast
 WANTLIB-main +=                gpg-error hogweed iconv idn2 intl m nettle 
nghttp2
 WANTLIB-main +=                p11-kit pthread relp ssl tasn1 unistring uuid z
 WANTLIB-main +=                execinfo nghttp3 ngtcp2 ngtcp2_crypto_libressl
+WANTLIB-main +=                yaml protobuf-c snappy
 
 WANTLIB-mysql +=       crypto m mariadb pthread ssl z
 
@@ -39,8 +39,11 @@ WANTLIB-pgsql +=     crypto m pq pthread ssl
 WANTLIB-elasticsearch +=       crypto curl m nghttp2 pthread ssl z
 WANTLIB-elasticsearch +=       nghttp3 ngtcp2 ngtcp2_crypto_libressl
 
-LIB_DEPENDS-main =     devel/libfastjson \
+LIB_DEPENDS-main =     archivers/snappy \
+                       devel/libfastjson \
                        devel/libestr \
+                       devel/libyaml \
+                       devel/protobuf-c \
                        net/curl \
                        security/libgcrypt \
                        security/gnutls \
@@ -57,6 +60,8 @@ RUN_DEPENDS-elasticsearch =   ${PKGNAME-ma
 
 SITES =                        https://www.rsyslog.com/files/download/rsyslog/
 
+USE_GMAKE=             Yes
+
 CONFIGURE_STYLE =      gnu
 LIBTOOL_FLAGS =                --tag=disable-static
 CONFIGURE_ARGS +=      --enable-pgsql \
@@ -68,7 +73,8 @@ CONFIGURE_ARGS +=     --enable-pgsql \
                        --enable-relp \
                        --enable-elasticsearch \
                        --enable-imfile
-CONFIGURE_ENV +=       CPPFLAGS="-I${LOCALBASE}/include"
+CONFIGURE_ENV +=       CPPFLAGS="-I${LOCALBASE}/include" \
+                       LDFLAGS="-L${LOCALBASE}/lib"
 
 post-install:
        rm ${PREFIX}/lib/rsyslog/*.la
Index: distinfo
===================================================================
RCS file: /cvs/ports/sysutils/rsyslog/distinfo,v
retrieving revision 1.14
diff -u -p -r1.14 distinfo
--- distinfo    1 Aug 2024 14:23:03 -0000       1.14
+++ distinfo    18 Nov 2026 16:17:00 -0000
@@ -1,2 +1,2 @@
-SHA256 (rsyslog-8.2404.0.tar.gz) = MFKNFA7BsfB5IkCB+jffbgZYf/QrAuPmHy2qBSbFTTM=
-SIZE (rsyslog-8.2404.0.tar.gz) = 3408657
+SHA256 (rsyslog-8.2610.0.tar.gz) = e9+V6B6mwO5dWGNC1X0qbjlbCJ+zxnMYoNxVWBbeQEs=
+SIZE (rsyslog-8.2610.0.tar.gz) = 12179843
Index: patches/patch-plugins_imdtls_imdtls_c
===================================================================
RCS file: patches/patch-plugins_imdtls_imdtls_c
diff -N patches/patch-plugins_imdtls_imdtls_c
--- /dev/null   1 Jan 1970 00:00:00 -0000
+++ patches/patch-plugins_imdtls_imdtls_c       18 Nov 2026 16:17:00 -0000
@@ -0,0 +1,273 @@
+Upstream fix for:
+
+       - 
https://github.com/rsyslog/rsyslog/security/advisories/GHSA-4chq-f2r9-5jp8
+
+Index: plugins/imdtls/imdtls.c
+--- plugins/imdtls/imdtls.c.orig
++++ plugins/imdtls/imdtls.c
+@@ -35,6 +35,7 @@
+ #include <poll.h>
+ #include <assert.h>
+ #include <time.h>
++#include <limits.h>
+ 
+ // --- Include openssl headers as well
+ #include <openssl/ssl.h>
+@@ -98,6 +99,10 @@ struct dtlsClient_s {
+     SSL *sslClient; /* DTSL (SSL) Client */
+     time_t lastActivityTime; /* Last Activity Time */
+     int clientfd; /* ClientFD */
++    int peerVerified; /* post-handshake permitted-peer check completed */
++    long verifiedRenegotiations; /* handshake generation covered by 
peerVerified */
++    short pollEvents; /* readiness needed by the handshake */
++    int drainPending; /* continue after the per-client read limit */
+ };
+ 
+ // Use typedef to define a type 'dtlsClient_t' based on 'struct dtlsClient_s'
+@@ -572,8 +577,34 @@ static void DTLScleanupSession(instanceConf_t *inst, i
+     }
+     inst->dtlsClients[idx]->sslClient = NULL;
+     inst->dtlsClients[idx]->lastActivityTime = 0;
++    inst->dtlsClients[idx]->peerVerified = 0;
++    inst->dtlsClients[idx]->verifiedRenegotiations = 0;
++    inst->dtlsClients[idx]->pollEvents = POLLIN;
++    inst->dtlsClients[idx]->drainPending = 0;
+ }
+ 
++static int DTLSVerifySession(instanceConf_t *inst, int idx) {
++    dtlsClient_t *client = inst->dtlsClients[idx];
++    if (!SSL_is_init_finished(client->sslClient)) {
++        client->peerVerified = 0;
++        return 0;
++    }
++    long renegotiations = SSL_total_renegotiations(client->sslClient);
++    if (client->peerVerified && client->verifiedRenegotiations == 
renegotiations) {
++        return 1;
++    }
++
++    if (imdtls_verify_callback(1, client->sslClient) == 0) {
++        LogMsg(0, RS_RET_NO_ERRCODE, LOG_WARNING, "imdtls: Cert Verify FAILED 
for DTLS client idx (%d)", idx);
++        DTLScleanupSession(inst, idx);
++        return 0;
++    }
++    client->peerVerified = 1;
++    client->verifiedRenegotiations = renegotiations;
++    DBGPRINTF("imdtls: Cert Verify SUCCESS for DTLS client idx (%d)\n", idx);
++    return 1;
++}
++
+ static void DTLSAcceptSession(instanceConf_t *inst, int idx) {
+     int ret, err;
+     SSL *ssl = inst->dtlsClients[idx]->sslClient;
+@@ -587,7 +618,7 @@ static void DTLSAcceptSession(instanceConf_t *inst, in
+         if (ret <= 0) {
+             err = SSL_get_error(ssl, ret);
+             if (err == SSL_ERROR_WANT_READ || err == SSL_ERROR_WANT_WRITE) {
+-                // Non-blocking operation did not complete; retry later
++                inst->dtlsClients[idx]->pollEvents = (err == 
SSL_ERROR_WANT_WRITE) ? POLLIN | POLLOUT : POLLIN;
+                 DBGPRINTF("imdtls: SSL_accept didn't complete (%d). Will 
retry.\n", err);
+             } else if (err == SSL_ERROR_SYSCALL) {
+                 DBGPRINTF("imdtls: SSL_accept failed SSL_ERROR_SYSCALL idx 
(%d), removing client.\n", idx);
+@@ -602,18 +633,12 @@ static void DTLSAcceptSession(instanceConf_t *inst, in
+         } else {
+             DBGPRINTF("imdtls: SSL_accept success idx (%d), adding 
client.\n", idx);
+             inst->dtlsClients[idx]->lastActivityTime = time(NULL);
+-
+-            int status = 1;
+-            status = imdtls_verify_callback(status, ssl);
+-            if (status == 0) {
+-                LogMsg(0, RS_RET_NO_ERRCODE, LOG_WARNING, "imdtls: Cert 
Verify FAILED for DTLS client idx (%d)", idx);
+-                DTLScleanupSession(inst, idx);
+-            } else {
+-                DBGPRINTF("imdtls: Cert Verify SUCCESS for DTLS client idx 
(%d)\n", idx);
+-            }
++            inst->dtlsClients[idx]->pollEvents = POLLIN;
++            DTLSVerifySession(inst, idx);
+         }
+     } else {
+         DBGPRINTF("imdtls: SSL_get_state for DTLS client idx (%d) is %d\n", 
idx, ret);
++        DTLSVerifySession(inst, idx);
+     }
+ }
+ 
+@@ -630,26 +655,44 @@ static void DTLSReadClient(instanceConf_t *inst, int i
+     int err;
+     SSL *ssl = inst->dtlsClients[idx]->sslClient;
+     DBGPRINTF("imdtls: DEBUG Check Client activity on index %d.\n", idx);
+-    if (revents & POLLIN) {
++    if (revents & (POLLIN | POLLOUT)) {
+         if (ssl == NULL) {
+             DBGPRINTF("imdtls: DTLSHandleSessions MISSING SSL OBJ for index 
%d.\n", idx);
+             return;
+         }
++        if (!SSL_is_init_finished(ssl)) {
++            DTLSAcceptSession(inst, idx);
++            ssl = inst->dtlsClients[idx]->sslClient;
++            if (ssl == NULL || !SSL_is_init_finished(ssl)) {
++                return;
++            }
++        }
++        if (!DTLSVerifySession(inst, idx) || !(revents & 
inst->dtlsClients[idx]->pollEvents)) {
++            return;
++        }
+         DBGPRINTF("imdtls: Read Client activity on index %d.\n", idx);
+         char buf[MAX_DTLS_MSGSIZE];
+         int len = 0;
++        int reads = 0;
++        inst->dtlsClients[idx]->drainPending = 0;
+         do {
+             len = SSL_read(ssl, buf, sizeof(buf) - 1);
+             if (len > 0) {
++                inst->dtlsClients[idx]->pollEvents = POLLIN;
++                if (!DTLSVerifySession(inst, idx)) {
++                    return;
++                }
+                 buf[len] = '\0';
+                 processMsg(inst, inst->dtlsClients[idx], buf, len);
+             } else {
+                 err = SSL_get_error(ssl, len);
+                 if (err == SSL_ERROR_WANT_READ) {
++                    inst->dtlsClients[idx]->pollEvents = POLLIN;
+                     DBGPRINTF("imdtls: SSL_ERROR_WANT_READ flush rbio on 
index %d.\n", idx);
+                     BIO *rbio = SSL_get_rbio(ssl);
+                     BIO_flush(rbio);
+                 } else if (err == SSL_ERROR_WANT_WRITE) {
++                    inst->dtlsClients[idx]->pollEvents = POLLIN | POLLOUT;
+                     DBGPRINTF("imdtls: SSL_ERROR_WANT_WRITE flush wbio on 
index %d.\n", idx);
+                     BIO *wbio = SSL_get_wbio(ssl);
+                     BIO_flush(wbio);
+@@ -668,7 +711,15 @@ static void DTLSReadClient(instanceConf_t *inst, int i
+                     break;
+                 }
+             }
+-        } while (len > 0);
++            ++reads;
++        } while (len > 0 && reads < 32);
++        /* OpenSSL can retain complete DTLS records after the datagram socket
++         * has been drained. Retry once on the next loop after the limit,
++         * even if poll reports no new socket data. A WANT_READ clears this
++         * flag, so an incomplete record cannot spin the event loop. */
++        if (len > 0 && reads == 32) {
++            inst->dtlsClients[idx]->drainPending = 1;
++        }
+     }
+ }
+ 
+@@ -678,6 +729,8 @@ static void DTLSHandleSessions(instanceConf_t *inst) {
+     int optval = 1;
+     int fdcount = 0;
+     int ret, err;
++    int pollTimeout = -1;
++    time_t now = time(NULL);
+     memset(clientIdxByPollSlot, -1, sizeof(clientIdxByPollSlot));
+     memset(fds, 0, sizeof(fds));
+     fds[0].fd = inst->sockfd;
+@@ -696,13 +749,36 @@ static void DTLSHandleSessions(instanceConf_t *inst) {
+             fdcount++;
+             DBGPRINTF("imdtls: DTLSHandleSessions handle client %d (%d)\n", 
fdcount, clientfd);
+             fds[fdcount].fd = clientfd;
+-            fds[fdcount].events = POLLIN;
++            fds[fdcount].events = inst->dtlsClients[i]->pollEvents;
+             clientIdxByPollSlot[fdcount] = i;
++            if (inst->dtlsClients[i]->drainPending) {
++                pollTimeout = 0;
++            }
++
++            /* A nonblocking DTLS handshake needs its retransmission timer
++             * serviced even if no socket becomes ready. */
++            if (!SSL_is_init_finished(inst->dtlsClients[i]->sslClient)) {
++                struct timeval tv;
++                if (DTLSv1_get_timeout(inst->dtlsClients[i]->sslClient, &tv)) 
{
++                    long long ms = (long long)tv.tv_sec * 1000 + (tv.tv_usec 
+ 999) / 1000;
++                    int delay = ms > INT_MAX ? INT_MAX : (int)ms;
++                    if (pollTimeout < 0 || delay < pollTimeout) {
++                        pollTimeout = delay;
++                    }
++                }
++            }
++            long long idleSeconds =
++                (long long)inst->timeout - (long long)difftime(now, 
inst->dtlsClients[i]->lastActivityTime);
++            long long idleMs = idleSeconds <= 0 ? 0 : idleSeconds * 1000;
++            int idleDelay = idleMs > INT_MAX ? INT_MAX : (int)idleMs;
++            if (pollTimeout < 0 || idleDelay < pollTimeout) {
++                pollTimeout = idleDelay;
++            }
+         }
+     }
+ 
+     DBGPRINTF("imdtls: Waiting for poll (clients %d) ...\n", fdcount);
+-    ret = poll(fds, fdcount + 1, -1);
++    ret = poll(fds, fdcount + 1, pollTimeout);
+     if (glbl.GetGlobalInputTermState() == 1) {
+         DBGPRINTF("imdtls: DTLSHandleSessions Terminate State\n");
+         return; /* terminate input! */
+@@ -716,14 +792,25 @@ static void DTLSHandleSessions(instanceConf_t *inst) {
+     DBGPRINTF("imdtls: DTLSHandleSessions handle client sockets (%d) \n", 
fdcount);
+     for (int i = 1; i <= fdcount; ++i) {
+         if (clientIdxByPollSlot[i] >= 0) {
+-            DTLSReadClient(inst, clientIdxByPollSlot[i], fds[i].revents);
++            int idx = clientIdxByPollSlot[i];
++            short revents = fds[i].revents | 
(inst->dtlsClients[idx]->drainPending ? POLLIN : 0);
++            DTLSReadClient(inst, idx, revents);
+         }
+     }
+ 
+     // Check session timeouts
+     for (int i = 0; i < MAX_DTLS_CLIENTS; ++i) {
+         if (inst->dtlsClients[i]->sslClient != NULL) {
+-            if (difftime(time(NULL), inst->dtlsClients[i]->lastActivityTime) 
> inst->timeout) {
++            if (!SSL_is_init_finished(inst->dtlsClients[i]->sslClient)) {
++                struct timeval tv;
++                if (DTLSv1_get_timeout(inst->dtlsClients[i]->sslClient, &tv) 
&& tv.tv_sec == 0 && tv.tv_usec == 0 &&
++                    DTLSv1_handle_timeout(inst->dtlsClients[i]->sslClient) < 
0) {
++                    DBGPRINTF("imdtls: DTLS retransmission failed for client 
index %d.\n", i);
++                    DTLScleanupSession(inst, i);
++                    continue;
++                }
++            }
++            if (difftime(time(NULL), inst->dtlsClients[i]->lastActivityTime) 
>= inst->timeout) {
+                 DBGPRINTF("imdtls: Session timeout (%d) for client index 
%d.\n", i, inst->timeout);
+                 DTLScleanupSession(inst, i);
+                 continue;
+@@ -832,12 +919,25 @@ static void DTLSHandleSessions(instanceConf_t *inst) {
+                     int addedClient = 0;
+                     BIO_ctrl_set_connected(rbio, client_addr);
+                     DBGPRINTF("imdtls: BIO_connect succeeded.\n");
++                    /* BIO_connect can reset the socket's blocking mode. Set
++                     * O_NONBLOCK only after the BIO has been connected. */
++                    int flags = fcntl(clientfd, F_GETFL, 0);
++                    if (flags < 0 || fcntl(clientfd, F_SETFL, flags | 
O_NONBLOCK) < 0) {
++                        LogError(0, NO_ERRCODE, "imdtls: unable to make 
client socket non-blocking");
++                        close(clientfd);
++                        SSL_free(ssl);
++                        break;
++                    }
+ 
+                     // Add to DTLS Clients
+                     for (int i = 0; i < MAX_DTLS_CLIENTS; ++i) {
+                         if (inst->dtlsClients[i]->sslClient == NULL) {
+                             inst->dtlsClients[i]->sslClient = ssl;
+                             inst->dtlsClients[i]->lastActivityTime = 
time(NULL);
++                            inst->dtlsClients[i]->peerVerified = 0;
++                            inst->dtlsClients[i]->verifiedRenegotiations = 0;
++                            inst->dtlsClients[i]->pollEvents = POLLIN;
++                            inst->dtlsClients[i]->drainPending = 0;
+                             DBGPRINTF("imdtls: New Client added at idx 
%d.\n", i);
+                             DTLSAcceptSession(inst, i);
+                             addedClient = 1;
+@@ -857,10 +957,11 @@ static void DTLSHandleSessions(instanceConf_t *inst) {
+                 /* Retry on EAGAIN (recv timeout, no datagram) and on ret == 0
+                  * with an empty error queue (no usable handshake data yet). 
*/
+                 if (err == SSL_ERROR_SYSCALL && (errno == EAGAIN || (ret == 0 
&& ERR_peek_error() == 0))) {
+-                    DBGPRINTF("imdtls: DTLSv1_listen RET %d (ERR %d / ERRNO 
%d), retry\n", ret, err, errno);
+-                    // Wait little and retry DTLSv1_listen
+-                    srSleep(0, 100000);
+-                    continue;
++                    DBGPRINTF("imdtls: DTLSv1_listen RET %d (ERR %d / ERRNO 
%d), defer\n", ret, err, errno);
++                    /* DTLSv1_listen is stateless across the cookie exchange.
++                     * Return to poll instead of waiting here for a second 
flight. */
++                    SSL_free(ssl);
++                    break;
+                 } else {
+                     DBGPRINTF("imdtls: DTLSv1_listen RET %d (ERR %d / ERRNO 
%d), abort\n", ret, err, errno);
+                     net_ossl.osslLastOpenSSLErrorMsg(NULL, err, ssl, 
LOG_WARNING, "DTLSHandleSessions",
Index: patches/patch-plugins_imuxsock_imuxsock_c
===================================================================
RCS file: patches/patch-plugins_imuxsock_imuxsock_c
diff -N patches/patch-plugins_imuxsock_imuxsock_c
--- /dev/null   1 Jan 1970 00:00:00 -0000
+++ patches/patch-plugins_imuxsock_imuxsock_c   18 Nov 2026 16:17:00 -0000
@@ -0,0 +1,279 @@
+Upstream fix for 
+       - 
https://github.com/rsyslog/rsyslog/security/advisories/GHSA-6rqh-v5w3-r7h4
+       - 
https://github.com/rsyslog/rsyslog/security/advisories/GHSA-jcrj-xmp8-8hqf
+       - 
https://github.com/rsyslog/rsyslog/security/advisories/GHSA-w259-2hhm-9vr7
+       - 
https://github.com/rsyslog/rsyslog/security/advisories/GHSA-xrxr-7942-54fr
+       - CVE-2026-129831 (correlates with GHSA-xrxr-7942-54fr)
+
+Index: plugins/imuxsock/imuxsock.c
+--- plugins/imuxsock/imuxsock.c.orig
++++ plugins/imuxsock/imuxsock.c
+@@ -782,10 +782,13 @@ static void fixPID(uchar *bufTAG, int *lenTag, struct 
+ 
+     lenPID = snprintf(bufPID, sizeof(bufPID), "[%lu]:", (unsigned 
long)cred->pid);
+ 
+-    for (i = *lenTag; i >= 0 && bufTAG[i] != '['; --i) /*JUST SKIP*/
++    for (i = *lenTag - 1; i >= 0 && bufTAG[i] != '['; --i) /*JUST SKIP*/
+         ;
+ 
+-    if (i < 0) i = *lenTag - 1; /* go right at end of TAG, pid was not 
present (-1 for ':') */
++    if (i < 0) {
++        i = *lenTag;
++        if (i > 0 && bufTAG[i - 1] == ':') --i;
++    }
+ 
+     if (i + lenPID > CONF_TAG_MAXSIZE) return; /* do not touch, as things 
would break */
+ 
+@@ -866,29 +869,40 @@ finalize_it:
+  * It is assumed the output buffer is large enough. Returns the number of
+  * characters added.
+  */
+-static int copyescaped(uchar *dstbuf, uchar *inbuf, int inlen) {
++static size_t copyescaped(uchar *dstbuf, const uchar *inbuf, const int inlen) 
{
++    static const uchar hex[] = "0123456789abcdef";
+     int iDst, iSrc;
+ 
+     *dstbuf = '"';
+-    for (iDst = 1, iSrc = 0; iSrc < inlen; ++iDst, ++iSrc) {
++    for (iDst = 1, iSrc = 0; iSrc < inlen; ++iSrc) {
+         if (inbuf[iSrc] == '"' || inbuf[iSrc] == '\\') {
+             dstbuf[iDst++] = '\\';
++            dstbuf[iDst++] = inbuf[iSrc];
++        } else if (iscntrl((unsigned char)inbuf[iSrc])) {
++            dstbuf[iDst++] = '\\';
++            dstbuf[iDst++] = 'x';
++            dstbuf[iDst++] = hex[inbuf[iSrc] >> 4];
++            dstbuf[iDst++] = hex[inbuf[iSrc] & 0x0f];
++        } else {
++            dstbuf[iDst++] = inbuf[iSrc];
+         }
+-        dstbuf[iDst] = inbuf[iSrc];
+     }
+     dstbuf[iDst++] = '"';
+-    return iDst;
++    return (size_t)iDst;
+ }
+ 
+ 
+-static size_t escapedLen(uchar *inbuf, int inlen) {
++static size_t escapedLen(const uchar *inbuf, const int inlen) {
+     size_t len = 2; /* surrounding quotes */
+ 
+     for (int i = 0; i < inlen; ++i) {
+         if (inbuf[i] == '"' || inbuf[i] == '\\') {
++            len += 2;
++        } else if (iscntrl((unsigned char)inbuf[i])) {
++            len += 4; /* \xNN */
++        } else {
+             ++len;
+         }
+-        ++len;
+     }
+     return len;
+ }
+@@ -909,6 +923,68 @@ finalize_it:
+ }
+ 
+ 
++static rsRetVal ensureTrustedPropSpace(
++    uchar **const dst, size_t *const dstLen, uchar *const stackDst, const 
size_t used, const size_t extra) {
++    uchar *newDst;
++    size_t needed;
++    size_t newLen;
++    DEFiRet;
++
++    if (extra > (size_t)-1 - used) {
++        ABORT_FINALIZE(RS_RET_ERR);
++    }
++    needed = used + extra;
++    if (needed <= *dstLen) {
++        FINALIZE;
++    }
++
++    newLen = *dstLen;
++    while (newLen < needed) {
++        if (newLen > (size_t)-1 / 2) {
++            newLen = needed;
++        } else {
++            newLen *= 2;
++        }
++    }
++
++    if (*dst == stackDst) {
++        CHKmalloc(newDst = malloc(newLen));
++        memcpy(newDst, *dst, used);
++    } else {
++        CHKmalloc(newDst = realloc(*dst, newLen));
++    }
++    *dst = newDst;
++    *dstLen = newLen;
++
++finalize_it:
++    RETiRet;
++}
++
++
++static rsRetVal appendEscapedTrustedProp(uchar **const dst,
++                                         size_t *const dstLen,
++                                         uchar *const stackDst,
++                                         size_t *const offs,
++                                         const uchar *const name,
++                                         const size_t nameLen,
++                                         const uchar *const value,
++                                         const int valueLen) {
++    size_t escaped;
++    DEFiRet;
++
++    escaped = escapedLen(value, valueLen);
++    if (nameLen > (size_t)-1 - escaped || nameLen + escaped > (size_t)-1 - 2) 
{
++        ABORT_FINALIZE(RS_RET_ERR);
++    }
++    CHKiRet(ensureTrustedPropSpace(dst, dstLen, stackDst, *offs, nameLen + 
escaped + 2));
++    CHKiRet(appendTrustedProp(*dst, *dstLen, offs, name, nameLen));
++    *offs += copyescaped(*dst + *offs, value, valueLen);
++
++finalize_it:
++    RETiRet;
++}
++
++
+ /* submit received message to the queue engine
+  * We now parse the message according to expected format so that we
+  * can also mangle it if necessary.
+@@ -945,7 +1021,7 @@ static rsRetVal SubmitMsg(uchar *pRcv, int lenRcv, lst
+     parse++;
+     pri = 0;
+     priDigitCount = 0;
+-    while (offs < lenMsg && isdigit(*parse)) {
++    while (offs < lenMsg && priDigitCount < 3 && isdigit(*parse)) {
+         pri = pri * 10 + *parse - '0';
+         ++parse;
+         ++offs;
+@@ -1021,22 +1097,17 @@ static rsRetVal SubmitMsg(uchar *pRcv, int lenRcv, lst
+         } else {
+             uchar msgbuf[8192];
+             uchar *pmsgbuf = msgbuf;
+-            const size_t trustedPropBufLen = sizeof(propBuf) - 1;
+-            const size_t trustedPropMaxExtra = 3 + /* " @[" */
+-                                               96 + /* _PID/_UID/_GID tags 
plus maximum decimal values */
+-                                               7 + trustedPropBufLen + /* 
_COMM= */
+-                                               6 + trustedPropBufLen + /* 
_EXE= */
+-                                               10 + 2 + 2 * trustedPropBufLen 
+ /* _CMDLINE= plus escaped value */
+-                                               2; /* closing bracket and NUL 
*/
++            const size_t trustedPropFixedExtra = 3 + /* " @[" */
++                                                 96 + /* _PID/_UID/_GID tags 
plus maximum decimal values */
++                                                 2; /* closing bracket and 
NUL */
+             size_t msgbuf_size = sizeof(msgbuf);
+             size_t toffs; /* offset for trusted properties */
+-            size_t escaped;
+ 
+-            if ((size_t)lenRcv > (size_t)-1 - trustedPropMaxExtra) {
++            if ((size_t)lenRcv > (size_t)-1 - trustedPropFixedExtra) {
+                 ABORT_FINALIZE(RS_RET_ERR);
+             }
+-            if ((size_t)lenRcv + trustedPropMaxExtra > sizeof(msgbuf)) {
+-                msgbuf_size = (size_t)lenRcv + trustedPropMaxExtra;
++            if ((size_t)lenRcv + trustedPropFixedExtra > sizeof(msgbuf)) {
++                msgbuf_size = (size_t)lenRcv + trustedPropFixedExtra;
+                 CHKmalloc(pmsgbuf = malloc(msgbuf_size));
+             }
+ 
+@@ -1056,30 +1127,25 @@ static rsRetVal SubmitMsg(uchar *pRcv, int lenRcv, lst
+             }
+ 
+             if (getTrustedProp(cred, "comm", propBuf, sizeof(propBuf), 
&lenProp) == RS_RET_OK) {
+-                if ((iRet = appendTrustedProp(pmsgbuf, msgbuf_size, &toffs, 
(uchar *)" _COMM=", 7)) != RS_RET_OK ||
+-                    (iRet = appendTrustedProp(pmsgbuf, msgbuf_size, &toffs, 
propBuf, (size_t)lenProp)) != RS_RET_OK) {
++                if ((iRet = appendEscapedTrustedProp(&pmsgbuf, &msgbuf_size, 
msgbuf, &toffs, (uchar *)" _COMM=", 7,
++                                                     propBuf, lenProp)) != 
RS_RET_OK) {
+                     if (pmsgbuf != msgbuf) free(pmsgbuf);
+                     FINALIZE;
+                 }
+             }
+             if (getTrustedExe(cred, propBuf, sizeof(propBuf), &lenProp) == 
RS_RET_OK) {
+-                if ((iRet = appendTrustedProp(pmsgbuf, msgbuf_size, &toffs, 
(uchar *)" _EXE=", 6)) != RS_RET_OK ||
+-                    (iRet = appendTrustedProp(pmsgbuf, msgbuf_size, &toffs, 
propBuf, (size_t)lenProp)) != RS_RET_OK) {
++                if ((iRet = appendEscapedTrustedProp(&pmsgbuf, &msgbuf_size, 
msgbuf, &toffs, (uchar *)" _EXE=", 6,
++                                                     propBuf, lenProp)) != 
RS_RET_OK) {
+                     if (pmsgbuf != msgbuf) free(pmsgbuf);
+                     FINALIZE;
+                 }
+             }
+             if (getTrustedProp(cred, "cmdline", propBuf, sizeof(propBuf), 
&lenProp) == RS_RET_OK) {
+-                if ((iRet = appendTrustedProp(pmsgbuf, msgbuf_size, &toffs, 
(uchar *)" _CMDLINE=", 10)) != RS_RET_OK) {
++                if ((iRet = appendEscapedTrustedProp(&pmsgbuf, &msgbuf_size, 
msgbuf, &toffs, (uchar *)" _CMDLINE=", 10,
++                                                     propBuf, lenProp)) != 
RS_RET_OK) {
+                     if (pmsgbuf != msgbuf) free(pmsgbuf);
+                     FINALIZE;
+                 }
+-                escaped = escapedLen(propBuf, lenProp);
+-                if (escaped > msgbuf_size || toffs > msgbuf_size - escaped) {
+-                    if (pmsgbuf != msgbuf) free(pmsgbuf);
+-                    ABORT_FINALIZE(RS_RET_ERR);
+-                }
+-                toffs += (size_t)copyescaped(pmsgbuf + toffs, propBuf, 
lenProp);
+             }
+ 
+             /* finalize string */
+@@ -1107,14 +1173,20 @@ static rsRetVal SubmitMsg(uchar *pRcv, int lenRcv, lst
+         pMsg->msgFlags = pLstn->flags;
+     }
+ 
+-    if (pLstn->bUseSpecialParser) {
++    if (pLstn->bUseSpecialParser && priValid) {
+         /* this is the legacy "log socket" parser which was written on the 
assumption
+          * that the log socket format would be fixed. While many folks said 
so, it
+          * seems to be different in practice, and this is why we now have 
choices...
+          * rgerhards, 2015-03-03
+          */
+-        parser.SanitizeMsg(pMsg);
+-        lenMsg = pMsg->iLenRawMsg - offs; /* SanitizeMsg() may have changed 
the size */
++        CHKiRet(parser.SanitizeMsg(pMsg));
++        /* Sanitizing may shorten the raw message. Never reuse a PRI cursor
++         * outside the current representation. */
++        if (offs >= pMsg->iLenRawMsg) {
++            pMsg->msgFlags |= NEEDS_PARSING;
++            goto submit;
++        }
++        lenMsg = pMsg->iLenRawMsg - offs;
+         parse = pMsg->pszRawMsg + offs;
+         msgSetPRI(pMsg, pri);
+         MsgSetAfterPRIOffs(pMsg, priValid ? offs + 1 : 0);
+@@ -1138,16 +1210,20 @@ static rsRetVal SubmitMsg(uchar *pRcv, int lenRcv, lst
+                 }
+             }
+         } else { /* if we pulled the time from the system, we need to update 
the message text */
+-            uchar *tmpParse = parse; /* just to check correctness of TS */
+-            if (datetime.ParseTIMESTAMP3339(&dummyTS, &tmpParse, &lenMsg) == 
RS_RET_OK ||
+-                datetime.ParseTIMESTAMP3164(&dummyTS, &tmpParse, &lenMsg, 
NO_PARSE3164_TZSTRING,
++            uchar *tmpParse = parse;
++            int remaining = lenMsg;
++            if (datetime.ParseTIMESTAMP3339(&dummyTS, &tmpParse, &remaining) 
== RS_RET_OK ||
++                datetime.ParseTIMESTAMP3164(&dummyTS, &tmpParse, &remaining, 
NO_PARSE3164_TZSTRING,
+                                             NO_PERMIT_YEAR_AFTER_TIME) == 
RS_RET_OK) {
+-                /* We modify the message only if it contained a valid 
timestamp,
+-                otherwise we do not touch it at all. */
+-                datetime.formatTimestamp3164(&st, (char *)parse, 0);
+-                parse[15] = ' '; /* re-write \0 from fromatTimestamp3164 by 
SP */
+-                /* update "counters" to reflect processed timestamp */
+-                parse += 16;
++                /* The permissive parsers accept timestamps shorter than the 
fixed
++                 * replacement. Only overwrite bytes belonging to the 
timestamp,
++                 * and keep the parser's cursor paired with its remaining 
length. */
++                if (tmpParse - parse == 16) {
++                    datetime.formatTimestamp3164(&st, (char *)parse, 0);
++                    parse[15] = ' '; /* replace the formatter's terminating 
NUL */
++                }
++                parse = tmpParse;
++                lenMsg = remaining;
+             }
+         }
+ 
+@@ -1166,6 +1242,7 @@ static rsRetVal SubmitMsg(uchar *pRcv, int lenRcv, lst
+         pMsg->msgFlags |= NEEDS_PARSING;
+     }
+ 
++submit:
+     MsgSetRcvFrom(pMsg, pLstn->hostName == NULL ? glbl.GetLocalHostNameProp() 
: pLstn->hostName);
+     CHKiRet(MsgSetRcvFromIP(pMsg, pLocalHostIP));
+     MsgSetRuleset(pMsg, pLstn->pRuleset);
Index: patches/patch-plugins_mmanon_mmanon_c
===================================================================
RCS file: patches/patch-plugins_mmanon_mmanon_c
diff -N patches/patch-plugins_mmanon_mmanon_c
--- /dev/null   1 Jan 1970 00:00:00 -0000
+++ patches/patch-plugins_mmanon_mmanon_c       18 Nov 2026 16:17:00 -0000
@@ -0,0 +1,27 @@
+Upstream fix for:
+
+       - 
https://github.com/rsyslog/rsyslog/security/advisories/GHSA-f9hg-rj32-693x
+
+Index: plugins/mmanon/mmanon.c
+--- plugins/mmanon/mmanon.c.orig
++++ plugins/mmanon/mmanon.c
+@@ -1756,7 +1756,7 @@ static int syntax_embedded(const uchar *const __restri
+ 
+     while (*nprocessed < buflen) {
+         numLen = isValidHexNum(buf + *nprocessed, buflen - *nprocessed, 
nprocessed, 1);
+-        if (numLen > 0) {  // found a valid num
++        if (numLen > 0 && numLen < 5) {  // found a valid IPv6 group
+             if ((ipParts == 6 && hadAbbrev) || ipParts > 6) {  // is 6 since 
the first part of
+                 // IPv4 will also result in a valid hexvalue
+                 isIP = 0;
+@@ -1929,7 +1929,9 @@ static void anonEmbedded(wrkrInstanceData_t *pWrkrData
+ 
+     int syn = syntax_embedded(*msg + offset, *pLenMsg - offset, &iplen, 
&v4Start);
+     if (syn) {
+-        assert(iplen < sizeof(address));
++        if (iplen >= sizeof(address)) {
++            return;
++        }
+         getip(*msg + offset, iplen, address);
+         offset += iplen;
+         process_embedded(address, pWrkrData, v4Start);
Index: patches/patch-runtime_datetime_c
===================================================================
RCS file: patches/patch-runtime_datetime_c
diff -N patches/patch-runtime_datetime_c
--- /dev/null   1 Jan 1970 00:00:00 -0000
+++ patches/patch-runtime_datetime_c    18 Nov 2026 16:17:00 -0000
@@ -0,0 +1,22 @@
+Upstream fix for:
+
+       - 
https://github.com/rsyslog/rsyslog/security/advisories/GHSA-5pc2-f2v7-5w5p
+
+Index: runtime/datetime.c
+--- runtime/datetime.c.orig
++++ runtime/datetime.c
+@@ -1187,6 +1187,7 @@ int getWeekdayNbr(struct syslogTime *ts) {
+     }
+     wday = ((36525 * g) / 100) + ((306 * f) / 10) + ts->day - 621049;
+     wday %= 7;
++    if (wday < 0) wday += 7;
+     return wday;
+ }
+ 
+@@ -1387,4 +1388,4 @@ BEGINAbstractObjClassInit(datetime, 1, OBJ_IS_CORE_MOD
+ ENDObjClassInit(datetime)
+ 
+ /* vi:set ai:
+- */
+\ No newline at end of file
++ */
Index: patches/patch-runtime_net_ossl_c
===================================================================
RCS file: patches/patch-runtime_net_ossl_c
diff -N patches/patch-runtime_net_ossl_c
--- patches/patch-runtime_net_ossl_c    1 Aug 2024 14:23:03 -0000       1.1
+++ /dev/null   1 Jan 1970 00:00:00 -0000
@@ -1,46 +0,0 @@
-LibreSSL does not support SSL_CONF_cmd.
-This is already present in rsyslog master and will most likely ship
-with a future version.
-https://github.com/rsyslog/rsyslog/commit/b79fd513271bdd02d8a37fa4197d2f293aaf6d11
-
-Index: runtime/net_ossl.c
---- runtime/net_ossl.c.orig
-+++ runtime/net_ossl.c
-@@ -59,7 +59,9 @@ void net_ossl_set_ssl_verify_callback(SSL *pSsl, int f
- void net_ossl_set_ctx_verify_callback(SSL_CTX *pCtx, int flags);
- void net_ossl_set_bio_callback(BIO *conn);
- int net_ossl_verify_callback(int status, X509_STORE_CTX *store);
-+#if OPENSSL_VERSION_NUMBER >= 0x10002000L && !defined(LIBRESSL_VERSION_NUMBER)
- rsRetVal net_ossl_apply_tlscgfcmd(net_ossl_t *pThis, uchar *tlscfgcmd);
-+#endif // OPENSSL_VERSION_NUMBER >= 0x10002000L
- rsRetVal net_ossl_chkpeercertvalidity(net_ossl_t *pThis, SSL *ssl, uchar 
*fromHostIP);
- X509* net_ossl_getpeercert(net_ossl_t *pThis, SSL *ssl, uchar *fromHostIP);
- rsRetVal net_ossl_peerfingerprint(net_ossl_t *pThis, X509* certpeer, uchar 
*fromHostIP);
-@@ -472,6 +474,7 @@ void net_ossl_lastOpenSSLErrorMsg
-       }
- }
- 
-+#if OPENSSL_VERSION_NUMBER >= 0x10002000L && !defined(LIBRESSL_VERSION_NUMBER)
- /* initialize tls config commands in openssl context
-  */
- rsRetVal net_ossl_apply_tlscgfcmd(net_ossl_t *pThis, uchar *tlscfgcmd)
-@@ -557,8 +560,8 @@ rsRetVal net_ossl_apply_tlscgfcmd(net_ossl_t *pThis, u
- finalize_it:
-       RETiRet;
- }
-+#endif // OPENSSL_VERSION_NUMBER >= 0x10002000L
- 
--
- /* Convert a fingerprint to printable data. The  conversion is carried out
-  * according IETF I-D syslog-transport-tls-12. The fingerprint string is
-  * returned in a new cstr object. It is the caller's responsibility to
-@@ -1195,7 +1198,9 @@ CODESTARTobjQueryInterface(net_ossl)
-       pIf->osslPeerfingerprint        = net_ossl_peerfingerprint;
-       pIf->osslGetpeercert            = net_ossl_getpeercert;
-       pIf->osslChkpeercertvalidity    = net_ossl_chkpeercertvalidity;
-+#if OPENSSL_VERSION_NUMBER >= 0x10002000L && !defined(LIBRESSL_VERSION_NUMBER)
-       pIf->osslApplyTlscgfcmd         = net_ossl_apply_tlscgfcmd;
-+#endif // OPENSSL_VERSION_NUMBER >= 0x10002000L
-       pIf->osslSetBioCallback         = net_ossl_set_bio_callback;
-       pIf->osslSetCtxVerifyCallback   = net_ossl_set_ctx_verify_callback;
-       pIf->osslSetSslVerifyCallback   = net_ossl_set_ssl_verify_callback;
Index: patches/patch-runtime_net_ossl_h
===================================================================
RCS file: patches/patch-runtime_net_ossl_h
diff -N patches/patch-runtime_net_ossl_h
--- patches/patch-runtime_net_ossl_h    1 Aug 2024 14:23:03 -0000       1.1
+++ /dev/null   1 Jan 1970 00:00:00 -0000
@@ -1,18 +0,0 @@
-LibreSSL does not support SSL_CONF_cmd.
-This is already present in rsyslog master and will most likely ship
-with a future version.
-https://github.com/rsyslog/rsyslog/commit/b79fd513271bdd02d8a37fa4197d2f293aaf6d11
-
-Index: runtime/net_ossl.h
---- runtime/net_ossl.h.orig
-+++ runtime/net_ossl.h
-@@ -88,7 +88,9 @@ BEGINinterface(net_ossl) /* name must also be changed 
-       rsRetVal (*osslPeerfingerprint)(net_ossl_t *pThis, X509* certpeer, 
uchar *fromHostIP);
-       X509* (*osslGetpeercert)(net_ossl_t *pThis, SSL *ssl, uchar 
*fromHostIP);
-       rsRetVal (*osslChkpeercertvalidity)(net_ossl_t *pThis, SSL *ssl, uchar 
*fromHostIP);
-+#if OPENSSL_VERSION_NUMBER >= 0x10002000L && !defined(LIBRESSL_VERSION_NUMBER)
-       rsRetVal (*osslApplyTlscgfcmd)(net_ossl_t *pThis, uchar *tlscfgcmd);
-+#endif // OPENSSL_VERSION_NUMBER >= 0x10002000L
-       void (*osslSetBioCallback)(BIO *conn);
-       void (*osslSetCtxVerifyCallback)(SSL_CTX *pCtx, int flags);
-       void (*osslSetSslVerifyCallback)(SSL *pSsl, int flags);
Index: patches/patch-runtime_template_c
===================================================================
RCS file: patches/patch-runtime_template_c
diff -N patches/patch-runtime_template_c
--- /dev/null   1 Jan 1970 00:00:00 -0000
+++ patches/patch-runtime_template_c    18 Nov 2026 16:17:00 -0000
@@ -0,0 +1,16 @@
+Upstream fix for:
+
+       - 
https://github.com/rsyslog/rsyslog/security/advisories/GHSA-cg8j-rwxh-vrg3
+
+Index: runtime/template.c
+--- runtime/template.c.orig
++++ runtime/template.c
+@@ -1161,7 +1161,7 @@ rsRetVal doEscape(uchar **pp, rs_size_t *pLen, unsigne
+     else if (mode == SQL_ESCAPE)
+         for (p = *pp; *p && *p != '\'' && *p != '\\'; ++p);
+     else if (mode == JSON_ESCAPE)
+-        for (p = *pp; *p && (*p == '"' || *p == '\\'); ++p);
++        for (p = *pp; *p && *p != '"' && *p != '\\'; ++p);
+     /* when we get out of the loop, we are either at the
+      * string terminator or the first character to escape */
+     if (p && *p == '\0') FINALIZE; /* nothing to do in this case! */
Index: pkg/PLIST-main
===================================================================
RCS file: /cvs/ports/sysutils/rsyslog/pkg/PLIST-main,v
retrieving revision 1.10
diff -u -p -r1.10 PLIST-main
--- pkg/PLIST-main      8 Nov 2022 11:17:12 -0000       1.10
+++ pkg/PLIST-main      18 Nov 2026 16:17:00 -0000
@@ -7,6 +7,7 @@ lib/rsyslog/
 @so lib/rsyslog/imfile.so
 @so lib/rsyslog/imklog.so
 @so lib/rsyslog/immark.so
+@so lib/rsyslog/impstats.so
 @so lib/rsyslog/imrelp.so
 @so lib/rsyslog/imtcp.so
 @so lib/rsyslog/imudp.so
@@ -22,6 +23,8 @@ lib/rsyslog/
 @so lib/rsyslog/lmtcpsrv.so
 @so lib/rsyslog/lmzlibw.so
 @so lib/rsyslog/mmexternal.so
+@so lib/rsyslog/mmleefparse.so
+@so lib/rsyslog/omkinesis.so
 @so lib/rsyslog/ommail.so
 @so lib/rsyslog/omrelp.so
 @so lib/rsyslog/omtesting.so



--
Mark Patruck ( mark at wrapped.cx )
GPG key 0xF2865E51 / 187F F6D3 EE04 1DCE 1C74  F644 0D3C F66F F286 5E51
 
https://www.wrapped.cx

Reply via email to