Вложения файлов со своего сервера доступа пользователя

This commit is contained in:
AidarKC
2026-10-07 11:42:12 +03:00
parent b1c42efa82
commit 7b8e178723
33 changed files with 1960 additions and 496 deletions
@@ -53,7 +53,7 @@ final class ChannelsReadSupport {
String stateSql = """
SELECT slug, display_name, channel_description, channel_type_code, channel_type_version,
ava_ar, ava_sha256, ava_size, meta_updated_at_ms, is_deleted, deleted_at_ms, deleted_block_number
created_at_ms, ava_ar, ava_sha256, ava_size, meta_updated_at_ms, is_deleted, deleted_at_ms, deleted_block_number
FROM channel_names_state
WHERE LOWER(owner_login)=LOWER(?) AND channel_root_block_number = ?
LIMIT 1
@@ -68,6 +68,7 @@ final class ChannelsReadSupport {
meta.channelDescription = String.valueOf(rs.getString("channel_description") == null ? "" : rs.getString("channel_description"));
meta.channelTypeCode = rs.getInt("channel_type_code");
meta.channelTypeVersion = rs.getInt("channel_type_version");
meta.createdAtMs = rs.getLong("created_at_ms");
meta.avaAr = String.valueOf(rs.getString("ava_ar") == null ? "" : rs.getString("ava_ar"));
meta.avaSha256 = String.valueOf(rs.getString("ava_sha256") == null ? "" : rs.getString("ava_sha256"));
meta.avaSize = rs.getLong("ava_size");
@@ -116,6 +117,7 @@ final class ChannelsReadSupport {
meta.avaAr = parsedMeta.avaAr();
meta.avaSha256 = parsedMeta.avaSha256();
meta.avaSize = parsedMeta.avaSize();
meta.createdAtMs = e.timestamp * 1000L;
meta.metaUpdatedAtMs = e.timestamp * 1000L;
}
} else {
@@ -713,6 +715,7 @@ final class ChannelsReadSupport {
String avaAr = "";
String avaSha256 = "";
long avaSize = 0L;
long createdAtMs = 0L;
long metaUpdatedAtMs = 0L;
boolean deleted = false;
long deletedAtMs = 0L;
@@ -67,6 +67,7 @@ public class Net_GetChannelMessages_Handler implements JsonMessageHandler {
channel.setAvaSha256(meta.avaSha256);
channel.setAvaSize(meta.avaSize);
channel.setMetaUpdatedAtMs(meta.metaUpdatedAtMs);
channel.setCreatedAtMs(meta.createdAtMs);
channel.setChannelTypeCode(meta.channelTypeCode);
channel.setChannelTypeVersion(meta.channelTypeVersion);
channel.setSubscribersCount(loadSubscribersCount(c, ownerBch, lineCode, meta.channelTypeCode));
@@ -30,6 +30,7 @@ public class Net_GetChannelMessages_Response extends Net_Response {
private String avaSha256;
private Long avaSize;
private Long metaUpdatedAtMs;
private Long createdAtMs;
private Integer channelTypeCode;
private Integer channelTypeVersion;
private Integer subscribersCount;
@@ -65,6 +66,9 @@ public class Net_GetChannelMessages_Response extends Net_Response {
public Long getMetaUpdatedAtMs() { return metaUpdatedAtMs; }
public void setMetaUpdatedAtMs(Long metaUpdatedAtMs) { this.metaUpdatedAtMs = metaUpdatedAtMs; }
public Long getCreatedAtMs() { return createdAtMs; }
public void setCreatedAtMs(Long createdAtMs) { this.createdAtMs = createdAtMs; }
public Integer getChannelTypeCode() { return channelTypeCode; }
public void setChannelTypeCode(Integer channelTypeCode) { this.channelTypeCode = channelTypeCode; }
@@ -0,0 +1,14 @@
package server.files;
import org.eclipse.jetty.servlet.ServletContextHandler;
import org.eclipse.jetty.servlet.ServletHolder;
/** Регистрирует HTTP API публичного content-addressed хранилища. */
public final class PublicFileApiConfigurator {
private PublicFileApiConfigurator() {}
public static void register(ServletContextHandler context) {
context.addServlet(new ServletHolder(new PublicFileServlet()), "/files/*");
}
}
@@ -0,0 +1,407 @@
package server.files;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import server.logic.ws_protocol.Base64Ws;
import server.logic.ws_protocol.JSON.utils.AuthKeyUtils;
import shine.db.dao.ActiveSessionsDAO;
import shine.db.entities.ActiveSessionEntry;
import utils.config.AppConfig;
import utils.crypto.Ed25519Util;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;
import java.nio.file.AtomicMoveNotSupportedException;
import java.nio.file.FileAlreadyExistsException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.nio.file.attribute.PosixFilePermission;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.sql.SQLException;
import java.util.HexFormat;
import java.util.Objects;
import java.util.Set;
import java.util.regex.Pattern;
/**
* Публичное content-addressed хранилище SHiNE.
*
* Идентификатор объекта — lowercase hex SHA-256 исходных байтов. Сервер не хранит
* имя, расширение, MIME или владельца внутри пути файла. Одинаковые байты всех
* пользователей дедуплицируются в один объект: data/public-files/<sha256>.
*
* В production GET/HEAD /files/<sha256> рекомендуется отдавать Caddy напрямую с
* того же каталога и кэшировать Cloudflare. Этот servlet оставляет GET/HEAD как
* рабочий fallback; PUT всегда проходит через Java, с проверкой session-signature
* и повторным вычислением SHA-256 полученных байтов.
*/
public final class PublicFileServlet extends HttpServlet {
private static final ObjectMapper MAPPER = new ObjectMapper();
private static final Pattern FILE_ID_PATTERN = Pattern.compile("^[0-9a-f]{64}$");
private static final String HEADER_SESSION_ID = "X-Shine-Session-Id";
private static final String HEADER_TIME_MS = "X-Shine-Time-Ms";
private static final String HEADER_CONTENT_LENGTH = "X-Shine-Content-Length";
private static final String HEADER_SIGNATURE = "X-Shine-Signature";
private static final long DEFAULT_MAX_BYTES = 512L * 1024L * 1024L;
private static final long MAX_AUTH_SKEW_MS = 60_000L;
private final boolean enabled;
private final Path storageDir;
private final long maxBytes;
public PublicFileServlet() {
AppConfig config = AppConfig.getInstance();
this.enabled = readBoolean(config, "public.files.enabled", true);
this.storageDir = Path.of(readString(config, "public.files.storageDir", "data/public-files"))
.toAbsolutePath()
.normalize();
this.maxBytes = Math.max(1L, readLong(config, "public.files.maxBytes", DEFAULT_MAX_BYTES));
}
@Override
protected void doOptions(HttpServletRequest req, HttpServletResponse resp) {
applyCors(resp);
resp.setStatus(HttpServletResponse.SC_NO_CONTENT);
}
@Override
protected void doPut(HttpServletRequest req, HttpServletResponse resp) throws IOException {
applyCors(resp);
if (!enabled) {
writeError(resp, HttpServletResponse.SC_NOT_FOUND, "FILES_DISABLED", "Публичные файлы отключены на сервере");
return;
}
String fileId = extractFileId(req);
if (fileId == null) {
writeError(resp, HttpServletResponse.SC_BAD_REQUEST, "BAD_FILE_ID", "Ожидается lowercase SHA-256 в URL /files/<sha256>");
return;
}
UploadAuth auth;
try {
auth = readAndVerifyUploadAuth(req, fileId);
} catch (AuthFailure failure) {
writeError(resp, failure.httpStatus, failure.code, failure.getMessage());
return;
}
if (auth.declaredLength > maxBytes) {
writeError(resp, HttpServletResponse.SC_REQUEST_ENTITY_TOO_LARGE, "FILE_TOO_LARGE", "Файл превышает лимит сервера");
return;
}
Files.createDirectories(storageDir);
Path target = safeTarget(fileId);
if (target == null) {
writeError(resp, HttpServletResponse.SC_BAD_REQUEST, "BAD_FILE_ID", "Некорректный SHA-256 файла");
return;
}
if (Files.isRegularFile(target)) {
StoredObjectCheck stored = verifyStoredObject(target, fileId);
if (stored.valid()) {
if (stored.size() != auth.declaredLength) {
writeError(resp, HttpServletResponse.SC_CONFLICT, "FILE_ID_CONFLICT", "Файл с таким SHA-256 уже существует с другим размером");
return;
}
ensurePublicReadable(target);
writeUploadOk(resp, fileId, auth.declaredLength, true);
return;
}
Files.deleteIfExists(target);
}
Path temp = Files.createTempFile(storageDir, ".public-upload-", ".tmp");
boolean tempMoved = false;
try {
MessageDigest digest = sha256Digest();
long actualLength = 0L;
byte[] buffer = new byte[64 * 1024];
try (InputStream in = req.getInputStream(); OutputStream out = Files.newOutputStream(temp)) {
int read;
while ((read = in.read(buffer)) >= 0) {
if (read == 0) continue;
actualLength += read;
if (actualLength > maxBytes || actualLength > auth.declaredLength) {
writeError(resp, HttpServletResponse.SC_REQUEST_ENTITY_TOO_LARGE, "FILE_TOO_LARGE", "Получено больше байтов, чем разрешено");
return;
}
digest.update(buffer, 0, read);
out.write(buffer, 0, read);
}
}
if (actualLength != auth.declaredLength) {
writeError(resp, HttpServletResponse.SC_BAD_REQUEST, "LENGTH_MISMATCH", "Размер загруженного файла не совпал с подписанным размером");
return;
}
String actualId = HexFormat.of().formatHex(digest.digest());
if (!Objects.equals(fileId, actualId)) {
writeError(resp, HttpServletResponse.SC_BAD_REQUEST, "HASH_MISMATCH", "SHA-256 полученных байтов не совпал с адресом файла");
return;
}
boolean alreadyExists = false;
try {
try {
Files.move(temp, target, StandardCopyOption.ATOMIC_MOVE);
} catch (AtomicMoveNotSupportedException ignored) {
Files.move(temp, target);
}
tempMoved = true;
} catch (FileAlreadyExistsException race) {
StoredObjectCheck stored = verifyStoredObject(target, fileId);
if (stored.valid() && stored.size() == actualLength) {
alreadyExists = true;
} else {
Files.deleteIfExists(target);
try {
Files.move(temp, target, StandardCopyOption.ATOMIC_MOVE);
} catch (AtomicMoveNotSupportedException ignored) {
Files.move(temp, target);
}
tempMoved = true;
}
}
ensurePublicReadable(target);
writeUploadOk(resp, fileId, actualLength, alreadyExists);
} finally {
if (!tempMoved) Files.deleteIfExists(temp);
}
}
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
serveFile(req, resp, false);
}
@Override
protected void doHead(HttpServletRequest req, HttpServletResponse resp) throws IOException {
serveFile(req, resp, true);
}
private void serveFile(HttpServletRequest req, HttpServletResponse resp, boolean headOnly) throws IOException {
applyCors(resp);
if (!enabled) {
writeError(resp, HttpServletResponse.SC_NOT_FOUND, "FILES_DISABLED", "Публичные файлы отключены на сервере");
return;
}
String fileId = extractFileId(req);
Path target = fileId == null ? null : safeTarget(fileId);
if (target == null || !Files.isRegularFile(target)) {
writeError(resp, HttpServletResponse.SC_NOT_FOUND, "FILE_NOT_FOUND", "Файл не найден");
return;
}
StoredObjectCheck stored = verifyStoredObject(target, fileId);
if (!stored.valid()) {
Files.deleteIfExists(target);
writeError(resp, HttpServletResponse.SC_NOT_FOUND, "FILE_NOT_FOUND", "Файл не найден");
return;
}
resp.setStatus(HttpServletResponse.SC_OK);
resp.setContentType("application/octet-stream");
resp.setHeader("Content-Length", Long.toString(stored.size()));
resp.setHeader("ETag", "\"" + fileId + "\"");
resp.setHeader("Cache-Control", "public, max-age=31536000, immutable");
resp.setHeader("Cross-Origin-Resource-Policy", "cross-origin");
if (!headOnly) {
try (InputStream in = Files.newInputStream(target); OutputStream out = resp.getOutputStream()) {
in.transferTo(out);
}
}
}
private static StoredObjectCheck verifyStoredObject(Path target, String expectedFileId) throws IOException {
MessageDigest digest = sha256Digest();
long size = 0L;
byte[] buffer = new byte[64 * 1024];
try (InputStream in = Files.newInputStream(target)) {
int read;
while ((read = in.read(buffer)) >= 0) {
if (read == 0) continue;
size += read;
digest.update(buffer, 0, read);
}
}
String actual = HexFormat.of().formatHex(digest.digest());
return new StoredObjectCheck(Objects.equals(expectedFileId, actual), size);
}
private UploadAuth readAndVerifyUploadAuth(HttpServletRequest req, String fileId) throws AuthFailure {
String sessionId = requiredHeader(req, HEADER_SESSION_ID);
String timeRaw = requiredHeader(req, HEADER_TIME_MS);
String lengthRaw = requiredHeader(req, HEADER_CONTENT_LENGTH);
String signatureRaw = requiredHeader(req, HEADER_SIGNATURE);
long timeMs;
long declaredLength;
try {
timeMs = Long.parseLong(timeRaw);
declaredLength = Long.parseLong(lengthRaw);
} catch (NumberFormatException badNumber) {
throw new AuthFailure(HttpServletResponse.SC_BAD_REQUEST, "BAD_UPLOAD_HEADERS", "Некорректные числовые заголовки загрузки");
}
if (declaredLength <= 0L) {
throw new AuthFailure(HttpServletResponse.SC_BAD_REQUEST, "BAD_UPLOAD_LENGTH", "Файл должен содержать хотя бы один байт");
}
long nowMs = System.currentTimeMillis();
if (timeMs < nowMs - MAX_AUTH_SKEW_MS || timeMs > nowMs + MAX_AUTH_SKEW_MS) {
throw new AuthFailure(HttpServletResponse.SC_UNAUTHORIZED, "UPLOAD_AUTH_EXPIRED", "Подпись загрузки устарела");
}
ActiveSessionEntry session;
try {
session = ActiveSessionsDAO.getInstance().getBySessionId(sessionId);
} catch (SQLException dbError) {
throw new AuthFailure(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "SESSION_LOOKUP_FAILED", "Не удалось проверить пользовательскую сессию");
}
if (session == null || session.getSessionKey() == null || session.getSessionKey().isBlank()) {
throw new AuthFailure(HttpServletResponse.SC_UNAUTHORIZED, "SESSION_NOT_FOUND", "Активная сессия не найдена");
}
byte[] signature;
byte[] publicKey;
try {
signature = Base64Ws.decodeLen(signatureRaw, Ed25519Util.SIGNATURE_LEN, "signature");
publicKey = AuthKeyUtils.parseEd25519PublicKey(session.getSessionKey(), "sessionKey");
} catch (RuntimeException badKey) {
throw new AuthFailure(HttpServletResponse.SC_UNAUTHORIZED, "BAD_UPLOAD_SIGNATURE", "Некорректная подпись загрузки");
}
String preimage = uploadPreimage(sessionId, fileId, declaredLength, timeMs);
if (!Ed25519Util.verify(preimage.getBytes(StandardCharsets.UTF_8), signature, publicKey)) {
throw new AuthFailure(HttpServletResponse.SC_UNAUTHORIZED, "BAD_UPLOAD_SIGNATURE", "Подпись загрузки не прошла проверку");
}
return new UploadAuth(declaredLength);
}
private static String uploadPreimage(String sessionId, String fileId, long size, long timeMs) {
return "PUBLIC_FILE_UPLOAD_V1:" + sessionId + ':' + fileId + ':' + size + ':' + timeMs;
}
private String extractFileId(HttpServletRequest req) {
String pathInfo = String.valueOf(req.getPathInfo() == null ? "" : req.getPathInfo()).trim();
if (!pathInfo.startsWith("/") || pathInfo.indexOf('/', 1) >= 0) return null;
String fileId = pathInfo.substring(1);
return FILE_ID_PATTERN.matcher(fileId).matches() ? fileId : null;
}
private Path safeTarget(String fileId) {
if (fileId == null || !FILE_ID_PATTERN.matcher(fileId).matches()) return null;
Path target = storageDir.resolve(fileId).normalize();
return target.getParent() != null && target.getParent().equals(storageDir) ? target : null;
}
private static String requiredHeader(HttpServletRequest req, String name) throws AuthFailure {
String value = req.getHeader(name);
if (value == null || value.isBlank()) {
throw new AuthFailure(HttpServletResponse.SC_UNAUTHORIZED, "MISSING_UPLOAD_AUTH", "Не хватает заголовка " + name);
}
return value.trim();
}
private static void ensurePublicReadable(Path target) throws IOException {
try {
Files.setPosixFilePermissions(target, Set.of(
PosixFilePermission.OWNER_READ,
PosixFilePermission.OWNER_WRITE,
PosixFilePermission.GROUP_READ,
PosixFilePermission.OTHERS_READ
));
} catch (UnsupportedOperationException ignored) {
// Не-POSIX FS: доступом управляет сама файловая система.
}
}
private static MessageDigest sha256Digest() throws IOException {
try {
return MessageDigest.getInstance("SHA-256");
} catch (NoSuchAlgorithmException impossible) {
throw new IOException("SHA-256 недоступен", impossible);
}
}
private static boolean readBoolean(AppConfig config, String key, boolean fallback) {
String value = config.getParam(key);
return value == null || value.isBlank() ? fallback : Boolean.parseBoolean(value.trim());
}
private static long readLong(AppConfig config, String key, long fallback) {
String value = config.getParam(key);
if (value == null || value.isBlank()) return fallback;
try {
return Long.parseLong(value.trim());
} catch (NumberFormatException ignored) {
return fallback;
}
}
private static String readString(AppConfig config, String key, String fallback) {
String value = config.getParam(key);
return value == null || value.isBlank() ? fallback : value.trim();
}
private static void applyCors(HttpServletResponse resp) {
resp.setHeader("Access-Control-Allow-Origin", "*");
resp.setHeader("Access-Control-Allow-Methods", "GET, HEAD, PUT, OPTIONS");
resp.setHeader("Access-Control-Allow-Headers",
"Content-Type, X-Shine-Session-Id, X-Shine-Time-Ms, X-Shine-Content-Length, X-Shine-Signature");
resp.setHeader("Access-Control-Expose-Headers", "Content-Length, ETag");
resp.setHeader("Vary", "Origin");
}
private static void writeUploadOk(HttpServletResponse resp, String fileId, long size, boolean alreadyExists) throws IOException {
ObjectNode payload = MAPPER.createObjectNode();
payload.put("ok", true);
payload.put("fileId", fileId);
payload.put("sha256", fileId);
payload.put("size", size);
payload.put("alreadyExists", alreadyExists);
writeJson(resp, HttpServletResponse.SC_OK, payload);
}
private static void writeError(HttpServletResponse resp, int status, String code, String message) throws IOException {
ObjectNode payload = MAPPER.createObjectNode();
payload.put("ok", false);
payload.put("error", code);
payload.put("message", message);
writeJson(resp, status, payload);
}
private static void writeJson(HttpServletResponse resp, int status, ObjectNode payload) throws IOException {
resp.setStatus(status);
resp.setCharacterEncoding(StandardCharsets.UTF_8.name());
resp.setContentType("application/json;charset=UTF-8");
MAPPER.writeValue(resp.getOutputStream(), payload);
}
private record StoredObjectCheck(boolean valid, long size) {}
private record UploadAuth(long declaredLength) {}
private static final class AuthFailure extends Exception {
private final int httpStatus;
private final String code;
private AuthFailure(int httpStatus, String code, String message) {
super(message);
this.httpStatus = httpStatus;
this.code = code;
}
}
}
@@ -11,6 +11,7 @@ import server.archive.ArweaveBlockPublisherScheduler;
import server.archive.ArweaveBlockSyncScheduler;
import server.debug.DebugApiConfigurator;
import server.files.DmFileApiConfigurator;
import server.files.PublicFileApiConfigurator;
import server.sync.PeriodicBlockchainSyncService;
import server.sync.PeriodicDmDeliveryService;
import server.sync.SolanaUsersSyncStartupService;
@@ -82,6 +83,10 @@ public final class WsServer {
// Зашифрованные вложения личных сообщений: PUT/GET /dm-files/{sha256-base58}
DmFileApiConfigurator.register(context);
// Публичные immutable-вложения каналов: PUT/GET/HEAD /files/{sha256-hex}.
// В production GET/HEAD может перехватывать Caddy и отдавать файл прямо с диска.
PublicFileApiConfigurator.register(context);
// Инициализация контейнера WebSocket
JettyWebSocketServletContainerInitializer.configure(context, (servletContext, wsContainer) -> {
// Таймаут простоя соединения (Jetty 11 синтаксис)
@@ -72,6 +72,15 @@ dm.files.storageDir=data/dm-files
# Значение 50 MiB сохранено для совместимости с DM file v1.
dm.files.maxBytes=52428816
# ================================
# Public immutable file storage
# ================================
# Исходные байты публичного вложения. Имя файла = lowercase hex SHA-256(bytes).
# GET/HEAD работает через Java даже без Caddy; в production можно отдать этот путь напрямую Caddy.
public.files.enabled=true
public.files.storageDir=data/public-files
public.files.maxBytes=536870912
webpush.vapid.public=BOdoWZndZRaNe9kyUFsJ5-xEfFABXNKennAKg15Z7ycAwUIQ7yDV_sIWWYJCwJriN4g9oU-CyJPrn1U6lfxuDbI
webpush.vapid.private=3hCt7XxTvLzuoxinjT5QcKRQEBnGZHXn8ZilU31RPNE
webpush.vapid.subject=mailto:admin@shine.local