Add secure HTTP server communication transport

SimpleAPI/pom.xml

@@ -16,6 +16,7 @@
         <maven.compiler.source>21</maven.compiler.source>
         <maven.compiler.target>21</maven.compiler.target>
         <maven.compiler.release>21</maven.compiler.release>
+        <bouncycastle.version>1.85</bouncycastle.version>
     </properties>
     <build>
         <sourceDirectory>src/main/java</sourceDirectory>
@@ -71,6 +72,11 @@
                     <finalName>${project.name}</finalName>
                 </configuration>
             </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>3.5.4</version>
+            </plugin>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-shade-plugin</artifactId>
@@ -155,6 +161,16 @@
         </repository>
     </repositories>
     <dependencies>
+        <dependency>
+            <groupId>org.bouncycastle</groupId>
+            <artifactId>bcpkix-jdk18on</artifactId>
+            <version>${bouncycastle.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.bouncycastle</groupId>
+            <artifactId>bcprov-jdk18on</artifactId>
+            <version>${bouncycastle.version}</version>
+        </dependency>
         <dependency>
             <groupId>org.spigotmc</groupId>
             <artifactId>spigot-api</artifactId>
@@ -407,4 +423,4 @@
             </build>
         </profile>
     </profiles>
-</project>
+</project>

SimpleAPI/src/main/java/com/bencodez/simpleapi/file/DurableFiles.java

@@ -0,0 +1,65 @@
+package com.bencodez.simpleapi.file;
+
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.file.AccessDeniedException;
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
+import java.nio.file.StandardOpenOption;
+import java.util.Locale;
+
+/** Cross-platform helpers for forcing file contents and published directory entries. */
+public final class DurableFiles {
+	private DurableFiles() { }
+
+	public static void forceFile(Path file) throws IOException {
+		try (FileChannel channel = FileChannel.open(file, StandardOpenOption.WRITE, LinkOption.NOFOLLOW_LINKS)) {
+			channel.force(true);
+		}
+	}
+
+	public static void forceDirectory(Path directory) throws IOException {
+		if (directory == null) return;
+		try {
+			try (FileChannel channel = FileChannel.open(directory, StandardOpenOption.READ)) {
+				channel.force(true);
+			}
+		} catch (AccessDeniedException unsupportedDirectoryHandle) {
+			// The Windows NIO provider cannot open directory handles. File contents are
+			// still forced before atomic publication; do not make persistence unusable.
+			if (!isWindowsName(System.getProperty("os.name", ""))) throw unsupportedDirectoryHandle;
+		} catch (UnsupportedOperationException unsupportedDirectoryForce) {
+			// Some providers support atomic moves but expose no directory-force operation.
+		}
+	}
+
+	public static boolean deleteIfExists(Path target) throws IOException {
+		boolean deleted = Files.deleteIfExists(target);
+		if (deleted) forceDirectory(target.toAbsolutePath().normalize().getParent());
+		return deleted;
+	}
+
+	public static void forceMoveDirectories(Path source, Path target) throws IOException {
+		try {
+			Path sourceParent = source.toAbsolutePath().normalize().getParent();
+			Path targetParent = target.toAbsolutePath().normalize().getParent();
+			forceDirectory(targetParent);
+			if (sourceParent != null && !sourceParent.equals(targetParent)) forceDirectory(sourceParent);
+		} catch (IOException failure) {
+			throw new PublishedException(failure);
+		}
+	}
+
+	public static boolean isWindowsName(String name) {
+		return name != null && name.trim().toLowerCase(Locale.ROOT).startsWith("windows");
+	}
+
+	/** Indicates that an atomic rename completed before metadata writeback failed. */
+	@SuppressWarnings("serial")
+	public static final class PublishedException extends IOException {
+		public PublishedException(IOException cause) {
+			super("File was published but its directory metadata could not be forced", cause);
+		}
+	}
+}

SimpleAPI/src/main/java/com/bencodez/simpleapi/file/PrivateFilePermissions.java

@@ -0,0 +1,84 @@
+package com.bencodez.simpleapi.file;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
+import java.nio.file.attribute.AclEntry;
+import java.nio.file.attribute.AclEntryPermission;
+import java.nio.file.attribute.AclEntryType;
+import java.nio.file.attribute.AclFileAttributeView;
+import java.nio.file.attribute.GroupPrincipal;
+import java.nio.file.attribute.PosixFilePermission;
+import java.nio.file.attribute.UserPrincipal;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.Set;
+
+/** Enforces and verifies owner-only access for persisted private material. */
+public final class PrivateFilePermissions {
+	private static final Set<PosixFilePermission> OWNER_FILE = EnumSet.of(
+			PosixFilePermission.OWNER_READ, PosixFilePermission.OWNER_WRITE);
+	private static final Set<PosixFilePermission> OWNER_DIRECTORY = EnumSet.of(
+			PosixFilePermission.OWNER_READ, PosixFilePermission.OWNER_WRITE, PosixFilePermission.OWNER_EXECUTE);
+	private static final Set<AclEntryPermission> OWNER_ACL = EnumSet.allOf(AclEntryPermission.class);
+
+	private PrivateFilePermissions() { }
+
+	/** Enforces 0600-equivalent access, or fails when the provider cannot prove it. */
+	public static void ownerOnlyFile(Path path) throws IOException {
+		enforce(path, OWNER_FILE);
+	}
+
+	/** Enforces 0700-equivalent access, or fails when the provider cannot prove it. */
+	public static void ownerOnlyDirectory(Path path) throws IOException {
+		enforce(path, OWNER_DIRECTORY);
+	}
+
+	private static void enforce(Path path, Set<PosixFilePermission> permissions) throws IOException {
+		if (path == null) throw new IllegalArgumentException("Private path is required");
+		if (Files.isSymbolicLink(path)) throw new IOException("Refusing symbolic link for private storage: " + path);
+		try {
+			Files.setPosixFilePermissions(path, permissions);
+			if (!Files.getPosixFilePermissions(path, LinkOption.NOFOLLOW_LINKS).equals(permissions))
+				throw new IOException("Could not verify owner-only POSIX permissions for " + path);
+			return;
+		} catch (UnsupportedOperationException unsupported) {
+			// A non-POSIX provider must expose an ACL that can be reduced and verified.
+		}
+		enforceWithAcl(path);
+	}
+
+	private static void enforceWithAcl(Path path) throws IOException {
+		try {
+			AclFileAttributeView view = Files.getFileAttributeView(path, AclFileAttributeView.class, LinkOption.NOFOLLOW_LINKS);
+			if (view == null) throw new IOException("Owner-only private storage is unsupported for " + path);
+			enforceWithAcl(view, path);
+		} catch (UnsupportedOperationException unsupported) {
+			throw new IOException("Owner-only private storage is unsupported for " + path, unsupported);
+		}
+	}
+
+	/** Package-visible for deterministic ACL-provider tests. */
+	static void enforceWithAcl(AclFileAttributeView view, Path path) throws IOException {
+		try {
+			if (view == null) throw new IOException("Owner-only private storage is unsupported for " + path);
+			UserPrincipal owner = view.getOwner();
+			if (owner == null || owner instanceof GroupPrincipal)
+				throw new IOException("Private storage owner is not an individual account for " + path);
+			AclEntry ownerEntry = AclEntry.newBuilder().setType(AclEntryType.ALLOW).setPrincipal(owner)
+					.setPermissions(OWNER_ACL).build();
+			view.setAcl(List.of(ownerEntry));
+			List<AclEntry> acl = view.getAcl();
+			if (acl.size() != 1 || !isVerifiedOwnerEntry(acl.get(0), owner))
+				throw new IOException("Could not verify owner-only ACL permissions for " + path);
+		} catch (UnsupportedOperationException unsupported) {
+			throw new IOException("Owner-only private storage is unsupported for " + path, unsupported);
+		}
+	}
+
+	private static boolean isVerifiedOwnerEntry(AclEntry entry, UserPrincipal owner) {
+		return entry.type() == AclEntryType.ALLOW && owner.equals(entry.principal()) && entry.flags().isEmpty()
+				&& entry.permissions().equals(OWNER_ACL);
+	}
+}