@devultur/self-host 1.2.0 → 1.3.1

package/dist/index.d.ts

@@ -167,7 +167,22 @@ interface WorkerConfig {
      */
     lock?: ObjectLock;
     transcode?: TranscodeConfig;
+    /**
+     * What an upload whose first bytes contradict its declared Content-Type gets (see `ContentSniffingMode`). Every
+     * mismatch is logged (`[content-sniff] {declared, detected, key, action}`). A transcode's outputs are never checked.
+     * Unset: `scriptable`.
+     */
+    contentSniffing?: ContentSniffingMode;
 }
+/**
+ * - `scriptable` (default): `415 content_type_mismatch` only when the bytes are markup (HTML, SVG, XML) under an inert
+ *   type; any other mismatch is stored with its declared type.
+ * - `reject`: `415` for every mismatch.
+ * - `octet-stream`: a single PUT that mismatches is stored as `application/octet-stream`; a multipart upload is
+ *   rejected (R2 fixes its type when it starts).
+ * - `off`: no check.
+ */
+type ContentSniffingMode = "scriptable" | "reject" | "octet-stream" | "off";
 /** What an auth plugin established about the request's credential. */
 interface RequestAccess {
     /**
@@ -752,4 +767,4 @@ interface CreateWorkerOptions {
 }
 declare function createWorker(options?: CreateWorkerOptions): Hono<WorkerApp, hono_types.BlankSchema, "/">;
 
-export { type AllowedCredential, type AssetListEntry, type AuthorizeLockChangeHook, type BeforeLinkRedeemHook, type ComposedPlugins, type CreateWorkerOptions, type CredentialDecision, type CredentialKind, type CredentialPolicyOptions, type CredentialRequest, DownloadLink, type DownloadLinkInfo, type DownloadLinkRecord, type DownloadLinkStorage, ENCRYPTION_KEY_MISSING_CODE, type EncodeMetrics, HOLD_PAGE_SIZE, type HoldSkip, type ImageTransformParams, type IssueCredentialHook, type Json, KEYS_BUCKET_MISSING_CODE, LOCK_AUDIT_PREFIX, LOCK_HOLD_HEADER, LOCK_METADATA_KEY, LOCK_SIDECAR_PREFIX, LOCK_UNTIL_HEADER, type LockAuditAction, type LockAuditRecord, type LockChangeAction, type LockChangeDecision, type LockChangeRequest, type LockLookupOptions, type LockSidecar, type LockSource, MAX_ASSET_LIST_LIMIT, MAX_EXPIRED_LOOKUPS, MAX_UPLOAD_TOKEN_TTL_SECONDS, MaxResolution, ObjectMeta, type OnLockAuditHook, type PendingUploadInfo, type PluginContext, type PluginMiddleware, type PluginRoute, type PrefixDeleteOptions, type PrefixDeleteResult, type PrefixWalkOptions, RESERVED_LOCK_PREFIXES, type RawStorageClass, type RequestAccess, type RequestState, type RequestStatePatch, type RetainedObject, type RetainedSummary, type RouteResult, type StoredObjectLock, TOKEN_REJECTED_CODE, type TranscodeConfig, type TranscodeJob, UPLOAD_TOKEN_TYPE, type UploadGrant, type UploadRules, type UploadTypeRule, type WorkerApp, WorkerAuthErrorCode, type WorkerConfig, type WorkerEnv, type WorkerPlugin, type WorkerVariables, cancelPendingUpload, createWorker, credentialPolicy, defaultPlugins, deletePrefix, deletePrefixRespectingLocks, downloadLinks, edgeCacheTag, getPendingUpload, getRequestState, getRouteResult, hashKey, imageOriginAuthorization, isAuthenticated, isImageOriginRequest, isObjectExpired, isOpenRoute, isServiceToken, isUploadUrl, isVariantKey, logEncodeMetrics, parseEncodeMetrics, parseTransformParams, readImageOriginScope, readObjectLock, readStoryboardKey, readTokenScopes, readTranscodeOutputKeys, readTranscodeOutputs, retainedSummary, servedCacheControl, staticConfig, storageKey, updateRequestState, uploadGrantFromClaims, variantPrefix, vcpuSecondsPerVideoMinute, verifyViewerToken, withOutputUrls, workerSecretAuth };
+export { type AllowedCredential, type AssetListEntry, type AuthorizeLockChangeHook, type BeforeLinkRedeemHook, type ComposedPlugins, type ContentSniffingMode, type CreateWorkerOptions, type CredentialDecision, type CredentialKind, type CredentialPolicyOptions, type CredentialRequest, DownloadLink, type DownloadLinkInfo, type DownloadLinkRecord, type DownloadLinkStorage, ENCRYPTION_KEY_MISSING_CODE, type EncodeMetrics, HOLD_PAGE_SIZE, type HoldSkip, type ImageTransformParams, type IssueCredentialHook, type Json, KEYS_BUCKET_MISSING_CODE, LOCK_AUDIT_PREFIX, LOCK_HOLD_HEADER, LOCK_METADATA_KEY, LOCK_SIDECAR_PREFIX, LOCK_UNTIL_HEADER, type LockAuditAction, type LockAuditRecord, type LockChangeAction, type LockChangeDecision, type LockChangeRequest, type LockLookupOptions, type LockSidecar, type LockSource, MAX_ASSET_LIST_LIMIT, MAX_EXPIRED_LOOKUPS, MAX_UPLOAD_TOKEN_TTL_SECONDS, MaxResolution, ObjectMeta, type OnLockAuditHook, type PendingUploadInfo, type PluginContext, type PluginMiddleware, type PluginRoute, type PrefixDeleteOptions, type PrefixDeleteResult, type PrefixWalkOptions, RESERVED_LOCK_PREFIXES, type RawStorageClass, type RequestAccess, type RequestState, type RequestStatePatch, type RetainedObject, type RetainedSummary, type RouteResult, type StoredObjectLock, TOKEN_REJECTED_CODE, type TranscodeConfig, type TranscodeJob, UPLOAD_TOKEN_TYPE, type UploadGrant, type UploadRules, type UploadTypeRule, type WorkerApp, WorkerAuthErrorCode, type WorkerConfig, type WorkerEnv, type WorkerPlugin, type WorkerVariables, cancelPendingUpload, createWorker, credentialPolicy, defaultPlugins, deletePrefix, deletePrefixRespectingLocks, downloadLinks, edgeCacheTag, getPendingUpload, getRequestState, getRouteResult, hashKey, imageOriginAuthorization, isAuthenticated, isImageOriginRequest, isObjectExpired, isOpenRoute, isServiceToken, isUploadUrl, isVariantKey, logEncodeMetrics, parseEncodeMetrics, parseTransformParams, readImageOriginScope, readObjectLock, readStoryboardKey, readTokenScopes, readTranscodeOutputKeys, readTranscodeOutputs, retainedSummary, servedCacheControl, staticConfig, storageKey, updateRequestState, uploadGrantFromClaims, variantPrefix, vcpuSecondsPerVideoMinute, verifyViewerToken, withOutputUrls, workerSecretAuth };

package/dist/index.js

@@ -801,6 +801,62 @@ function addRouteResult(context, result) {
   context.set(ROUTE_RESULT_VARIABLE, { ...getRouteResult(context), ...result });
 }
 
+// src/routes/content-safety.ts
+var SANDBOX_CSP = "sandbox; default-src 'none'";
+var SAFE_INLINE_TYPES = /* @__PURE__ */ new Set([
+  "image/png",
+  "image/jpeg",
+  "image/webp",
+  "image/gif",
+  "image/avif",
+  "application/pdf",
+  "text/plain",
+  "text/csv",
+  "application/json",
+  "text/vtt",
+  "application/vnd.apple.mpegurl",
+  "application/x-mpegurl"
+]);
+var SAFE_INLINE_FAMILIES = ["video/", "audio/"];
+function contentTypeEssence(contentType) {
+  return contentType?.split(";")[0]?.trim().toLowerCase() ?? "";
+}
+function isSafeInlineType(contentType) {
+  const essence = contentTypeEssence(contentType);
+  if (SAFE_INLINE_TYPES.has(essence)) return true;
+  return SAFE_INLINE_FAMILIES.some((family) => essence.startsWith(family));
+}
+function attachmentOf(disposition, filename) {
+  if (disposition?.startsWith("attachment")) return disposition;
+  if (disposition?.startsWith("inline")) return `attachment${disposition.slice("inline".length)}`;
+  return contentDispositionAttachment(filename || "download");
+}
+function applyContentSafety(headers, filename, isPublic) {
+  headers.set("X-Content-Type-Options", "nosniff");
+  if (isPublic) headers.set("Cross-Origin-Resource-Policy", "cross-origin");
+  if (isSafeInlineType(headers.get("Content-Type"))) return;
+  headers.set("Content-Security-Policy", SANDBOX_CSP);
+  headers.set("Content-Disposition", attachmentOf(headers.get("Content-Disposition"), filename));
+}
+function basenameOf(url) {
+  const last = new URL(url).pathname.split("/").pop() ?? "";
+  try {
+    return decodeURIComponent(last);
+  } catch {
+    return last;
+  }
+}
+function isPublicMediaUrl(url) {
+  return new URL(url).pathname.startsWith("/v1/media/public/");
+}
+var contentSafety = async (context, next) => {
+  await next();
+  const headers = new Headers(context.res.headers);
+  applyContentSafety(headers, basenameOf(context.req.url), isPublicMediaUrl(context.req.url));
+  const { body, status, statusText } = context.res;
+  context.res = new Response(body, { status, statusText, headers });
+};
+
 // src/routes/object-response.ts
 import {
   AES_BLOCK_BYTES,
@@ -865,6 +921,25 @@ async function digestBody(body, declared, header) {
   if (expected && expected !== actual) return { mismatch: { expected, actual } };
   return { sha256: actual };
 }
+async function checkPartSha256(context, multipart, body) {
+  const partSha256 = headerSha256(context);
+  if (partSha256 === null) {
+    return context.json({ error: "x-devultur-sha256 must be a 64-character hex string", code: "invalid_sha256" }, 400);
+  }
+  if (multipart.sha256 && !partSha256) {
+    return context.json(
+      {
+        error: "Each part must carry its x-devultur-sha256 when the upload declares one",
+        code: "part_sha256_required"
+      },
+      400
+    );
+  }
+  if (!partSha256) return null;
+  const digest = await digestBody(body, void 0, partSha256);
+  if ("mismatch" in digest) return sha256Mismatch(context, digest.mismatch.expected, digest.mismatch.actual);
+  return null;
+}
 function lockMetadata(lock) {
   const encoded = encodeLockMetadata(lock);
   return encoded ? { [LOCK_METADATA_KEY]: encoded } : {};
@@ -1053,6 +1128,7 @@ async function gateRedemption(context, stub) {
   return gateLinkRedemption(context, linkInfoOf(await peeked.json()));
 }
 var download = new Hono2();
+download.use("*", contentSafety);
 download.get("/:linkId", async (context) => {
   if (context.req.method === "HEAD") return new Response(null, { status: 405, headers: { Allow: "GET" } });
   const linkId = context.req.param("linkId");
@@ -1256,6 +1332,14 @@ function inferMediaType(contentType) {
   if (contentType.startsWith("application/")) return MediaType.FILE;
   return null;
 }
+function resolveUploadMediaType(declared, contentType, isAssetRequest) {
+  const inferredType = inferMediaType(contentType);
+  if (declared && inferredType && declared !== inferredType) {
+    return failure(400, "media_type_mismatch", `mediaType "${declared}" does not match content type ${contentType}`);
+  }
+  const mediaType = declared ?? inferredType ?? (isAssetRequest ? MediaType.FILE : null);
+  return mediaType ?? failure(400, "unsupported_content_type", `Unsupported content type: ${contentType}`);
+}
 
 // src/routes/token-upload.ts
 var UPLOAD_TOKEN_TYPE = "upload";
@@ -2508,8 +2592,8 @@ function readJpeg(bytes) {
   return null;
 }
 function readPng(bytes) {
-  const isPng = bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71;
-  if (!isPng || bytes.length < 24) return null;
+  const isPng2 = bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71;
+  if (!isPng2 || bytes.length < 24) return null;
   return { width: uint32BE(bytes, 16), height: uint32BE(bytes, 20) };
 }
 function readWebp(bytes) {
@@ -2920,6 +3004,7 @@ function downloadDisposition(storedDisposition, key, filename) {
   return contentDispositionAttachment(key.split("/").pop() || "download");
 }
 var media = new Hono7();
+media.use("*", contentSafety);
 media.get("/:key{.+}", async (context) => {
   const key = context.req.param("key");
   const fullKey = storageKey(context, key);
@@ -3042,6 +3127,7 @@ media.get("/:key{.+}", async (context) => {
     headers.set("Content-Disposition", object.httpMetadata.contentDisposition);
   }
   if (isOwnerAccess) for (const [name, value] of await lockHeaders(context, key, object)) headers.set(name, value);
+  applyContentSafety(headers, key.split("/").pop() ?? "", !isPrivate);
   const { response, kind } = await streamObject({
     bucket: context.env.MEDIA_BUCKET,
     keysBucket: context.env.KEYS_BUCKET,
@@ -4369,6 +4455,17 @@ var DERIVED_CONTENT_TYPES = /* @__PURE__ */ new Set([
 function isDerivedAssetKey(key) {
   return DERIVED_ASSET_KEY.test(key);
 }
+var DERIVED_TYPES_BY_FOLDER = {
+  hls: /* @__PURE__ */ new Set(["application/vnd.apple.mpegurl", "video/mp2t"]),
+  mp4: /* @__PURE__ */ new Set(["video/mp4"]),
+  thumbnails: /* @__PURE__ */ new Set(["image/jpeg"]),
+  storyboard: /* @__PURE__ */ new Set(["image/jpeg", "text/vtt"])
+};
+var DERIVED_OUTPUT_KEY = /^(?:public|private)\/video\/[A-Za-z0-9-]+\/(hls|mp4|thumbnails|storyboard)\/.+$/;
+function isTrustedDerivedOutput(key, contentType) {
+  const folder = DERIVED_OUTPUT_KEY.exec(key)?.[1];
+  return folder !== void 0 && (DERIVED_TYPES_BY_FOLDER[folder]?.has(contentType) ?? false);
+}
 var RAW_LIST_LIMIT = 100;
 async function inheritedExpiresAt(context, key) {
   if (!isDerivedAssetKey(key)) return void 0;
@@ -4391,6 +4488,7 @@ async function derivedAssetPending(context, key) {
   return {
     contentType: DERIVED_CONTENT_TYPES.has(declared) ? declared : "application/octet-stream",
     storageKey: storageKey(context, key),
+    isDerived: true,
     ...security ? { security } : {},
     ...expiresAt ? { expiresAt } : {}
   };
@@ -4457,12 +4555,298 @@ async function afterUploadWrite(context, key, pending, write, writtenEnc) {
   });
 }
 
+// src/routes/upload-content-check.ts
+import { decodeEncryptionMeta as decodeEncryptionMeta9 } from "@devultur/core";
+
+// src/markup-sniff.ts
+var MARKUP_WINDOW_BYTES = 1024;
+function utf16Encoding(head) {
+  if (head[0] === 255 && head[1] === 254) return "utf-16le";
+  if (head[0] === 254 && head[1] === 255) return "utf-16be";
+  return null;
+}
+function isBinaryDataByte(byte) {
+  return byte <= 8 || byte === 11 || byte >= 14 && byte <= 26 || byte >= 28 && byte <= 31;
+}
+function decodesStrictly(head, encoding) {
+  try {
+    new TextDecoder(encoding, { fatal: true }).decode(head, { stream: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function leadingText(head) {
+  const window = head.subarray(0, MARKUP_WINDOW_BYTES);
+  const decoded = new TextDecoder(utf16Encoding(head) ?? "utf-8").decode(window, { stream: true });
+  return decoded.replace(/^/, "").trimStart();
+}
+var HTML_TAGS = ["html", "head", "script", "iframe", "h1", "div", "font", "table", "a", "style", "title", "b"];
+var MORE_HTML_TAGS = ["body", "br", "p"];
+var DISTINCT_TAGS = ["html", "head", "script", "iframe", "div", "font", "table", "style", "title", "body"];
+var tagSource = (tags) => `<(?:${tags.join("|")})[\\s>]`;
+var ANY_HTML_TAG = new RegExp(tagSource([...HTML_TAGS, ...MORE_HTML_TAGS]));
+var DISTINCT_HTML_TAG = new RegExp(tagSource(DISTINCT_TAGS));
+var SVG_TAG = /<svg[\s>/]/;
+var LEADING_HTML = new RegExp(`^(?:<!doctype html|<!--|${tagSource([...HTML_TAGS, ...MORE_HTML_TAGS])})`);
+function detectScriptable(head) {
+  const start = leadingText(head).slice(0, 512).toLowerCase();
+  if (start.startsWith("<?xml")) return SVG_TAG.test(start) ? "svg" : "xml";
+  if (/^<svg[\s>/]/.test(start)) return "svg";
+  if (LEADING_HTML.test(start)) return "html";
+  return null;
+}
+function windowText(head, end) {
+  const window = head.subarray(0, Math.min(end, MARKUP_WINDOW_BYTES));
+  const utf16 = utf16Encoding(head);
+  const text = utf16 ? new TextDecoder(utf16).decode(window, { stream: true }) : String.fromCharCode(...window);
+  return text.toLowerCase();
+}
+function markupIn(text, htmlTag) {
+  if (SVG_TAG.test(text)) return "svg";
+  if (text.includes("<!doctype html") || htmlTag.test(text)) return "html";
+  return null;
+}
+function detectEmbeddedMarkup(head) {
+  return markupIn(windowText(head, MARKUP_WINDOW_BYTES), DISTINCT_HTML_TAG);
+}
+function detectMarkupBefore(head, end) {
+  const text = windowText(head, end);
+  if (text.includes("<!--")) return "html";
+  return markupIn(text, ANY_HTML_TAG);
+}
+
+// src/content-sniff.ts
+var SNIFF_HEAD_BYTES = 4096;
+var ascii = (text) => Array.from(text, (char) => char.charCodeAt(0));
+function hasBytesAt(head, offset, bytes) {
+  if (head.length < offset + bytes.length) return false;
+  return bytes.every((byte, index) => head[offset + index] === byte);
+}
+function readAscii(head, start, end) {
+  return String.fromCharCode(...head.subarray(start, Math.min(end, head.length)));
+}
+var startsWith = (...bytes) => (head) => hasBytesAt(head, 0, bytes);
+var riff = (form) => (head) => hasBytesAt(head, 0, ascii("RIFF")) && hasBytesAt(head, 8, ascii(form));
+var PDF_HEADER = ascii("%PDF-");
+function pdfHeaderOffset(head) {
+  const searchEnd = Math.min(head.length, MARKUP_WINDOW_BYTES) - PDF_HEADER.length;
+  for (let offset = 0; offset <= searchEnd; offset++) {
+    if (hasBytesAt(head, offset, PDF_HEADER)) return offset;
+  }
+  return -1;
+}
+var isPdf = (head) => pdfHeaderOffset(head) >= 0;
+function ftypBrands(head) {
+  if (!hasBytesAt(head, 4, ascii("ftyp"))) return null;
+  const boxSize = (head[0] ?? 0) << 24 | (head[1] ?? 0) << 16 | (head[2] ?? 0) << 8 | (head[3] ?? 0);
+  const boxEnd = Math.min(boxSize >= 16 ? boxSize : 16, head.length);
+  const brands = [readAscii(head, 8, 12)];
+  for (let offset = 16; offset + 4 <= boxEnd; offset += 4) brands.push(readAscii(head, offset, offset + 4));
+  return brands;
+}
+var AVIF_BRANDS = /* @__PURE__ */ new Set(["avif", "avis"]);
+var HEIF_BRANDS = /* @__PURE__ */ new Set(["heic", "heix", "heim", "heis", "hevc", "hevx", "mif1", "msf1"]);
+var LEGACY_MOV_ATOMS = ["moov", "mdat", "wide", "free", "skip", "pnot"];
+var hasBrand = (brands) => (head) => ftypBrands(head)?.some((brand) => brands.has(brand)) ?? false;
+var isIsoMedia = (head) => {
+  const brands = ftypBrands(head);
+  if (!brands) return LEGACY_MOV_ATOMS.some((atom) => hasBytesAt(head, 4, ascii(atom)));
+  const majorBrand = brands[0] ?? "";
+  return !AVIF_BRANDS.has(majorBrand) && !HEIF_BRANDS.has(majorBrand);
+};
+var EBML_MAGIC = [26, 69, 223, 163];
+var ebmlDocType = (...docTypes) => (head) => {
+  if (!hasBytesAt(head, 0, EBML_MAGIC)) return false;
+  const header = readAscii(head, 4, 64);
+  return docTypes.some((docType) => header.includes(docType));
+};
+var isPng = startsWith(137, 80, 78, 71, 13, 10, 26, 10);
+var isJpeg = startsWith(255, 216, 255);
+var isGif = (head) => hasBytesAt(head, 0, ascii("GIF87a")) || hasBytesAt(head, 0, ascii("GIF89a"));
+var isWebp = riff("WEBP");
+var isWav = riff("WAVE");
+var isAvif = hasBrand(AVIF_BRANDS);
+var isHeif = hasBrand(HEIF_BRANDS);
+var isWebm = ebmlDocType("webm");
+var isMatroskaOrWebm = ebmlDocType("matroska", "webm");
+var isOgg = startsWith(...ascii("OggS"), 0);
+var isFlac = startsWith(...ascii("fLaC"));
+var isMp3 = (head) => hasBytesAt(head, 0, ascii("ID3")) || head[0] === 255 && ((head[1] ?? 0) & 224) === 224;
+var isZip = (head) => hasBytesAt(head, 0, [80, 75, 3, 4]) || hasBytesAt(head, 0, [80, 75, 5, 6]);
+var isText = (head) => {
+  const utf16 = utf16Encoding(head);
+  if (utf16) return decodesStrictly(head.subarray(2), utf16);
+  return !head.some(isBinaryDataByte);
+};
+var isJson = (head) => !head.some(isBinaryDataByte) && decodesStrictly(head, "utf-8") && /^[{[]/.test(leadingText(head));
+var FAMILIES = [
+  ["pdf", startsWith(...PDF_HEADER)],
+  ["png", isPng],
+  ["jpeg", isJpeg],
+  ["gif", isGif],
+  ["webp", isWebp],
+  ["wav", isWav],
+  ["avif", isAvif],
+  ["heif", isHeif],
+  ["mp4", isIsoMedia],
+  ["webm", isWebm],
+  ["matroska", isMatroskaOrWebm],
+  ["ogg", isOgg],
+  ["flac", isFlac],
+  ["zip", isZip],
+  ["mp3", isMp3],
+  ["json", isJson],
+  ["text", isText],
+  ["pdf", isPdf]
+];
+function detectFamily(head) {
+  if (head.length === 0) return "empty";
+  const scriptable = detectScriptable(head);
+  if (scriptable) return scriptable;
+  return FAMILIES.find(([, signature]) => signature(head))?.[0] ?? "binary";
+}
+var OFFICE_ZIP_TYPES = ["wordprocessingml.document", "spreadsheetml.sheet", "presentationml.presentation"].map(
+  (subtype) => `application/vnd.openxmlformats-officedocument.${subtype}`
+);
+var typesWith = (types, signature) => types.map((type) => [type, signature]);
+var SIGNATURES = new Map([
+  ["application/pdf", isPdf],
+  ["image/png", isPng],
+  ["image/jpeg", isJpeg],
+  ["image/gif", isGif],
+  ["image/webp", isWebp],
+  ["image/avif", isAvif],
+  ...typesWith(["image/heic", "image/heif"], isHeif),
+  ...typesWith(["video/mp4", "video/quicktime", "video/x-m4v", "video/3gpp", "audio/mp4", "audio/x-m4a"], isIsoMedia),
+  ...typesWith(["video/webm", "audio/webm"], isWebm),
+  ...typesWith(["video/x-matroska", "audio/x-matroska"], isMatroskaOrWebm),
+  ...typesWith(["audio/mpeg", "audio/mp3"], isMp3),
+  ...typesWith(["audio/ogg", "video/ogg", "application/ogg", "audio/opus"], isOgg),
+  ...typesWith(["audio/wav", "audio/x-wav", "audio/wave", "audio/vnd.wave"], isWav),
+  ...typesWith(["audio/flac", "audio/x-flac"], isFlac),
+  ...typesWith(["application/zip", "application/x-zip-compressed", ...OFFICE_ZIP_TYPES], isZip),
+  ...typesWith(["text/plain", "text/csv", "text/markdown", "text/tab-separated-values"], isText),
+  ["application/json", isJson]
+]);
+function essenceOf(contentType) {
+  return contentType.split(";")[0]?.trim().toLowerCase() ?? "";
+}
+var TEXT_TYPES = /* @__PURE__ */ new Set([
+  "text/plain",
+  "text/csv",
+  "text/markdown",
+  "text/tab-separated-values",
+  "application/json"
+]);
+function embeddedMarkup(essence, head) {
+  if (essence === "application/pdf") {
+    const headerOffset = pdfHeaderOffset(head);
+    const before = detectMarkupBefore(head, headerOffset < 0 ? MARKUP_WINDOW_BYTES : headerOffset);
+    return before ?? detectEmbeddedMarkup(head);
+  }
+  return TEXT_TYPES.has(essence) ? detectEmbeddedMarkup(head) : null;
+}
+var SCRIPTABLE_FAMILIES = /* @__PURE__ */ new Set(["html", "svg", "xml"]);
+var mismatch = (detected) => ({
+  verdict: "mismatch",
+  detected,
+  isScriptable: SCRIPTABLE_FAMILIES.has(detected)
+});
+function sniffContent(declaredType, head) {
+  const essence = essenceOf(declaredType);
+  const signature = SIGNATURES.get(essence);
+  if (!signature) return { verdict: "unverifiable" };
+  const sample = head.subarray(0, SNIFF_HEAD_BYTES);
+  const scriptable = detectScriptable(sample) ?? embeddedMarkup(essence, sample);
+  if (scriptable) return mismatch(scriptable);
+  if (signature(sample)) return { verdict: "match" };
+  return mismatch(detectFamily(sample));
+}
+
+// src/routes/upload-content-check.ts
+var OCTET_STREAM = "application/octet-stream";
+var MULTIPART_PENDING_TTL_SECONDS = 24 * 60 * 60;
+function sniffingModeOf(context, pending) {
+  return pending?.contentSniffing ?? getRequestState(context).config?.contentSniffing ?? "scriptable";
+}
+function shouldSniffUpload(context, key, pending, contentType) {
+  const isRunnerWrite = pending ? Boolean(pending.isDerived) : true;
+  if (isRunnerWrite && isTrustedDerivedOutput(key, contentType)) return false;
+  return sniffingModeOf(context, pending) !== "off";
+}
+function mismatchAction(mode, mismatch2, isMultipart) {
+  if (mode === "scriptable") return mismatch2.isScriptable ? "rejected" : "accepted";
+  if (mode === "octet-stream" && !isMultipart) return "stored_as_octet_stream";
+  return "rejected";
+}
+function logMismatch(declared, mismatch2, key, action) {
+  console.warn(`[content-sniff] ${JSON.stringify({ declared, detected: mismatch2.detected, key, action })}`);
+}
+function contentTypeMismatch(context, declared, detected) {
+  return context.json(
+    {
+      error: `The file's content (${detected}) does not match its declared Content-Type ${declared}`,
+      code: "content_type_mismatch",
+      declared,
+      detected
+    },
+    415
+  );
+}
+function sniffHead(declared, body) {
+  return sniffContent(declared, new Uint8Array(body, 0, Math.min(body.byteLength, SNIFF_HEAD_BYTES)));
+}
+function checkSinglePutContent(context, upload2) {
+  const { contentType, key, pending } = upload2;
+  if (!shouldSniffUpload(context, key, pending, contentType)) return { contentType };
+  const result = sniffHead(contentType, upload2.body);
+  if (result.verdict !== "mismatch") return { contentType };
+  const action = mismatchAction(sniffingModeOf(context, pending), result, false);
+  logMismatch(contentType, result, key, action);
+  if (action === "accepted") return { contentType };
+  if (action === "stored_as_octet_stream") return { contentType: OCTET_STREAM };
+  return { rejected: contentTypeMismatch(context, contentType, result.detected) };
+}
+async function discardMultipart(context, active) {
+  const { pending, multipart, kvKey } = active;
+  await context.env.MEDIA_BUCKET.resumeMultipartUpload(pending.storageKey, multipart.uploadId).abort();
+  await context.env.MEDIA_KV.delete(kvKey);
+  const meta = decodeEncryptionMeta9(multipart.enc);
+  if (meta && context.env.KEYS_BUCKET) await context.env.KEYS_BUCKET.delete(`${pending.storageKey}/${meta.keyId}`);
+}
+async function checkFirstPart(context, active, key, partNumber, body) {
+  const { pending, multipart } = active;
+  if (partNumber !== 1 || !multipart.checksFirstPart) return null;
+  const result = sniffHead(pending.contentType, body);
+  if (result.verdict !== "mismatch") return null;
+  const action = mismatchAction(sniffingModeOf(context, pending), result, true);
+  logMismatch(pending.contentType, result, key, action);
+  if (action === "accepted") return null;
+  await discardMultipart(context, active);
+  return contentTypeMismatch(context, pending.contentType, result.detected);
+}
+async function recordFirstPart(context, active, partNumber, etag) {
+  const { pending, multipart, kvKey } = active;
+  if (partNumber !== 1 || !multipart.checksFirstPart) return;
+  const recorded = { ...pending, multipart: { ...multipart, firstPartEtag: etag } };
+  await context.env.MEDIA_KV.put(kvKey, JSON.stringify(recorded), { expirationTtl: MULTIPART_PENDING_TTL_SECONDS });
+}
+function unverifiedFirstPart(context, multipart, parts) {
+  if (!multipart.checksFirstPart) return null;
+  if (multipart.firstPartEtag && parts[0]?.etag === multipart.firstPartEtag) return null;
+  return context.json(
+    { error: "Part 1 of this upload has not been checked yet, or was replaced", code: "content_unverified" },
+    409
+  );
+}
+
 // src/routes/upload-multipart.ts
 import {
   AES_BLOCK_BYTES as AES_BLOCK_BYTES2,
   classifyUploadRequest,
   counterForBlock,
-  decodeEncryptionMeta as decodeEncryptionMeta9,
+  decodeEncryptionMeta as decodeEncryptionMeta10,
   encryptBytes,
   MULTIPART_PART_SIZE_BYTES,
   MULTIPART_QUERY,
@@ -4568,7 +4952,6 @@ async function cancelPendingUpload(context, uploadUrl) {
 }
 
 // src/routes/upload-multipart.ts
-var MULTIPART_PENDING_TTL_SECONDS = 24 * 60 * 60;
 var MAX_PART_COUNT = 1e4;
 async function readMultipartAt(context, kvKey) {
   const raw = await context.env.MEDIA_KV.get(kvKey);
@@ -4660,7 +5043,9 @@ async function handleMultipartCreate(context, key, target) {
     size,
     partSize,
     ...enc ? { enc } : {},
-    ...declaredSha256 ? { sha256: declaredSha256 } : {}
+    ...declaredSha256 ? { sha256: declaredSha256 } : {},
+    // The type is fixed now, before any byte: part 1 is checked against it when it arrives.
+    ...shouldSniffUpload(context, key, pending, pending.contentType) ? { checksFirstPart: true } : {}
   };
   await context.env.MEDIA_KV.put(kvKey, JSON.stringify({ ...pending, multipart }), {
     expirationTtl: MULTIPART_PENDING_TTL_SECONDS
@@ -4674,7 +5059,7 @@ async function handleMultipartCreate(context, key, target) {
 }
 async function encryptPart(context, pending, multipart, partNumber, body) {
   if (!multipart.enc) return body;
-  const meta = decodeEncryptionMeta9(multipart.enc);
+  const meta = decodeEncryptionMeta10(multipart.enc);
   const material = meta ? await loadStorageKey(context.env.KEYS_BUCKET, pending.storageKey, meta.keyId) : null;
   if (!meta || !material) return null;
   const startBlock = (partNumber - 1) * multipart.partSize / AES_BLOCK_BYTES2;
@@ -4698,10 +5083,13 @@ async function handleMultipartPart(context) {
   }
   const partChecksumFailure = await checkPartSha256(context, multipart, body);
   if (partChecksumFailure) return partChecksumFailure;
+  const contentFailure = await checkFirstPart(context, active, key, partNumber, body);
+  if (contentFailure) return contentFailure;
   const storedPart = await encryptPart(context, pending, multipart, partNumber, body);
   if (!storedPart) return context.json({ error: "Encryption key not found for this upload" }, 500);
   const multipartUpload = context.env.MEDIA_BUCKET.resumeMultipartUpload(pending.storageKey, multipart.uploadId);
   const uploaded = await multipartUpload.uploadPart(partNumber, storedPart);
+  await recordFirstPart(context, active, partNumber, uploaded.etag);
   return context.json({ partNumber: uploaded.partNumber, etag: uploaded.etag });
 }
 async function handleMultipartComplete(context, key) {
@@ -4711,6 +5099,8 @@ async function handleMultipartComplete(context, key) {
   const { pending, multipart, kvKey } = active;
   const parts = normalizeCompletedParts(multipart, body?.parts);
   if (!parts) return context.json({ error: "parts must list every part exactly once", code: "invalid_parts" }, 400);
+  const unverified = unverifiedFirstPart(context, multipart, parts);
+  if (unverified) return unverified;
   const write = await prepareUploadWrite(context, pending.key ?? key, pending, pending.storageKey);
   if ("blocked" in write) return write.blocked;
   const multipartUpload = context.env.MEDIA_BUCKET.resumeMultipartUpload(pending.storageKey, multipart.uploadId);
@@ -4725,25 +5115,6 @@ async function handleMultipartComplete(context, key) {
   const integrity = multipart.sha256 ? { sha256: multipart.sha256, sha256Verified: false } : {};
   return context.json({ key, size: object.size, ...integrity });
 }
-async function checkPartSha256(context, multipart, body) {
-  const partSha256 = headerSha256(context);
-  if (partSha256 === null) {
-    return context.json({ error: "x-devultur-sha256 must be a 64-character hex string", code: "invalid_sha256" }, 400);
-  }
-  if (multipart.sha256 && !partSha256) {
-    return context.json(
-      {
-        error: "Each part must carry its x-devultur-sha256 when the upload declares one",
-        code: "part_sha256_required"
-      },
-      400
-    );
-  }
-  if (!partSha256) return null;
-  const digest = await digestBody(body, void 0, partSha256);
-  if ("mismatch" in digest) return sha256Mismatch(context, digest.mismatch.expected, digest.mismatch.actual);
-  return null;
-}
 async function handleMultipartPost(context) {
   const key = context.req.param("key") ?? "";
   const kind = uploadRequestKindOf(context);
@@ -4777,20 +5148,8 @@ upload.post("/", async (context) => {
   if (!filename || !body.contentType) {
     return context.json({ error: "filename and contentType are required" }, 400);
   }
-  const inferredType = inferMediaType(body.contentType);
-  if (body.mediaType && inferredType && body.mediaType !== inferredType) {
-    return context.json(
-      {
-        error: `mediaType "${body.mediaType}" does not match content type ${body.contentType}`,
-        code: "media_type_mismatch"
-      },
-      400
-    );
-  }
-  const mediaType = body.mediaType ?? inferredType ?? (isAssetRequest ? MediaType2.FILE : null);
-  if (!mediaType) {
-    return context.json({ error: `Unsupported content type: ${body.contentType}` }, 400);
-  }
+  const mediaType = resolveUploadMediaType(body.mediaType, body.contentType, isAssetRequest);
+  if (isUploadTargetError(mediaType)) return targetFailure(context, mediaType);
   const scope = getRequestState(context);
   const uploadRule = scope.config?.uploadRules?.[mediaType];
   if (!isContentTypeAllowed(body.contentType, uploadRule?.accept)) {
@@ -4854,7 +5213,8 @@ upload.post("/", async (context) => {
     ...target.isAsset ? { isAsset: true, overwrite: shouldOverwrite } : {},
     ...cacheControl ? { cacheControl } : {},
     ...scope.config?.uploadMetadata ? { uploadMetadata: scope.config.uploadMetadata } : {},
-    ...lock ? { lock } : {}
+    ...lock ? { lock } : {},
+    ...scope.config?.contentSniffing ? { contentSniffing: scope.config.contentSniffing } : {}
   };
   const pendingId = newUploadPendingId();
   await context.env.MEDIA_KV.put(uploadPendingKvKey(pendingId), JSON.stringify(pending), {
@@ -4885,9 +5245,9 @@ upload.put("/:key{.+}", async (context) => {
   const maxSizeBytes = pending?.maxSizeBytes ?? null;
   const storageClass = pending?.storageClass ?? "Standard";
   const resourceSecurity = pending?.security ?? parseSecurityHeader(context.req.header(RESOURCE_SECURITY_HEADER));
-  const contentType = context.req.header("Content-Type") ?? "application/octet-stream";
-  if (expectedContentType && contentType !== expectedContentType) {
-    return context.json({ error: `Expected Content-Type ${expectedContentType}, got ${contentType}` }, 400);
+  const declaredContentType = context.req.header("Content-Type") ?? OCTET_STREAM;
+  if (expectedContentType && declaredContentType !== expectedContentType) {
+    return context.json({ error: `Expected Content-Type ${expectedContentType}, got ${declaredContentType}` }, 400);
   }
   const declaredSize = Number(context.req.header("content-length") ?? "0");
   if (maxSizeBytes != null && Number.isFinite(declaredSize) && declaredSize > maxSizeBytes) {
@@ -4908,6 +5268,9 @@ upload.put("/:key{.+}", async (context) => {
     return context.json({ error: "x-devultur-sha256 must be a 64-character hex string", code: "invalid_sha256" }, 400);
   }
   if ("mismatch" in digest) return sha256Mismatch(context, digest.mismatch.expected, digest.mismatch.actual);
+  const content = checkSinglePutContent(context, { key, pending, contentType: declaredContentType, body });
+  if ("rejected" in content) return content.rejected;
+  const { contentType } = content;
   const policy = resolveSecurity5(resourceSecurity, getRequestState(context).config?.security);
   const shouldEncrypt = shouldEncryptAtRest(policy, key);
   if (isKeysBucketMissing(shouldEncrypt, context.env)) return keysBucketMissing(context);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devultur/self-host",
-  "version": "1.2.0",
+  "version": "1.3.1",
   "description": "Self-hosted media Worker for Cloudflare: R2 uploads, edge-cached delivery, image transforms, HLS transcode and captions",
   "keywords": [
     "cloudflare-workers",
@@ -46,7 +46,7 @@
     "@jsquash/resize": "2.1.1",
     "@jsquash/webp": "1.5.0",
     "hono": "^4.7.0",
-    "@devultur/core": "1.2.0"
+    "@devultur/core": "1.3.1"
   },
   "devDependencies": {
     "@cf-wasm/photon": "0.4.0",