SHA256
Поддержать range-загрузку публичных файлов
This commit is contained in:
@@ -14,11 +14,15 @@ import utils.crypto.Ed25519Util;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.nio.ByteBuffer;
|
||||
import java.nio.channels.FileChannel;
|
||||
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.LinkOption;
|
||||
import java.nio.file.StandardOpenOption;
|
||||
import java.nio.file.Path;
|
||||
import java.nio.file.StandardCopyOption;
|
||||
import java.nio.file.attribute.PosixFilePermission;
|
||||
@@ -37,10 +41,10 @@ import java.util.regex.Pattern;
|
||||
* имя, расширение, MIME или владельца внутри пути файла. Одинаковые байты всех
|
||||
* пользователей дедуплицируются в один объект: data/public-files/<sha256>.
|
||||
*
|
||||
* В production GET/HEAD /files/<sha256> рекомендуется отдавать Caddy напрямую с
|
||||
* того же каталога и кэшировать Cloudflare. Этот servlet оставляет GET/HEAD как
|
||||
* рабочий fallback; PUT всегда проходит через Java, с проверкой session-signature
|
||||
* и повторным вычислением SHA-256 полученных байтов.
|
||||
* GET поддерживает HTTP Range для потокового просмотра видео без полной загрузки.
|
||||
* Проверка SHA-256 выполняется при PUT; GET/HEAD читают метаданные файла без
|
||||
* повторного хеширования всего содержимого. Caddy также может отдавать immutable
|
||||
* файлы напрямую, если настроен на корректную выдачу байтовых диапазонов и MIME.
|
||||
*/
|
||||
public final class PublicFileServlet extends HttpServlet {
|
||||
|
||||
@@ -202,29 +206,118 @@ public final class PublicFileServlet extends HttpServlet {
|
||||
|
||||
String fileId = extractFileId(req);
|
||||
Path target = fileId == null ? null : safeTarget(fileId);
|
||||
if (target == null || !Files.isRegularFile(target)) {
|
||||
// Не следуем по символическим ссылкам: без повторной проверки хеша GET не должен
|
||||
// иметь возможность прочитать посторонний файл из-за подмены пути.
|
||||
if (target == null || !Files.isRegularFile(target, LinkOption.NOFOLLOW_LINKS)) {
|
||||
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 + "\"");
|
||||
long size = Files.size(target);
|
||||
String etag = "\"" + fileId + "\"";
|
||||
resp.setHeader("ETag", etag);
|
||||
resp.setHeader("Accept-Ranges", "bytes");
|
||||
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);
|
||||
resp.setContentType(detectContentType(target));
|
||||
|
||||
// По HTTP заголовок Range относится к GET. Для HEAD отдаём обычные
|
||||
// метаданные целого объекта, что нужно в том числе проверке вложений в UI.
|
||||
String rangeHeader = headOnly ? null : req.getHeader("Range");
|
||||
String ifRange = req.getHeader("If-Range");
|
||||
if (rangeHeader != null && ifRange != null && !ifRange.trim().equals(etag)) {
|
||||
rangeHeader = null; // неподтверждённая версия: отправляем обычный 200
|
||||
}
|
||||
ByteRange range = null;
|
||||
if (rangeHeader != null) {
|
||||
range = parseSingleRange(rangeHeader, size);
|
||||
if (range == null) {
|
||||
resp.setStatus(HttpServletResponse.SC_REQUESTED_RANGE_NOT_SATISFIABLE);
|
||||
resp.setHeader("Content-Range", "bytes */" + size);
|
||||
resp.setHeader("Content-Length", "0");
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
long firstByte = range == null ? 0L : range.start();
|
||||
long byteCount = range == null ? size : range.length();
|
||||
resp.setStatus(range == null ? HttpServletResponse.SC_OK : HttpServletResponse.SC_PARTIAL_CONTENT);
|
||||
resp.setHeader("Content-Length", Long.toString(byteCount));
|
||||
if (range != null) resp.setHeader("Content-Range", "bytes " + range.start() + "-" + range.end() + "/" + size);
|
||||
if (headOnly || byteCount == 0) return;
|
||||
|
||||
// Файловый канал позиционируется в начале запрошенного участка — не читаем
|
||||
// все предыдущие байты и не буферизуем видео целиком в памяти.
|
||||
try (FileChannel channel = FileChannel.open(target, StandardOpenOption.READ, LinkOption.NOFOLLOW_LINKS)) {
|
||||
channel.position(firstByte);
|
||||
OutputStream out = resp.getOutputStream();
|
||||
byte[] buffer = new byte[64 * 1024];
|
||||
long remaining = byteCount;
|
||||
while (remaining > 0) {
|
||||
ByteBuffer chunk = ByteBuffer.wrap(buffer, 0, (int) Math.min(buffer.length, remaining));
|
||||
int read = channel.read(chunk);
|
||||
if (read < 0) break; // файл мог быть удалён/усечён во время чтения
|
||||
if (read == 0) continue;
|
||||
out.write(buffer, 0, read);
|
||||
remaining -= read;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Поддерживается один диапазон (стандартные запросы браузерных <video>).
|
||||
// Некорректные, составные или не удовлетворяемые диапазоны отвечают 416.
|
||||
static ByteRange parseSingleRange(String header, long size) {
|
||||
if (header == null || !header.startsWith("bytes=") || size <= 0) return null;
|
||||
String value = header.substring("bytes=".length()).trim();
|
||||
if (value.indexOf(',') >= 0) return null;
|
||||
int dash = value.indexOf('-');
|
||||
if (dash < 0 || dash != value.lastIndexOf('-')) return null;
|
||||
String first = value.substring(0, dash).trim();
|
||||
String last = value.substring(dash + 1).trim();
|
||||
if (first.isEmpty() && last.isEmpty()) return null;
|
||||
try {
|
||||
if (first.isEmpty()) {
|
||||
long suffixBytes = Long.parseLong(last);
|
||||
if (suffixBytes <= 0) return null;
|
||||
return new ByteRange(size - Math.min(suffixBytes, size), size - 1);
|
||||
}
|
||||
long start = Long.parseLong(first);
|
||||
if (start < 0 || start >= size) return null;
|
||||
long end = last.isEmpty() ? size - 1 : Long.parseLong(last);
|
||||
if (end < start) return null;
|
||||
return new ByteRange(start, Math.min(end, size - 1));
|
||||
} catch (NumberFormatException ignored) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
// Объекты на диске не имеют расширений. Тип распознаём по сигнатуре первых
|
||||
// байтов; обычные файлы по-прежнему отдаются как application/octet-stream.
|
||||
private static String detectContentType(Path target) throws IOException {
|
||||
byte[] signature = new byte[16];
|
||||
int count;
|
||||
try (InputStream in = Files.newInputStream(target, LinkOption.NOFOLLOW_LINKS)) {
|
||||
count = in.read(signature);
|
||||
}
|
||||
if (count >= 12 && signature[4] == 'f' && signature[5] == 't'
|
||||
&& signature[6] == 'y' && signature[7] == 'p') {
|
||||
return "video/mp4";
|
||||
}
|
||||
if (count >= 4 && (signature[0] & 0xff) == 0x1a && (signature[1] & 0xff) == 0x45
|
||||
&& (signature[2] & 0xff) == 0xdf && (signature[3] & 0xff) == 0xa3) {
|
||||
return "video/webm";
|
||||
}
|
||||
if (count >= 4 && signature[0] == 'O' && signature[1] == 'g'
|
||||
&& signature[2] == 'g' && signature[3] == 'S') return "video/ogg";
|
||||
if (count >= 12 && signature[0] == 'R' && signature[1] == 'I'
|
||||
&& signature[2] == 'F' && signature[3] == 'F'
|
||||
&& signature[8] == 'A' && signature[9] == 'V'
|
||||
&& signature[10] == 'I' && signature[11] == ' ') return "video/x-msvideo";
|
||||
return "application/octet-stream";
|
||||
}
|
||||
|
||||
record ByteRange(long start, long end) {
|
||||
long length() { return end - start + 1; }
|
||||
}
|
||||
|
||||
private static StoredObjectCheck verifyStoredObject(Path target, String expectedFileId) throws IOException {
|
||||
@@ -361,8 +454,8 @@ public final class PublicFileServlet extends HttpServlet {
|
||||
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");
|
||||
"Content-Type, Range, If-Range, X-Shine-Session-Id, X-Shine-Time-Ms, X-Shine-Content-Length, X-Shine-Signature");
|
||||
resp.setHeader("Access-Control-Expose-Headers", "Content-Length, ETag, Accept-Ranges, Content-Range, Content-Type");
|
||||
resp.setHeader("Vary", "Origin");
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,39 @@
|
||||
package server.files;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
class PublicFileRangeTest {
|
||||
|
||||
private static void assertRange(String header, long size, long start, long end) {
|
||||
PublicFileServlet.ByteRange range = PublicFileServlet.parseSingleRange(header, size);
|
||||
assertNotNull(range);
|
||||
assertEquals(start, range.start());
|
||||
assertEquals(end, range.end());
|
||||
assertEquals(end - start + 1, range.length());
|
||||
}
|
||||
|
||||
@Test
|
||||
void readsExplicitOpenAndSuffixRanges() {
|
||||
assertRange("bytes=0-1023", 2048, 0, 1023);
|
||||
assertRange("bytes=1024-", 2048, 1024, 2047);
|
||||
assertRange("bytes=-256", 2048, 1792, 2047);
|
||||
assertRange("bytes=-4096", 2048, 0, 2047);
|
||||
assertRange("bytes=2047-9999", 2048, 2047, 2047);
|
||||
assertRange("bytes=0-0", 2048, 0, 0);
|
||||
assertRange("bytes=0-0", 1, 0, 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
void rejectsUnsatisfiableAndMalformedRanges() {
|
||||
for (String header : new String[] {
|
||||
"bytes=2048-", "bytes=2000-1999", "bytes=-0", "bytes=-", "bytes=0-1,10-20",
|
||||
"bytes=a-b", "bytes=-9223372036854775808", "bytes=9223372036854775808-",
|
||||
"items=0-1", "bytes=-1-2", "bytes=0--1"
|
||||
}) {
|
||||
assertNull(PublicFileServlet.parseSingleRange(header, 2048), header);
|
||||
}
|
||||
assertNull(PublicFileServlet.parseSingleRange("bytes=0-0", 0));
|
||||
}
|
||||
}
|
||||
+2
-2
@@ -1,2 +1,2 @@
|
||||
client.version=1.16.0
|
||||
server.version=1.13.0
|
||||
client.version=1.17.0
|
||||
server.version=1.14.0
|
||||
|
||||
@@ -37,6 +37,28 @@ chmod 755 /home/player/shine-public-files
|
||||
|
||||
## 2. Caddyfile
|
||||
|
||||
### Вариант A: GET/HEAD/PUT через Java (надежный MIME и HTTP Range)
|
||||
|
||||
Для запуска предпросмотра видео проще всего добавить **в каждый site block**
|
||||
(`shineup.me`, `:80` и соответствующие тестовые домены) до общего SPA `handle`:
|
||||
|
||||
```caddyfile
|
||||
@shinePublicFiles path_regexp shine_public_file ^/files/[0-9a-f]{64}$
|
||||
handle @shinePublicFiles {
|
||||
reverse_proxy 127.0.0.1:7070
|
||||
}
|
||||
```
|
||||
|
||||
Java проверяет подпись/хеш при PUT, а при GET поддерживает `206`, Range,
|
||||
`Accept-Ranges`, `Content-Range`, узнаёт MP4/WebM по сигнатуре и отдаёт
|
||||
байты потоково без SHA-256 проверки при каждом скачивании. Маршрут должен
|
||||
располагаться раньше SPA fallback; иначе `/files/<sha256>` может получить HTML.
|
||||
Проверьте порт Java-сервера (в примере `7070`). Для больших потоков это
|
||||
проще в настройке, но нагружает Java больше, чем прямая раздача Caddy.
|
||||
|
||||
### Вариант B: прямая отдача Caddy (лучше для большого трафика)
|
||||
|
||||
|
||||
Маршруты `/files/*` должны стоять **до SPA fallback**.
|
||||
|
||||
```caddyfile
|
||||
@@ -92,7 +114,7 @@ shineup.me {
|
||||
|
||||
Если используется отдельный `:80` site block, тот же `/files` routing нужно добавить и туда либо перенаправлять HTTP на HTTPS.
|
||||
|
||||
После изменения:
|
||||
После изменения любого варианта:
|
||||
|
||||
```bash
|
||||
sudo caddy validate --config /etc/caddy/Caddyfile
|
||||
@@ -142,6 +164,9 @@ UI дополнительно уже отправляет `Cache-Control: no-sto
|
||||
|
||||
```bash
|
||||
curl -I https://shineup.me/files/<sha256>
|
||||
curl -i -H 'Range: bytes=0-1023' https://shineup.me/files/<sha256> -o /dev/null -D -
|
||||
# Ожидается: HTTP 206, Content-Range: bytes 0-1023/<size>, Content-Length: 1024
|
||||
# Без Range: 200; Range: bytes=999999999999- : 416 + Content-Range: bytes */<size>
|
||||
```
|
||||
|
||||
Ожидается:
|
||||
|
||||
@@ -65,19 +65,55 @@ SHA256(received bytes) == sha256 из URL
|
||||
|
||||
Если корректный объект уже существует и размер совпадает, PUT идемпотентно отвечает `alreadyExists=true`.
|
||||
|
||||
## 4. GET и HEAD
|
||||
## 4. GET и HEAD (включая HTTP Range)
|
||||
|
||||
Java servlet умеет `GET` и `HEAD` как fallback. В production рекомендуется не пропускать чтение через Java: Caddy должен отдавать файл непосредственно с диска.
|
||||
Java servlet обслуживает `GET /files/<sha256>` и `HEAD /files/<sha256>`.
|
||||
Проверка SHA-256 **при чтении не выполняется**: хеш проверяется при исходном PUT,
|
||||
файл immutable, а скачивание не должно требовать предварительного прочтения всех байтов.
|
||||
Проверка корректности при повторном PUT уже имеющегося объекта сохранена.
|
||||
|
||||
Ответ immutable:
|
||||
Полный GET, как и прежде, возвращает `200 OK` и `Content-Length` всего файла.
|
||||
HEAD всегда возвращает метаданные **полного объекта** без тела и без обхода
|
||||
всего файла по байтам (Range в HEAD игнорируется).
|
||||
|
||||
```text
|
||||
Cache-Control: public, max-age=31536000, immutable
|
||||
ETag: "<sha256>"
|
||||
Content-Type: application/octet-stream
|
||||
Для `GET` с одним диапазоном:
|
||||
|
||||
```http
|
||||
Range: bytes=0-262143
|
||||
```
|
||||
|
||||
Файловое хранилище не определяет тип контента. Официальный клиент решает, как интерпретировать байты, на основании имени `nm` из `S:att`. Если пользователь указал неверное расширение или положил неподходящие байты, клиент просто не сможет отобразить такой media-файл.
|
||||
Ответ:
|
||||
|
||||
```http
|
||||
HTTP/1.1 206 Partial Content
|
||||
Accept-Ranges: bytes
|
||||
Content-Range: bytes 0-262143/<общий размер>
|
||||
Content-Length: 262144
|
||||
ETag: "<sha256>"
|
||||
```
|
||||
|
||||
Поддерживаются формы `bytes=START-END`, `bytes=START-` и `bytes=-SUFFIX`.
|
||||
Для составных или неудовлетворяемых диапазонов сервер возвращает `416` +
|
||||
`Content-Range: bytes */<общий размер>`. `If-Range` поддерживает точный
|
||||
совпадающий ETag; при несовпадении возвращается полный `200`.
|
||||
|
||||
Остальные заголовки:
|
||||
|
||||
```http
|
||||
Cache-Control: public, max-age=31536000, immutable
|
||||
Cross-Origin-Resource-Policy: cross-origin
|
||||
Access-Control-Allow-Origin: *
|
||||
```
|
||||
|
||||
Тип для MP4, WebM, Ogg и AVI Java определяет по первым байтам файла.
|
||||
Неизвестные типы остаются `application/octet-stream`. Протокол `S:att`
|
||||
не меняется, имя файла/тип на сервере не сохраняются.
|
||||
|
||||
При прямой выдаче Caddy (`file_server`) Range обеспечивает Caddy, а не Java.
|
||||
Следует проверить `Content-Type` (у файлов с именем SHA-256 нет расширения),
|
||||
а также корректность ответа `206` через публичный домен, особенно с CDN.
|
||||
Если нужен корректный MIME по сигнатуре, используйте HTTP reverse_proxy к Java
|
||||
из инструкции `deploy/PUBLIC_FILES_CADDY_CLOUDFLARE.md`.
|
||||
|
||||
## 5. Связь с `S:att`
|
||||
|
||||
@@ -101,4 +137,6 @@ https://<current-access-server>/files/<sha256>
|
||||
|
||||
## 6. Preview
|
||||
|
||||
В UI видео со storage=server получает прямую ссылку `/files/<sha256>` (без полного `fetch` в Blob): браузер сам запрашивает диапазоны, читает длительность и загружает стартовый кадр. Размер берётся из `sz` вложения. Для Arweave частичная загрузка зависит от gateway.
|
||||
|
||||
Отдельных preview-файлов сейчас нет. `preAr`, `preSha256`, `previewAr`, `previewSha256` не являются частью текущего протокола.
|
||||
|
||||
@@ -214,6 +214,17 @@ function createFileCard({ item, url, messageTimestampMs, slide }) {
|
||||
return card;
|
||||
}
|
||||
|
||||
function formatVideoDuration(seconds) {
|
||||
if (!Number.isFinite(seconds) || seconds < 0) return '';
|
||||
const wholeSeconds = Math.floor(seconds);
|
||||
const hours = Math.floor(wholeSeconds / 3600);
|
||||
const minutes = Math.floor((wholeSeconds % 3600) / 60);
|
||||
const secondsPart = String(wholeSeconds % 60).padStart(2, '0');
|
||||
return hours > 0
|
||||
? `${hours}:${String(minutes).padStart(2, '0')}:${secondsPart}`
|
||||
: `${String(minutes).padStart(2, '0')}:${secondsPart}`;
|
||||
}
|
||||
|
||||
function createMediaSlide({ item, url, kind, messageTimestampMs, slide, onOpen }) {
|
||||
const frame = document.createElement('div');
|
||||
frame.className = `message-attachment-media-frame message-attachment-media-frame--${kind}`;
|
||||
@@ -261,10 +272,26 @@ function createMediaSlide({ item, url, kind, messageTimestampMs, slide, onOpen }
|
||||
video.playsInline = true;
|
||||
video.addEventListener('error', () => replaceWithUnavailable(slide, messageTimestampMs, attachmentStorage(item)), { once: true });
|
||||
video.addEventListener('loadeddata', () => frame.classList.add('is-loaded'), { once: true });
|
||||
|
||||
// Размер известен из S:att, длительность появляется после получения метаданных.
|
||||
// <video> сам запрашивает небольшие диапазоны через HTTP Range, без fetch всего файла.
|
||||
const info = document.createElement('span');
|
||||
info.className = 'message-attachment-video-info';
|
||||
const videoSize = formatBytes(item.size);
|
||||
info.textContent = videoSize;
|
||||
video.addEventListener('loadedmetadata', () => {
|
||||
const duration = formatVideoDuration(video.duration);
|
||||
info.textContent = duration ? `${videoSize} · ${duration}` : videoSize;
|
||||
// Metadata сама по себе не гарантирует первого кадра. Переход к самому
|
||||
// началу видео побуждает браузер запросить только нужные части файла.
|
||||
if (video.readyState < HTMLMediaElement.HAVE_CURRENT_DATA && Number.isFinite(video.duration) && video.duration > 0) {
|
||||
try { video.currentTime = Math.min(0.05, video.duration); } catch { /* зависит от кодека */ }
|
||||
}
|
||||
}, { once: true });
|
||||
const play = document.createElement('span');
|
||||
play.className = 'message-attachment-play';
|
||||
play.textContent = '▶';
|
||||
frame.append(video, play);
|
||||
frame.append(video, play, info);
|
||||
}
|
||||
|
||||
return frame;
|
||||
@@ -334,9 +361,11 @@ async function resolveAttachmentDisplayUrl(item, options = {}) {
|
||||
fallbackServerLogin: options.fallbackServerLogin,
|
||||
});
|
||||
const kind = getAttachmentKind(item);
|
||||
if (kind === 'file') return { url: serverUrl, objectUrl: false };
|
||||
// Видео подключаем напрямую. Иначе fetch + Blob + полный SHA-256 сначала
|
||||
// скачает ВСЕ байты и браузер не сможет запрашивать Range для просмотра.
|
||||
if (kind === 'video' || kind === 'file') return { url: serverUrl, objectUrl: false };
|
||||
|
||||
// /files хранит только байты и SHA-256. Для media тип задаёт клиент по имени из S:att.
|
||||
// Для изображений сохраняем прежнюю проверку SHA-256 после скачивания.
|
||||
const response = await fetch(serverUrl);
|
||||
if (!response.ok) throw new Error(`HTTP ${response.status} ${serverUrl}`);
|
||||
const buffer = await response.arrayBuffer();
|
||||
|
||||
@@ -118,6 +118,25 @@
|
||||
}
|
||||
|
||||
|
||||
.message-attachment-video-info {
|
||||
position: absolute;
|
||||
top: 0.65rem;
|
||||
right: 0.65rem;
|
||||
z-index: 1;
|
||||
max-width: calc(100% - 1.3rem);
|
||||
padding: 0.3rem 0.55rem;
|
||||
border-radius: 0.5rem;
|
||||
background: rgb(0 0 0 / 70%);
|
||||
color: #fff;
|
||||
font-size: 0.75rem;
|
||||
font-variant-numeric: tabular-nums;
|
||||
line-height: 1.2;
|
||||
white-space: nowrap;
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
pointer-events: none;
|
||||
}
|
||||
|
||||
.message-attachment-play {
|
||||
align-items: center;
|
||||
background: var(--surface);
|
||||
|
||||
Reference in New Issue
Block a user