SHA256
Вложения файлов со своего сервера доступа пользователя
This commit is contained in:
+4
-1
@@ -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;
|
||||
|
||||
+1
@@ -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));
|
||||
|
||||
+4
@@ -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
|
||||
|
||||
Reference in New Issue
Block a user