Skip to content

Commit 37a8d9f

Browse files
morningmanclaude
andcommitted
[feature](fe) Gate catalog SSRF endpoints and driver_url via a connector security surface
### What problem does this PR solve? Problem Summary: External catalogs register user-supplied network endpoints (e.g. an HMS catalog's `hive.metastore.uris`) that the FE connects to. When the operator installed the SSRF security SDK (the `security_checker_class_name` config, i.e. Aliyun `com.aliyun.securitysdk.SecurityUtil`), those endpoints were not checked against the SSRF policy at CREATE / ALTER CATALOG, so a user with CREATE_PRIV (no SUPER) could point a catalog at an intranet address. This PR adds one replay-safe gate that, when an SSRF checker is installed, brackets a lightweight TCP connect to each user-supplied endpoint with the SDK's net-hook so an intranet target is rejected before the catalog is accepted. The judgment is delegated entirely to the SDK. With no checker installed (the default open-source build) the gate is a no-op and behavior is unchanged. Connector-agnostic by construction. The engine must not hard-code any catalog type's property names (the fe-connector invariant: no source-name branching in shared fe-core nodes). So a connector now declares its security-sensitive property keys through a new SPI value type, `ConnectorSecuritySurface` (returned by `ConnectorProvider.securitySurface()`), and the engine looks it up by type -- without initializing a connector -- to drive the gate. The HMS connector declares `hive.metastore.uris` / `uri`. The same change unifies the pre-existing jdbc driver-url operator gate (`jdbc_driver_secure_path` / `jdbc_driver_url_white_list`) onto this mechanism: the `driver_url` keys and their flavor conditions now come from each jdbc-flavored connector's `securitySurface()`, and the two fe-core key tables that previously hard-coded catalog types (`driverUrlKeysOf`, `ssrfEndpointKeysOf`) are deleted. The gates stay exactly where they were -- CREATE through `checkWhenCreating`, ALTER through `validatePropertiesBeforeUpdate`, never on replay -- and the driver-url gate's mandatory rule (`JdbcDriverUrlSecurity.check`) still runs even under `jdbc_driver_secure_path=*`. Sourcing the keys from the provider does not weaken the gate: when no provider backs a type the catalog cannot initialize and thus cannot load a jar or open a connection, so there is nothing to police. This PR also fixes a latent bug in the existing SSRF wiring: `UrlSecurityChecker` bound the SDK's stop method as `stopSSRFNetHookChecking(String)` but invoked it with no argument, so the net-hook was never removed and leaked onto the pooled FE thread after any bracketed request. It now binds and invokes the no-arg `stopSSRFNetHookChecking()`, and adds the no-arg `startSSRFNetHookChecking()` (TCP form) needed to hook non-http connections such as HMS thrift. Because this changes the connector plugin SPI surface (a new type and a new provider method), `connector.plugin.api.version` is bumped 20.0 -> 21.0 and `connector-plugin-surface.txt` is regenerated in the same commit. SSRF surface note (per repo policy): the probe is a new FE -> user-named-host outbound TCP connect, performed only when the operator installed the SSRF SDK and only at CREATE / ALTER CATALOG (actor: CREATE_PRIV or ADMIN for CREATE, ALTER privilege for ALTER). Its sole purpose is to let the SDK reject an intranet target; a plain connectivity failure is ignored (not treated as a rejection), so a catalog pointing at a currently-unreachable public endpoint can still be created. Known limit: point-in-time check only -- it does not guard a later runtime connection (DNS rebinding) or clients that bypass the JDK socket layer (e.g. Netty native epoll). ### Release note None ### Check List (For Author) - Test: - Unit Test: SecurityCheckerTest (fe-common); PluginDrivenExternalCatalogSsrfGateTest and the migrated PluginDrivenExternalCatalogDriverUrlGateTest (fe-core); ConnectorPluginSurfaceTest and the four {Hive,Jdbc,Iceberg,Paimon}ConnectorProviderSecuritySurfaceTest (fe-connector). A full `mvn install` builds every module against the new SPI. - Behavior changed: Yes -- a new CREATE/ALTER CATALOG SSRF gate, the jdbc driver-url gate migrated to a connector-declared security surface, and a fix to the SSRF net-hook stop binding. The SSRF gate is active only when `security_checker_class_name` is configured; the default open-source build is unchanged. Connector plugin API bumped 20.0 -> 21.0. - Does this need documentation: No Co-Authored-By: Claude Opus 4.8 <[email protected]>
1 parent 8ebb909 commit 37a8d9f

21 files changed

Lines changed: 946 additions & 50 deletions

File tree

‎AGENTS.md‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -14,9 +14,9 @@ The existing `driver_url` paths (jdbc / iceberg-jdbc / paimon-jdbc catalogs) rem
1414

1515
When a feature genuinely needs an operator-supplied artifact, read it from a local, operator-controlled directory (the `jdbc_drivers_dir` / plugin-directory pattern), not from a URL. The ADBC catalog's `AdbcDriverPathResolver` is the model: remote schemes rejected outright, a scheme-less value restricted to a bare file name so no path separator can escape the configured directory, and the check placed where the artifact is loaded rather than only at CREATE.
1616

17-
Every consumer of the **jdbc-flavored** `driver_url` (the jdbc / iceberg-jdbc / paimon-jdbc catalogs, which do accept a URL) must route the raw value through `JdbcDriverUrlSecurity.check` (`fe-foundation`, `foundation.security`) from its property holder's statement-time validation — `JdbcCatalogProperties.checkCreateTimeOnlyRules` and the iceberg/paimon JDBC metastore holders' `validate()` — which the engine reaches on both CREATE and ALTER CATALOG and never on replay or a catalog rebuild. That class is the single source of truth for the rule; do not fork or re-derive it per connector, and never call it from a holder's `of()`. Such a property must also get a row in the key table of `PluginDrivenExternalCatalog#driverUrlKeysOf` (one table drives both the gate trigger set and the checked values), which is how the operator's `jdbc_driver_secure_path` / `jdbc_driver_url_white_list` policy reaches the ALTER CATALOG path — ALTER never runs `Connector.preCreateValidation`, where CREATE applies that policy, so a key missing from that table lets an ALTER repoint the jar past the operator's configuration.
17+
Every consumer of the **jdbc-flavored** `driver_url` (the jdbc / iceberg-jdbc / paimon-jdbc catalogs, which do accept a URL) must route the raw value through `JdbcDriverUrlSecurity.check` (`fe-foundation`, `foundation.security`) from its property holder's statement-time validation — `JdbcCatalogProperties.checkCreateTimeOnlyRules` and the iceberg/paimon JDBC metastore holders' `validate()` — which the engine reaches on both CREATE and ALTER CATALOG and never on replay or a catalog rebuild. That class is the single source of truth for the rule; do not fork or re-derive it per connector, and never call it from a holder's `of()`. The connector must also declare those `driver_url` property keys (with their flavor condition) in its `ConnectorProvider.securitySurface()` via `ConnectorSecuritySurface.ofJdbcDriverUrls(...)`: the engine looks that surface up by catalog type (without initializing a connector) and applies the operator's `jdbc_driver_secure_path` / `jdbc_driver_url_white_list` policy from `PluginDrivenExternalCatalog`'s CREATE and ALTER validation, never on replay. ALTER never runs `Connector.preCreateValidation`, where CREATE applies that policy, so a key missing from the surface lets an ALTER repoint the jar past the operator's configuration.
1818

19-
Separately, any new outbound HTTP request the FE or BE issues to a host named by a non-SUPER user is an SSRF surface. Call it out explicitly in the PR description together with the privilege required to reach it.
19+
Separately, any new outbound HTTP request the FE or BE issues to a host named by a non-SUPER user is an SSRF surface. Call it out explicitly in the PR description together with the privilege required to reach it. A catalog connector whose user-supplied property names a host the FE connects to also declares that key in its `ConnectorProvider.securitySurface()` via `ConnectorSecuritySurface.ofSsrfEndpoints(...)`; the engine's CREATE / ALTER CATALOG SSRF gate — active only when `security_checker_class_name` is configured — probes those endpoints through it, so the engine never hard-codes a catalog type's property names.
2020

2121
## Thrift and Protobuf Field Ids
2222

‎fe/fe-common/src/main/java/org/apache/doris/cloud/security/DummySecurityChecker.java‎

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -30,8 +30,18 @@ public void startSSRFChecking(String originUri) throws Exception {
3030
return;
3131
}
3232

33+
@Override
34+
public void startSSRFChecking() throws Exception {
35+
return;
36+
}
37+
3338
@Override
3439
public void stopSSRFChecking() {
3540
return;
3641
}
42+
43+
@Override
44+
public boolean isEnabled() {
45+
return false;
46+
}
3747
}

‎fe/fe-common/src/main/java/org/apache/doris/cloud/security/SecurityChecker.java‎

Lines changed: 96 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -18,22 +18,47 @@
1818
package org.apache.doris.cloud.security;
1919

2020
import org.apache.doris.common.Config;
21+
import org.apache.doris.common.DdlException;
2122

23+
import com.google.common.annotations.VisibleForTesting;
2224
import com.google.common.base.Strings;
25+
import org.apache.logging.log4j.LogManager;
26+
import org.apache.logging.log4j.Logger;
27+
28+
import java.io.IOException;
29+
import java.net.InetSocketAddress;
30+
import java.net.Socket;
2331

2432
/**
2533
* SecurityChecker is used to check if the url is safe
2634
*/
2735
public abstract class SecurityChecker {
28-
private static class SingletonHolder {
29-
private static final SecurityChecker INSTANCE = Strings.isNullOrEmpty(Config.security_checker_class_name)
30-
? new DummySecurityChecker() : new UrlSecurityChecker();
31-
}
36+
private static final Logger LOG = LogManager.getLogger(SecurityChecker.class);
37+
38+
// Upper bound for one SSRF connectivity probe. The probe only needs the net-hook to observe the
39+
// resolved IP before the TCP handshake completes; a short timeout keeps CREATE/ALTER responsive when
40+
// the endpoint is a public-but-unreachable host (that outcome is ignored, see checkEndpointForSsrf).
41+
private static final int SSRF_PROBE_CONNECT_TIMEOUT_MS = 5000;
42+
43+
private static volatile SecurityChecker instance;
3244

3345
protected SecurityChecker() {}
3446

3547
public static SecurityChecker getInstance() {
36-
return SingletonHolder.INSTANCE;
48+
if (instance == null) {
49+
synchronized (SecurityChecker.class) {
50+
if (instance == null) {
51+
instance = Strings.isNullOrEmpty(Config.security_checker_class_name)
52+
? new DummySecurityChecker() : new UrlSecurityChecker();
53+
}
54+
}
55+
}
56+
return instance;
57+
}
58+
59+
@VisibleForTesting
60+
public static void setInstanceForTest(SecurityChecker checker) {
61+
instance = checker;
3762
}
3863

3964
/**
@@ -45,12 +70,76 @@ public static SecurityChecker getInstance() {
4570
public abstract String getSafeJdbcUrl(String originJdbcUrl) throws Exception;
4671

4772
/**
48-
* Check if the uri is safe, avoid SSRF attack
49-
* Only handle http:// https://
73+
* Install the net-hook for an http(s) request on the current thread, avoid SSRF attack.
74+
* Only handle http:// https://. Must bracket a real request: startSSRFChecking before issuing it,
75+
* {@link #stopSSRFChecking()} after it, and no further request may be issued once stopped.
5076
* @param originUri
5177
* @throws Exception
5278
*/
5379
public abstract void startSSRFChecking(String originUri) throws Exception;
5480

81+
/**
82+
* Install the net-hook for a raw TCP connection on the current thread, avoid SSRF attack.
83+
* Handles any protocol that connects through a JDK socket (thrift, jdbc, ...), not only http.
84+
* Same bracketing contract as {@link #startSSRFChecking(String)}.
85+
* @throws Exception
86+
*/
87+
public abstract void startSSRFChecking() throws Exception;
88+
5589
public abstract void stopSSRFChecking();
90+
91+
/**
92+
* Whether a real SSRF checker (the third-party SDK) is installed. When false every
93+
* {@link #checkEndpointForSsrf(String, int)} is a no-op, so the default open-source build behaves
94+
* exactly as before.
95+
*/
96+
public abstract boolean isEnabled();
97+
98+
/**
99+
* Point-in-time SSRF gate for a single user-supplied endpoint: brackets a lightweight TCP connect
100+
* with the no-arg net-hook so the SDK resolves the host and rejects an intranet target before the
101+
* handshake completes.
102+
*
103+
* <p>The SDK signals an intranet target by throwing {@code SSRFUnsafeConnectionException} (a
104+
* {@link SecurityException}) from inside the connect; that — and only that — is the rejection. A plain
105+
* connectivity failure (refused / timeout / unknown host) is NOT an SSRF signal and is ignored, so a
106+
* catalog that points at a currently-unreachable but public endpoint can still be created.
107+
*/
108+
public final void checkEndpointForSsrf(String host, int port) throws DdlException {
109+
if (!isEnabled()) {
110+
return;
111+
}
112+
try {
113+
startSSRFChecking();
114+
} catch (Exception e) {
115+
// isEnabled() is true but the SDK net-hook could not be installed: surface the misconfiguration
116+
// rather than silently skipping the security gate.
117+
throw new DdlException("Failed to initialize SSRF checking for endpoint " + host + ":" + port
118+
+ ": " + e.getMessage(), e);
119+
}
120+
try {
121+
doConnect(host, port, SSRF_PROBE_CONNECT_TIMEOUT_MS);
122+
} catch (SecurityException e) {
123+
throw new DdlException("Endpoint " + host + ":" + port
124+
+ " is rejected by the SSRF policy (intranet address not allowed): " + e.getMessage());
125+
} catch (IOException e) {
126+
if (LOG.isDebugEnabled()) {
127+
LOG.debug("SSRF probe to {}:{} did not complete, ignored (not an SSRF rejection): {}",
128+
host, port, e.toString());
129+
}
130+
} finally {
131+
stopSSRFChecking();
132+
}
133+
}
134+
135+
/**
136+
* The connection seam of {@link #checkEndpointForSsrf(String, int)}: a single real TCP connect the
137+
* net-hook can observe. Overridable so unit tests can drive the SSRF / unreachable / success branches
138+
* without the third-party SDK or a live server.
139+
*/
140+
protected void doConnect(String host, int port, int connectTimeoutMs) throws IOException {
141+
try (Socket socket = new Socket()) {
142+
socket.connect(new InetSocketAddress(host, port), connectTimeoutMs);
143+
}
144+
}
56145
}

‎fe/fe-common/src/main/java/org/apache/doris/cloud/security/UrlSecurityChecker.java‎

Lines changed: 20 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -29,14 +29,19 @@ public class UrlSecurityChecker extends SecurityChecker {
2929
private static final Logger LOG = LogManager.getLogger(UrlSecurityChecker.class);
3030
private static Method jdbcUrlCheckMethod = null;
3131
private static Method urlSecurityCheckMethod = null;
32+
private static Method tcpSecurityCheckMethod = null;
3233
private static Method urlSecurityStopCheckMethod = null;
3334

3435
static {
3536
try {
3637
Class clazz = Class.forName(Config.security_checker_class_name);
3738
jdbcUrlCheckMethod = clazz.getMethod("filterJdbcConnectionSource", String.class);
3839
urlSecurityCheckMethod = clazz.getMethod("startSSRFNetHookChecking", String.class);
39-
urlSecurityStopCheckMethod = clazz.getMethod("stopSSRFNetHookChecking", String.class);
40+
// No-arg overload: hooks a raw TCP connection (thrift / jdbc / ...), not only http.
41+
tcpSecurityCheckMethod = clazz.getMethod("startSSRFNetHookChecking");
42+
// The SDK's stop is no-arg. Binding it with String.class (then invoking with no argument)
43+
// meant stop never fired and the net-hook leaked onto the pooled thread.
44+
urlSecurityStopCheckMethod = clazz.getMethod("stopSSRFNetHookChecking");
4045
} catch (Exception e) {
4146
LOG.warn("security_checker_class_name:{} exception:", Config.security_checker_class_name, e);
4247
LogUtils.stderr("Failed to find com.aliyun.securitysdk.SecurityUtil's method");
@@ -63,6 +68,20 @@ public void startSSRFChecking(String originUri) throws Exception {
6368
throw new Exception("SecurityUtil.startSSRFNetHookChecking not found");
6469
}
6570

71+
@Override
72+
public void startSSRFChecking() throws Exception {
73+
if (tcpSecurityCheckMethod != null) {
74+
tcpSecurityCheckMethod.invoke(null);
75+
return;
76+
}
77+
throw new Exception("SecurityUtil.startSSRFNetHookChecking (no-arg) not found");
78+
}
79+
80+
@Override
81+
public boolean isEnabled() {
82+
return true;
83+
}
84+
6685
@Override
6786
public void stopSSRFChecking() {
6887
if (urlSecurityStopCheckMethod != null) {
Lines changed: 146 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,146 @@
1+
// Licensed to the Apache Software Foundation (ASF) under one
2+
// or more contributor license agreements. See the NOTICE file
3+
// distributed with this work for additional information
4+
// regarding copyright ownership. The ASF licenses this file
5+
// to you under the Apache License, Version 2.0 (the
6+
// "License"); you may not use this file except in compliance
7+
// with the License. You may obtain a copy of the License at
8+
//
9+
// http://www.apache.org/licenses/LICENSE-2.0
10+
//
11+
// Unless required by applicable law or agreed to in writing,
12+
// software distributed under the License is distributed on an
13+
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
14+
// KIND, either express or implied. See the License for the
15+
// specific language governing permissions and limitations
16+
// under the License.
17+
18+
package org.apache.doris.cloud.security;
19+
20+
import org.apache.doris.common.DdlException;
21+
22+
import org.junit.jupiter.api.Assertions;
23+
import org.junit.jupiter.api.Test;
24+
25+
import java.io.IOException;
26+
import java.util.ArrayList;
27+
import java.util.Arrays;
28+
import java.util.List;
29+
30+
/**
31+
* {@link SecurityChecker#checkEndpointForSsrf} is the single primitive the catalog SSRF gate delegates to.
32+
* The real third-party SDK is operator-supplied and absent in CI, so these tests drive its branches through
33+
* the {@code doConnect} seam: the SDK signals an intranet target by throwing {@link SecurityException} from
34+
* inside the connect, a plain connectivity failure is {@link IOException}, and when no checker is installed
35+
* the whole probe is a no-op.
36+
*/
37+
public class SecurityCheckerTest {
38+
39+
private enum ConnectBehavior { SUCCESS, SSRF, IO }
40+
41+
/** A SecurityChecker whose net-hook bracket and connect are recorded, not real. */
42+
private static final class RecordingChecker extends SecurityChecker {
43+
private boolean enabled = true;
44+
private boolean startThrows = false;
45+
private ConnectBehavior connectBehavior = ConnectBehavior.SUCCESS;
46+
private final List<String> events = new ArrayList<>();
47+
48+
@Override
49+
public String getSafeJdbcUrl(String originJdbcUrl) {
50+
return originJdbcUrl;
51+
}
52+
53+
@Override
54+
public void startSSRFChecking(String originUri) throws Exception {
55+
start();
56+
}
57+
58+
@Override
59+
public void startSSRFChecking() throws Exception {
60+
start();
61+
}
62+
63+
private void start() throws Exception {
64+
events.add("start");
65+
if (startThrows) {
66+
throw new Exception("cannot install net-hook");
67+
}
68+
}
69+
70+
@Override
71+
public void stopSSRFChecking() {
72+
events.add("stop");
73+
}
74+
75+
@Override
76+
public boolean isEnabled() {
77+
return enabled;
78+
}
79+
80+
@Override
81+
protected void doConnect(String host, int port, int connectTimeoutMs) throws IOException {
82+
events.add("connect");
83+
switch (connectBehavior) {
84+
case SSRF:
85+
throw new SecurityException("simulated SSRFUnsafeConnectionException for " + host);
86+
case IO:
87+
throw new IOException("connection refused");
88+
default:
89+
break;
90+
}
91+
}
92+
}
93+
94+
@Test
95+
public void disabledCheckerSkipsProbeEntirely() throws DdlException {
96+
RecordingChecker checker = new RecordingChecker();
97+
checker.enabled = false;
98+
// Intranet-looking host, but a disabled checker must not even connect.
99+
checker.checkEndpointForSsrf("10.0.0.1", 9083);
100+
Assertions.assertTrue(checker.events.isEmpty(), "disabled checker must not touch the network");
101+
}
102+
103+
@Test
104+
public void successfulProbeBracketsConnectAndReturns() throws DdlException {
105+
RecordingChecker checker = new RecordingChecker();
106+
checker.connectBehavior = ConnectBehavior.SUCCESS;
107+
checker.checkEndpointForSsrf("public.example.com", 9083);
108+
Assertions.assertEquals(Arrays.asList("start", "connect", "stop"), checker.events);
109+
}
110+
111+
@Test
112+
public void intranetTargetIsRejectedAsDdlException() {
113+
RecordingChecker checker = new RecordingChecker();
114+
checker.connectBehavior = ConnectBehavior.SSRF;
115+
DdlException e = Assertions.assertThrows(DdlException.class,
116+
() -> checker.checkEndpointForSsrf("10.0.0.1", 9083));
117+
Assertions.assertTrue(e.getMessage().contains("SSRF policy"), e.getMessage());
118+
// stop still runs in the finally block even when the connect throws.
119+
Assertions.assertEquals(Arrays.asList("start", "connect", "stop"), checker.events);
120+
}
121+
122+
@Test
123+
public void unreachableEndpointIsNotAnSsrfRejection() throws DdlException {
124+
RecordingChecker checker = new RecordingChecker();
125+
checker.connectBehavior = ConnectBehavior.IO;
126+
// A refused/timed-out connect is a reachability fact, not an SSRF signal: must not throw.
127+
checker.checkEndpointForSsrf("public-but-down.example.com", 9083);
128+
Assertions.assertEquals(Arrays.asList("start", "connect", "stop"), checker.events);
129+
}
130+
131+
@Test
132+
public void failedHookInstallSurfacesAsDdlExceptionWithoutConnecting() {
133+
RecordingChecker checker = new RecordingChecker();
134+
checker.startThrows = true;
135+
DdlException e = Assertions.assertThrows(DdlException.class,
136+
() -> checker.checkEndpointForSsrf("some.host", 9083));
137+
Assertions.assertTrue(e.getMessage().contains("Failed to initialize SSRF checking"), e.getMessage());
138+
// No connect attempt, and nothing to stop since the hook was never installed.
139+
Assertions.assertEquals(Arrays.asList("start"), checker.events);
140+
}
141+
142+
@Test
143+
public void dummyCheckerIsDisabled() {
144+
Assertions.assertFalse(new DummySecurityChecker().isEnabled());
145+
}
146+
}

‎fe/fe-connector/fe-connector-hive/src/main/java/org/apache/doris/connector/hive/HiveConnectorProvider.java‎

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,7 @@
2020
import org.apache.doris.connector.spi.Connector;
2121
import org.apache.doris.connector.spi.ConnectorContext;
2222
import org.apache.doris.connector.spi.ConnectorProvider;
23+
import org.apache.doris.connector.spi.ConnectorSecuritySurface;
2324

2425
import java.util.Collections;
2526
import java.util.HashMap;
@@ -80,4 +81,11 @@ public void validatePropertiesForUpdate(
8081
candidate.putAll(updatedProperties);
8182
HiveCatalogProperties.of(candidate).checkCreateTimeOnlyRules(updatedProperties);
8283
}
84+
85+
@Override
86+
public ConnectorSecuritySurface securitySurface() {
87+
// hive.metastore.uris (documented alias: uri) is the user-supplied thrift endpoint the FE connects
88+
// to; the engine's SSRF gate rejects an intranet target there at CREATE / ALTER CATALOG.
89+
return ConnectorSecuritySurface.ofSsrfEndpoints(HiveCatalogProperties.HIVE_METASTORE_URIS, "uri");
90+
}
8391
}

0 commit comments

Comments
 (0)