Перевести вложения DM на R2 и обновить файловый API

This commit is contained in:
AidarKC
2026-11-15 14:33:52 +03:00
parent 3ecec25fce
commit 70540ff041
23 changed files with 770 additions and 202 deletions
+65
View File
@@ -0,0 +1,65 @@
# SHiNE — патч DM R2 v3 (15.11.2026)
## Основа патча
Накладывать **поверх версии проекта с применённым патчем** `SHiNE-R2-public-MVP-patch-2026.11.14.zip` на архив `SHiNE-bundle-2026.11.14-13.22.24.zip` (либо поверх более новой версии, совместимой с этими серверными API).
Патч **не заменяет** изменённый после предыдущей работы `attachment-format.js` и не трогает новую публичную загрузку, Arweave и аватары.
## Что изменилось
- **Новые DM**: формат `S:file;v=3`, root manifest и AES-256-GCM-шифрование отдельных кусков до 8 МиБ, id = Base58(SHA-256(ciphertext)); **никаких новых BitTorrent/Merkle-хешей**.
- Клиент отправляет JSON `fileId, size` на `POST /api/dm-files/prepare` со старым session key Ed25519 и отдельным доменом подписи `DM_R2_PREPARE_V1`.
- Java подписывает PUT только в корзину `shine-dm`. Ciphertext загружается браузером **напрямую** в S3 endpoint R2. PUT использует `If-None-Match: *`; `Content-Type: application/octet-stream`.
- Скачивание напрямую `https://dm-files.shineup.me/<fileId>` по публичной ссылке; получатель перед расшифровкой проверяет SHA-256/Base58 каждого объекта.
- Никакой ключ AES и исходный MIME в R2 не передаются, они находятся только в E2EE DM.
- **Чтение старых вложений v1 и v2** сохранено. В старых v2 BitTorrent ещё проверяется — исключительно ради совместимости. UI не показывает подпись BitTorrent для v3.
- Передача голосовых вложений использует тот же v3.
- Лимит одного исходного файла в MVP 500 МиБ, один ciphertext-объект ≤8 МиБ+16; нет S3 Multipart и нет строгой гарантии отсутствия повреждённого R2-объекта при первом недобросовестном PUT.
## Настройка Cloudflare
1. Проверьте, что корзина R2 **`shine-dm`** существует и пользовательский домен **`dm-files.shineup.me`** имеет статус **Active**.
2. К `shine-dm` применено **Object Lifecycle → Delete after 14 days → All objects**. По согласованной политике это очистка R2, не гарантия исчезновения CDN-копий.
3. У `shine-dm` установлен CORS для `https://shineup.me` (и реально используемых клиентских доменов). Methods `GET`, `HEAD`, `PUT`; Headers `*`; Expose `Content-Length`, `ETag`.
4. R2 API credential server имеет права **Object Read & Write** для **`shine-files` и `shine-dm`**. Никакие ключи не передаются в UI.
## Настройка Java-сервера
В приватной конфигурации приложения:
```properties
r2.dmBucket=shine-dm
```
В переменных окружения сервиса Java (используются и публичным R2-модулем):
```text
R2_ENDPOINT=https://<account-id>.r2.cloudflarestorage.com
R2_ACCESS_KEY_ID=<серверный S3 Access Key ID>
R2_SECRET_ACCESS_KEY=<серверный S3 Secret Access Key>
```
В случае jurisdiction-specific endpoint использовать именно значение из Cloudflare. Не включать переменные в Git или клиентский JS. После применения патча обновить JAR и выполнить restart службы.
**Caddy / Nginx:** добавить точный маршрут `POST /api/dm-files/prepare` (и CORS OPTIONS на тот же URL) к той же Java/Jetty, которая обрабатывает `/ws` и публичный `/api/files/prepare`. Маршрут должен быть выше SPA fallback; `/dm-files/*` оставить для старых файлов v1/v2.
## Проверки
```bash
node scripts/tests/test-dm-r2-v3.mjs
node scripts/tests/test-r2-file-preparation.mjs
python3 scripts/check_docs.py
```
Нужно дополнительно сделать полноценную **Java-сборку и live R2 интеграционный тест на тестовом сервере**, поскольку в среде сборки этого патча Gradle не может скачать дистрибутив.
Рекомендуемый живой сценарий: отправить файл ~9 МиБ из личного чата; убедиться, что появились 2 ciphertext-части и 1 зашифрованный manifest в `shine-dm`, что ключи не попали в R2, а получатель скачал и открыл исходный файл. Затем проверить отправку голосового сообщения, файл 0 байт, файл около 500 МиБ, отсутствующую CORS-настройку и старую переписку v2.
### Ограничения перед production
- Нужны rate limits на выдачу подписанных URL и мониторинг расходов R2; сервер не проверяет байты против объявленного SHA-256 (это проверяет скачивающий клиент).
- `If-None-Match: *` запрещает перезапись уже существующего ID, но не предотвращает первоначальную загрузку неправильных байтов под этим ID.
- Старые клиенты **не умеют читать v3** — потребуется обновить клиентов обоих участников DM.
- Пропуск зашифрованного файла через Java не происходит, но Java подписывает каждую новую часть; возможны десятки prepare-запросов на одно крупное вложение.
- **Production deployment не выполнялся**.
@@ -10,5 +10,6 @@ public final class DmFileApiConfigurator {
public static void register(ServletContextHandler context) { public static void register(ServletContextHandler context) {
context.addServlet(new ServletHolder(new DmFileServlet()), "/dm-files/*"); context.addServlet(new ServletHolder(new DmFileServlet()), "/dm-files/*");
context.addServlet(new ServletHolder(new R2DmPrepareServlet()), "/api/dm-files/prepare");
} }
} }
@@ -247,6 +247,36 @@ public final class DmFileServlet extends HttpServlet {
private record StoredObjectCheck(boolean valid, long size) {} private record StoredObjectCheck(boolean valid, long size) {}
/** Проверка отдельной Ed25519-подписи запроса временной ссылки R2, без передачи ciphertext. */
static void verifyR2Prepare(HttpServletRequest req, String fileId, long encryptedSize) throws IOException {
String sessionId = req.getHeader(HEADER_SESSION_ID);
String timestamp = req.getHeader(HEADER_TIME_MS);
String signatureText = req.getHeader(HEADER_SIGNATURE);
if (sessionId == null || timestamp == null || signatureText == null) {
throw new SecurityException("Missing signed session headers");
}
try {
long timeMs = Long.parseLong(timestamp);
if (Math.abs(System.currentTimeMillis() - timeMs) > MAX_AUTH_SKEW_MS) {
throw new SecurityException("Expired signed request");
}
ActiveSessionEntry session = ActiveSessionsDAO.getInstance().getBySessionId(sessionId);
if (session == null || session.getSessionKey() == null || session.getSessionKey().isBlank()) {
throw new SecurityException("Session not found");
}
byte[] sig = Base64Ws.decodeLen(signatureText, Ed25519Util.SIGNATURE_LEN, "signature");
byte[] pub = AuthKeyUtils.parseEd25519PublicKey(session.getSessionKey(), "sessionKey");
String message = "DM_R2_PREPARE_V1:" + sessionId + ':' + fileId + ':' + encryptedSize + ':' + timeMs;
if (!Ed25519Util.verify(message.getBytes(StandardCharsets.UTF_8), sig, pub)) {
throw new SecurityException("Invalid signature");
}
} catch (SQLException e) {
throw new IOException("Session lookup failed", e);
} catch (RuntimeException e) {
throw new SecurityException("Invalid DM R2 authorization", e);
}
}
private UploadAuth readAndVerifyUploadAuth(HttpServletRequest req, String fileId) throws AuthFailure { private UploadAuth readAndVerifyUploadAuth(HttpServletRequest req, String fileId) throws AuthFailure {
String sessionId = requiredHeader(req, HEADER_SESSION_ID); String sessionId = requiredHeader(req, HEADER_SESSION_ID);
String timeRaw = requiredHeader(req, HEADER_TIME_MS); String timeRaw = requiredHeader(req, HEADER_TIME_MS);
@@ -0,0 +1,129 @@
package server.files;
import com.fasterxml.jackson.databind.JsonNode;
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 software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.HeadObjectRequest;
import software.amazon.awssdk.services.s3.model.PutObjectRequest;
import software.amazon.awssdk.services.s3.presigner.S3Presigner;
import software.amazon.awssdk.services.s3.presigner.model.PutObjectPresignRequest;
import utils.config.AppConfig;
import java.io.IOException;
import java.net.URI;
import java.time.Duration;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;
/**
* Выдача временных PUT в shine-dm. Сервер не получает ciphertext, AES-key и MIME исходного файла.
* Идентификатор объекта: Base58(SHA-256(ciphertext)); доступ к GET — по публичному домену R2.
*/
public final class R2DmPrepareServlet extends HttpServlet {
private static final ObjectMapper JSON = new ObjectMapper();
private static final Pattern FILE_ID = Pattern.compile("^[1-9A-HJ-NP-Za-km-z]{32,44}$");
private static final long MAX_OBJECT_BYTES = 8L * 1024L * 1024L + 16L;
private static final String CONTENT_TYPE = "application/octet-stream";
private static final String PUBLIC_BASE = "https://dm-files.shineup.me/";
@Override protected void doOptions(HttpServletRequest req, HttpServletResponse resp) {
cors(req, resp);
resp.setStatus(HttpServletResponse.SC_NO_CONTENT);
}
@Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
cors(req, resp);
try {
if (req.getContentLengthLong() > 2048) { fail(resp, 413, "Request too large"); return; }
JsonNode input = JSON.readTree(req.getInputStream());
if (input == null) { fail(resp, 400, "Missing JSON body"); return; }
String fileId = input.path("fileId").asText("").trim();
long size = input.path("size").asLong(-1L);
if (!FILE_ID.matcher(fileId).matches() || size < 16 || size > MAX_OBJECT_BYTES) {
fail(resp, 400, "Invalid ciphertext ID or size"); return;
}
try { DmFileServlet.verifyR2Prepare(req, fileId, size); }
catch (SecurityException denied) { fail(resp, 401, "Unauthorized"); return; }
String endpoint = setting("R2_ENDPOINT", "r2.endpoint");
String accessKey = setting("R2_ACCESS_KEY_ID", "r2.accessKeyId");
String secret = setting("R2_SECRET_ACCESS_KEY", "r2.secretAccessKey");
String bucket = AppConfig.getInstance().getParam("r2.dmBucket");
if (bucket == null || bucket.isBlank()) bucket = "shine-dm";
if (endpoint == null || accessKey == null || secret == null) {
fail(resp, 503, "R2 is not configured"); return;
}
var credentials = StaticCredentialsProvider.create(AwsBasicCredentials.create(accessKey, secret));
var apiEndpoint = URI.create(endpoint);
ObjectNode result = JSON.createObjectNode();
result.put("fileUrl", PUBLIC_BASE + fileId);
try (S3Client s3 = S3Client.builder().region(Region.of("auto"))
.endpointOverride(apiEndpoint).credentialsProvider(credentials).forcePathStyle(true).build()) {
try {
var head = s3.headObject(HeadObjectRequest.builder().bucket(bucket).key(fileId).build());
if (head.contentLength() != size) { fail(resp, 409, "Existing object size mismatch"); return; }
result.put("exists", true);
} catch (software.amazon.awssdk.services.s3.model.S3Exception notFound) {
if (notFound.statusCode() != 404) throw notFound;
result.put("exists", false);
var put = PutObjectRequest.builder().bucket(bucket).key(fileId)
.contentType(CONTENT_TYPE).contentLength(size).ifNoneMatch("*").build();
try (S3Presigner signer = S3Presigner.builder().region(Region.of("auto"))
.endpointOverride(apiEndpoint).credentialsProvider(credentials)
.serviceConfiguration(software.amazon.awssdk.services.s3.S3Configuration.builder()
.pathStyleAccessEnabled(true).build()).build()) {
var signed = signer.presignPutObject(PutObjectPresignRequest.builder()
.signatureDuration(Duration.ofMinutes(30)).putObjectRequest(put).build());
result.put("uploadUrl", signed.url().toString());
ObjectNode headers = result.putObject("requiredHeaders");
for (Map.Entry<String, List<String>> entry : signed.signedHeaders().entrySet()) {
// Content-Length браузер выставляет автоматически из Uint8Array.
if (!entry.getKey().equalsIgnoreCase("host")
&& !entry.getKey().equalsIgnoreCase("content-length")) {
headers.put(entry.getKey(), String.join(",", entry.getValue()));
}
}
}
}
}
respond(resp, 200, result);
} catch (Exception error) {
getServletContext().log("R2 DM prepare failed", error);
fail(resp, 503, "R2 DM upload preparation failed");
}
}
private static String setting(String environment, String property) {
String value = System.getenv(environment);
if (value == null || value.isBlank()) value = AppConfig.getInstance().getParam(property);
return value == null || value.isBlank() ? null : value.trim();
}
private static void cors(HttpServletRequest req, HttpServletResponse resp) {
String origin = req.getHeader("Origin");
if ("https://shineup.me".equals(origin) || "https://www.shineup.me".equals(origin)
|| "https://test.shineup.me".equals(origin)
|| "https://t2.shineup.me".equals(origin)) {
resp.setHeader("Access-Control-Allow-Origin", origin);
resp.setHeader("Vary", "Origin");
}
resp.setHeader("Access-Control-Allow-Methods", "POST, OPTIONS");
resp.setHeader("Access-Control-Allow-Headers", "Content-Type, X-Shine-Session-Id, X-Shine-Time-Ms, X-Shine-Signature");
}
private static void fail(HttpServletResponse resp, int status, String message) throws IOException {
ObjectNode obj = JSON.createObjectNode(); obj.put("error", message); respond(resp, status, obj);
}
private static void respond(HttpServletResponse resp, int status, ObjectNode json) throws IOException {
resp.setStatus(status);
resp.setContentType("application/json;charset=UTF-8");
JSON.writeValue(resp.getOutputStream(), json);
}
}
@@ -18,6 +18,7 @@ import utils.config.AppConfig;
import java.io.IOException; import java.io.IOException;
import java.net.URI; import java.net.URI;
import java.math.BigInteger;
import java.time.Duration; import java.time.Duration;
import java.util.Map; import java.util.Map;
import java.util.regex.Pattern; import java.util.regex.Pattern;
@@ -25,7 +26,8 @@ import java.util.regex.Pattern;
/** Only signs single-object uploads. File contents never pass through SHiNE. */ /** Only signs single-object uploads. File contents never pass through SHiNE. */
public final class R2PrepareServlet extends HttpServlet { public final class R2PrepareServlet extends HttpServlet {
private static final ObjectMapper JSON = new ObjectMapper(); private static final ObjectMapper JSON = new ObjectMapper();
private static final Pattern ROOT = Pattern.compile("^[A-Za-z0-9_-]{43}$"); private static final String BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
private static final Pattern ROOT = Pattern.compile("^[1-9A-HJ-NP-Za-km-z]{32,44}$");
private static final Pattern MIME = Pattern.compile("^[a-zA-Z0-9!#$&^_.+-]+/[a-zA-Z0-9!#$&^_.+-]+$"); private static final Pattern MIME = Pattern.compile("^[a-zA-Z0-9!#$&^_.+-]+/[a-zA-Z0-9!#$&^_.+-]+$");
private static final long MAX_BYTES = 500L * 1024L * 1024L; private static final long MAX_BYTES = 500L * 1024L * 1024L;
@@ -42,7 +44,7 @@ public final class R2PrepareServlet extends HttpServlet {
String root = input.path("pr").asText(""); String root = input.path("pr").asText("");
String mime = input.path("mm").asText("application/octet-stream").trim(); String mime = input.path("mm").asText("application/octet-stream").trim();
long size = input.path("size").asLong(-1); long size = input.path("size").asLong(-1);
if (!ROOT.matcher(root).matches() || size < 1 || size > MAX_BYTES || !MIME.matcher(mime).matches() || mime.length() > 127) { if (!validPiecesRoot(root) || size < 1 || size > MAX_BYTES || !MIME.matcher(mime).matches() || mime.length() > 127) {
fail(resp, 400, "Invalid root, size or MIME"); return; fail(resp, 400, "Invalid root, size or MIME"); return;
} }
// The same authenticated session signing pattern as /files, with a distinct domain separator. // The same authenticated session signing pattern as /files, with a distinct domain separator.
@@ -90,6 +92,22 @@ public final class R2PrepareServlet extends HttpServlet {
} }
} }
/** Только канонический Base58 от ровно 32 байт Merkle-корня (не Base64URL). */
static boolean validPiecesRoot(String root) {
if (root == null || !ROOT.matcher(root).matches()) return false;
int leadingZeroBytes = 0;
while (leadingZeroBytes < root.length() && root.charAt(leadingZeroBytes) == '1') leadingZeroBytes++;
BigInteger value = BigInteger.ZERO;
for (int i = leadingZeroBytes; i < root.length(); i++) {
int digit = BASE58_ALPHABET.indexOf(root.charAt(i));
if (digit < 0) return false;
value = value.multiply(BigInteger.valueOf(58)).add(BigInteger.valueOf(digit));
}
// BigInteger не хранит ведущие нулевые байты; их кодируют символы '1'.
int dataBytes = value.signum() == 0 ? 0 : (value.bitLength() + 7) / 8;
return leadingZeroBytes + dataBytes == 32;
}
private static String setting(String env, String property) { private static String setting(String env, String property) {
String value = System.getenv(env); String value = System.getenv(env);
if (value == null || value.isBlank()) value = AppConfig.getInstance().getParam(property); if (value == null || value.isBlank()) value = AppConfig.getInstance().getParam(property);
@@ -0,0 +1,27 @@
package server.files;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
class R2PrepareServletTest {
@Test
void acceptsCanonicalBase58PiecesRootsOf32Bytes() {
assertTrue(R2PrepareServlet.validPiecesRoot("11111111111111111111111111111111"));
assertTrue(R2PrepareServlet.validPiecesRoot("4vJ9JU1bJJE96FWSJKvHsmmFADCg4gpZQff4P3bkLKi"));
assertTrue(R2PrepareServlet.validPiecesRoot("JEKNVnkbo3jma5nREBBJCDoXFVeKkD56V3xKrvRmWxFG"));
}
@Test
void rejectsNonBase58AndWrongSizeRoots() {
assertFalse(R2PrepareServlet.validPiecesRoot(null));
assertFalse(R2PrepareServlet.validPiecesRoot(""));
assertFalse(R2PrepareServlet.validPiecesRoot("A".repeat(42) + "_"));
assertFalse(R2PrepareServlet.validPiecesRoot("A".repeat(42) + "-"));
assertFalse(R2PrepareServlet.validPiecesRoot("O".repeat(44)));
assertFalse(R2PrepareServlet.validPiecesRoot("1".repeat(31)));
assertFalse(R2PrepareServlet.validPiecesRoot("1".repeat(33)));
assertFalse(R2PrepareServlet.validPiecesRoot("A".repeat(45)));
}
}
+2 -2
View File
@@ -1,2 +1,2 @@
client.version=1.20.41 client.version=1.20.42
server.version=1.16.23 server.version=1.16.24
+7 -8
View File
@@ -33,13 +33,12 @@ call.ice.turn.sharedSecret=
# The deployment script copies allowed-email-domains.txt alongside shine-server.jar. # The deployment script copies allowed-email-domains.txt alongside shine-server.jar.
freeRegistration.email.allowedDomainsFile=allowed-email-domains.txt freeRegistration.email.allowedDomainsFile=allowed-email-domains.txt
# R2 public attachment direct uploads. # R2 public attachment direct uploads (keep credentials in server environment)
# These values belong only in the private server application.properties,
# never in Git or the browser bundle.
r2.publicBucket=shine-files r2.publicBucket=shine-files
r2.endpoint= # R2_ENDPOINT=https://<account>.r2.cloudflarestorage.com
r2.accessKeyId= # R2_ACCESS_KEY_ID=...
r2.secretAccessKey= # R2_SECRET_ACCESS_KEY=...
# Environment variables R2_ENDPOINT, R2_ACCESS_KEY_ID and # R2 DM encrypted attachments (publicly downloadable ciphertext, 14-day lifecycle)
# R2_SECRET_ACCESS_KEY override the three properties above. r2.dmBucket=shine-dm
# Configure R2 credentials via R2_ENDPOINT, R2_ACCESS_KEY_ID, R2_SECRET_ACCESS_KEY
+10 -1
View File
@@ -2,7 +2,7 @@
## 1. Назначение ## 1. Назначение
Файлы личных сообщений хранятся только на access-сервере отправителя и только в зашифрованном виде. Ранее файлы DM хранились только на access-сервере отправителя. **Новые DM v3** хранятся в Cloudflare R2 `shine-dm`, а legacy `/dm-files` продолжает обслуживать старые файлы v1/v2.
HTTP API не получает исходное имя файла, MIME-тип или ключ расшифрования. HTTP API не получает исходное имя файла, MIME-тип или ключ расшифрования.
Клиент: Клиент:
@@ -111,3 +111,12 @@ Caddy/Nginx должен проксировать `/dm-files/*` в тот же J
- encrypted root manifest — ссылки на страницы + BitTorrent v2 root metadata. - encrypted root manifest — ссылки на страницы + BitTorrent v2 root metadata.
Никаких новых доверенных серверных операций для v2 не требуется: сервер по-прежнему только проверяет подпись PUT, длину и `Base58(SHA-256(ciphertext))`. Никаких новых доверенных серверных операций для v2 не требуется: сервер по-прежнему только проверяет подпись PUT, длину и `Base58(SHA-256(ciphertext))`.
## 9. Новый R2 API: `POST /api/dm-files/prepare` (DM v3)
Новые зашифрованные вложения загружаются браузером прямо в R2. Клиент посылает JSON `{ "fileId": "Base58_SHA256(ciphertext)", "size": 12345 }` и подписанные заголовки `X-Shine-Session-Id`, `X-Shine-Time-Ms`, `X-Shine-Signature`. Строка Ed25519-подписи: `DM_R2_PREPARE_V1:{sessionId}:{fileId}:{size}:{timeMs}`. Сервер подтверждает существование объекта или выдаёт `uploadUrl` и `requiredHeaders` с условием `If-None-Match: *`.
Максимальный размер одного ciphertext-объекта — 8 МиБ + 16 байт. Подписанный PUT действителен 30 минут. Загрузка не идёт через Java. Новый URL скачивания: `https://dm-files.shineup.me/<fileId>`; GET публичный, но объект содержит только AES-GCM ciphertext. R2 объект содержит `Content-Type: application/octet-stream`; исходный MIME хранится внутри зашифрованного `<S:file;v=3...>`.
Доступ к R2 требует настроек `r2.dmBucket=shine-dm` и серверных `R2_ENDPOINT`, `R2_ACCESS_KEY_ID`, `R2_SECRET_ACCESS_KEY`. Рекомендуется lifecycle rule **14 дней**. Кэш CDN допускается и может продлить доступность ciphertext после удаления из R2. Сервер не гарантирует соответствие загруженных байтов hash: читающий клиент проверяет `Base58(SHA-256(ciphertext))`. Полный формат DM v3 описан в `docs/Personal_Messages/Файлы_DM_v3_R2.md`.
+1 -1
View File
@@ -144,6 +144,6 @@ https://<current-access-server>/files/<sha256>
## R2 direct upload (MVP, 2026-11) ## R2 direct upload (MVP, 2026-11)
New public attachments use BitTorrent v2 `pr` (base64url 43 characters), `mm` (optional MIME) and `v=1`. Avatars retain the original SHA-256 `/files/<sha256>` API. The client signs `PUBLIC_R2_PREPARE_V1:{sessionId}:{pr}:{size}:{mm}:{timeMs}` with its Ed25519 session key, submits JSON `{pr,size,mm}` to `POST /api/files/prepare` and provides `X-Shine-Session-Id`, `X-Shine-Time-Ms` and `X-Shine-Signature`. The endpoint returns `exists`, `fileUrl`, and for missing objects `uploadUrl` and `requiredHeaders`. The browser uploads the original Blob directly to the S3 endpoint, not the Java server. A signature does not certify the hash of uploaded content. The public GET URL is `https://files.shineup.me/<pr>`. New public attachments use BitTorrent v2 `pr` (canonical Base58 encoding of the 32-byte Pieces Root, normally 43–44 characters, variable length 32–44), `mm` (optional MIME) and `v=1`. Avatars retain the original SHA-256 `/files/<sha256>` API. The client signs `PUBLIC_R2_PREPARE_V1:{sessionId}:{pr}:{size}:{mm}:{timeMs}` with its Ed25519 session key, submits JSON `{pr,size,mm}` to `POST /api/files/prepare` and provides `X-Shine-Session-Id`, `X-Shine-Time-Ms` and `X-Shine-Signature`. The endpoint returns `exists`, `fileUrl`, and for missing objects `uploadUrl` and `requiredHeaders`. The browser uploads the original Blob directly to the S3 endpoint, not the Java server. A signature does not certify the hash of uploaded content. The public GET URL is `https://files.shineup.me/<pr>`; the R2 object key is exactly the same Base58 `pr` (no extension). Old Base64URL PR identifiers are not read or migrated. Arweave TX IDs and DM file identifiers keep their existing encodings. Client and Java server must be updated together.
Configuration: `R2_ENDPOINT`, `R2_ACCESS_KEY_ID`, `R2_SECRET_ACCESS_KEY`, `r2.publicBucket=shine-files` (or `r2.endpoint`, `r2.accessKeyId`, `r2.secretAccessKey` in trusted server config). Never publish keys. Configure browser CORS to permit signed PUT headers including `If-None-Match`. Max size: 500 MiB. Single PUT only, no multipart in this MVP. Configuration: `R2_ENDPOINT`, `R2_ACCESS_KEY_ID`, `R2_SECRET_ACCESS_KEY`, `r2.publicBucket=shine-files` (or `r2.endpoint`, `r2.accessKeyId`, `r2.secretAccessKey` in trusted server config). Never publish keys. Configure browser CORS to permit signed PUT headers including `If-None-Match`. Max size: 500 MiB. Single PUT only, no multipart in this MVP.
+6 -5
View File
@@ -9,10 +9,11 @@
- `docs/Personal_Messages/Доставка_и_синхронизация_DM.md` — доставка на - `docs/Personal_Messages/Доставка_и_синхронизация_DM.md` — доставка на
единственный access-сервер, retry-воркер и UI-статусы единственный access-сервер, retry-воркер и UI-статусы
- `docs/Personal_Messages/Технические_вставки_DM_v1.md` — формат специальных `<S:...>` вставок внутри plaintext DM после расшифровки - `docs/Personal_Messages/Технические_вставки_DM_v1.md` — формат специальных `<S:...>` вставок внутри plaintext DM после расшифровки
- `docs/Personal_Messages/Файлы_DM_v2.md` — большие chunked-вложения, голосовые и BitTorrent v2 SHA-256/Merkle metadata - `docs/Personal_Messages/Файлы_DM_v2.md` — старый формат chunked-вложений с BitTorrent v2 (только чтение);
- `docs/Personal_Messages/Файлы_DM_v3_R2.md` — **новые** chunked-вложения и голосовые в Cloudflare R2, AES-GCM, SHA-256/Base58
- `docs/API/18_DM_File_Storage_API.md` — HTTP-хранилище зашифрованных файлов DM на access-сервере отправителя - `docs/API/18_DM_File_Storage_API.md` — HTTP-хранилище зашифрованных файлов DM на access-сервере отправителя
Документы с версиями `v1` и `v2` описывают разные уровни: `v1` — контейнер и доставка сообщения, `v2` — формат больших файлов внутри зашифрованного содержимого DM. Реализация `v2` находится в `shine-UI/js/services/dm-file-service.js` и `dm-tech-blocks.js`. Документы с версиями `v1`, `v2` и `v3` описывают разные уровни: `v1` — контейнер и доставка сообщения, `v2` — старый формат больших файлов, `v3` — новые файлы в R2 без BitTorrent. Клиентская реализация находится в `shine-UI/js/services/dm-file-service.js` и `dm-tech-blocks.js`.
Правило сопровождения: Правило сопровождения:
@@ -22,12 +23,12 @@
## Зашифрованные файлы DM ## Зашифрованные файлы DM
Официальный UI v1 умеет отправлять файл как внешний зашифрованный объект: Официальный UI v3 отправляет файл как зашифрованные объекты R2 (чтение старого v1/v2 поддерживается):
- файл шифруется в браузере `AES-256-GCM`; - файл шифруется в браузере `AES-256-GCM`;
- ciphertext хранится только на access-сервере отправителя под именем `Base58(SHA-256(ciphertext))`; - новый ciphertext хранится в корзине `shine-dm` по адресу `https://dm-files.shineup.me/<Base58(SHA-256(ciphertext))>`;
- AES-key, IV, исходное имя, MIME, размер и URL находятся в `<S:file...>` внутри plaintext DM, а значит сами защищены существующим E2EE DM; - AES-key, IV, исходное имя, MIME, размер и URL находятся в `<S:file...>` внутри plaintext DM, а значит сами защищены существующим E2EE DM;
- получатель скачивает ciphertext с сервера отправителя, проверяет SHA-256, расшифровывает локально и только затем отдаёт Blob браузеру для сохранения под исходным именем; - получатель скачивает новый ciphertext напрямую из R2, проверяет SHA-256, расшифровывает локально и только затем отдаёт Blob браузеру для сохранения под исходным именем;
- сервер файлов ключ расшифрования не получает. - сервер файлов ключ расшифрования не получает.
Формат бинарного контейнера `SHiNE_DM` при этом не меняется. Формат бинарного контейнера `SHiNE_DM` при этом не меняется.
@@ -195,3 +195,14 @@ fromLogin|toLogin|timeMs|nonce
В одном plaintext DM разрешено несколько последовательных `<S:file...>` блоков. Официальный UI собирает их в один список вложений и скрывает fallback-текст. В одном plaintext DM разрешено несколько последовательных `<S:file...>` блоков. Официальный UI собирает их в один список вложений и скрывает fallback-текст.
Подробный формат chunk encryption, manifest pages и BitTorrent v2 hashing: `Файлы_DM_v2.md`. Подробный формат chunk encryption, manifest pages и BitTorrent v2 hashing: `Файлы_DM_v2.md`.
## 11. Новый `file` v3 — R2 без BitTorrent
Новые вложения и голосовые сообщения отправляются только в `v=3`, при этом продолжается чтение v1 и v2:
```text
<S:file;v=3;id=BASE58_SHA256_ROOT_CIPHERTEXT;url=ENCODED_HTTPS_DM_FILES_URL;key=BASE64URL_AES_KEY;ivp=BASE64URL_4BYTE_PREFIX;name=ENCODED_NAME;mime=ENCODED_MIME;size=10485760;encsize=104859XX;chunk=8388608;chunks=2;kind=file;dur=0>
```
Здесь **нет** `th` или `pr`; `id` обозначает SHA-256 **зашифрованного корневого манифеста** в Base58. Все части и манифест шифруются AES-256-GCM, хранятся по `Base58(SHA-256(ciphertext))`. Встроенный MIME по-прежнему называется `mime` в DM-протоколе (сокращение `mm` касается публичного `S:att`). Бинарный E2EE-контейнер не меняется. Подробности: `Файлы_DM_v3_R2.md`.
@@ -0,0 +1,94 @@
# DM file v3: Cloudflare R2, AES-GCM, SHA-256 / Base58
## Назначение
Все **новые** файлы и голосовые сообщения DM официального PWA загружаются непосредственно в R2 `shine-dm`.
Содержимое файлов Java-сервером не проксируется, а сервер выдаёт временные S3 PUT URL после проверки Ed25519-сессии.
Скачивание публичное по `https://dm-files.shineup.me/<id>`: там хранится **только ciphertext**.
Ключ AES, префикс IV, имя, MIME и размер помещаются внутрь уже E2EE-зашифрованного сообщения.
В v3 **нет BitTorrent, Merkle/`pieces root` и infohash**. Они сохранились только для чтения ранее отправленных DM v2.
## Как создаётся файл
- Клиент делит исходный файл на куски по **8 МиБ**; это границы шифрования, а не торрентные pieces.
- На всё вложение генерируется новый случайный AES-256-GCM key и новый 4-байтный IV prefix.
- Для каждой части используется отдельный 12-байтный IV: `prefix[4] || uint64_be(index)`; AAD содержит домен `chunk`, index и IV prefix. IV страниц манифеста и корня зарезервированы отдельно, как в v2.
- Каждая часть шифруется независимо и получает идентификатор **`Base58(SHA-256(ciphertext))`**.
- Клиент загружает части параллельно не более чем по одной (последовательно) через подписанные URL (без Multipart).
- Список частей помещается **в один зашифрованный корневой манифест**, который также получает собственный SHA-256/Base58 ID и загружается в R2.
- Итоговая `<S:file;v=3...>`-вставка с ключом и ссылкой на root manifest передаётся только внутри обычного E2EE DM.
Максимальный размер оригинального файла в этом MVP — **500 МиБ**. Обычная загрузка одного ciphertext-объекта — до `8 МиБ + 16` байт. Дополнительная проверка хеша исходного plaintext не требуется: каждый объект проверяется по SHA-256 ciphertext, а расшифрование AES-GCM аутентифицирует содержимое каждого куска и его порядковый номер.
## Манифест после расшифрования
```json
{
"v": 3,
"scheme": "SHINE-DM-R2-AES-256-GCM",
"chunkSize": 8388608,
"fileSize": 10485760,
"chunkCount": 2,
"chunks": [
{"i": 0, "id": "<Base58 SHA256 ciphertext>", "ps": 8388608, "es": 8388624},
{"i": 1, "id": "<Base58 SHA256 ciphertext>", "ps": 2097152, "es": 2097168}
]
}
```
`ps` — размер plaintext, `es = ps + 16` — размер ciphertext с GCM tag. Манифест и любой отдельный chunk в R2 имеют `Content-Type: application/octet-stream`; MIME исходного файла хранится **только в E2EE технической вставке**.
## Загрузка через R2
`POST /api/dm-files/prepare` с JSON `{ "fileId": "Base58_SHA256_CIPHERTEXT", "size": 8388624 }`.
Заголовки:
- `X-Shine-Session-Id`
- `X-Shine-Time-Ms`
- `X-Shine-Signature` — Base64 Ed25519 подписи активным session key.
Подписываемая UTF-8 строка:
```
DM_R2_PREPARE_V1:{sessionId}:{fileId}:{size}:{timeMs}
```
Сервер проверяет действующую сессию и размер, выполняет S3 `HeadObject` в `shine-dm`, затем возвращает:
- `exists: true` — объект уже существует и совпадает по размеру;
- либо `exists: false`, `uploadUrl` и `requiredHeaders` для одноразового по назначению (но действующего в течение срока) S3 PUT. PUT требует `If-None-Match: *` для исключения перезаписи.
Срок действия ссылки: 30 минут. Сервер не проверяет SHA-256 загруженного ciphertext, поэтому клиент при чтении **обязан** проверить Base58(SHA-256(downloadedCiphertext)) перед расшифрованием. SHA-256 объекта не равен S3 ETag.
## Скачивание
1. Скачать ciphertext root manifest по адресу, записанному в E2EE-сообщении.
2. Проверить `Base58(SHA-256(ciphertext)) == id`.
3. Расшифровать AES-GCM и проверить структуру манифеста.
4. Получить каждую зашифрованную часть напрямую с `dm-files.shineup.me/<id>`.
5. Проверить SHA-256 каждой части, расшифровать AES-GCM, проверить порядок и длину.
6. Последовательно записать исходные данные в браузерный поток сохранения или Blob fallback.
## Настройка Cloudflare
- R2 Bucket: `shine-dm`, публичный custom domain `dm-files.shineup.me` (в R2 только шифротекст).
- Object Lifecycle: удалить объекты через 14 дней (Cloudflare выполняет удаление асинхронно).
- CDN-кэширование разрешено: файлы могут оставаться доступными из кэша после удаления из R2, гарантий точного срока недоступности нет.
- CORS: с origin сайта SHiNE разрешить `GET`, `HEAD`, `PUT`; `AllowedHeaders: ["*"]`; `ExposeHeaders: ["Content-Length", "ETag"]`.
- Секреты S3 (`R2_ENDPOINT`, `R2_ACCESS_KEY_ID`, `R2_SECRET_ACCESS_KEY`) задаются **на Java-сервере**, никак не в браузере.
- `r2.dmBucket=shine-dm` в конфигурации Java.
- Обеспечить reverse proxy **только нового** `POST /api/dm-files/prepare` к Java-серверу (до SPA fallback), помимо уже действующего `/dm-files/*` для старых DM.
- Токен R2 должен иметь Object Read & Write для обоих buckets `shine-files` и `shine-dm`.
## Совместимость
DM v1 и DM v2 читаются прежними обработчиками (с локальных старых URL), но новые вложения генерируются **только v3**. В v2 используется BitTorrent v2, в v3 — нет. Старым клиентам v3 необходимо обновление: это новая версия технической вставки. Бинарный формат E2EE-контейнера DM и его криптопротокол не меняются.
## Границы MVP и ограничения
- Нет Multipart Upload в S3, нет возобновления одного незавершённого PUT.
- Java-сервер не доказывает соответствие присланных байтов объявленному SHA-256; повреждённые объекты обнаруживаются получателем. Подмена первого объекта до дедупликации требует отдельной доверенной проверки в будущем.
- Заявленный размер и URL не защищают от всех злоупотреблений: для публичного запуска дополнительно нужны лимиты и мониторинг R2-расходов.
- Удаление из R2 не удаляет уже скачанные копии, CDN-кэш и копии у получателей.
+99
View File
@@ -0,0 +1,99 @@
import assert from 'node:assert/strict';
import { createHash, webcrypto } from 'node:crypto';
import { encryptAndUploadDmFile, decryptDmFileToBlob } from '../../shine-UI/js/services/dm-file-service.js';
import { buildDmFileTechBlock, parseDmTechBlocks } from '../../shine-UI/js/services/dm-tech-blocks.js';
import { exportPkcs8B64 } from '../../shine-UI/js/services/crypto-utils.js';
// Fake IndexedDB only for session-key lookup (no external R2 or Java server required).
globalThis.crypto ??= webcrypto;
globalThis.window = { location: { href: 'https://shineup.me/' } };
const keyPair = await crypto.subtle.generateKey({ name: 'Ed25519' }, true, ['sign', 'verify']);
const session = { sessionId: 'test-session', sessionPrivPkcs8: await exportPkcs8B64(keyPair.privateKey) };
globalThis.indexedDB = {
open() {
const request = {};
const db = {
objectStoreNames: { contains: () => true },
transaction() {
return { objectStore() { return { get() {
const result = { result: session };
queueMicrotask(() => result.onsuccess?.());
return result;
} }; } };
},
close() {},
};
request.result = db;
queueMicrotask(() => request.onsuccess?.());
return request;
},
};
const stored = new Map();
let signedRequests = 0;
let putRequests = 0;
const bytesFromBody = async body => new Uint8Array(await new Response(body).arrayBuffer());
globalThis.fetch = async (url, opts = {}) => {
const method = opts.method || 'GET';
const target = String(url);
if (target.endsWith('/api/dm-files/prepare')) {
assert.equal(method, 'POST');
const { fileId, size } = JSON.parse(opts.body);
const sigBytes = Buffer.from(opts.headers['X-Shine-Signature'], 'base64');
const timeMs = opts.headers['X-Shine-Time-Ms'];
const preimage = `DM_R2_PREPARE_V1:test-session:${fileId}:${size}:${timeMs}`;
assert.equal(await crypto.subtle.verify('Ed25519', keyPair.publicKey, sigBytes, new TextEncoder().encode(preimage)), true);
signedRequests++;
return Response.json(stored.has(fileId) ? { exists: true } : {
exists: false,
uploadUrl: `https://r2.invalid/${fileId}`,
requiredHeaders: { 'content-type': 'application/octet-stream', 'if-none-match': '*' },
});
}
const id = target.split('/').at(-1);
if (target.startsWith('https://r2.invalid/')) {
assert.equal(method, 'PUT');
assert.equal(opts.headers['if-none-match'], '*');
const bytes = await bytesFromBody(opts.body);
assert.equal(id.length >= 32, true);
if (stored.has(id)) return new Response('', { status: 412 });
stored.set(id, bytes);
putRequests++;
return new Response('', { status: 200 });
}
if (target.startsWith('https://dm-files.shineup.me/')) {
const bytes = stored.get(id);
if (!bytes) return new Response('', { status: 404 });
return new Response(method === 'HEAD' ? null : bytes, { status: 200, headers: {
'Content-Length': String(bytes.byteLength), 'Content-Type': 'application/octet-stream',
} });
}
throw new Error(`Unexpected fetch: ${method} ${target}`);
};
const data = new Uint8Array(9 * 1024 * 1024 + 137);
for (let i = 0; i < data.length; i++) data[i] = i % 251;
const file = new File([data], 'movie.bin', { type: 'application/octet-stream' });
const upload = await encryptAndUploadDmFile({
file, login: 'alice', sessionId: 'test-session', wsUrl: 'wss://shineup.me/ws',
});
assert.equal(upload.version, 3);
assert.equal(upload.chunkCount, 2);
assert.equal(upload.chunkSize, 8 * 1024 * 1024);
assert.equal(stored.size, 3); // ciphertext chunk 0, chunk 1, encrypted manifest
assert.equal(putRequests, 3);
assert.equal(signedRequests, 3);
assert.match(upload.url, /^https:\/\/dm-files\.shineup\.me\/[1-9A-HJ-NP-Za-km-z]+$/);
const raw = buildDmFileTechBlock(upload);
assert.match(raw, /<S:file;v=3;/);
assert.doesNotMatch(raw, /;th=|;pr=/);
const parsed = parseDmTechBlocks(`${raw}test`).fileAttachment;
assert.equal(parsed.version, 3);
assert.equal(parsed.torrentV2PiecesRootB64Url, undefined);
const recovered = new Uint8Array(await (await decryptDmFileToBlob(parsed)).arrayBuffer());
assert.equal(createHash('sha256').update(recovered).digest('hex'), createHash('sha256').update(data).digest('hex'));
const ids = [...stored.keys()].filter(id => id !== upload.id);
const damaged = stored.get(ids[0]).slice();
damaged[0] ^= 1;
stored.set(ids[0], damaged);
await assert.rejects(() => decryptDmFileToBlob(parsed), /SHA-256/);
console.log('DM R2 v3 end-to-end simulation OK (encrypt → signed PUT → manifest → decrypt; corruption rejected)');
+1 -1
View File
@@ -57,7 +57,7 @@ export function createDmFileAttachmentCard(attachment) {
const fileMeta = document.createElement('span'); const fileMeta = document.createElement('span');
fileMeta.className = 'dm-file-card__meta'; fileMeta.className = 'dm-file-card__meta';
const metaParts = [formatBytes(attachment.size)]; const metaParts = [formatBytes(attachment.size)];
if (Number(attachment?.version || 1) >= 2) metaParts.push('BitTorrent v2'); if (Number(attachment?.version || 1) === 2) metaParts.push('BitTorrent v2');
fileMeta.textContent = metaParts.join(' · '); fileMeta.textContent = metaParts.join(' · ');
fileCopy.append(fileName, fileMeta); fileCopy.append(fileName, fileMeta);
+3 -2
View File
@@ -3,6 +3,7 @@ import { formatNumber } from '../i18n/format.js';
import { openMediaViewer } from '../components/media-viewer.js'; import { openMediaViewer } from '../components/media-viewer.js';
import { buildArweaveDataUrl, sha256HexFromArrayBuffer, validateArweaveTxId, validateSha256Hex } from './arweave-file-service.js'; import { buildArweaveDataUrl, sha256HexFromArrayBuffer, validateArweaveTxId, validateSha256Hex } from './arweave-file-service.js';
import { resolvePublicFileUrl } from './public-file-service.js'; import { resolvePublicFileUrl } from './public-file-service.js';
import { validatePublicPiecesRoot } from './public-pieces-root.js';
const ATTACH_BLOCK_RE = /^<(?:SHiNE|S):(attach|att);([^>]*)>\n?/u; const ATTACH_BLOCK_RE = /^<(?:SHiNE|S):(attach|att);([^>]*)>\n?/u;
export const MAX_MESSAGE_ATTACHMENTS = 10; export const MAX_MESSAGE_ATTACHMENTS = 10;
@@ -47,8 +48,8 @@ export function normalizeAttachment(input = {}) {
const size = Number(input.sz || input.size || input.sizeBytes || 0); const size = Number(input.sz || input.size || input.sizeBytes || 0);
const name = normalizeName(input.nm || input.name || input.fileName || 'file'); const name = normalizeName(input.nm || input.name || input.fileName || 'file');
if (txId && !validateArweaveTxId(txId)) throw new Error(t('remaining.attachment_errors.invalid_arweave_transaction_id')); if (txId && !validateArweaveTxId(txId)) throw new Error(t('remaining.attachment_errors.invalid_arweave_transaction_id'));
if (!/^[A-Za-z0-9_-]{43}$/.test(pr) && !validateSha256Hex(sha256Hex)) throw new Error('Некорректный идентификатор файла'); if (!validatePublicPiecesRoot(pr) && !validateSha256Hex(sha256Hex)) throw new Error('Некорректный идентификатор файла');
if (pr && !/^[A-Za-z0-9_-]{43}$/.test(pr)) throw new Error('Некорректный Pieces Root'); if (pr && !validatePublicPiecesRoot(pr)) throw new Error('Некорректный Pieces Root');
if (mm && (!/^[a-z0-9!#$&^_.+-]+\/[a-z0-9!#$&^_.+-]+$/i.test(mm) || mm.length > 127)) throw new Error('Некорректный MIME'); if (mm && (!/^[a-z0-9!#$&^_.+-]+\/[a-z0-9!#$&^_.+-]+$/i.test(mm) || mm.length > 127)) throw new Error('Некорректный MIME');
if (!Number.isInteger(size) || size <= 0) throw new Error(t('remaining.attachment_errors.invalid_file_size')); if (!Number.isInteger(size) || size <= 0) throw new Error(t('remaining.attachment_errors.invalid_file_size'));
return { v: 1, name, size, sha256: sha256Hex, pr, mm, ar: txId, uploadedAtMs: Number(input.uploadedAtMs || 0) || Date.now() }; return { v: 1, name, size, sha256: sha256Hex, pr, mm, ar: txId, uploadedAtMs: Number(input.uploadedAtMs || 0) || Date.now() };
+169 -172
View File
@@ -20,12 +20,18 @@ import {
computeTorrentV2PieceRoot, computeTorrentV2PieceRoot,
} from './torrent-v2-service.js'; } from './torrent-v2-service.js';
export const DM_FILE_CHUNK_BYTES = TORRENT_V2_PIECE_BYTES; export const DM_FILE_CHUNK_BYTES = 8 * 1024 * 1024;
const LEGACY_DM_FILE_CHUNK_BYTES = TORRENT_V2_PIECE_BYTES;
export const DM_FILE_MANIFEST_PAGE_CHUNKS = 256; export const DM_FILE_MANIFEST_PAGE_CHUNKS = 256;
export const DM_MAX_ATTACHMENTS_PER_MESSAGE = 10; export const DM_MAX_ATTACHMENTS_PER_MESSAGE = 10;
const MANIFEST_VERSION = 2; const MANIFEST_VERSION = 2;
const MANIFEST_SCHEME = 'SHINE-DM-CHUNKED-AES-256-GCM'; const MANIFEST_SCHEME = 'SHINE-DM-CHUNKED-AES-256-GCM';
const R2_MANIFEST_VERSION = 3;
const R2_MANIFEST_SCHEME = 'SHINE-DM-R2-AES-256-GCM';
const DM_R2_PUBLIC_BASE = 'https://dm-files.shineup.me';
const DM_R2_OBJECT_MAX_BYTES = DM_FILE_CHUNK_BYTES + 16;
const DM_R2_FILE_MAX_BYTES = 500 * 1024 * 1024;
const ROOT_IV_TOKEN = 0xffffffffffffffffn; const ROOT_IV_TOKEN = 0xffffffffffffffffn;
const PAGE_IV_BASE = 0x8000000000000000n; const PAGE_IV_BASE = 0x8000000000000000n;
const encoder = new TextEncoder(); const encoder = new TextEncoder();
@@ -52,7 +58,7 @@ function wsUrlToHttpBase(wsUrl = '') {
} }
function uploadPreimage({ sessionId, fileId, encryptedSize, timeMs }) { function uploadPreimage({ sessionId, fileId, encryptedSize, timeMs }) {
return `DM_FILE_UPLOAD_V1:${sessionId}:${fileId}:${Number(encryptedSize)}:${Number(timeMs)}`; return `DM_R2_PREPARE_V1:${sessionId}:${fileId}:${Number(encryptedSize)}:${Number(timeMs)}`;
} }
async function readErrorMessage(response) { async function readErrorMessage(response) {
@@ -71,7 +77,10 @@ async function readErrorMessage(response) {
} }
function objectUrl(serverBase, id) { function objectUrl(serverBase, id) {
return `${String(serverBase || '').replace(/\/$/, '')}/dm-files/${encodeURIComponent(String(id || ''))}`; const base = String(serverBase || '').replace(/\/$/, '');
// Старые вложения читаем с access-сервера, новые — с отдельного домена R2.
const path = new URL(base).hostname === 'dm-files.shineup.me' ? '' : '/dm-files';
return `${base}${path}/${encodeURIComponent(String(id || ''))}`;
} }
function objectBaseFromUrl(url = '') { function objectBaseFromUrl(url = '') {
@@ -143,66 +152,58 @@ async function createUploadContext({ login, sessionId, wsUrl }) {
async function uploadEncryptedObject(bytes, context) { async function uploadEncryptedObject(bytes, context) {
const payload = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes || 0); const payload = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes || 0);
const fileId = bytesToBase58(await sha256Bytes(payload)); if (payload.byteLength < 16 || payload.byteLength > DM_R2_OBJECT_MAX_BYTES) {
const url = objectUrl(context.serverBase, fileId); throw new Error('Зашифрованный объект DM превышает лимит R2');
// Быстрая дедупликация: если сервер уже подтверждает content-addressed объект,
// не отправляем его байты повторно. HEAD на сервере сам перепроверяет SHA-256 файла.
try {
const existing = await fetch(url, { method: 'HEAD', cache: 'no-store' });
if (existing.ok) {
const storedSize = Number(existing.headers.get('Content-Length') || -1);
const etag = String(existing.headers.get('ETag') || '').replace(/^"|"$/g, '');
if (storedSize === payload.byteLength && (!etag || etag === fileId)) {
return { id: fileId, url, encryptedSize: payload.byteLength, alreadyExists: true };
}
}
} catch {
// Старый сервер или временная ошибка HEAD не должны ломать загрузку: PUT остаётся источником истины.
} }
const fileId = bytesToBase58(await sha256Bytes(payload));
const timeMs = Date.now(); const timeMs = Date.now();
const signatureB64 = await signBase64(context.privateKey, uploadPreimage({ const signatureB64 = await signBase64(context.privateKey, uploadPreimage({
sessionId: context.sessionId, sessionId: context.sessionId, fileId, encryptedSize: payload.byteLength, timeMs,
fileId,
encryptedSize: payload.byteLength,
timeMs,
})); }));
let response; const prepare = await fetch(`${context.serverBase}/api/dm-files/prepare`, {
try { method: 'POST',
response = await fetch(url, { headers: {
method: 'PUT', 'Content-Type': 'application/json',
headers: { 'X-Shine-Session-Id': context.sessionId,
'Content-Type': 'application/octet-stream', 'X-Shine-Time-Ms': String(timeMs),
'X-Shine-Session-Id': context.sessionId, 'X-Shine-Signature': signatureB64,
'X-Shine-Time-Ms': String(timeMs), },
'X-Shine-Content-Length': String(payload.byteLength), body: JSON.stringify({ fileId, size: payload.byteLength }),
'X-Shine-Signature': signatureB64, });
}, if (!prepare.ok) {
body: payload, const detail = await readErrorMessage(prepare);
cache: 'no-store', throw new Error(detail || `R2 DM prepare: HTTP ${prepare.status}`);
});
} catch (error) {
throw new Error(`Не удалось загрузить часть файла на сервер отправителя: ${error?.message || 'network error'}`);
} }
if (!response.ok) { const answer = await prepare.json();
const detail = await readErrorMessage(response); const url = `${DM_R2_PUBLIC_BASE}/${fileId}`;
throw new Error(detail || `Сервер отклонил часть файла (HTTP ${response.status})`); if (!answer.exists) {
if (!answer.uploadUrl || !answer.requiredHeaders) throw new Error('Сервер не вернул параметры загрузки R2');
let result;
try {
result = await fetch(answer.uploadUrl, {
method: 'PUT', headers: answer.requiredHeaders, body: payload,
});
} catch (error) {
throw new Error(`Не удалось загрузить зашифрованные данные в R2: ${error?.message || 'network error'}`);
}
if (result.status === 412) {
// Другой клиент успел создать объект. Его реальные байты проверит получатель по SHA-256.
const check = await fetch(url, { method: 'HEAD' });
if (!check.ok || Number(check.headers.get('Content-Length')) !== payload.byteLength) {
throw new Error('Конфликт загрузки зашифрованного объекта R2');
}
} else if (!result.ok) {
const detail = await readErrorMessage(result);
throw new Error(detail || `Ошибка загрузки зашифрованных данных в R2 (HTTP ${result.status})`);
}
} }
let alreadyExists = false; return { id: fileId, url, encryptedSize: payload.byteLength, alreadyExists: Boolean(answer.exists) };
try {
const payloadJson = await response.clone().json();
alreadyExists = Boolean(payloadJson?.alreadyExists);
} catch {
// Ответ старого сервера может не содержать JSON-флаг; успешного HTTP достаточно.
}
return { id: fileId, url, encryptedSize: payload.byteLength, alreadyExists };
} }
async function fetchVerifiedObject(url, expectedId) { async function fetchVerifiedObject(url, expectedId) {
let response; let response;
try { try {
response = await fetch(url, { method: 'GET', cache: 'no-store' }); response = await fetch(url, { method: 'GET' });
} catch (error) { } catch (error) {
throw new Error(`Не удалось скачать зашифрованные данные: ${error?.message || 'network error'}`); throw new Error(`Не удалось скачать зашифрованные данные: ${error?.message || 'network error'}`);
} }
@@ -226,26 +227,6 @@ function decodeJson(bytes) {
return JSON.parse(decoder.decode(bytes)); return JSON.parse(decoder.decode(bytes));
} }
async function encryptAndUploadManifestPage({ descriptors, pageIndex, fileKey, ivPrefix, uploadContext }) {
const plain = encodeJson({ v: MANIFEST_VERSION, page: pageIndex, chunks: descriptors });
const iv = pageIv(ivPrefix, pageIndex);
const aad = pageAad(ivPrefix, pageIndex);
let encrypted;
try {
encrypted = await encryptBytesAesGcm(plain, fileKey, iv, aad);
const stored = await uploadEncryptedObject(encrypted, uploadContext);
return {
id: stored.id,
count: descriptors.length,
encryptedSize: stored.encryptedSize,
};
} finally {
plain.fill(0);
iv.fill(0);
aad.fill(0);
encrypted?.fill(0);
}
}
export function formatDmFileSize(bytes = 0) { export function formatDmFileSize(bytes = 0) {
const value = Math.max(0, Number(bytes || 0)); const value = Math.max(0, Number(bytes || 0));
@@ -256,148 +237,164 @@ export function formatDmFileSize(bytes = 0) {
} }
/** /**
* V2 uploader: no whole-file size limit. Only one 1 MiB plaintext piece is held in * Новые DM v3: AES-GCM по 8 МиБ, SHA-256(ciphertext) для каждого объекта.
* memory at a time. Every piece is independently AES-256-GCM encrypted and stored * BitTorrent/Merkle не вычисляются. Старые v1/v2 остаются доступны на чтение.
* as Base58(SHA-256(ciphertext)).
*/ */
export async function encryptAndUploadDmFile({ export async function encryptAndUploadDmFile({
file, file, login, sessionId, wsUrl, kind = 'file', durationMs = 0, onProgress = null,
login,
sessionId,
wsUrl,
kind = 'file',
durationMs = 0,
onProgress = null,
} = {}) { } = {}) {
if (!file || typeof file.slice !== 'function') throw new Error('Файл не выбран'); if (!file || typeof file.slice !== 'function') throw new Error('Файл не выбран');
const fileSize = Number(file.size);
if (!Number.isSafeInteger(fileSize) || fileSize < 0 || fileSize > DM_R2_FILE_MAX_BYTES) {
throw new Error('Максимальный размер личного файла — 500 МиБ');
}
const uploadContext = await createUploadContext({ login, sessionId, wsUrl }); const uploadContext = await createUploadContext({ login, sessionId, wsUrl });
const fileKey = randomBytes(32); const fileKey = randomBytes(32);
const ivPrefix = randomBytes(4); const ivPrefix = randomBytes(4);
const fileSize = Math.max(0, Number(file.size || 0));
const chunkCount = Math.ceil(fileSize / DM_FILE_CHUNK_BYTES); const chunkCount = Math.ceil(fileSize / DM_FILE_CHUNK_BYTES);
const pageRefs = []; const descriptors = [];
let pageDescriptors = []; let encryptedTotal = 0;
let pageIndex = 0;
const pieceAccumulator = new TorrentV2PieceAccumulator();
let singlePieceRoot = null;
let completedBytes = 0;
try { try {
for (let index = 0; index < chunkCount; index += 1) { for (let index = 0; index < chunkCount; index += 1) {
const start = index * DM_FILE_CHUNK_BYTES; const start = index * DM_FILE_CHUNK_BYTES;
const end = Math.min(fileSize, start + DM_FILE_CHUNK_BYTES); const plain = new Uint8Array(await file.slice(start, Math.min(fileSize, start + DM_FILE_CHUNK_BYTES)).arrayBuffer());
const plain = new Uint8Array(await file.slice(start, end).arrayBuffer());
const iv = chunkIv(ivPrefix, index); const iv = chunkIv(ivPrefix, index);
const aad = chunkAad(ivPrefix, index); const aad = chunkAad(ivPrefix, index);
let encrypted = null; let encrypted = null;
try { try {
const pieceRoot = await computeTorrentV2PieceRoot(plain, {
padToPieceLength: fileSize > TORRENT_V2_PIECE_BYTES,
});
if (!pieceRoot) throw new Error('Не удалось вычислить torrent-v2 hash части');
if (chunkCount <= 1) singlePieceRoot = pieceRoot.slice();
else await pieceAccumulator.addPieceRoot(pieceRoot);
encrypted = await encryptBytesAesGcm(plain, fileKey, iv, aad); encrypted = await encryptBytesAesGcm(plain, fileKey, iv, aad);
const stored = await uploadEncryptedObject(encrypted, uploadContext); const stored = await uploadEncryptedObject(encrypted, uploadContext);
pageDescriptors.push({ descriptors.push({ i: index, id: stored.id, ps: plain.byteLength, es: stored.encryptedSize });
i: index, encryptedTotal += stored.encryptedSize;
id: stored.id, onProgress?.({ phase: 'chunks', chunkIndex: index, chunkCount,
ps: plain.byteLength, processedBytes: Math.min(fileSize, start + plain.byteLength), totalBytes: fileSize });
es: encrypted.byteLength,
ph: bytesToBase64Url(pieceRoot),
});
completedBytes += plain.byteLength;
onProgress?.({
phase: 'chunks',
chunkIndex: index,
chunkCount,
processedBytes: completedBytes,
totalBytes: fileSize,
});
} finally { } finally {
plain.fill(0); plain.fill(0);
iv.fill(0); iv.fill(0);
aad.fill(0); aad.fill(0);
encrypted?.fill(0); encrypted?.fill(0);
} }
if (pageDescriptors.length >= DM_FILE_MANIFEST_PAGE_CHUNKS || index === chunkCount - 1) {
const pageRef = await encryptAndUploadManifestPage({
descriptors: pageDescriptors,
pageIndex,
fileKey,
ivPrefix,
uploadContext,
});
pageRefs.push(pageRef);
pageDescriptors = [];
pageIndex += 1;
}
} }
const manifestBytes = encodeJson({
const piecesRoot = fileSize <= 0 v: R2_MANIFEST_VERSION, scheme: R2_MANIFEST_SCHEME,
? null chunkSize: DM_FILE_CHUNK_BYTES, fileSize, chunkCount, chunks: descriptors,
: (chunkCount <= 1 ? singlePieceRoot : await pieceAccumulator.finalize());
const torrentInfo = await computeTorrentV2InfoHash({
name: normalizeFileName(file.name),
size: fileSize,
piecesRoot,
}); });
const rootManifest = {
v: MANIFEST_VERSION,
scheme: MANIFEST_SCHEME,
chunkSize: DM_FILE_CHUNK_BYTES,
fileSize,
chunkCount,
pages: pageRefs,
torrent: {
metaVersion: 2,
blockLength: TORRENT_V2_BLOCK_BYTES,
pieceLength: TORRENT_V2_PIECE_BYTES,
piecesRoot: piecesRoot ? bytesToBase64Url(piecesRoot) : '',
infoHash: torrentInfo.infoHashB64Url,
},
};
const rootPlain = encodeJson(rootManifest);
const iv = rootIv(ivPrefix); const iv = rootIv(ivPrefix);
const aad = rootAad(ivPrefix); const aad = rootAad(ivPrefix);
let rootEncrypted = null; let encryptedManifest = null;
try { try {
rootEncrypted = await encryptBytesAesGcm(rootPlain, fileKey, iv, aad); encryptedManifest = await encryptBytesAesGcm(manifestBytes, fileKey, iv, aad);
const storedRoot = await uploadEncryptedObject(rootEncrypted, uploadContext); const stored = await uploadEncryptedObject(encryptedManifest, uploadContext);
onProgress?.({ phase: 'manifest', processedBytes: fileSize, totalBytes: fileSize, chunkCount }); onProgress?.({ phase: 'manifest', processedBytes: fileSize, totalBytes: fileSize, chunkCount });
return { return {
version: 2, version: R2_MANIFEST_VERSION,
id: storedRoot.id, id: stored.id, url: stored.url,
url: storedRoot.url,
keyB64Url: bytesToBase64Url(fileKey), keyB64Url: bytesToBase64Url(fileKey),
ivPrefixB64Url: bytesToBase64Url(ivPrefix), ivPrefixB64Url: bytesToBase64Url(ivPrefix),
name: normalizeFileName(file.name), name: normalizeFileName(file.name),
mime: String(file.type || 'application/octet-stream').trim().slice(0, 160) || 'application/octet-stream', mime: String(file.type || 'application/octet-stream').trim().slice(0, 160) || 'application/octet-stream',
size: fileSize, size: fileSize, encryptedSize: encryptedTotal + stored.encryptedSize,
encryptedSize: pageRefs.reduce((sum, item) => sum + Number(item.encryptedSize || 0), 0) + storedRoot.encryptedSize, chunkSize: DM_FILE_CHUNK_BYTES, chunkCount,
chunkSize: DM_FILE_CHUNK_BYTES,
chunkCount,
torrentV2InfoHashB64Url: torrentInfo.infoHashB64Url,
torrentV2PiecesRootB64Url: piecesRoot ? bytesToBase64Url(piecesRoot) : '',
kind: String(kind || 'file') === 'voice' ? 'voice' : 'file', kind: String(kind || 'file') === 'voice' ? 'voice' : 'file',
durationMs: Math.max(0, Math.floor(Number(durationMs || 0))), durationMs: Math.max(0, Math.floor(Number(durationMs || 0))),
}; };
} finally { } finally {
rootPlain.fill(0); manifestBytes.fill(0);
iv.fill(0); iv.fill(0);
aad.fill(0); aad.fill(0);
rootEncrypted?.fill(0); encryptedManifest?.fill(0);
} }
} finally { } finally {
fileKey.fill(0); fileKey.fill(0);
ivPrefix.fill(0); ivPrefix.fill(0);
singlePieceRoot?.fill(0);
} }
} }
/** Получение зашифрованного манифеста v3 без BitTorrent-метаданных. */
async function loadV3RootManifest(attachment) {
const id = String(attachment?.id || '').trim();
const url = String(attachment?.url || '').trim();
const key = base64UrlToBytes(String(attachment?.keyB64Url || ''));
const ivPrefix = base64UrlToBytes(String(attachment?.ivPrefixB64Url || ''));
if (!id || !url || key.byteLength !== 32 || ivPrefix.byteLength !== 4) {
key.fill(0); ivPrefix.fill(0);
throw new Error('Недостаточно данных для расшифровки личного файла');
}
let encrypted = null;
let plain = null;
const iv = rootIv(ivPrefix);
const aad = rootAad(ivPrefix);
try {
encrypted = await fetchVerifiedObject(url, id);
plain = await decryptBytesAesGcm(encrypted, key, iv, aad);
const manifest = decodeJson(plain);
const size = Number(manifest?.fileSize);
const count = Number(manifest?.chunkCount);
if (manifest?.v !== R2_MANIFEST_VERSION || manifest.scheme !== R2_MANIFEST_SCHEME
|| manifest.chunkSize !== DM_FILE_CHUNK_BYTES
|| !Number.isSafeInteger(size) || size < 0 || size > DM_R2_FILE_MAX_BYTES
|| size !== Number(attachment.size)
|| count !== Math.ceil(size / DM_FILE_CHUNK_BYTES)
|| !Array.isArray(manifest.chunks) || manifest.chunks.length !== count) {
throw new Error('Некорректный манифест личного файла R2');
}
for (let i = 0; i < count; i += 1) {
const item = manifest.chunks[i];
const expectedSize = Math.min(DM_FILE_CHUNK_BYTES, size - i * DM_FILE_CHUNK_BYTES);
if (item?.i !== i || !/^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(String(item.id || ''))
|| item.ps !== expectedSize || item.es !== expectedSize + 16) {
throw new Error('Повреждены ссылки на части файла');
}
}
return { manifest, key, ivPrefix, serverBase: objectBaseFromUrl(url) };
} catch (error) {
key.fill(0); ivPrefix.fill(0);
throw error;
} finally {
encrypted?.fill(0);
plain?.fill(0);
iv.fill(0);
aad.fill(0);
}
}
async function decryptV3ToSink(attachment, sink, { onProgress = null } = {}) {
const context = await loadV3RootManifest(attachment);
let processedBytes = 0;
try {
for (const item of context.manifest.chunks) {
const encrypted = await fetchVerifiedObject(objectUrl(context.serverBase, item.id), item.id);
const iv = chunkIv(context.ivPrefix, item.i);
const aad = chunkAad(context.ivPrefix, item.i);
let plain = null;
try {
if (encrypted.byteLength !== item.es) throw new Error('Неверный размер зашифрованной части');
plain = await decryptBytesAesGcm(encrypted, context.key, iv, aad);
if (plain.byteLength !== item.ps) throw new Error('Неверный размер расшифрованной части');
await sink(plain, item);
processedBytes += plain.byteLength;
onProgress?.({ processedBytes, totalBytes: context.manifest.fileSize,
chunkIndex: item.i, chunkCount: context.manifest.chunkCount });
} finally {
encrypted.fill(0);
iv.fill(0);
aad.fill(0);
plain?.fill(0);
}
}
if (processedBytes !== context.manifest.fileSize) throw new Error('Неверный итоговый размер файла');
return context.manifest;
} finally {
context.key.fill(0);
context.ivPrefix.fill(0);
}
}
async function decryptChunkedToSink(attachment, sink, options) {
if (Number(attachment?.version) >= 3) return decryptV3ToSink(attachment, sink, options);
return decryptV2ToSink(attachment, sink, options);
}
async function loadV2RootManifest(attachment) { async function loadV2RootManifest(attachment) {
const id = String(attachment?.id || '').trim(); const id = String(attachment?.id || '').trim();
const url = String(attachment?.url || '').trim(); const url = String(attachment?.url || '').trim();
@@ -418,9 +415,9 @@ async function loadV2RootManifest(attachment) {
if (Number(manifest?.v) !== MANIFEST_VERSION || manifest?.scheme !== MANIFEST_SCHEME) { if (Number(manifest?.v) !== MANIFEST_VERSION || manifest?.scheme !== MANIFEST_SCHEME) {
throw new Error('Неизвестная версия манифеста файла'); throw new Error('Неизвестная версия манифеста файла');
} }
if (Number(manifest.chunkSize) !== DM_FILE_CHUNK_BYTES) throw new Error('Неожиданный размер chunk в манифесте'); if (Number(manifest.chunkSize) !== LEGACY_DM_FILE_CHUNK_BYTES) throw new Error('Неожиданный размер chunk в манифесте');
if (Number(manifest.fileSize) !== Number(attachment?.size || 0)) throw new Error('Размер файла не совпал с манифестом'); if (Number(manifest.fileSize) !== Number(attachment?.size || 0)) throw new Error('Размер файла не совпал с манифестом');
if (Number(manifest.chunkCount) !== Math.ceil(Number(manifest.fileSize || 0) / DM_FILE_CHUNK_BYTES)) { if (Number(manifest.chunkCount) !== Math.ceil(Number(manifest.fileSize || 0) / LEGACY_DM_FILE_CHUNK_BYTES)) {
throw new Error('Некорректное число частей в манифесте'); throw new Error('Некорректное число частей в манифесте');
} }
@@ -635,7 +632,7 @@ export async function decryptDmFileToBlob(attachment = {}, options = {}) {
return blob; return blob;
} }
const parts = []; const parts = [];
await decryptV2ToSink(attachment, async (plain) => { await decryptChunkedToSink(attachment, async (plain) => {
parts.push(plain.slice().buffer); parts.push(plain.slice().buffer);
}, options); }, options);
return new Blob(parts, { type: String(attachment?.mime || 'application/octet-stream') || 'application/octet-stream' }); return new Blob(parts, { type: String(attachment?.mime || 'application/octet-stream') || 'application/octet-stream' });
@@ -672,7 +669,7 @@ export async function downloadAndDecryptDmFile(attachment = {}, { onProgress = n
if (writable) { if (writable) {
try { try {
await decryptV2ToSink(attachment, async (plain) => { await decryptChunkedToSink(attachment, async (plain) => {
await writable.write(plain); await writable.write(plain);
}, { onProgress }); }, { onProgress });
await writable.close(); await writable.close();
@@ -692,7 +689,7 @@ export async function downloadAndDecryptDmFile(attachment = {}, { onProgress = n
} }
export async function buildDmFileTorrentV2(attachment = {}) { export async function buildDmFileTorrentV2(attachment = {}) {
if (Number(attachment?.version || 1) < 2) throw new Error('Torrent-v2 metadata есть только у файлов Сияния v2'); if (Number(attachment?.version || 1) !== 2) throw new Error('Torrent-v2 metadata есть только у старых файлов Сияния v2');
const context = await loadV2RootManifest(attachment); const context = await loadV2RootManifest(attachment);
const pieceLayer = []; const pieceLayer = [];
try { try {
+6 -3
View File
@@ -128,8 +128,10 @@ function normalizeFileAttachment(fields = {}) {
encryptedSize: Number.isFinite(encryptedSize) && encryptedSize > 0 ? encryptedSize : 0, encryptedSize: Number.isFinite(encryptedSize) && encryptedSize > 0 ? encryptedSize : 0,
chunkSize: Number.isFinite(chunkSize) && chunkSize > 0 ? chunkSize : 0, chunkSize: Number.isFinite(chunkSize) && chunkSize > 0 ? chunkSize : 0,
chunkCount: Number.isFinite(chunkCount) && chunkCount >= 0 ? Math.floor(chunkCount) : 0, chunkCount: Number.isFinite(chunkCount) && chunkCount >= 0 ? Math.floor(chunkCount) : 0,
torrentV2InfoHashB64Url: String(fields.th || '').trim(), ...(version === 2 ? {
torrentV2PiecesRootB64Url: String(fields.pr || '').trim(), torrentV2InfoHashB64Url: String(fields.th || '').trim(),
torrentV2PiecesRootB64Url: String(fields.pr || '').trim(),
} : {}),
kind, kind,
durationMs, durationMs,
}; };
@@ -173,7 +175,8 @@ export function buildDmFileTechBlock(attachment = {}) {
const piecesRoot = String(attachment?.torrentV2PiecesRootB64Url || '').trim(); const piecesRoot = String(attachment?.torrentV2PiecesRootB64Url || '').trim();
const kind = String(attachment?.kind || 'file') === 'voice' ? 'voice' : 'file'; const kind = String(attachment?.kind || 'file') === 'voice' ? 'voice' : 'file';
const durationMs = Math.max(0, Math.floor(Number(attachment?.durationMs || 0))); const durationMs = Math.max(0, Math.floor(Number(attachment?.durationMs || 0)));
return `<S:file;v=2;id=${id};url=${encodedUrl};key=${keyB64Url};ivp=${ivPrefix};name=${name};mime=${mime};size=${size};encsize=${encryptedSize};chunk=${chunkSize};chunks=${chunkCount};th=${torrentHash};pr=${piecesRoot};kind=${kind};dur=${durationMs}>`; const torrentFields = version === 2 ? `;th=${torrentHash};pr=${piecesRoot}` : '';
return `<S:file;v=${version};id=${id};url=${encodedUrl};key=${keyB64Url};ivp=${ivPrefix};name=${name};mime=${mime};size=${size};encsize=${encryptedSize};chunk=${chunkSize};chunks=${chunkCount}${torrentFields};kind=${kind};dur=${durationMs}>`;
} }
const ivB64Url = String(attachment?.ivB64Url || '').trim(); const ivB64Url = String(attachment?.ivB64Url || '').trim();
@@ -1,4 +1,4 @@
import { bytesToBase64Url } from './crypto-utils.js'; import { encodePublicPiecesRoot } from './public-pieces-root.js';
import { computeTorrentV2PieceRoot, TorrentV2PieceAccumulator, TORRENT_V2_PIECE_BYTES } from './torrent-v2-service.js'; import { computeTorrentV2PieceRoot, TorrentV2PieceAccumulator, TORRENT_V2_PIECE_BYTES } from './torrent-v2-service.js';
export const R2_MAX_FILE_BYTES = 500 * 1024 * 1024; export const R2_MAX_FILE_BYTES = 500 * 1024 * 1024;
@@ -18,5 +18,5 @@ export async function preparePublicFile(file, { onProgress = null } = {}) {
onProgress?.(Math.min(file.size, offset + bytes.byteLength), file.size); onProgress?.(Math.min(file.size, offset + bytes.byteLength), file.size);
} }
const root = await accumulator.finalize(); const root = await accumulator.finalize();
return { file, name: String(file.name || 'file'), size: file.size, mm: fileMime(file), pr: bytesToBase64Url(root) }; return { file, name: String(file.name || 'file'), size: file.size, mm: fileMime(file), pr: encodePublicPiecesRoot(root) };
} }
+3 -2
View File
@@ -1,5 +1,6 @@
import { t } from '../i18n/index.js'; import { t } from '../i18n/index.js';
import { preparePublicFile, R2_MAX_FILE_BYTES } from './file-preparation-service.js'; import { preparePublicFile, R2_MAX_FILE_BYTES } from './file-preparation-service.js';
import { validatePublicPiecesRoot } from './public-pieces-root.js';
import { importPkcs8Ed25519, signBase64 } from './crypto-utils.js'; import { importPkcs8Ed25519, signBase64 } from './crypto-utils.js';
import { sha256HexFromArrayBuffer, validateSha256Hex } from './arweave-file-service.js'; import { sha256HexFromArrayBuffer, validateSha256Hex } from './arweave-file-service.js';
import { loadSessionMaterial } from './key-vault.js'; import { loadSessionMaterial } from './key-vault.js';
@@ -232,7 +233,7 @@ async function uploadR2PublicFile({ file, login, sessionId, wsUrl, onStatus }) {
} }
export function publicR2Url(pr) { export function publicR2Url(pr) {
const root = String(pr || '').trim(); const root = String(pr || '');
if (!/^[A-Za-z0-9_-]{43}$/.test(root)) throw new Error('Некорректный Pieces Root'); if (!validatePublicPiecesRoot(root)) throw new Error('Некорректный Pieces Root');
return `https://files.shineup.me/${root}`; return `https://files.shineup.me/${root}`;
} }
@@ -0,0 +1,22 @@
import { base58ToBytes, bytesToBase58 } from './crypto-utils.js';
// Публичные вложения: PR — 32 байта корня BitTorrent v2 в каноническом Base58.
// Длина строки переменная (обычно 43–44 символа); DM v2 и Arweave TX ID не затрагиваются.
const PUBLIC_PR_BASE58 = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
export function encodePublicPiecesRoot(rootBytes) {
if (!(rootBytes instanceof Uint8Array) || rootBytes.byteLength !== 32) {
throw new Error('Некорректный 32-байтный Pieces Root');
}
return bytesToBase58(rootBytes);
}
export function validatePublicPiecesRoot(pr) {
if (typeof pr !== 'string' || !PUBLIC_PR_BASE58.test(pr)) return false;
try {
const bytes = base58ToBytes(pr);
return bytes.byteLength === 32 && bytesToBase58(bytes) === pr;
} catch {
return false;
}
}
@@ -1,6 +1,7 @@
import test from 'node:test'; import test from 'node:test';
import assert from 'node:assert/strict'; import assert from 'node:assert/strict';
import { readFile } from 'node:fs/promises'; import { readFile } from 'node:fs/promises';
import { validatePublicPiecesRoot } from '../js/services/public-pieces-root.js';
const source = await readFile(new URL('../js/services/attachment-format.js', import.meta.url), 'utf8'); const source = await readFile(new URL('../js/services/attachment-format.js', import.meta.url), 'utf8');
@@ -52,7 +53,7 @@ function loadRenderer() {
.replace(/^import .*;\s*$/gm, '') .replace(/^import .*;\s*$/gm, '')
.replace(/^export /gm, ''); .replace(/^export /gm, '');
const factory = new Function('t', 'th', 'formatNumber', 'openMediaViewer', 'buildArweaveDataUrl', const factory = new Function('t', 'th', 'formatNumber', 'openMediaViewer', 'buildArweaveDataUrl',
'validateArweaveTxId', 'validateSha256Hex', 'resolvePublicFileUrl', 'document', 'window', 'fetch', 'validateArweaveTxId', 'validateSha256Hex', 'resolvePublicFileUrl', 'validatePublicPiecesRoot', 'document', 'window', 'fetch',
`${normalized}\nreturn { getAttachmentKind, createAttachmentCarouselElement, parseMessageAttachments };`); `${normalized}\nreturn { getAttachmentKind, createAttachmentCarouselElement, parseMessageAttachments };`);
const api = factory( const api = factory(
(key) => key, (key) => key,
@@ -63,6 +64,7 @@ function loadRenderer() {
(id) => /^[A-Za-z0-9_-]{43}$/.test(id), (id) => /^[A-Za-z0-9_-]{43}$/.test(id),
(id) => /^[a-f0-9]{64}$/.test(id), (id) => /^[a-f0-9]{64}$/.test(id),
async ({ pr, sha256 }) => pr ? `https://files.shineup.me/${pr}` : `https://old.example/files/${sha256}`, async ({ pr, sha256 }) => pr ? `https://files.shineup.me/${pr}` : `https://old.example/files/${sha256}`,
validatePublicPiecesRoot,
{ createElement: (tag) => new TestElement(tag) }, { createElement: (tag) => new TestElement(tag) },
{ location: { origin: 'https://shineup.me' }, open() {} }, { location: { origin: 'https://shineup.me' }, open() {} },
async () => ({ ok: true }), async () => ({ ok: true }),
@@ -0,0 +1,59 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import { encodePublicPiecesRoot, validatePublicPiecesRoot } from '../js/services/public-pieces-root.js';
import { preparePublicFile } from '../js/services/file-preparation-service.js';
import { publicR2Url } from '../js/services/public-file-service.js';
import { buildAttachmentBlock, parseMessageAttachments, normalizeAttachment } from '../js/services/attachment-format.js';
import { computeTorrentV2PieceRoot } from '../js/services/torrent-v2-service.js';
test('Base58-кодирование публичного PR: 32 байта, в том числе ведущие нули', () => {
const vectors = [
[0, '1'.repeat(32)],
[1, '4vJ9JU1bJJE96FWSJKvHsmmFADCg4gpZQff4P3bkLKi'],
[255, 'JEKNVnkbo3jma5nREBBJCDoXFVeKkD56V3xKrvRmWxFG'],
];
for (const [value, expected] of vectors) {
assert.equal(encodePublicPiecesRoot(new Uint8Array(32).fill(value)), expected);
assert.equal(validatePublicPiecesRoot(expected), true);
assert.equal(publicR2Url(expected), `https://files.shineup.me/${expected}`);
}
assert.throws(() => encodePublicPiecesRoot(new Uint8Array(31)));
});
test('не принимает старый Base64URL, некорректные символы, длину и ненормализованные значения', () => {
for (const invalid of [
'', 'A'.repeat(42) + '_', 'A'.repeat(42) + '-', 'A'.repeat(43) + '=',
'0'.repeat(44), 'O'.repeat(44), 'I'.repeat(44), 'l'.repeat(44),
'A'.repeat(31), 'A'.repeat(45), '1'.repeat(33), ` ${'1'.repeat(32)}`,
]) {
assert.equal(validatePublicPiecesRoot(invalid), false, invalid);
assert.throws(() => publicR2Url(invalid), invalid);
}
});
test('подготовка публичного файла создаёт BitTorrent v2 PR именно в Base58', async () => {
const bytes = Uint8Array.from([10, 20, 30, 40, 50, 60, 70]);
const file = new File([bytes], 'photo.png', { type: 'image/png' });
const prepared = await preparePublicFile(file);
const expectedMerkleRoot = await computeTorrentV2PieceRoot(bytes);
assert.equal(prepared.pr, encodePublicPiecesRoot(expectedMerkleRoot));
assert.equal(validatePublicPiecesRoot(prepared.pr), true);
assert.equal(prepared.mm, 'image/png');
assert.equal(prepared.size, bytes.length);
});
test('публичный S:att сохраняет PR в Base58 без перекодирования, включая Arweave', () => {
for (const value of [0, 1, 255]) {
const pr = encodePublicPiecesRoot(new Uint8Array(32).fill(value));
const attachment = { name: 'photo.jpg', size: 100, pr, mm: 'image/jpeg', ar: '' };
const encoded = buildAttachmentBlock(attachment);
assert.match(encoded, new RegExp(`;pr=${pr};mm=image/jpeg>`));
const decoded = parseMessageAttachments(`${encoded}\nТекст`);
assert.equal(decoded.attachments.length, 1);
assert.equal(decoded.attachments[0].pr, pr);
assert.equal(decoded.text, 'Текст');
assert.equal(normalizeAttachment({ ...attachment, ar: 'A'.repeat(43) }).ar, 'A'.repeat(43));
}
const legacyEncoded = `<S:att;v=1;nm=photo.jpg;sz=100;pr=${'A'.repeat(42)}_>`;
assert.equal(parseMessageAttachments(legacyEncoded).attachments.length, 0);
});