You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@geode.apache.org by ji...@apache.org on 2026/08/26 14:43:09 UTC
(geode) branch develop updated: Add configurable output directories for export data (#8037)
This is an automated email from the ASF dual-hosted git repository.
JinwooHwang pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/geode.git
The following commit(s) were added to refs/heads/develop by this push:
new 5f339dd0c0 Add configurable output directories for export data (#8037)
5f339dd0c0 is described below
commit 5f339dd0c0852eabaf0cba9a429c85b4326153f7
Author: Jinwoo Hwang <92...@users.noreply.github.com>
AuthorDate: Wed Aug 26 10:43:03 2026 -0400
Add configurable output directories for export data (#8037)
---
.../ExportDataCommandPermissionsDUnitTest.java | 227 +++++++++++++++++++
.../ExportDataPathValidationIntegrationTest.java | 211 ++++++++++++++++++
.../ExportDataCommandPathValidationTest.java | 215 ++++++++++++++++++
.../ExportDataFunctionPathValidationTest.java | 248 +++++++++++++++++++++
4 files changed, 901 insertions(+)
diff --git a/geode-gfsh/src/distributedTest/java/org/apache/geode/management/internal/cli/commands/ExportDataCommandPermissionsDUnitTest.java b/geode-gfsh/src/distributedTest/java/org/apache/geode/management/internal/cli/commands/ExportDataCommandPermissionsDUnitTest.java
new file mode 100644
index 0000000000..92324e04b3
--- /dev/null
+++ b/geode-gfsh/src/distributedTest/java/org/apache/geode/management/internal/cli/commands/ExportDataCommandPermissionsDUnitTest.java
@@ -0,0 +1,227 @@
+/*
+ * 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.geode.management.internal.cli.commands;
+
+import static org.apache.geode.distributed.ConfigurationProperties.SECURITY_MANAGER;
+import static org.apache.geode.management.internal.cli.functions.ExportDataFunction.EXPORT_DATA_DIRS_PROPERTY;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.io.Serializable;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Properties;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.ClassRule;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.rules.TemporaryFolder;
+
+import org.apache.geode.cache.RegionShortcut;
+import org.apache.geode.examples.SimpleSecurityManager;
+import org.apache.geode.internal.cache.InternalCache;
+import org.apache.geode.management.internal.security.ResourceConstants;
+import org.apache.geode.test.dunit.IgnoredException;
+import org.apache.geode.test.dunit.rules.ClusterStartupRule;
+import org.apache.geode.test.dunit.rules.MemberVM;
+import org.apache.geode.test.junit.categories.SecurityTest;
+import org.apache.geode.test.junit.rules.GfshCommandRule;
+
+/**
+ * Tests which principals may run {@code export data} in a secured cluster.
+ *
+ * <p>
+ * {@link SimpleSecurityManager} authorizes a user for exactly those permissions whose string form
+ * starts with the user name, and treats a comma separated user name as a set of roles. So
+ * "dataRead" holds DATA:READ alone, while "dataRead,clusterWrite" is the operator {@code
+ * export data} requires.
+ */
+@Category(SecurityTest.class)
+public class ExportDataCommandPermissionsDUnitTest implements Serializable {
+
+ private static final String REGION_NAME = "testRegion";
+ private static final String READ_ONLY_USER = "dataRead";
+ private static final String EXPORT_OPERATOR = "dataRead,clusterWrite";
+
+ @ClassRule
+ public static ClusterStartupRule cluster = new ClusterStartupRule();
+
+ @Rule
+ public GfshCommandRule gfsh = new GfshCommandRule();
+
+ @Rule
+ public TemporaryFolder temporaryFolder = new TemporaryFolder();
+
+ private static MemberVM locator;
+ private static MemberVM server;
+
+ /** The directory the server has been configured to permit exports into. */
+ private Path permittedDir;
+
+ /** Any other location on the server host. */
+ private Path otherDir;
+
+ @BeforeClass
+ public static void beforeClass() {
+ Properties locatorProps = new Properties();
+ locatorProps.setProperty(SECURITY_MANAGER, SimpleSecurityManager.class.getName());
+ locator = cluster.startLocatorVM(0, locatorProps);
+
+ Properties serverProps = new Properties();
+ serverProps.setProperty(ResourceConstants.USER_NAME, "clusterManage");
+ serverProps.setProperty(ResourceConstants.PASSWORD, "clusterManage");
+ server = cluster.startServerVM(1, serverProps, locator.getPort());
+
+ server.invoke(() -> {
+ InternalCache cache = ClusterStartupRule.getCache();
+ assertThat(cache).isNotNull();
+ cache.createRegionFactory(RegionShortcut.REPLICATE).create(REGION_NAME).put("key", "value");
+ });
+ }
+
+ @Before
+ public void configurePermittedExportDirectory() throws Exception {
+ // Refusing an export is logged at error level on the member; that is the expected outcome of
+ // most of these tests, not a symptom of one going wrong.
+ IgnoredException.addIgnoredException("Cannot export to");
+
+ permittedDir = temporaryFolder.newFolder("permitted").toPath();
+ otherDir = temporaryFolder.newFolder("other").toPath();
+
+ String permitted = permittedDir.toString();
+ server.invoke(() -> System.setProperty(EXPORT_DATA_DIRS_PROPERTY, permitted));
+ }
+
+ @After
+ public void clearPermittedExportDirectory() {
+ server.invoke(() -> System.clearProperty(EXPORT_DATA_DIRS_PROPERTY));
+ }
+
+ private void connectAs(String user) throws Exception {
+ gfsh.secureConnectAndVerify(locator.getPort(), GfshCommandRule.PortType.locator, user, user);
+ }
+
+ private String exportTo(String option, Path path) {
+ return "export data --member=" + server.getName() + " --region=" + REGION_NAME + " --"
+ + option + "=" + path;
+ }
+
+ /**
+ * Read access to region data on its own does not permit an export.
+ */
+ @Test
+ public void dataReadUserCannotExport() throws Exception {
+ connectAs(READ_ONLY_USER);
+ Path target = permittedDir.resolve("snapshot.gfd");
+
+ gfsh.executeAndAssertThat(exportTo("file", target))
+ .statusIsError()
+ .containsOutput("not authorized for CLUSTER:WRITE");
+
+ assertThat(target).doesNotExist();
+ }
+
+ /**
+ * Permissions are checked before the path, so the target directory makes no difference.
+ */
+ @Test
+ public void dataReadUserIsRefusedForAnyDirectory() throws Exception {
+ connectAs(READ_ONLY_USER);
+ Path target = otherDir.resolve("snapshot.gfd");
+
+ gfsh.executeAndAssertThat(exportTo("file", target))
+ .statusIsError()
+ .containsOutput("not authorized for CLUSTER:WRITE");
+
+ assertThat(target).doesNotExist();
+ }
+
+ /**
+ * The command works for a principal holding both permissions.
+ */
+ @Test
+ public void operatorWithClusterWriteCanExportIntoThePermittedDirectory() throws Exception {
+ connectAs(EXPORT_OPERATOR);
+ Path target = permittedDir.resolve("snapshot.gfd");
+
+ gfsh.executeAndAssertThat(exportTo("file", target))
+ .statusIsSuccess()
+ .containsOutput("Data successfully exported");
+
+ assertThat(target).exists();
+ }
+
+ /**
+ * The directory restriction applies independently of the permission: even a permitted operator
+ * cannot place the snapshot anywhere it likes.
+ */
+ @Test
+ public void operatorCannotExportOutsideThePermittedDirectory() throws Exception {
+ connectAs(EXPORT_OPERATOR);
+ Path target = otherDir.resolve("snapshot.gfd");
+
+ gfsh.executeAndAssertThat(exportTo("file", target)).statusIsError();
+
+ assertThat(target).doesNotExist();
+ }
+
+ /**
+ * Nor can the operator leave the permitted directory with "../".
+ */
+ @Test
+ public void operatorCannotLeavePermittedDirectoryWithParentReference() throws Exception {
+ connectAs(EXPORT_OPERATOR);
+ Path withParentReference = permittedDir.resolve("..").resolve("other");
+
+ gfsh.executeAndAssertThat(exportTo("dir", withParentReference)).statusIsError();
+
+ assertThat(otherDir.resolve(REGION_NAME + ".gfd")).doesNotExist();
+ }
+
+ /**
+ * An existing file outside the permitted directory survives an export aimed at it.
+ */
+ @Test
+ public void existingFileOutsideThePermittedDirectoryIsNotOverwritten() throws Exception {
+ connectAs(EXPORT_OPERATOR);
+ Path existingFile = otherDir.resolve("existing.gfd");
+ String originalContent = "existing content";
+ Files.write(existingFile, originalContent.getBytes(StandardCharsets.UTF_8));
+
+ gfsh.executeAndAssertThat(exportTo("file", existingFile)).statusIsError();
+
+ assertThat(new String(Files.readAllBytes(existingFile), StandardCharsets.UTF_8))
+ .isEqualTo(originalContent);
+ }
+
+ /**
+ * Confirms the read only grant really is read only, so the refusals above are the permission
+ * check taking effect rather than a misconfigured principal.
+ */
+ @Test
+ public void readOnlyUserCanStillReadData() throws Exception {
+ connectAs(READ_ONLY_USER);
+
+ gfsh.executeAndAssertThat("get --region=" + REGION_NAME + " --key=key").statusIsSuccess();
+ gfsh.executeAndAssertThat("put --region=" + REGION_NAME + " --key=k --value=v")
+ .statusIsError()
+ .containsOutput("dataRead not authorized for DATA:WRITE");
+ }
+}
diff --git a/geode-gfsh/src/integrationTest/java/org/apache/geode/management/internal/cli/commands/ExportDataPathValidationIntegrationTest.java b/geode-gfsh/src/integrationTest/java/org/apache/geode/management/internal/cli/commands/ExportDataPathValidationIntegrationTest.java
new file mode 100644
index 0000000000..6b6add92a1
--- /dev/null
+++ b/geode-gfsh/src/integrationTest/java/org/apache/geode/management/internal/cli/commands/ExportDataPathValidationIntegrationTest.java
@@ -0,0 +1,211 @@
+/*
+ * 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.geode.management.internal.cli.commands;
+
+import static org.apache.geode.management.internal.cli.functions.ExportDataFunction.EXPORT_DATA_DIRS_PROPERTY;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.io.File;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.stream.IntStream;
+
+import org.junit.Before;
+import org.junit.ClassRule;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.contrib.java.lang.system.RestoreSystemProperties;
+import org.junit.rules.TemporaryFolder;
+
+import org.apache.geode.cache.Region;
+import org.apache.geode.cache.RegionShortcut;
+import org.apache.geode.management.internal.cli.util.CommandStringBuilder;
+import org.apache.geode.management.internal.i18n.CliStrings;
+import org.apache.geode.test.junit.rules.GfshCommandRule;
+import org.apache.geode.test.junit.rules.ServerStarterRule;
+
+/**
+ * End to end tests of the directories {@code export data} writes into: a live server exports into
+ * the directories it is configured to permit, and refuses paths that resolve outside them.
+ */
+public class ExportDataPathValidationIntegrationTest {
+ private static final String TEST_REGION_NAME = "testRegion";
+ private static final int DATA_POINTS = 10;
+
+ @ClassRule
+ public static ServerStarterRule server = new ServerStarterRule().withJMXManager()
+ .withRegion(RegionShortcut.PARTITION, TEST_REGION_NAME).withEmbeddedLocator();
+
+ @Rule
+ public GfshCommandRule gfsh = new GfshCommandRule();
+
+ @Rule
+ public TemporaryFolder temporaryFolder = new TemporaryFolder();
+
+ @Rule
+ public RestoreSystemProperties restoreSystemProperties = new RestoreSystemProperties();
+
+ /** The directory an operator has permitted this member to export into. */
+ private Path permittedDir;
+
+ /** Any other location on the server host. */
+ private Path otherDir;
+
+ private Region<String, Object> region;
+
+ @Before
+ public void setup() throws Exception {
+ gfsh.connectAndVerify(server.getEmbeddedLocatorPort(), GfshCommandRule.PortType.locator);
+ region = server.getCache().getRegion(TEST_REGION_NAME);
+ IntStream.range(0, DATA_POINTS).forEach(i -> region.put("key" + i, "value" + i));
+
+ permittedDir = temporaryFolder.newFolder("permitted").toPath();
+ otherDir = temporaryFolder.newFolder("other").toPath();
+ System.setProperty(EXPORT_DATA_DIRS_PROPERTY, permittedDir.toString());
+ }
+
+ /** The gfsh table wraps long messages, so compare against whitespace normalized output. */
+ private String normalizedOutput() {
+ return gfsh.getGfshOutput().replaceAll("\\s+", " ");
+ }
+
+ /**
+ * Exports into a permitted directory work normally.
+ */
+ @Test
+ public void exportIntoThePermittedDirectorySucceeds() {
+ Path target = permittedDir.resolve("snapshot.gfd");
+
+ gfsh.executeAndAssertThat(baseCommand()
+ .addOption(CliStrings.EXPORT_DATA__FILE, target.toString())
+ .getCommandString()).statusIsSuccess();
+
+ assertThat(target).exists();
+ assertThat(target.toFile().length()).isGreaterThan(0L);
+ }
+
+ /** The --dir form works the same way. */
+ @Test
+ public void exportIntoThePermittedDirectoryWithDirOptionSucceeds() {
+ gfsh.executeAndAssertThat(baseCommand()
+ .addOption(CliStrings.EXPORT_DATA__DIR, permittedDir.toString())
+ .getCommandString()).statusIsSuccess();
+
+ assertThat(permittedDir.resolve(TEST_REGION_NAME + ".gfd")).exists();
+ }
+
+ /**
+ * An absolute path outside the permitted directories does not produce a file.
+ */
+ @Test
+ public void exportToAnAbsolutePathOutsideThePermittedDirectoryIsRefused() {
+ Path target = otherDir.resolve("snapshot.gfd");
+
+ gfsh.executeAndAssertThat(baseCommand()
+ .addOption(CliStrings.EXPORT_DATA__FILE, target.toString())
+ .getCommandString()).statusIsError();
+
+ assertThat(normalizedOutput()).contains("export directories configured for this member");
+ assertThat(target).doesNotExist();
+ }
+
+ /**
+ * A "../" in --dir is refused, and nothing is written at the location it points to.
+ */
+ @Test
+ public void exportWithParentReferenceInDirOptionIsRefused() {
+ String dirWithParentReference = permittedDir.resolve("..").resolve("other").toString();
+
+ gfsh.executeAndAssertThat(baseCommand()
+ .addOption(CliStrings.EXPORT_DATA__DIR, dirWithParentReference)
+ .getCommandString()).statusIsError();
+
+ assertThat(normalizedOutput()).contains("path segment");
+ assertThat(otherDir.resolve(TEST_REGION_NAME + ".gfd")).doesNotExist();
+ }
+
+ /**
+ * The same for --file: it is caught before the export is sent to the member.
+ */
+ @Test
+ public void exportWithParentReferenceInFileOptionIsRefused() {
+ String fileWithParentReference = permittedDir.resolve("..").resolve("other")
+ .resolve("snapshot.gfd").toString();
+
+ gfsh.executeAndAssertThat(baseCommand()
+ .addOption(CliStrings.EXPORT_DATA__FILE, fileWithParentReference)
+ .getCommandString()).statusIsError();
+
+ assertThat(normalizedOutput()).contains("path segment");
+ assertThat(otherDir.resolve("snapshot.gfd")).doesNotExist();
+ }
+
+ /**
+ * An existing file outside the permitted directories keeps its contents.
+ */
+ @Test
+ public void existingFileOutsideThePermittedDirectoryIsNotOverwritten() throws Exception {
+ Path existingFile = otherDir.resolve("existing.gfd");
+ String originalContent = "existing content";
+ Files.write(existingFile, originalContent.getBytes(StandardCharsets.UTF_8));
+
+ gfsh.executeAndAssertThat(baseCommand()
+ .addOption(CliStrings.EXPORT_DATA__FILE, existingFile.toString())
+ .getCommandString()).statusIsError();
+
+ assertThat(new String(Files.readAllBytes(existingFile), StandardCharsets.UTF_8))
+ .isEqualTo(originalContent);
+ }
+
+ /**
+ * A parallel export does not create a directory tree outside the permitted directories.
+ */
+ @Test
+ public void parallelExportOutsideThePermittedDirectoryCreatesNoDirectories() {
+ Path newTree = otherDir.resolve("created/by/export");
+
+ gfsh.executeAndAssertThat(baseCommand()
+ .addOption(CliStrings.EXPORT_DATA__DIR, newTree.toString())
+ .addOption(CliStrings.EXPORT_DATA__PARALLEL, "true")
+ .getCommandString()).statusIsError();
+
+ assertThat(newTree).doesNotExist();
+ }
+
+ /**
+ * Without configuration the member permits only its own working directory.
+ */
+ @Test
+ public void withoutConfigurationExportOutsideTheWorkingDirectoryIsRefused() {
+ System.clearProperty(EXPORT_DATA_DIRS_PROPERTY);
+ Path target = otherDir.resolve("snapshot.gfd");
+
+ gfsh.executeAndAssertThat(baseCommand()
+ .addOption(CliStrings.EXPORT_DATA__FILE, target.toString())
+ .getCommandString()).statusIsError();
+
+ assertThat(target).doesNotExist();
+ assertThat(normalizedOutput())
+ .contains(new File(System.getProperty("user.dir")).getName());
+ }
+
+ private CommandStringBuilder baseCommand() {
+ return new CommandStringBuilder(CliStrings.EXPORT_DATA)
+ .addOption(CliStrings.MEMBER, server.getName())
+ .addOption(CliStrings.EXPORT_DATA__REGION, TEST_REGION_NAME);
+ }
+}
diff --git a/geode-gfsh/src/test/java/org/apache/geode/management/internal/cli/commands/ExportDataCommandPathValidationTest.java b/geode-gfsh/src/test/java/org/apache/geode/management/internal/cli/commands/ExportDataCommandPathValidationTest.java
new file mode 100644
index 0000000000..da38688064
--- /dev/null
+++ b/geode-gfsh/src/test/java/org/apache/geode/management/internal/cli/commands/ExportDataCommandPathValidationTest.java
@@ -0,0 +1,215 @@
+/*
+ * 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.geode.management.internal.cli.commands;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+
+import java.io.File;
+import java.util.Collections;
+
+import org.junit.Before;
+import org.junit.ClassRule;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+
+import org.apache.geode.cache.execute.ResultCollector;
+import org.apache.geode.distributed.DistributedMember;
+import org.apache.geode.management.internal.functions.CliFunctionResult;
+import org.apache.geode.security.NotAuthorizedException;
+import org.apache.geode.security.ResourcePermission;
+import org.apache.geode.security.ResourcePermission.Operation;
+import org.apache.geode.security.ResourcePermission.Resource;
+import org.apache.geode.test.junit.rules.GfshParserRule;
+
+/**
+ * Tests the path validation and the authorization {@code export data} applies before it sends any
+ * work to a member.
+ *
+ * <p>
+ * The directory configuration is applied on the member; the command checks the option for a parent
+ * directory reference and asks for the permissions the operation needs.
+ *
+ * @see ExportDataCommandPermissionsDUnitTest for the permissions end to end in a secured
+ * cluster
+ */
+public class ExportDataCommandPathValidationTest {
+
+ @ClassRule
+ public static GfshParserRule parser = new GfshParserRule();
+
+ private static final String REGION = "testRegion";
+ /**
+ * On this branch the option carries no ConverterHint.REGION_PATH, so the command method sees the
+ * region name exactly as typed (on support/1.15 the converter prepends the separator).
+ */
+ private static final String REGION_PATH = REGION;
+
+ private ExportDataCommand command;
+ private ArgumentCaptor<Object> functionArgsCaptor;
+
+ @Before
+ public void before() {
+ command = spy(ExportDataCommand.class);
+
+ doNothing().when(command).authorize(any(Resource.class), any(Operation.class), anyString());
+ doReturn(mock(DistributedMember.class)).when(command).getMember(anyString());
+
+ CliFunctionResult okResult =
+ new CliFunctionResult("server1", CliFunctionResult.StatusState.OK, "exported");
+ ResultCollector<?, ?> collector = mock(ResultCollector.class);
+ doReturn(Collections.singletonList(okResult)).when(collector).getResult();
+
+ functionArgsCaptor = ArgumentCaptor.forClass(Object.class);
+ doReturn(collector).when(command).executeFunction(any(), functionArgsCaptor.capture(),
+ any(DistributedMember.class));
+ }
+
+ private String capturedExportPath() {
+ Object args = functionArgsCaptor.getValue();
+ assertThat(args).isInstanceOf(String[].class);
+ return ((String[]) args)[1];
+ }
+
+ private void verifyNoExportWasRequested() {
+ verify(command, never()).executeFunction(any(), any(), any(DistributedMember.class));
+ }
+
+ /**
+ * A "../" element in --file is refused before anything is sent to a member.
+ */
+ @Test
+ public void parentReferenceInFileOptionIsRejected() {
+ parser
+ .executeAndAssertThat(command, "export data --member=server1 --region=" + REGION
+ + " --file=../../../../var/tmp/snapshot.gfd")
+ .statusIsError()
+ .containsOutput("must not contain a \"..\" path segment");
+
+ verifyNoExportWasRequested();
+ }
+
+ /**
+ * A "../" buried in the middle of an otherwise absolute --file is refused too - the check looks
+ * at every element of the path, not just its start.
+ */
+ @Test
+ public void parentReferenceInsideAnAbsoluteFilePathIsRejected() {
+ parser
+ .executeAndAssertThat(command, "export data --member=server1 --region=" + REGION
+ + " --file=/var/tmp/subdir/../../snapshot.gfd")
+ .statusIsError()
+ .containsOutput("must not contain a \"..\" path segment");
+
+ verifyNoExportWasRequested();
+ }
+
+ /**
+ * The --dir option is checked as well, even though its file name is generated rather than
+ * supplied.
+ */
+ @Test
+ public void parentReferenceInDirOptionIsRejected() {
+ parser
+ .executeAndAssertThat(command,
+ "export data --member=server1 --region=" + REGION + " --dir=/tmp/subdir/../../var/tmp")
+ .statusIsError()
+ .containsOutput("must not contain a \"..\" path segment");
+
+ verifyNoExportWasRequested();
+ }
+
+ /**
+ * An ordinary path is forwarded unchanged, for the member to resolve.
+ */
+ @Test
+ public void ordinaryPathIsForwardedToTheMember() {
+ parser
+ .executeAndAssertThat(command,
+ "export data --member=server1 --region=" + REGION + " --file=/var/tmp/snapshot.gfd")
+ .statusIsSuccess();
+
+ assertThat(capturedExportPath()).isEqualTo("/var/tmp/snapshot.gfd");
+ }
+
+ /**
+ * Same for --dir, with the generated file name appended.
+ */
+ @Test
+ public void ordinaryDirectoryIsForwardedToTheMember() {
+ parser
+ .executeAndAssertThat(command,
+ "export data --member=server1 --region=" + REGION + " --dir=/var/tmp")
+ .statusIsSuccess();
+
+ assertThat(capturedExportPath()).isEqualTo(new File("/var/tmp", REGION + ".gfd").getPath());
+ }
+
+ /**
+ * The extension check still applies.
+ */
+ @Test
+ public void fileExtensionIsValidated() {
+ parser
+ .executeAndAssertThat(command,
+ "export data --member=server1 --region=" + REGION + " --file=/var/tmp/snapshot.txt")
+ .statusIsError()
+ .containsOutput("Invalid file type, the file extension must be \".gfd\"");
+
+ verifyNoExportWasRequested();
+ }
+
+ /**
+ * Writing a file on a member's host needs a cluster write permission, alongside read access to
+ * the data being exported.
+ */
+ @Test
+ public void exportRequiresClusterWriteAndDataRead() {
+ parser
+ .executeAndAssertThat(command,
+ "export data --member=server1 --region=" + REGION + " --file=/var/tmp/snapshot.gfd")
+ .statusIsSuccess();
+
+ verify(command).authorize(Resource.DATA, Operation.READ, REGION_PATH);
+ verify(command).authorize(Resource.CLUSTER, Operation.WRITE, ResourcePermission.ALL);
+ }
+
+ /**
+ * Permissions are checked before any work is done, so the export is not sent to the member.
+ */
+ @Test
+ public void clusterWriteIsCheckedBeforeTheExportIsSent() {
+ doThrow(new NotAuthorizedException("dataRead not authorized for CLUSTER:WRITE"))
+ .when(command).authorize(eq(Resource.CLUSTER), eq(Operation.WRITE), anyString());
+
+ assertThatThrownBy(
+ () -> command.exportData("server1", REGION_PATH, "/var/tmp/snapshot.gfd", null, false))
+ .isInstanceOf(NotAuthorizedException.class)
+ .hasMessageContaining("CLUSTER:WRITE");
+
+ verifyNoExportWasRequested();
+ }
+}
diff --git a/geode-gfsh/src/test/java/org/apache/geode/management/internal/cli/functions/ExportDataFunctionPathValidationTest.java b/geode-gfsh/src/test/java/org/apache/geode/management/internal/cli/functions/ExportDataFunctionPathValidationTest.java
new file mode 100644
index 0000000000..23a2a89b41
--- /dev/null
+++ b/geode-gfsh/src/test/java/org/apache/geode/management/internal/cli/functions/ExportDataFunctionPathValidationTest.java
@@ -0,0 +1,248 @@
+/*
+ * 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.geode.management.internal.cli.functions;
+
+import static org.apache.geode.management.internal.cli.functions.ExportDataFunction.EXPORT_DATA_DIRS_PROPERTY;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.io.File;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.contrib.java.lang.system.RestoreSystemProperties;
+import org.junit.rules.TemporaryFolder;
+import org.mockito.ArgumentCaptor;
+
+import org.apache.geode.cache.Region;
+import org.apache.geode.cache.execute.FunctionContext;
+import org.apache.geode.cache.snapshot.RegionSnapshotService;
+import org.apache.geode.cache.snapshot.SnapshotOptions.SnapshotFormat;
+import org.apache.geode.distributed.internal.InternalDistributedSystem;
+import org.apache.geode.distributed.internal.membership.InternalDistributedMember;
+import org.apache.geode.internal.cache.InternalCache;
+import org.apache.geode.internal.cache.InternalCacheForClientAccess;
+import org.apache.geode.management.internal.functions.CliFunctionResult;
+
+/**
+ * Tests the directories a member permits {@code export data} to write into.
+ */
+public class ExportDataFunctionPathValidationTest {
+
+ private static final String REGION = "testRegion";
+
+ @Rule
+ public TemporaryFolder temporaryFolder = new TemporaryFolder();
+
+ @Rule
+ public RestoreSystemProperties restoreSystemProperties = new RestoreSystemProperties();
+
+ private ExportDataFunction function;
+ private RegionSnapshotService<Object, Object> snapshotService;
+ private FunctionContext<String[]> context;
+
+ @Before
+ @SuppressWarnings("unchecked")
+ public void before() {
+ function = new ExportDataFunction();
+
+ snapshotService = mock(RegionSnapshotService.class);
+ Region<Object, Object> region = mock(Region.class);
+ when(region.getSnapshotService()).thenReturn(snapshotService);
+
+ InternalCacheForClientAccess clientCache = mock(InternalCacheForClientAccess.class);
+ when(clientCache.getRegion(REGION)).thenReturn(region);
+
+ InternalCache cache = mock(InternalCache.class);
+ when(cache.getCacheForProcessingClientRequests()).thenReturn(clientCache);
+
+ InternalDistributedMember member = mock(InternalDistributedMember.class);
+ when(member.getHost()).thenReturn("localhost");
+ InternalDistributedSystem system = mock(InternalDistributedSystem.class);
+ when(system.getDistributedMember()).thenReturn(member);
+ when(clientCache.getDistributedSystem()).thenReturn(system);
+
+ context = mock(FunctionContext.class);
+ when(context.getCache()).thenReturn(cache);
+ when(context.getMemberName()).thenReturn("server1");
+ }
+
+ /** Permits exports into the temporary folder, in addition to the working directory. */
+ private Path permitTemporaryFolder() {
+ Path permitted = temporaryFolder.getRoot().toPath();
+ System.setProperty(EXPORT_DATA_DIRS_PROPERTY, permitted.toString());
+ return permitted;
+ }
+
+ private CliFunctionResult export(String requestedPath) throws Exception {
+ when(context.getArguments())
+ .thenReturn(new String[] {REGION, requestedPath, Boolean.toString(false)});
+ return function.executeFunction(context);
+ }
+
+ private File captureExportFile() throws Exception {
+ ArgumentCaptor<File> fileCaptor = ArgumentCaptor.forClass(File.class);
+ verify(snapshotService).save(fileCaptor.capture(), eq(SnapshotFormat.GEODE));
+ return fileCaptor.getValue();
+ }
+
+ private void verifyNothingWasWritten() throws Exception {
+ verify(snapshotService, never()).save(any(File.class), eq(SnapshotFormat.GEODE));
+ }
+
+ /**
+ * An export into a permitted directory works normally.
+ */
+ @Test
+ public void exportIntoAPermittedDirectorySucceeds() throws Exception {
+ Path permitted = permitTemporaryFolder();
+
+ CliFunctionResult result = export(permitted.resolve("snapshot.gfd").toString());
+
+ assertThat(result.isSuccessful()).isTrue();
+ assertThat(captureExportFile().toPath())
+ .isEqualTo(permitted.toRealPath().resolve("snapshot.gfd"));
+ }
+
+ /** Sub-directories of a permitted directory are permitted too. */
+ @Test
+ public void exportIntoASubdirectoryOfAPermittedDirectorySucceeds() throws Exception {
+ Path permitted = permitTemporaryFolder();
+
+ CliFunctionResult result = export(permitted.resolve("nested/snapshot.gfd").toString());
+
+ assertThat(result.isSuccessful()).isTrue();
+ }
+
+ /**
+ * An absolute path outside every permitted directory is refused.
+ */
+ @Test
+ public void exportToAnAbsolutePathOutsideEveryPermittedDirectoryIsRefused() throws Exception {
+ permitTemporaryFolder();
+
+ assertThatThrownBy(() -> export("/var/tmp/snapshot.gfd"))
+ .isInstanceOf(IllegalArgumentException.class)
+ .hasMessageContaining("not within the export directories configured for this member");
+
+ verifyNothingWasWritten();
+ }
+
+ /**
+ * A "../" element that climbs out of a permitted directory is refused: the path is canonicalized
+ * before it is compared, so the comparison uses the location actually written to.
+ */
+ @Test
+ public void parentReferenceOutOfAPermittedDirectoryIsRefused() throws Exception {
+ Path permitted = permitTemporaryFolder();
+
+ assertThatThrownBy(() -> export(permitted.resolve("../escaped.gfd").toString()))
+ .isInstanceOf(IllegalArgumentException.class)
+ .hasMessageContaining("not within the export directories configured for this member");
+
+ verifyNothingWasWritten();
+ }
+
+ /**
+ * A "../" element that stays inside a permitted directory is honoured, and is resolved before
+ * the write, so no "../" reaches the snapshot service.
+ */
+ @Test
+ public void parentReferenceInsideAPermittedDirectoryIsResolvedBeforeTheWrite()
+ throws Exception {
+ Path permitted = permitTemporaryFolder();
+
+ CliFunctionResult result =
+ export(permitted.resolve("nested/../snapshot.gfd").toString());
+
+ assertThat(result.isSuccessful()).isTrue();
+ File exportFile = captureExportFile();
+ assertThat(exportFile.getPath()).doesNotContain("..");
+ assertThat(exportFile.toPath()).isEqualTo(permitted.toRealPath().resolve("snapshot.gfd"));
+ }
+
+ /**
+ * With no configuration, the only permitted directory is the member's working directory - which
+ * is where a relative export path lands.
+ */
+ @Test
+ public void withoutConfigurationOnlyTheMemberWorkingDirectoryIsPermitted() throws Exception {
+ System.clearProperty(EXPORT_DATA_DIRS_PROPERTY);
+ Path workingDir = Paths.get(System.getProperty("user.dir")).toRealPath();
+
+ assertThat(export(workingDir.resolve("snapshot.gfd").toString()).isSuccessful()).isTrue();
+
+ assertThatThrownBy(() -> export(temporaryFolder.getRoot().toPath().resolve("x.gfd").toString()))
+ .isInstanceOf(IllegalArgumentException.class);
+ }
+
+ /**
+ * The member's working directory stays permitted when other directories are configured, so a
+ * relative export path keeps working.
+ */
+ @Test
+ public void theWorkingDirectoryRemainsPermittedWhenOtherDirectoriesAreConfigured()
+ throws Exception {
+ permitTemporaryFolder();
+
+ assertThat(export("snapshot.gfd").isSuccessful()).isTrue();
+ assertThat(captureExportFile().toPath())
+ .isEqualTo(Paths.get(System.getProperty("user.dir")).toRealPath().resolve("snapshot.gfd"));
+ }
+
+ /**
+ * More than one directory can be permitted, which is how a deployment that exports to a
+ * dedicated backup location configures the member.
+ */
+ @Test
+ public void severalDirectoriesCanBePermitted() throws Exception {
+ File backup = temporaryFolder.newFolder("backup");
+ File other = temporaryFolder.newFolder("other");
+ System.setProperty(EXPORT_DATA_DIRS_PROPERTY,
+ backup.getAbsolutePath() + File.pathSeparator + other.getAbsolutePath());
+
+ assertThat(export(new File(backup, "snapshot.gfd").getPath()).isSuccessful()).isTrue();
+ assertThat(export(new File(other, "snapshot.gfd").getPath()).isSuccessful()).isTrue();
+
+ assertThatThrownBy(() -> export(temporaryFolder.getRoot().toPath().resolve("x.gfd").toString()))
+ .isInstanceOf(IllegalArgumentException.class);
+ }
+
+ /**
+ * A directory whose name merely starts with a permitted directory's name is not inside it - the
+ * check compares path elements, not string prefixes.
+ */
+ @Test
+ public void aSiblingDirectoryWithAMatchingNamePrefixIsNotPermitted() throws Exception {
+ File permitted = temporaryFolder.newFolder("exports");
+ File sibling = temporaryFolder.newFolder("exports-archive");
+ System.setProperty(EXPORT_DATA_DIRS_PROPERTY, permitted.getAbsolutePath());
+
+ assertThatThrownBy(() -> export(new File(sibling, "snapshot.gfd").getPath()))
+ .isInstanceOf(IllegalArgumentException.class);
+
+ verifyNothingWasWritten();
+ }
+}