25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
fix(kafka): avoid reverse DNS for SASL IP brokers
t8y294b5856e8daa
diff --git a/agents/drivers/kafka/src/main/java/com/dbx/agent/kafka/DbxInetAddressResolverProvider.java b/agents/drivers/kafka/src/main/java/com/dbx/agent/kafka/DbxInetAddressResolverProvider.javanew file mode 100644index 0000000000..5ab28a367f--- /dev/null+++ b/agents/drivers/kafka/src/main/java/com/dbx/agent/kafka/DbxInetAddressResolverProvider.java@@ -0,0 +1,51 @@+package com.dbx.agent.kafka;++import java.net.InetAddress;+import java.net.UnknownHostException;+import java.net.spi.InetAddressResolver;+import java.net.spi.InetAddressResolverProvider;+import java.util.Objects;+import java.util.stream.Stream;++public final class DbxInetAddressResolverProvider extends InetAddressResolverProvider {+ private static volatile boolean avoidReverseDns;++ @Override+ public InetAddressResolver get(Configuration configuration) {+ return wrapping(configuration.builtinResolver());+ }++ @Override+ public String name() {+ return "dbx-kafka";+ }++ static boolean setAvoidReverseDns(boolean avoid) {+ boolean previous = avoidReverseDns;+ avoidReverseDns = avoid;+ return previous;+ }++ static InetAddressResolver wrapping(InetAddressResolver delegate) {+ Objects.requireNonNull(delegate, "delegate");+ return new InetAddressResolver() {+ @Override+ public Stream<InetAddress> lookupByName(String host, LookupPolicy lookupPolicy)+ throws UnknownHostException {+ return delegate.lookupByName(host, lookupPolicy);+ }++ @Override+ public String lookupByAddress(byte[] address) throws UnknownHostException {+ if (!avoidReverseDns) {+ return delegate.lookupByAddress(address);+ }+ Objects.requireNonNull(address, "address");+ if (address.length != 4 && address.length != 16) {+ throw new IllegalArgumentException("Invalid address length");+ }+ return InetAddress.getByAddress(address).getHostAddress();+ }+ };+ }+}diff --git a/agents/drivers/kafka/src/main/java/com/dbx/agent/kafka/KafkaAgent.java b/agents/drivers/kafka/src/main/java/com/dbx/agent/kafka/KafkaAgent.javaindex 61dffc8f48..87daf0f1ec 100644--- a/agents/drivers/kafka/src/main/java/com/dbx/agent/kafka/KafkaAgent.java+++ b/agents/drivers/kafka/src/main/java/com/dbx/agent/kafka/KafkaAgent.java@@ -46,6 +46,12 @@ public final class KafkaAgent {private static final int DEFAULT_SESSION_TIMEOUT_MS = 30_000;private static final int DEFAULT_ZOOKEEPER_CONNECTION_TIMEOUT_MS = 10_000;private static final String ZOOKEEPER_PROPERTY_PREFIX = "zookeeper.";+ private static final Set<String> SASL_MECHANISMS_WITHOUT_SERVER_NAME = Set.of(+ "PLAIN",+ "SCRAM-SHA-256",+ "SCRAM-SHA-512",+ "OAUTHBEARER"+ );private static final Set<String> KERBEROS_SYSTEM_PROPERTY_KEYS = Set.of("java.security.krb5.conf","sun.security.krb5.debug",@@ -134,8 +140,17 @@ public final class KafkaAgent {case "handshake" -> handshakeResult();case "connect" -> connect(params);case "test_connection" -> testConnection(params);- case "disconnect" -> { closeClients(); yield Collections.singletonMap("ok", true); }- case "shutdown" -> { closeClients(); shutdownRequested = true; yield Collections.singletonMap("ok", true); }+ case "disconnect" -> {+ closeClients();+ DbxInetAddressResolverProvider.setAvoidReverseDns(false);+ yield Collections.singletonMap("ok", true);+ }+ case "shutdown" -> {+ closeClients();+ DbxInetAddressResolverProvider.setAvoidReverseDns(false);+ shutdownRequested = true;+ yield Collections.singletonMap("ok", true);+ }// Topic managementcase "mq_list_topics" -> listTopics(params);case "mq_create_topic" -> createTopic(params);@@ -175,6 +190,9 @@ public final class KafkaAgent {private static Object connect(JsonObject params) throws Exception {JsonObject conn = resolveBrokerConnection(connectionObject(params));+ boolean previousReverseDnsMode = DbxInetAddressResolverProvider.setAvoidReverseDns(+ shouldAvoidSaslReverseDns(conn)+ );Map<String, String> previousKerberosSystemProperties = applyKerberosSystemProperties(conn);AdminClient nextAdmin = null;KafkaProducer<String, byte[]> nextProducer = null;@@ -198,12 +216,16 @@ public final class KafkaAgent {nextProducer.close(Duration.ofSeconds(5));}restoreKerberosSystemProperties(previousKerberosSystemProperties);+ DbxInetAddressResolverProvider.setAvoidReverseDns(previousReverseDnsMode);throw e;}}private static Object testConnection(JsonObject params) throws Exception {JsonObject conn = resolveBrokerConnection(connectionObject(params));+ boolean previousReverseDnsMode = DbxInetAddressResolverProvider.setAvoidReverseDns(+ shouldAvoidSaslReverseDns(conn)+ );Map<String, String> previousKerberosSystemProperties = applyKerberosSystemProperties(conn);AdminClient probe = null;try {@@ -244,6 +266,7 @@ public final class KafkaAgent {probe.close(Duration.ofSeconds(5));}restoreKerberosSystemProperties(previousKerberosSystemProperties);+ DbxInetAddressResolverProvider.setAvoidReverseDns(previousReverseDnsMode);}}@@ -470,6 +493,25 @@ public final class KafkaAgent {return protocol.isBlank() ? "PLAINTEXT" : protocol;}+ static boolean shouldAvoidSaslReverseDns(JsonObject conn) {+ JsonObject properties = connectionProperties(conn);+ String configuredProtocol = stringProperty(properties, "security.protocol");+ String protocol = configuredProtocol == null || configuredProtocol.isBlank()+ ? securityProtocol(conn)+ : configuredProtocol;+ if (!protocol.trim().toUpperCase(Locale.ROOT).startsWith("SASL_")) {+ return false;+ }++ String mechanism = stringOrEmpty(conn, "sasl_mechanism");+ if (mechanism.isBlank()) mechanism = stringOrEmpty(conn, "saslMechanism");+ String configuredMechanism = stringProperty(properties, "sasl.mechanism");+ if (configuredMechanism != null && !configuredMechanism.isBlank()) {+ mechanism = configuredMechanism;+ }+ return SASL_MECHANISMS_WITHOUT_SERVER_NAME.contains(mechanism.trim().toUpperCase(Locale.ROOT));+ }+static void applySecurityProperties(JsonObject conn, Properties props) {String securityProtocol = stringOrEmpty(conn, "security_protocol");if (securityProtocol.isBlank()) {diff --git a/agents/drivers/kafka/src/main/resources/META-INF/services/java.net.spi.InetAddressResolverProvider b/agents/drivers/kafka/src/main/resources/META-INF/services/java.net.spi.InetAddressResolverProvidernew file mode 100644index 0000000000..6a63b4533b--- /dev/null+++ b/agents/drivers/kafka/src/main/resources/META-INF/services/java.net.spi.InetAddressResolverProvider@@ -0,0 +1 @@+com.dbx.agent.kafka.DbxInetAddressResolverProviderdiff --git a/agents/drivers/kafka/src/test/java/com/dbx/agent/kafka/DbxInetAddressResolverProviderTest.java b/agents/drivers/kafka/src/test/java/com/dbx/agent/kafka/DbxInetAddressResolverProviderTest.javanew file mode 100644index 0000000000..3f955296b5--- /dev/null+++ b/agents/drivers/kafka/src/test/java/com/dbx/agent/kafka/DbxInetAddressResolverProviderTest.java@@ -0,0 +1,139 @@+package com.dbx.agent.kafka;++import java.net.InetAddress;+import java.net.UnknownHostException;+import java.net.spi.InetAddressResolver;+import java.net.spi.InetAddressResolverProvider;+import java.util.ServiceLoader;+import java.util.concurrent.atomic.AtomicInteger;+import java.util.stream.Stream;+import org.junit.jupiter.api.Test;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;++class DbxInetAddressResolverProviderTest {+ @Test+ void providerIsPublishedAsTheKafkaAgentResolverService() {+ assertTrue(ServiceLoader.load(InetAddressResolverProvider.class).stream()+ .anyMatch(provider -> provider.type() == DbxInetAddressResolverProvider.class));+ }++ @Test+ void installedProviderShortCircuitsTheInetAddressCallUsedByKafka() throws Exception {+ boolean previous = DbxInetAddressResolverProvider.setAvoidReverseDns(true);+ try {+ InetAddress numericAddress = InetAddress.getByAddress(new byte[] { 127, 0, 0, 1 });++ assertEquals("127.0.0.1", numericAddress.getHostName());+ } finally {+ DbxInetAddressResolverProvider.setAvoidReverseDns(previous);+ }+ }++ @Test+ void nonKerberosSaslReturnsNumericAddressWithoutCallingReverseDns() throws Exception {+ AtomicInteger reverseLookups = new AtomicInteger();+ InetAddressResolver resolver = DbxInetAddressResolverProvider.wrapping(+ resolverReturning("broker.example.test", reverseLookups)+ );+ boolean previous = DbxInetAddressResolverProvider.setAvoidReverseDns(true);+ try {+ assertEquals("192.0.2.25", resolver.lookupByAddress(new byte[] {+ (byte) 192, 0, 2, 25+ }));+ assertEquals(0, reverseLookups.get());+ } finally {+ DbxInetAddressResolverProvider.setAvoidReverseDns(previous);+ }+ }++ @Test+ void kerberosModeKeepsPlatformReverseDnsBehavior() throws Exception {+ AtomicInteger reverseLookups = new AtomicInteger();+ InetAddressResolver resolver = DbxInetAddressResolverProvider.wrapping(+ resolverReturning("broker.example.test", reverseLookups)+ );+ boolean previous = DbxInetAddressResolverProvider.setAvoidReverseDns(false);+ try {+ assertEquals("broker.example.test", resolver.lookupByAddress(new byte[] {+ (byte) 192, 0, 2, 25+ }));+ assertEquals(1, reverseLookups.get());+ } finally {+ DbxInetAddressResolverProvider.setAvoidReverseDns(previous);+ }+ }++ @Test+ void platformReverseDnsFailuresRemainVisibleWhenBypassIsDisabled() {+ InetAddressResolver delegate = new InetAddressResolver() {+ @Override+ public Stream<InetAddress> lookupByName(String host, LookupPolicy lookupPolicy) {+ throw new AssertionError("forward lookup was not expected");+ }++ @Override+ public String lookupByAddress(byte[] address) throws UnknownHostException {+ throw new UnknownHostException("PTR lookup failed");+ }+ };+ InetAddressResolver resolver = DbxInetAddressResolverProvider.wrapping(delegate);+ boolean previous = DbxInetAddressResolverProvider.setAvoidReverseDns(false);+ try {+ UnknownHostException error = assertThrows(UnknownHostException.class,+ () -> resolver.lookupByAddress(new byte[] { (byte) 192, 0, 2, 25 }));+ assertEquals("PTR lookup failed", error.getMessage());+ } finally {+ DbxInetAddressResolverProvider.setAvoidReverseDns(previous);+ }+ }++ @Test+ void hostnameLookupAlwaysUsesThePlatformResolver() throws Exception {+ AtomicInteger forwardLookups = new AtomicInteger();+ InetAddressResolver delegate = new InetAddressResolver() {+ @Override+ public Stream<InetAddress> lookupByName(String host, LookupPolicy lookupPolicy)+ throws UnknownHostException {+ forwardLookups.incrementAndGet();+ return Stream.of(InetAddress.getByAddress(host, new byte[] { 127, 0, 0, 1 }));+ }++ @Override+ public String lookupByAddress(byte[] address) {+ throw new AssertionError("reverse lookup was not expected");+ }+ };+ InetAddressResolver resolver = DbxInetAddressResolverProvider.wrapping(delegate);+ boolean previous = DbxInetAddressResolverProvider.setAvoidReverseDns(true);+ try {+ InetAddress resolved = resolver+ .lookupByName("broker.example.test", InetAddressResolver.LookupPolicy.of(+ InetAddressResolver.LookupPolicy.IPV4+ ))+ .findFirst()+ .orElseThrow();+ assertEquals("broker.example.test", resolved.getHostName());+ assertEquals(1, forwardLookups.get());+ } finally {+ DbxInetAddressResolverProvider.setAvoidReverseDns(previous);+ }+ }++ private static InetAddressResolver resolverReturning(String reverseResult, AtomicInteger reverseLookups) {+ return new InetAddressResolver() {+ @Override+ public Stream<InetAddress> lookupByName(String host, LookupPolicy lookupPolicy) {+ throw new AssertionError("forward lookup was not expected");+ }++ @Override+ public String lookupByAddress(byte[] address) {+ reverseLookups.incrementAndGet();+ return reverseResult;+ }+ };+ }+}diff --git a/agents/drivers/kafka/src/test/java/com/dbx/agent/kafka/KafkaAgentTest.java b/agents/drivers/kafka/src/test/java/com/dbx/agent/kafka/KafkaAgentTest.javaindex eaeaa46e0c..e4a653f110 100644--- a/agents/drivers/kafka/src/test/java/com/dbx/agent/kafka/KafkaAgentTest.java+++ b/agents/drivers/kafka/src/test/java/com/dbx/agent/kafka/KafkaAgentTest.java@@ -581,6 +581,35 @@ class KafkaAgentTest {assertNull(kafkaProperties.getProperty("zookeeper.ssl.trustStore.password"));}+ @Test+ void reverseDnsIsSkippedOnlyForSupportedNonKerberosSaslMechanisms() {+ assertTrue(KafkaAgent.shouldAvoidSaslReverseDns(connectionWithSecurity(+ "SASL_PLAINTEXT", "PLAIN")));+ assertTrue(KafkaAgent.shouldAvoidSaslReverseDns(connectionWithSecurity(+ "SASL_SSL", "SCRAM-SHA-512")));+ assertFalse(KafkaAgent.shouldAvoidSaslReverseDns(connectionWithSecurity(+ "SASL_PLAINTEXT", "GSSAPI")));+ assertFalse(KafkaAgent.shouldAvoidSaslReverseDns(connectionWithSecurity(+ "PLAINTEXT", "PLAIN")));+ assertFalse(KafkaAgent.shouldAvoidSaslReverseDns(connectionWithSecurity(+ "SSL", "PLAIN")));+ assertFalse(KafkaAgent.shouldAvoidSaslReverseDns(connectionWithSecurity(+ "SASL_PLAINTEXT", "CUSTOM")));+ assertFalse(KafkaAgent.shouldAvoidSaslReverseDns(connectionWithSecurity(+ "SASL_PLAINTEXT", "")));+ }++ @Test+ void explicitKafkaPropertiesControlReverseDnsMode() {+ JsonObject connection = connectionWithSecurity("SASL_PLAINTEXT", "PLAIN");+ JsonObject properties = new JsonObject();+ properties.addProperty("security.protocol", "SASL_SSL");+ properties.addProperty("sasl.mechanism", "GSSAPI");+ connection.add("properties", properties);++ assertFalse(KafkaAgent.shouldAvoidSaslReverseDns(connection));+ }+@Testvoid producerDefaultsToLegacyCompatibleNonIdempotentDelivery() {JsonObject connection = new JsonObject();@@ -592,6 +621,13 @@ class KafkaAgentTest {assertEquals("false", properties.getProperty(ProducerConfig.ENABLE_IDEMPOTENCE_CONFIG));}+ private static JsonObject connectionWithSecurity(String protocol, String mechanism) {+ JsonObject connection = new JsonObject();+ connection.addProperty("security_protocol", protocol);+ connection.addProperty("sasl_mechanism", mechanism);+ return connection;+ }+@Testvoid producerAllowsExplicitIdempotenceForModernBrokers() {JsonObject extraProperties = new JsonObject();