This is an automated email from the ASF dual-hosted git repository. davsclaus pushed a commit to branch CAMEL-27224-4.18.x in repository https://gitbox.apache.org/repos/asf/camel.git
commit 499698e17119c7198c55cbbc16f901e745fb6c47 Author: Claus Ibsen <[email protected]> AuthorDate: Thu Nov 19 13:20:28 2026 +0100 CAMEL-27224: camel-snmp - the trap consumer receives only the traps of its snmpVersion, and for SNMPv3 of its user and security level (#30367) The trap consumer receives only the traps of the snmpVersion of its endpoint. With snmpVersion 0 (default) or 1 it receives SNMPv1 and SNMPv2c traps and drops SNMPv3 traps. With snmpVersion 3 it receives only the SNMPv3 traps of the user in securityName, checked with the authentication and privacy options of the endpoint and with at least securityLevel, using its own message dispatcher and USM instead of the JVM-wide SecurityModels of SNMP4J. Dropped traps are logged at DEBUG. Upgrade guide entry for 4.24. Co-Authored-By: Claude Opus 5.5 <[email protected]> Signed-off-by: Claus Ibsen <[email protected]> (cherry picked from commit 4dc8c2d888ae3cae8feff1fed38c7467aacf97c6, adapted for camel-4.18.x) Signed-off-by: Claus Ibsen <[email protected]> --- .../camel-snmp/src/main/docs/snmp-component.adoc | 15 ++ .../apache/camel/component/snmp/SnmpHelper.java | 12 +- .../camel/component/snmp/SnmpTrapConsumer.java | 66 ++++- .../component/snmp/TrapConsumerVersionTest.java | 285 +++++++++++++++++++++ 4 files changed, 375 insertions(+), 3 deletions(-) diff --git a/components/camel-snmp/src/main/docs/snmp-component.adoc b/components/camel-snmp/src/main/docs/snmp-component.adoc index 383c267dfa45..275dbe2b5960 100644 --- a/components/camel-snmp/src/main/docs/snmp-component.adoc +++ b/components/camel-snmp/src/main/docs/snmp-component.adoc @@ -129,6 +129,21 @@ snmp:127.0.0.1:162?protocol=udp&type=TRAP You can get the community of SNMP TRAP with message header `securityName`, peer address of the SNMP TRAP with message header `peerAddress`. +The trap receiver receives only the traps of its `snmpVersion`: + +* With `snmpVersion` 0 (the default) or 1, it receives SNMPv1 and SNMPv2c traps, whatever their community. The route +can check the community in the `securityName` header. +* With `snmpVersion` 3, it receives only the SNMPv3 traps of the user set in `securityName`, with at least the +`securityLevel` of the endpoint (the default is 3, authentication and privacy). The traps are checked and decrypted with +the `authenticationProtocol`, `authenticationPassphrase`, `privacyProtocol` and `privacyPassphrase` of the endpoint. +These protocols must be registered in the `org.snmp4j.security.SecurityProtocols` of SNMP4J, for example with +`SecurityProtocols.getInstance().addAuthenticationProtocol(new AuthSHA())`. + +------------------------------------------------------------------------------------------------------------------ +snmp:0.0.0.0:162?protocol=udp&type=TRAP&snmpVersion=3&securityName=camel&securityLevel=3 + &authenticationProtocol=SHA1&authenticationPassphrase=RAW(...)&privacyProtocol=AES128&privacyPassphrase=RAW(...) +------------------------------------------------------------------------------------------------------------------ + Routing example in Java: (converts the SNMP PDU to XML String) [source,java] diff --git a/components/camel-snmp/src/main/java/org/apache/camel/component/snmp/SnmpHelper.java b/components/camel-snmp/src/main/java/org/apache/camel/component/snmp/SnmpHelper.java index ee2636af0dda..7521c611047e 100644 --- a/components/camel-snmp/src/main/java/org/apache/camel/component/snmp/SnmpHelper.java +++ b/components/camel-snmp/src/main/java/org/apache/camel/component/snmp/SnmpHelper.java @@ -77,12 +77,20 @@ final class SnmpHelper { } private static USM internalCreateAndSetUSM(SnmpEndpoint endpoint) { + USM usm = createUSM(endpoint); + SecurityModels.getInstance().addSecurityModel(usm); + return usm; + } + + /** + * Creates a USM with the user of the endpoint, without registering it in the JVM-wide {@link SecurityModels}. + */ + static USM createUSM(SnmpEndpoint endpoint) { if (endpoint.getSecurityName() == null) { - throw new IllegalArgumentException("SecurityNme is required for SNMP v3"); + throw new IllegalArgumentException("SecurityName is required for SNMP v3"); } USM usm = new USM(SecurityProtocols.getInstance(), new OctetString(MPv3.createLocalEngineID()), 0); - SecurityModels.getInstance().addSecurityModel(usm); OID authProtocol = convertAuthenticationProtocol(endpoint.getAuthenticationProtocol()); diff --git a/components/camel-snmp/src/main/java/org/apache/camel/component/snmp/SnmpTrapConsumer.java b/components/camel-snmp/src/main/java/org/apache/camel/component/snmp/SnmpTrapConsumer.java index 849401607b10..4899cdedb3a6 100644 --- a/components/camel-snmp/src/main/java/org/apache/camel/component/snmp/SnmpTrapConsumer.java +++ b/components/camel-snmp/src/main/java/org/apache/camel/component/snmp/SnmpTrapConsumer.java @@ -16,6 +16,8 @@ */ package org.apache.camel.component.snmp; +import java.util.Arrays; + import org.apache.camel.Exchange; import org.apache.camel.Processor; import org.apache.camel.support.DefaultConsumer; @@ -24,14 +26,22 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.snmp4j.CommandResponder; import org.snmp4j.CommandResponderEvent; +import org.snmp4j.MessageDispatcherImpl; import org.snmp4j.MessageException; import org.snmp4j.PDU; import org.snmp4j.Snmp; import org.snmp4j.TransportMapping; +import org.snmp4j.mp.MPv1; +import org.snmp4j.mp.MPv2c; +import org.snmp4j.mp.MPv3; +import org.snmp4j.mp.MessageProcessingModel; +import org.snmp4j.mp.SnmpConstants; import org.snmp4j.mp.StateReference; import org.snmp4j.mp.StatusInformation; +import org.snmp4j.security.USM; import org.snmp4j.smi.Address; import org.snmp4j.smi.GenericAddress; +import org.snmp4j.smi.OctetString; import org.snmp4j.smi.TcpAddress; import org.snmp4j.smi.UdpAddress; import org.snmp4j.transport.DefaultTcpTransportMapping; @@ -71,7 +81,7 @@ public class SnmpTrapConsumer extends DefaultConsumer implements CommandResponde } // NOTE: the object is going to be closed by stop() lifecycle. - this.snmp = new Snmp(transport); // NOSONAR + this.snmp = new Snmp(createMessageDispatcher(), transport); // NOSONAR snmp.addCommandResponder(this); // listen to the transport @@ -84,6 +94,57 @@ public class SnmpTrapConsumer extends DefaultConsumer implements CommandResponde } } + /** + * Creates a message dispatcher with only the message processing models of the configured snmpVersion: SNMPv1 and + * SNMPv2c for the versions 0 and 1, and SNMPv3 with a USM of its own that holds only the user of the endpoint for + * the version 3. + */ + private MessageDispatcherImpl createMessageDispatcher() { + MessageDispatcherImpl dispatcher = new MessageDispatcherImpl(); + int version = endpoint.getSnmpVersion(); + if (version == SnmpConstants.version1 || version == SnmpConstants.version2c) { + dispatcher.addMessageProcessingModel(new MPv1()); + dispatcher.addMessageProcessingModel(new MPv2c()); + } else if (version == SnmpConstants.version3) { + USM usm = SnmpHelper.createUSM(endpoint); + dispatcher.addMessageProcessingModel(new MPv3(usm)); + } else { + throw new IllegalArgumentException("Unknown snmpVersion: " + version); + } + return dispatcher; + } + + /** + * Whether the event matches the configured snmpVersion and, for SNMPv3, the security name and the minimum security + * level of the endpoint. + */ + private boolean isAccepted(CommandResponderEvent event) { + int version = endpoint.getSnmpVersion(); + int model = event.getMessageProcessingModel(); + if (version == SnmpConstants.version3) { + if (model != MessageProcessingModel.MPv3) { + LOG.debug("Dropping trap from {}: message processing model {} is not SNMPv3", event.getPeerAddress(), model); + return false; + } + if (!Arrays.equals(new OctetString(endpoint.getSecurityName()).getValue(), event.getSecurityName())) { + LOG.debug("Dropping trap from {}: security name is not the one of the endpoint", event.getPeerAddress()); + return false; + } + if (event.getSecurityLevel() < endpoint.getSecurityLevel()) { + LOG.debug("Dropping trap from {}: security level {} is below the security level {} of the endpoint", + event.getPeerAddress(), event.getSecurityLevel(), endpoint.getSecurityLevel()); + return false; + } + return true; + } + if (model != MessageProcessingModel.MPv1 && model != MessageProcessingModel.MPv2c) { + LOG.debug("Dropping trap from {}: message processing model {} is not SNMPv1 or SNMPv2c", event.getPeerAddress(), + model); + return false; + } + return true; + } + @Override protected void doStop() throws Exception { // stop listening to the transport @@ -101,6 +162,9 @@ public class SnmpTrapConsumer extends DefaultConsumer implements CommandResponde @Override public void processPdu(CommandResponderEvent event) { + if (!isAccepted(event)) { + return; + } PDU pdu = event.getPDU(); // check PDU not null if (pdu != null) { diff --git a/components/camel-snmp/src/test/java/org/apache/camel/component/snmp/TrapConsumerVersionTest.java b/components/camel-snmp/src/test/java/org/apache/camel/component/snmp/TrapConsumerVersionTest.java new file mode 100644 index 000000000000..971ae2ea2b45 --- /dev/null +++ b/components/camel-snmp/src/test/java/org/apache/camel/component/snmp/TrapConsumerVersionTest.java @@ -0,0 +1,285 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.camel.component.snmp; + +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.component.mock.MockEndpoint; +import org.apache.camel.test.AvailablePortFinder; +import org.apache.camel.test.junit5.CamelTestSupport; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.snmp4j.CommunityTarget; +import org.snmp4j.MessageDispatcherImpl; +import org.snmp4j.PDU; +import org.snmp4j.PDUv1; +import org.snmp4j.ScopedPDU; +import org.snmp4j.Snmp; +import org.snmp4j.Target; +import org.snmp4j.UserTarget; +import org.snmp4j.mp.MPv1; +import org.snmp4j.mp.MPv2c; +import org.snmp4j.mp.MPv3; +import org.snmp4j.mp.SnmpConstants; +import org.snmp4j.security.AuthSHA; +import org.snmp4j.security.PrivAES128; +import org.snmp4j.security.SecurityLevel; +import org.snmp4j.security.SecurityModel; +import org.snmp4j.security.SecurityModels; +import org.snmp4j.security.SecurityProtocols; +import org.snmp4j.security.USM; +import org.snmp4j.security.UsmUser; +import org.snmp4j.smi.Integer32; +import org.snmp4j.smi.OID; +import org.snmp4j.smi.OctetString; +import org.snmp4j.smi.TimeTicks; +import org.snmp4j.smi.UdpAddress; +import org.snmp4j.smi.VariableBinding; +import org.snmp4j.transport.DefaultUdpTransportMapping; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * The trap consumer receives only the traps of its snmpVersion and, for SNMPv3, of its user and security level. The + * traps are sent by a plain SNMP4J sender, and the consumer is the only snmp endpoint of the CamelContext. + */ +public class TrapConsumerVersionTest extends CamelTestSupport { + + private static final String USER = "camel"; + private static final String AUTH_PASSPHRASE = "authpass12"; + private static final String PRIV_PASSPHRASE = "privpass12"; + private static final String V3_AUTH_PRIV = "snmpVersion=3&securityName=" + USER + "&securityLevel=3" + + "&authenticationProtocol=SHA1&authenticationPassphrase=" + AUTH_PASSPHRASE + + "&privacyProtocol=AES128&privacyPassphrase=" + PRIV_PASSPHRASE; + + @RegisterExtension + AvailablePortFinder.Port trapPort = AvailablePortFinder.find(); + + private boolean addedAuthSha; + private boolean addedPrivAes128; + + @BeforeEach + void registerSecurityProtocols() { + // the authentication and privacy protocols of SNMP4J are JVM-wide, and none is registered by default + SecurityProtocols protocols = SecurityProtocols.getInstance(); + if (protocols.getAuthenticationProtocol(AuthSHA.ID) == null) { + protocols.addAuthenticationProtocol(new AuthSHA()); + addedAuthSha = true; + } + if (protocols.getPrivacyProtocol(PrivAES128.ID) == null) { + protocols.addPrivacyProtocol(new PrivAES128()); + addedPrivAes128 = true; + } + } + + @AfterEach + void removeSecurityProtocols() { + if (addedAuthSha) { + SecurityProtocols.getInstance().removeAuthenticationProtocol(AuthSHA.ID); + } + if (addedPrivAes128) { + SecurityProtocols.getInstance().removePrivacyProtocol(PrivAES128.ID); + } + } + + @Test + public void v3ConsumerReceivesV3AuthPrivTrap() throws Exception { + MockEndpoint mock = startConsumer(V3_AUTH_PRIV); + + sendV3Trap(USER, AUTH_PASSPHRASE, SecurityLevel.AUTH_PRIV, "accepted"); + + assertReceivedOnly(mock, "accepted"); + // the consumer does not register its user in the JVM-wide SecurityModels of SNMP4J + assertNull(SecurityModels.getInstance().getSecurityModel(new Integer32(SecurityModel.SECURITY_MODEL_USM))); + } + + @Test + public void v3ConsumerDropsV2cTrap() throws Exception { + MockEndpoint mock = startConsumer(V3_AUTH_PRIV); + + sendCommunityTrap(SnmpConstants.version2c, "public", "dropped"); + sendV3Trap(USER, AUTH_PASSPHRASE, SecurityLevel.AUTH_PRIV, "accepted"); + + assertReceivedOnly(mock, "accepted"); + } + + @Test + public void v3ConsumerDropsV1Trap() throws Exception { + MockEndpoint mock = startConsumer(V3_AUTH_PRIV); + + sendCommunityTrap(SnmpConstants.version1, "public", "dropped"); + sendV3Trap(USER, AUTH_PASSPHRASE, SecurityLevel.AUTH_PRIV, "accepted"); + + assertReceivedOnly(mock, "accepted"); + } + + @Test + public void v3ConsumerDropsTrapBelowSecurityLevel() throws Exception { + MockEndpoint mock = startConsumer(V3_AUTH_PRIV); + + sendV3Trap(USER, AUTH_PASSPHRASE, SecurityLevel.NOAUTH_NOPRIV, "dropped"); + sendV3Trap(USER, AUTH_PASSPHRASE, SecurityLevel.AUTH_NOPRIV, "dropped"); + sendV3Trap(USER, AUTH_PASSPHRASE, SecurityLevel.AUTH_PRIV, "accepted"); + + assertReceivedOnly(mock, "accepted"); + } + + @Test + public void v3ConsumerDropsTrapOfAnotherUser() throws Exception { + MockEndpoint mock = startConsumer(V3_AUTH_PRIV); + + sendV3Trap("other", AUTH_PASSPHRASE, SecurityLevel.AUTH_PRIV, "dropped"); + sendV3Trap("other", AUTH_PASSPHRASE, SecurityLevel.NOAUTH_NOPRIV, "dropped"); + sendV3Trap(USER, AUTH_PASSPHRASE, SecurityLevel.AUTH_PRIV, "accepted"); + + assertReceivedOnly(mock, "accepted"); + } + + @Test + public void v3ConsumerDropsTrapWithAnotherPassphrase() throws Exception { + MockEndpoint mock = startConsumer(V3_AUTH_PRIV); + + sendV3Trap(USER, "otherpass12", SecurityLevel.AUTH_PRIV, "dropped"); + sendV3Trap(USER, AUTH_PASSPHRASE, SecurityLevel.AUTH_PRIV, "accepted"); + + assertReceivedOnly(mock, "accepted"); + } + + @Test + public void v3NoAuthNoPrivConsumerReceivesV3Trap() throws Exception { + MockEndpoint mock = startConsumer("snmpVersion=3&securityName=" + USER + "&securityLevel=1"); + + sendV3Trap(USER, null, SecurityLevel.NOAUTH_NOPRIV, "accepted"); + + assertReceivedOnly(mock, "accepted"); + } + + @Test + public void v2cConsumerReceivesV1AndV2cTrapsAndDropsV3Trap() throws Exception { + MockEndpoint mock = startConsumer("snmpVersion=1"); + mock.expectedMessageCount(2); + + sendV3Trap(USER, AUTH_PASSPHRASE, SecurityLevel.NOAUTH_NOPRIV, "dropped"); + sendCommunityTrap(SnmpConstants.version1, "public", "first"); + sendCommunityTrap(SnmpConstants.version2c, "public", "second"); + + MockEndpoint.assertIsSatisfied(context); + assertTrue(mock.getReceivedExchanges().get(0).getMessage().getBody(String.class).contains("first")); + assertTrue(mock.getReceivedExchanges().get(1).getMessage().getBody(String.class).contains("second")); + } + + @Test + public void v1ConsumerDropsV3Trap() throws Exception { + MockEndpoint mock = startConsumer("snmpVersion=0"); + + sendV3Trap(USER, AUTH_PASSPHRASE, SecurityLevel.NOAUTH_NOPRIV, "dropped"); + sendCommunityTrap(SnmpConstants.version1, "public", "accepted"); + + assertReceivedOnly(mock, "accepted"); + } + + private MockEndpoint startConsumer(String options) throws Exception { + context.addRoutes(new RouteBuilder() { + @Override + public void configure() { + from("snmp:127.0.0.1:" + trapPort.getPort() + "?protocol=udp&type=TRAP&" + options).to("mock:trap"); + } + }); + return getMockEndpoint("mock:trap"); + } + + /** + * The traps are sent one after the other to the single listener thread of the consumer, so a dropped trap sent + * before the accepted one would have been received first. + */ + private void assertReceivedOnly(MockEndpoint mock, String marker) throws Exception { + mock.expectedMessageCount(1); + MockEndpoint.assertIsSatisfied(context); + String body = mock.getReceivedExchanges().get(0).getMessage().getBody(String.class); + assertTrue(body.contains(marker), "Expected the trap " + marker + " but got: " + body); + assertEquals(1, mock.getReceivedCounter()); + } + + private void sendCommunityTrap(int version, String community, String marker) throws Exception { + CommunityTarget<UdpAddress> target = new CommunityTarget<>(trapAddress(), new OctetString(community)); + target.setVersion(version); + PDU pdu; + if (version == SnmpConstants.version1) { + PDUv1 v1 = new PDUv1(); + v1.setType(PDU.V1TRAP); + v1.setEnterprise(new OID("1.2.3.4")); + v1.setGenericTrap(PDUv1.ENTERPRISE_SPECIFIC); + v1.setSpecificTrap(1); + pdu = v1; + } else { + pdu = new PDU(); + pdu.setType(PDU.TRAP); + addTrapBindings(pdu); + } + pdu.add(new VariableBinding(new OID("1.2.3.4.5.1"), new OctetString(marker))); + + MessageDispatcherImpl dispatcher = new MessageDispatcherImpl(); + dispatcher.addMessageProcessingModel(new MPv1()); + dispatcher.addMessageProcessingModel(new MPv2c()); + send(dispatcher, pdu, target); + } + + private void sendV3Trap(String user, String authPassphrase, int securityLevel, String marker) throws Exception { + USM usm = new USM(SecurityProtocols.getInstance(), new OctetString(MPv3.createLocalEngineID()), 0); + if (authPassphrase != null) { + usm.addUser(new OctetString(user), new UsmUser( + new OctetString(user), AuthSHA.ID, new OctetString(authPassphrase), PrivAES128.ID, + new OctetString(PRIV_PASSPHRASE))); + } else { + usm.addUser(new OctetString(user), new UsmUser(new OctetString(user), null, null, null, null)); + } + MessageDispatcherImpl dispatcher = new MessageDispatcherImpl(); + dispatcher.addMessageProcessingModel(new MPv3(usm)); + + UserTarget<UdpAddress> target = new UserTarget<>(); + target.setAddress(trapAddress()); + target.setVersion(SnmpConstants.version3); + target.setSecurityName(new OctetString(user)); + target.setSecurityLevel(securityLevel); + + ScopedPDU pdu = new ScopedPDU(); + pdu.setType(PDU.TRAP); + addTrapBindings(pdu); + pdu.add(new VariableBinding(new OID("1.2.3.4.5.1"), new OctetString(marker))); + send(dispatcher, pdu, target); + } + + private static void addTrapBindings(PDU pdu) { + pdu.add(new VariableBinding(SnmpConstants.sysUpTime, new TimeTicks(5000))); + pdu.add(new VariableBinding(SnmpConstants.snmpTrapOID, new OID("1.2.3.4.5"))); + } + + private UdpAddress trapAddress() { + return new UdpAddress("127.0.0.1/" + trapPort.getPort()); + } + + private static void send(MessageDispatcherImpl dispatcher, PDU pdu, Target<UdpAddress> target) throws Exception { + DefaultUdpTransportMapping transport = new DefaultUdpTransportMapping(); + try (Snmp snmp = new Snmp(dispatcher, transport)) { + transport.listen(); + snmp.send(pdu, target); + } + } +}
