@estiva-app/protocol 0.17.0 → 0.19.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +85 -0
- package/dist/index.d.ts +2 -2
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +2 -2
- package/dist/index.js.map +1 -1
- package/dist/media.d.ts +118 -0
- package/dist/media.d.ts.map +1 -1
- package/dist/media.js +326 -0
- package/dist/media.js.map +1 -1
- package/package.json +1 -1
- package/src/index.ts +7 -1
- package/src/media.ts +383 -2
package/CHANGELOG.md
CHANGED
|
@@ -4,6 +4,91 @@ Every entry answers the wire question explicitly, including when the answer is
|
|
|
4
4
|
nothing (ADR 0002 §4b). A change to the bytes an app publishes is a MAJOR — in
|
|
5
5
|
`0.x`, a MINOR — even when no TypeScript signature moved.
|
|
6
6
|
|
|
7
|
+
## 0.19.0 — 2026-09-10
|
|
8
|
+
|
|
9
|
+
**Wire behaviour: the bytes an upload sends change.** `uploadBlob` now strips
|
|
10
|
+
an image's metadata before hashing it, so the blob's sha256 — and therefore the
|
|
11
|
+
`x` and `url` of the `imeta` that names it — differ from what the same file
|
|
12
|
+
would have produced in 0.18.0. Nothing already published can disagree, because
|
|
13
|
+
in 0.18.0 such an upload **failed**: the relay refused it. This turns a 422 into
|
|
14
|
+
a blob.
|
|
15
|
+
|
|
16
|
+
- **New: `canonicalizeImage`, and `uploadBlob` applies it by default.**
|
|
17
|
+
|
|
18
|
+
Buzz refuses media carrying metadata, structurally — `validate_image_metadata_free`
|
|
19
|
+
returns `MetadataForbidden` and the upload 422s with
|
|
20
|
+
`media contains metadata or a non-canonical metadata channel`. Its video path
|
|
21
|
+
names the piece that was missing: *"only the canonical primary stream produced
|
|
22
|
+
by the client sanitizer is permitted."* There was no client sanitizer, in
|
|
23
|
+
either app, so **an unmodified screenshot was refused every time** — capture
|
|
24
|
+
tools write a `pHYs` and a `tEXt` software tag, and neither is on Buzz's
|
|
25
|
+
rendering allowlist. `pHYs` is excluded deliberately; the relay's comment
|
|
26
|
+
calls arbitrary values an identity channel.
|
|
27
|
+
|
|
28
|
+
PNG: keeps the critical chunks and the eleven rendering ancillaries Buzz
|
|
29
|
+
allows, plus a single Buzz snapshot-manifest `tEXt` — stripping that would
|
|
30
|
+
leave a `.agent.png` that still looks like an image and silently no longer
|
|
31
|
+
carries its manifest. JPEG: keeps a canonical JFIF `APP0` and a 12-byte Adobe
|
|
32
|
+
`APP14`, drops `APP1`–`APP13` (EXIF lives in `APP1`), `APP15` and `COM`, and
|
|
33
|
+
truncates trailing bytes after `EOI`, which is where a metadata editor leaves
|
|
34
|
+
them.
|
|
35
|
+
|
|
36
|
+
**Chunks are dropped, never re-encoded.** A canvas round trip is the obvious
|
|
37
|
+
implementation and it does not work: the browser's encoder adds an ICC profile
|
|
38
|
+
back, which the relay refuses identically. Dropping is also lossless — every
|
|
39
|
+
chunk removed is ancillary by the format's own definition.
|
|
40
|
+
|
|
41
|
+
GIF and WebP pass through untouched. Their metadata is not a droppable chunk
|
|
42
|
+
(WebP records EXIF/ICC/XMP presence in `VP8X` flags that must stay consistent
|
|
43
|
+
with the chunks; GIF hides it in extension blocks) and a wrong rewrite makes a
|
|
44
|
+
corrupt image, which is worse than the refusal it replaces.
|
|
45
|
+
|
|
46
|
+
`canonicalize: false` opts out for a caller sending something it does not want
|
|
47
|
+
touched. It is not a way round a refusal — the relay's answer is the same.
|
|
48
|
+
|
|
49
|
+
## Backfill — 0.16.0 through 0.18.0
|
|
50
|
+
|
|
51
|
+
These three shipped without entries, which this file's own header forbids. The
|
|
52
|
+
omissions were mine. Recorded now rather than left as three published versions
|
|
53
|
+
whose wire question nobody answered. (`0.14.0` is still missing and is not mine
|
|
54
|
+
to reconstruct.)
|
|
55
|
+
|
|
56
|
+
## 0.18.0 — 2026-09-09
|
|
57
|
+
|
|
58
|
+
**Wire behaviour: unchanged in shape.** It adds a request an app did not make
|
|
59
|
+
before — `PUT /upload` — but nothing about a published event moves.
|
|
60
|
+
|
|
61
|
+
- **New: `uploadBlob`, `imetaFor`, `sha256Of`.** CON-12's write half. The
|
|
62
|
+
upload must land before the message that names it: ingest runs
|
|
63
|
+
`verify_imeta_blobs` and refuses a message whose blob it does not already
|
|
64
|
+
hold, so a dangling attachment cannot be published at all. `imetaFor` exists
|
|
65
|
+
because `m` and `x` must be the **relay's** answers about what it stored, not
|
|
66
|
+
the client's guess from a file extension — `validate_imeta_tags` compares them
|
|
67
|
+
and refuses with nothing to say which field was wrong.
|
|
68
|
+
|
|
69
|
+
## 0.17.0 — 2026-09-09
|
|
70
|
+
|
|
71
|
+
**Wire behaviour: unchanged.** Read-only; nothing is published.
|
|
72
|
+
|
|
73
|
+
- **New: `fetchBlob`, `sha256FromMediaUrl`.** Media GET is unconditionally
|
|
74
|
+
authenticated — `get_blob` calls `authenticate_media_read` before it touches
|
|
75
|
+
storage, and the `BUZZ_REQUIRE_MEDIA_GET_AUTH` flag that reads like an opt-in
|
|
76
|
+
is inert — so an `<img src>` answers 401 and every reader has to sign a `get`
|
|
77
|
+
authorization. Shared because both apps have the same problem with the same
|
|
78
|
+
relay, and one trap is genuinely surprising: **a thumbnail authorizes against
|
|
79
|
+
its parent hash**, since the relay splits `sha256_ext` on the first dot.
|
|
80
|
+
|
|
81
|
+
## 0.16.0 — 2026-09-08
|
|
82
|
+
|
|
83
|
+
**Wire behaviour: new.** Apps begin publishing an `imeta` tag on messages, and
|
|
84
|
+
signing a `kind:24242` that never existed here before.
|
|
85
|
+
|
|
86
|
+
- **New: `buildBlossomAuth`, `blossomAuthHeader`, `imetaTag`, `imetaOf`, `Imeta`.**
|
|
87
|
+
A `kind:24242` Blossom authorization (BUD-01/BUD-11) and the NIP-92 tag that
|
|
88
|
+
references a blob. Parsing lives here rather than in each app because the
|
|
89
|
+
relay refuses a malformed tag, and a second parser is a second set of refusals
|
|
90
|
+
to get wrong.
|
|
91
|
+
|
|
7
92
|
## 0.15.0 — 2026-09-07
|
|
8
93
|
|
|
9
94
|
**Wire behaviour: unchanged.** Nothing about what an app publishes moves, and
|
package/dist/index.d.ts
CHANGED
|
@@ -46,7 +46,7 @@
|
|
|
46
46
|
/** Bumped by hand with the version in package.json — `test/version.test.ts`
|
|
47
47
|
* pins the two together. It exists so "the upgrade reached the app" can be
|
|
48
48
|
* checked by grepping a built bundle rather than by trusting a lockfile. */
|
|
49
|
-
export declare const PROTOCOL_VERSION = "0.
|
|
49
|
+
export declare const PROTOCOL_VERSION = "0.19.0";
|
|
50
50
|
export { type NostrTag, type UnsignedEvent, type SignedEvent, type Profile, type ThreadRef, type ChannelVisibility, type ChannelKind, type MemberRole, type Label, type ResolutionAction, KIND, MAX_EMOJI_CHARS, MAX_MESSAGE_BYTES, MAX_MENTIONS, MAX_RATIONALE_BYTES, RELAY_AUTH_TOLERANCE_SECS, ASSERTION_SUBTYPE, computeEventId, toNostrSeconds, canonicalChannelName, threadTags, addr, relayAuthUrl, buildProfile, parseProfile, buildCreateChannel, buildDeleteChannel, buildEditChannelMetadata, buildAddMember, buildReaction, buildDeletion, buildEdit, buildMessage, buildResolution, buildFile, buildComponent, buildHighlight, buildUnsignedRelayAuthEvent, } from './events.js';
|
|
51
51
|
export { type AddressPointer, type EventPointer, encodeNevent, decodeNevent, convertBits, bech32Encode, bech32Decode, encodeNaddr, decodeNaddr, pointerToAddress, addressToPointer, addrToNaddr, naddrToAddr, referenceToPointer, NADDR_RE, findNaddrs, stripNaddrs, encodeNpub, decodeNpub, NOSTR_URI_RE, findNostrUris, } from './nip19.js';
|
|
52
52
|
export { type AuthEventArgs, TIMESTAMP_TOLERANCE_SECS, normalizeUrl, buildUnsignedAuthEvent, base64, authorizationHeaderFor, authorizationHeader, } from './nip98.js';
|
|
@@ -59,5 +59,5 @@ export { type Block, type BlockDocument, type KnownBlockType, KNOWN_BLOCK_TYPES,
|
|
|
59
59
|
export { type RenderInline, type RenderBlock, type RenderFormat, type ContentFormat, CONTENT_FORMAT_TAG, BLOCK_DOCUMENT_FORMAT, contentFormatOf, toRenderTree, renderTreeText, standaloneReference, referencesIn, } from './render.js';
|
|
60
60
|
export { markerTextToBlockDocument, blockDocumentToMarkerText, } from './bridge-content.js';
|
|
61
61
|
export { type BlockAnchor, BLOCK_ANCHOR_TAG, blockAnchorOf, resolveBlockAnchor, } from './anchors.js';
|
|
62
|
-
export { type BlossomVerb, type Imeta, BLOSSOM_AUTH_TTL_SECS, buildBlossomAuth, blossomAuthHeader, imetaTag, imetaOf, type BlobFetchLike, type BlobResponseLike, type FetchedBlob, sha256FromMediaUrl, fetchBlob, } from './media.js';
|
|
62
|
+
export { type BlossomVerb, type Imeta, BLOSSOM_AUTH_TTL_SECS, buildBlossomAuth, blossomAuthHeader, imetaTag, imetaOf, type BlobFetchLike, type BlobResponseLike, type FetchedBlob, sha256FromMediaUrl, fetchBlob, sha256Of, uploadBlob, imetaFor, canonicalizeImage, type UploadedBlob, type BlobUploadFetchLike, } from './media.js';
|
|
63
63
|
//# sourceMappingURL=index.d.ts.map
|
package/dist/index.d.ts.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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
|
|
1
|
+
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
|
package/dist/index.js
CHANGED
|
@@ -46,7 +46,7 @@
|
|
|
46
46
|
/** Bumped by hand with the version in package.json — `test/version.test.ts`
|
|
47
47
|
* pins the two together. It exists so "the upgrade reached the app" can be
|
|
48
48
|
* checked by grepping a built bundle rather than by trusting a lockfile. */
|
|
49
|
-
export const PROTOCOL_VERSION = '0.
|
|
49
|
+
export const PROTOCOL_VERSION = '0.19.0';
|
|
50
50
|
export {
|
|
51
51
|
// constants
|
|
52
52
|
KIND, MAX_EMOJI_CHARS, MAX_MESSAGE_BYTES, MAX_MENTIONS, MAX_RATIONALE_BYTES, RELAY_AUTH_TOLERANCE_SECS, ASSERTION_SUBTYPE,
|
|
@@ -65,5 +65,5 @@ export { KNOWN_BLOCK_TYPES, BlockDocumentError, validateBlockDocument, parseBloc
|
|
|
65
65
|
export { CONTENT_FORMAT_TAG, BLOCK_DOCUMENT_FORMAT, contentFormatOf, toRenderTree, renderTreeText, standaloneReference, referencesIn, } from './render.js';
|
|
66
66
|
export { markerTextToBlockDocument, blockDocumentToMarkerText, } from './bridge-content.js';
|
|
67
67
|
export { BLOCK_ANCHOR_TAG, blockAnchorOf, resolveBlockAnchor, } from './anchors.js';
|
|
68
|
-
export { BLOSSOM_AUTH_TTL_SECS, buildBlossomAuth, blossomAuthHeader, imetaTag, imetaOf, sha256FromMediaUrl, fetchBlob, } from './media.js';
|
|
68
|
+
export { BLOSSOM_AUTH_TTL_SECS, buildBlossomAuth, blossomAuthHeader, imetaTag, imetaOf, sha256FromMediaUrl, fetchBlob, sha256Of, uploadBlob, imetaFor, canonicalizeImage, } from './media.js';
|
|
69
69
|
//# sourceMappingURL=index.js.map
|
package/dist/index.js.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAEH;;4EAE4E;AAC5E,MAAM,CAAC,MAAM,gBAAgB,GAAG,QAAQ,CAAA;AAExC,OAAO;AAYL,YAAY;AACZ,IAAI,EACJ,eAAe,EACf,iBAAiB,EACjB,YAAY,EACZ,mBAAmB,EACnB,yBAAyB,EACzB,iBAAiB;AACjB,8CAA8C;AAC9C,cAAc,EACd,cAAc,EACd,oBAAoB,EACpB,UAAU,EACV,IAAI,EACJ,YAAY;AACZ,WAAW;AACX,YAAY,EACZ,YAAY,EACZ,kBAAkB,EAClB,kBAAkB,EAClB,wBAAwB,EACxB,cAAc,EACd,aAAa,EACb,aAAa,EACb,SAAS,EACT,YAAY,EACZ,eAAe,EACf,SAAS,EACT,cAAc,EACd,cAAc,EACd,2BAA2B,GAC5B,MAAM,aAAa,CAAA;AAEpB,OAAO,EAGL,YAAY,EACZ,YAAY,EACZ,WAAW,EACX,YAAY,EACZ,YAAY,EACZ,WAAW,EACX,WAAW,EACX,gBAAgB,EAChB,gBAAgB,EAChB,WAAW,EACX,WAAW,EACX,kBAAkB,EAClB,QAAQ,EACR,UAAU,EACV,WAAW,EACX,UAAU,EACV,UAAU,EACV,YAAY,EACZ,aAAa,GACd,MAAM,YAAY,CAAA;AAEnB,OAAO,EAEL,wBAAwB,EACxB,YAAY,EACZ,sBAAsB,EACtB,MAAM,EACN,sBAAsB,EACtB,mBAAmB,GACpB,MAAM,YAAY,CAAA;AAEnB,OAAO,EAGL,mBAAmB,EACnB,SAAS,EACT,eAAe,GAChB,MAAM,WAAW,CAAA;AAElB,OAAO,EAOL,oBAAoB,EACpB,kBAAkB,EAClB,kBAAkB,EAClB,yBAAyB,EACzB,qBAAqB,EACrB,KAAK,GACN,MAAM,aAAa,CAAA;AAEpB,OAAO,EAOL,cAAc,EACd,UAAU,EACV,eAAe,GAChB,MAAM,WAAW,CAAA;AAElB,OAAO,EAIL,0BAA0B,GAC3B,MAAM,oBAAoB,CAAA;AAE3B,OAAO,EAML,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EACjB,qBAAqB,EACrB,oBAAoB,EACpB,oBAAoB,EACpB,iBAAiB,GAClB,MAAM,cAAc,CAAA;AAErB,OAAO,EAIL,iBAAiB,EACjB,kBAAkB,EAClB,qBAAqB,EACrB,kBAAkB,EAClB,sBAAsB,EACtB,UAAU,EACV,qBAAqB,EACrB,QAAQ,EACR,SAAS,EACT,YAAY,EACZ,YAAY,GACb,MAAM,aAAa,CAAA;AAEpB,OAAO,EAKL,kBAAkB,EAClB,qBAAqB,EACrB,eAAe,EACf,YAAY,EACZ,cAAc,EACd,mBAAmB,EACnB,YAAY,GACb,MAAM,aAAa,CAAA;AAEpB,OAAO,EACL,yBAAyB,EACzB,yBAAyB,GAC1B,MAAM,qBAAqB,CAAA;AAE5B,OAAO,EAEL,gBAAgB,EAChB,aAAa,EACb,kBAAkB,GACnB,MAAM,cAAc,CAAA;AACrB,OAAO,EAGL,qBAAqB,EACrB,gBAAgB,EAChB,iBAAiB,EACjB,QAAQ,EACR,OAAO,EAIP,kBAAkB,EAClB,SAAS,
|
|
1
|
+
{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAEH;;4EAE4E;AAC5E,MAAM,CAAC,MAAM,gBAAgB,GAAG,QAAQ,CAAA;AAExC,OAAO;AAYL,YAAY;AACZ,IAAI,EACJ,eAAe,EACf,iBAAiB,EACjB,YAAY,EACZ,mBAAmB,EACnB,yBAAyB,EACzB,iBAAiB;AACjB,8CAA8C;AAC9C,cAAc,EACd,cAAc,EACd,oBAAoB,EACpB,UAAU,EACV,IAAI,EACJ,YAAY;AACZ,WAAW;AACX,YAAY,EACZ,YAAY,EACZ,kBAAkB,EAClB,kBAAkB,EAClB,wBAAwB,EACxB,cAAc,EACd,aAAa,EACb,aAAa,EACb,SAAS,EACT,YAAY,EACZ,eAAe,EACf,SAAS,EACT,cAAc,EACd,cAAc,EACd,2BAA2B,GAC5B,MAAM,aAAa,CAAA;AAEpB,OAAO,EAGL,YAAY,EACZ,YAAY,EACZ,WAAW,EACX,YAAY,EACZ,YAAY,EACZ,WAAW,EACX,WAAW,EACX,gBAAgB,EAChB,gBAAgB,EAChB,WAAW,EACX,WAAW,EACX,kBAAkB,EAClB,QAAQ,EACR,UAAU,EACV,WAAW,EACX,UAAU,EACV,UAAU,EACV,YAAY,EACZ,aAAa,GACd,MAAM,YAAY,CAAA;AAEnB,OAAO,EAEL,wBAAwB,EACxB,YAAY,EACZ,sBAAsB,EACtB,MAAM,EACN,sBAAsB,EACtB,mBAAmB,GACpB,MAAM,YAAY,CAAA;AAEnB,OAAO,EAGL,mBAAmB,EACnB,SAAS,EACT,eAAe,GAChB,MAAM,WAAW,CAAA;AAElB,OAAO,EAOL,oBAAoB,EACpB,kBAAkB,EAClB,kBAAkB,EAClB,yBAAyB,EACzB,qBAAqB,EACrB,KAAK,GACN,MAAM,aAAa,CAAA;AAEpB,OAAO,EAOL,cAAc,EACd,UAAU,EACV,eAAe,GAChB,MAAM,WAAW,CAAA;AAElB,OAAO,EAIL,0BAA0B,GAC3B,MAAM,oBAAoB,CAAA;AAE3B,OAAO,EAML,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EACjB,qBAAqB,EACrB,oBAAoB,EACpB,oBAAoB,EACpB,iBAAiB,GAClB,MAAM,cAAc,CAAA;AAErB,OAAO,EAIL,iBAAiB,EACjB,kBAAkB,EAClB,qBAAqB,EACrB,kBAAkB,EAClB,sBAAsB,EACtB,UAAU,EACV,qBAAqB,EACrB,QAAQ,EACR,SAAS,EACT,YAAY,EACZ,YAAY,GACb,MAAM,aAAa,CAAA;AAEpB,OAAO,EAKL,kBAAkB,EAClB,qBAAqB,EACrB,eAAe,EACf,YAAY,EACZ,cAAc,EACd,mBAAmB,EACnB,YAAY,GACb,MAAM,aAAa,CAAA;AAEpB,OAAO,EACL,yBAAyB,EACzB,yBAAyB,GAC1B,MAAM,qBAAqB,CAAA;AAE5B,OAAO,EAEL,gBAAgB,EAChB,aAAa,EACb,kBAAkB,GACnB,MAAM,cAAc,CAAA;AACrB,OAAO,EAGL,qBAAqB,EACrB,gBAAgB,EAChB,iBAAiB,EACjB,QAAQ,EACR,OAAO,EAIP,kBAAkB,EAClB,SAAS,EACT,QAAQ,EACR,UAAU,EACV,QAAQ,EACR,iBAAiB,GAGlB,MAAM,YAAY,CAAA"}
|
package/dist/media.d.ts
CHANGED
|
@@ -171,4 +171,122 @@ export declare function fetchBlob(args: {
|
|
|
171
171
|
pubkey: string;
|
|
172
172
|
transport?: BlobFetchLike;
|
|
173
173
|
}): Promise<FetchedBlob>;
|
|
174
|
+
/**
|
|
175
|
+
* A blob's identity: its sha256, lowercase hex.
|
|
176
|
+
*
|
|
177
|
+
* `@noble/hashes` rather than `crypto.subtle`, which is async, absent from
|
|
178
|
+
* older Node without a flag, and unavailable on an insecure origin. This
|
|
179
|
+
* package already hashes every event id with it.
|
|
180
|
+
*/
|
|
181
|
+
export declare function sha256Of(bytes: ArrayBuffer | Uint8Array): string;
|
|
182
|
+
/** What the relay hands back once it holds the bytes — BUD-02 descriptor. */
|
|
183
|
+
export interface UploadedBlob {
|
|
184
|
+
/** Where the bytes are. Already rewritten for the tenant, so it goes straight into `imeta`. */
|
|
185
|
+
url: string;
|
|
186
|
+
sha256: string;
|
|
187
|
+
size: number;
|
|
188
|
+
/** MIME **as the relay stored it**. `imeta`'s `m` must equal this exactly. */
|
|
189
|
+
type: string;
|
|
190
|
+
/** `<width>x<height>`, computed by the relay rather than by the client. */
|
|
191
|
+
dim?: string;
|
|
192
|
+
/** The relay's generated thumbnail, when it made one. */
|
|
193
|
+
thumb?: string;
|
|
194
|
+
}
|
|
195
|
+
/**
|
|
196
|
+
* A transport that can send bytes.
|
|
197
|
+
*
|
|
198
|
+
* A third shape, and for the third reason: {@link FetchLike} sends a string
|
|
199
|
+
* body, {@link BlobFetchLike} sends none and reads bytes, this one sends bytes
|
|
200
|
+
* and reads a string. One type that did all three would be loose enough to let
|
|
201
|
+
* any of them be called wrongly.
|
|
202
|
+
*/
|
|
203
|
+
export type BlobUploadFetchLike = (url: string, init: {
|
|
204
|
+
method: string;
|
|
205
|
+
headers: Record<string, string>;
|
|
206
|
+
body: ArrayBuffer;
|
|
207
|
+
}) => Promise<{
|
|
208
|
+
status: number;
|
|
209
|
+
text(): Promise<string>;
|
|
210
|
+
}>;
|
|
211
|
+
/**
|
|
212
|
+
* Put a file on the relay — CON-12's write half, BUD-01/BUD-11.
|
|
213
|
+
*
|
|
214
|
+
* **The upload must land before the message that names it.** Ingest runs
|
|
215
|
+
* `verify_imeta_blobs` and refuses a message whose blob it does not already
|
|
216
|
+
* hold, so this is not an optimisation to reorder — it is the only order that
|
|
217
|
+
* works. A dangling attachment reference cannot be published at all, which is
|
|
218
|
+
* a constraint worth being glad about.
|
|
219
|
+
*
|
|
220
|
+
* The hash is computed here rather than read off the response, because it is
|
|
221
|
+
* what the authorization has to name: BUD-11 requires the `x` tag to match, so
|
|
222
|
+
* the client must know the digest *before* it may ask permission to send the
|
|
223
|
+
* bytes. `x-sha-256` carries it again on the PUT, where the relay checks the
|
|
224
|
+
* bytes against it rather than trusting either side's arithmetic.
|
|
225
|
+
*
|
|
226
|
+
* Takes bytes rather than a `File`: `File` is a DOM type, this package builds
|
|
227
|
+
* without `lib.dom`, and a caller that has one passes `await file.arrayBuffer()`.
|
|
228
|
+
*
|
|
229
|
+
* Throws with the relay's own words. What that means is the caller's to decide.
|
|
230
|
+
*/
|
|
231
|
+
export declare function uploadBlob(args: {
|
|
232
|
+
/** The relay origin. `/upload` is appended. */
|
|
233
|
+
relayUrl: string;
|
|
234
|
+
bytes: ArrayBuffer;
|
|
235
|
+
/** The MIME to send. The relay stores its own answer, which wins — see {@link UploadedBlob.type}. */
|
|
236
|
+
contentType?: string;
|
|
237
|
+
/** Display name. Goes in the authorization's human-readable reason, nowhere else. */
|
|
238
|
+
filename?: string;
|
|
239
|
+
sign: (unsigned: UnsignedEvent) => Promise<SignedEvent>;
|
|
240
|
+
pubkey: string;
|
|
241
|
+
transport?: BlobUploadFetchLike;
|
|
242
|
+
/** Skip {@link canonicalizeImage}. Default `true`; see the note below. */
|
|
243
|
+
canonicalize?: boolean;
|
|
244
|
+
}): Promise<UploadedBlob>;
|
|
245
|
+
/**
|
|
246
|
+
* An uploaded blob as the `imeta` that references it.
|
|
247
|
+
*
|
|
248
|
+
* Shared because the mapping has one trap in it: `m` and `x` must be the
|
|
249
|
+
* **relay's** answers, not the client's. `validate_imeta_tags` compares them
|
|
250
|
+
* against what it stored, and a browser that re-encoded a file on the way in —
|
|
251
|
+
* or simply guessed a MIME from an extension — publishes a message the relay
|
|
252
|
+
* refuses, with nothing to say which field was wrong.
|
|
253
|
+
*/
|
|
254
|
+
export declare function imetaFor(blob: UploadedBlob, extra?: {
|
|
255
|
+
alt?: string;
|
|
256
|
+
filename?: string;
|
|
257
|
+
}): Imeta;
|
|
258
|
+
/**
|
|
259
|
+
* Strip an image down to what the relay will store — SHA-25.
|
|
260
|
+
*
|
|
261
|
+
* Buzz refuses media carrying metadata, and refuses it *structurally* rather
|
|
262
|
+
* than by scrubbing it: `validate_image_metadata_free` returns
|
|
263
|
+
* `MetadataForbidden` and the whole upload 422s. Its video path names the piece
|
|
264
|
+
* that was missing — "only the canonical primary stream produced by the **client
|
|
265
|
+
* sanitizer** is permitted" — and until this there was no client sanitizer, in
|
|
266
|
+
* either app. An unmodified screenshot was refused, every time, because capture
|
|
267
|
+
* tools write `pHYs` and a `tEXt` software tag.
|
|
268
|
+
*
|
|
269
|
+
* ## Chunks are dropped, never re-encoded
|
|
270
|
+
*
|
|
271
|
+
* The obvious implementation is a canvas round trip, and it does not work: the
|
|
272
|
+
* browser's encoder **adds an ICC profile back**, which the relay refuses
|
|
273
|
+
* identically. Dropping chunks is also lossless — every chunk removed here is
|
|
274
|
+
* ancillary by the format's own definition — where a re-encode would quietly
|
|
275
|
+
* degrade a screenshot to make it acceptable.
|
|
276
|
+
*
|
|
277
|
+
* ## PNG and JPEG only
|
|
278
|
+
*
|
|
279
|
+
* GIF and WebP are accepted by the relay and are **passed through untouched**.
|
|
280
|
+
* Their metadata is not a droppable chunk: WebP records EXIF/ICC/XMP presence
|
|
281
|
+
* in `VP8X` flags that have to stay consistent with the chunks, and GIF hides
|
|
282
|
+
* it in extension blocks. Rewriting either wrongly produces a corrupt image,
|
|
283
|
+
* which is worse than the refusal it replaces — so they keep today's behaviour
|
|
284
|
+
* and the relay's own words. Screenshots are PNG or JPEG, which is the case
|
|
285
|
+
* that was actually costing anything.
|
|
286
|
+
*
|
|
287
|
+
* Throws on malformed input rather than returning the bytes unchanged: an image
|
|
288
|
+
* this cannot parse is one it cannot vouch for, and uploading it anyway would
|
|
289
|
+
* turn a clear failure here into an opaque 422 later.
|
|
290
|
+
*/
|
|
291
|
+
export declare function canonicalizeImage(bytes: ArrayBuffer | Uint8Array): Uint8Array;
|
|
174
292
|
//# sourceMappingURL=media.d.ts.map
|
package/dist/media.d.ts.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"media.d.ts","sourceRoot":"","sources":["../src/media.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;
|
|
1
|
+
{"version":3,"file":"media.d.ts","sourceRoot":"","sources":["../src/media.ts"],"names":[],"mappings":"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"}
|
package/dist/media.js
CHANGED
|
@@ -1,5 +1,7 @@
|
|
|
1
1
|
import { KIND, toNostrSeconds } from './events.js';
|
|
2
2
|
import { authorizationHeaderFor } from './nip98.js';
|
|
3
|
+
import { sha256 } from '@noble/hashes/sha256';
|
|
4
|
+
import { bytesToHex } from '@noble/hashes/utils';
|
|
3
5
|
/** How long an authorization stays valid unless the caller says otherwise. */
|
|
4
6
|
export const BLOSSOM_AUTH_TTL_SECS = 300;
|
|
5
7
|
/**
|
|
@@ -182,4 +184,328 @@ export async function fetchBlob(args) {
|
|
|
182
184
|
contentType: response.headers.get('content-type') ?? 'application/octet-stream',
|
|
183
185
|
};
|
|
184
186
|
}
|
|
187
|
+
/**
|
|
188
|
+
* A blob's identity: its sha256, lowercase hex.
|
|
189
|
+
*
|
|
190
|
+
* `@noble/hashes` rather than `crypto.subtle`, which is async, absent from
|
|
191
|
+
* older Node without a flag, and unavailable on an insecure origin. This
|
|
192
|
+
* package already hashes every event id with it.
|
|
193
|
+
*/
|
|
194
|
+
export function sha256Of(bytes) {
|
|
195
|
+
return bytesToHex(sha256(bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes)));
|
|
196
|
+
}
|
|
197
|
+
/**
|
|
198
|
+
* Put a file on the relay — CON-12's write half, BUD-01/BUD-11.
|
|
199
|
+
*
|
|
200
|
+
* **The upload must land before the message that names it.** Ingest runs
|
|
201
|
+
* `verify_imeta_blobs` and refuses a message whose blob it does not already
|
|
202
|
+
* hold, so this is not an optimisation to reorder — it is the only order that
|
|
203
|
+
* works. A dangling attachment reference cannot be published at all, which is
|
|
204
|
+
* a constraint worth being glad about.
|
|
205
|
+
*
|
|
206
|
+
* The hash is computed here rather than read off the response, because it is
|
|
207
|
+
* what the authorization has to name: BUD-11 requires the `x` tag to match, so
|
|
208
|
+
* the client must know the digest *before* it may ask permission to send the
|
|
209
|
+
* bytes. `x-sha-256` carries it again on the PUT, where the relay checks the
|
|
210
|
+
* bytes against it rather than trusting either side's arithmetic.
|
|
211
|
+
*
|
|
212
|
+
* Takes bytes rather than a `File`: `File` is a DOM type, this package builds
|
|
213
|
+
* without `lib.dom`, and a caller that has one passes `await file.arrayBuffer()`.
|
|
214
|
+
*
|
|
215
|
+
* Throws with the relay's own words. What that means is the caller's to decide.
|
|
216
|
+
*/
|
|
217
|
+
export async function uploadBlob(args) {
|
|
218
|
+
/*
|
|
219
|
+
Canonicalized first, and the hash taken after — SHA-25.
|
|
220
|
+
|
|
221
|
+
The relay refuses media carrying metadata, so an unmodified screenshot 422s:
|
|
222
|
+
capture tools write a `pHYs` and a `tEXt` software tag, and neither is on
|
|
223
|
+
Buzz's rendering allowlist. Doing it here rather than asking each caller to
|
|
224
|
+
remember means there is one place the relay's rule is understood, which is
|
|
225
|
+
the same argument that put `uploadBlob` in this package at all.
|
|
226
|
+
|
|
227
|
+
The order is forced. `x` in the authorization, `x-sha-256` on the PUT and
|
|
228
|
+
`x` in the `imeta` must all be the digest of the bytes the relay actually
|
|
229
|
+
stores, so hashing before stripping would name a blob that never existed.
|
|
230
|
+
|
|
231
|
+
`canonicalize: false` is for a caller that has already done it, or is
|
|
232
|
+
sending something this does not understand and does not want touched. It is
|
|
233
|
+
not a way round a refusal: the relay's answer does not change.
|
|
234
|
+
*/
|
|
235
|
+
const canonical = args.canonicalize === false
|
|
236
|
+
? args.bytes instanceof Uint8Array
|
|
237
|
+
? args.bytes
|
|
238
|
+
: new Uint8Array(args.bytes)
|
|
239
|
+
: canonicalizeImage(args.bytes);
|
|
240
|
+
/*
|
|
241
|
+
A standalone `ArrayBuffer`, because the transport's `body` is one and a
|
|
242
|
+
`Uint8Array` may be a window onto a larger buffer — sending `.buffer` would
|
|
243
|
+
upload whatever else is in it. One copy, against a network PUT.
|
|
244
|
+
*/
|
|
245
|
+
const payload = canonical.buffer.slice(canonical.byteOffset, canonical.byteOffset + canonical.byteLength);
|
|
246
|
+
const digest = sha256Of(payload);
|
|
247
|
+
const auth = await args.sign(buildBlossomAuth(args.pubkey, Date.now(), {
|
|
248
|
+
verb: 'upload',
|
|
249
|
+
sha256: digest,
|
|
250
|
+
reason: args.filename ? `Upload ${args.filename}` : 'Upload attachment',
|
|
251
|
+
}));
|
|
252
|
+
const send = args.transport ?? fetch;
|
|
253
|
+
const response = await send(`${args.relayUrl.replace(/\/+$/, '')}/upload`, {
|
|
254
|
+
method: 'PUT',
|
|
255
|
+
headers: {
|
|
256
|
+
authorization: blossomAuthHeader(auth),
|
|
257
|
+
// BUD-11 makes this mandatory on PUT /upload.
|
|
258
|
+
'x-sha-256': digest,
|
|
259
|
+
'content-type': args.contentType || 'application/octet-stream',
|
|
260
|
+
},
|
|
261
|
+
body: payload,
|
|
262
|
+
});
|
|
263
|
+
const body = await response.text();
|
|
264
|
+
if (response.status < 200 || response.status >= 300) {
|
|
265
|
+
throw new Error(`upload failed: ${response.status} ${body.slice(0, 200)}`);
|
|
266
|
+
}
|
|
267
|
+
let descriptor;
|
|
268
|
+
try {
|
|
269
|
+
descriptor = JSON.parse(body);
|
|
270
|
+
}
|
|
271
|
+
catch {
|
|
272
|
+
throw new Error('upload returned no blob descriptor');
|
|
273
|
+
}
|
|
274
|
+
// `url` is the relay's own, already rewritten for the tenant — assembling a
|
|
275
|
+
// host here would produce something `validate_imeta_tags` rejects as
|
|
276
|
+
// non-local on any deployment whose tenant host is not the configured one.
|
|
277
|
+
if (!descriptor.url || !descriptor.sha256)
|
|
278
|
+
throw new Error('upload returned no blob descriptor');
|
|
279
|
+
return {
|
|
280
|
+
url: descriptor.url,
|
|
281
|
+
sha256: descriptor.sha256,
|
|
282
|
+
size: descriptor.size ?? args.bytes.byteLength,
|
|
283
|
+
type: descriptor.type ?? args.contentType ?? 'application/octet-stream',
|
|
284
|
+
dim: descriptor.dim,
|
|
285
|
+
thumb: descriptor.thumb,
|
|
286
|
+
};
|
|
287
|
+
}
|
|
288
|
+
/**
|
|
289
|
+
* An uploaded blob as the `imeta` that references it.
|
|
290
|
+
*
|
|
291
|
+
* Shared because the mapping has one trap in it: `m` and `x` must be the
|
|
292
|
+
* **relay's** answers, not the client's. `validate_imeta_tags` compares them
|
|
293
|
+
* against what it stored, and a browser that re-encoded a file on the way in —
|
|
294
|
+
* or simply guessed a MIME from an extension — publishes a message the relay
|
|
295
|
+
* refuses, with nothing to say which field was wrong.
|
|
296
|
+
*/
|
|
297
|
+
export function imetaFor(blob, extra) {
|
|
298
|
+
return {
|
|
299
|
+
url: blob.url,
|
|
300
|
+
m: blob.type,
|
|
301
|
+
x: blob.sha256,
|
|
302
|
+
size: blob.size,
|
|
303
|
+
dim: blob.dim,
|
|
304
|
+
thumb: blob.thumb,
|
|
305
|
+
alt: extra?.alt,
|
|
306
|
+
filename: extra?.filename,
|
|
307
|
+
};
|
|
308
|
+
}
|
|
309
|
+
/* ────────────────────────────────────────────────────────────────────────────
|
|
310
|
+
Canonicalizing an image before it is uploaded — SHA-25
|
|
311
|
+
──────────────────────────────────────────────────────────────────────────── */
|
|
312
|
+
/**
|
|
313
|
+
* PNG ancillary chunks the relay treats as rendering rather than metadata.
|
|
314
|
+
*
|
|
315
|
+
* Exactly `known_rendering` in `buzz-media`'s `validate_png_metadata_free`.
|
|
316
|
+
* **`pHYs` is not on it**, deliberately: the relay's comment calls arbitrary
|
|
317
|
+
* values an identity channel, and nearly every screen-capture tool writes one.
|
|
318
|
+
* That single omission is why an ordinary screenshot is refused.
|
|
319
|
+
*/
|
|
320
|
+
const PNG_RENDERING_CHUNKS = new Set([
|
|
321
|
+
'cHRM', 'gAMA', 'sBIT', 'sRGB', 'bKGD', 'hIST', 'tRNS', 'sPLT', 'acTL', 'fcTL', 'fdAT',
|
|
322
|
+
]);
|
|
323
|
+
/**
|
|
324
|
+
* `tEXt` keywords the relay exempts — Buzz agent/team snapshot manifests.
|
|
325
|
+
*
|
|
326
|
+
* A deliberate product payload rather than metadata, so it is kept. Stripping
|
|
327
|
+
* it would leave a `.agent.png` that still looks like an image and silently no
|
|
328
|
+
* longer carries the thing it exists to carry, which is worse than a refusal.
|
|
329
|
+
*/
|
|
330
|
+
const PNG_SNAPSHOT_KEYWORDS = ['buzz_agent_snapshot', 'buzz_team_snapshot'];
|
|
331
|
+
const PNG_SIGNATURE = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
|
|
332
|
+
/** A `tEXt` payload is `<keyword>\0<text>`. Only an allowlisted keyword survives. */
|
|
333
|
+
function isSnapshotText(payload) {
|
|
334
|
+
return PNG_SNAPSHOT_KEYWORDS.some((keyword) => {
|
|
335
|
+
if (payload.length <= keyword.length || payload[keyword.length] !== 0)
|
|
336
|
+
return false;
|
|
337
|
+
for (let i = 0; i < keyword.length; i++)
|
|
338
|
+
if (payload[i] !== keyword.charCodeAt(i))
|
|
339
|
+
return false;
|
|
340
|
+
return true;
|
|
341
|
+
});
|
|
342
|
+
}
|
|
343
|
+
function canonicalizePng(bytes) {
|
|
344
|
+
const kept = [new Uint8Array(PNG_SIGNATURE)];
|
|
345
|
+
let i = PNG_SIGNATURE.length;
|
|
346
|
+
let sawSnapshot = false;
|
|
347
|
+
let sawIend = false;
|
|
348
|
+
while (i < bytes.length) {
|
|
349
|
+
if (i + 12 > bytes.length)
|
|
350
|
+
throw new Error('malformed PNG: truncated chunk header');
|
|
351
|
+
const length = (bytes[i] << 24) | (bytes[i + 1] << 16) | (bytes[i + 2] << 8) | bytes[i + 3];
|
|
352
|
+
const type = String.fromCharCode(bytes[i + 4], bytes[i + 5], bytes[i + 6], bytes[i + 7]);
|
|
353
|
+
const end = i + 12 + length;
|
|
354
|
+
if (length < 0 || end > bytes.length)
|
|
355
|
+
throw new Error(`malformed PNG: truncated ${type} chunk`);
|
|
356
|
+
// Bit 5 of the first byte: lowercase means ancillary, and ancillary means
|
|
357
|
+
// droppable. Critical chunks are the image and are never touched.
|
|
358
|
+
const ancillary = (bytes[i + 4] & 0x20) !== 0;
|
|
359
|
+
let keep = !ancillary || PNG_RENDERING_CHUNKS.has(type);
|
|
360
|
+
if (type === 'tEXt') {
|
|
361
|
+
// One snapshot manifest survives; a second is a metadata channel again.
|
|
362
|
+
keep = !sawSnapshot && isSnapshotText(bytes.subarray(i + 8, end - 4));
|
|
363
|
+
if (keep)
|
|
364
|
+
sawSnapshot = true;
|
|
365
|
+
}
|
|
366
|
+
if (keep)
|
|
367
|
+
kept.push(bytes.subarray(i, end));
|
|
368
|
+
i = end;
|
|
369
|
+
if (type === 'IEND') {
|
|
370
|
+
sawIend = true;
|
|
371
|
+
break; // Anything after IEND is trailing data, which the relay refuses.
|
|
372
|
+
}
|
|
373
|
+
}
|
|
374
|
+
if (!sawIend)
|
|
375
|
+
throw new Error('malformed PNG: no IEND');
|
|
376
|
+
return concatBytes(kept);
|
|
377
|
+
}
|
|
378
|
+
/**
|
|
379
|
+
* A JPEG segment the relay accepts.
|
|
380
|
+
*
|
|
381
|
+
* `APP0` and `APP14` are allowed only in their canonical colour-header forms —
|
|
382
|
+
* accepting an arbitrary payload under those markers would leave exactly the
|
|
383
|
+
* side channel the ban is for. `APP1`–`APP13`, `APP15` and `COM` are refused
|
|
384
|
+
* outright, and `APP1` is where EXIF lives.
|
|
385
|
+
*/
|
|
386
|
+
function keepJpegSegment(marker, payload) {
|
|
387
|
+
if (marker === 0xe0) {
|
|
388
|
+
const jfif = payload.length >= 14 && String.fromCharCode(...payload.subarray(0, 5)) === 'JFIF\0';
|
|
389
|
+
return jfif && payload.length === 14 + 3 * payload[12] * payload[13];
|
|
390
|
+
}
|
|
391
|
+
if (marker === 0xee) {
|
|
392
|
+
return payload.length === 12 && String.fromCharCode(...payload.subarray(0, 5)) === 'Adobe';
|
|
393
|
+
}
|
|
394
|
+
if ((marker >= 0xe1 && marker <= 0xed) || marker === 0xef || marker === 0xfe)
|
|
395
|
+
return false;
|
|
396
|
+
return true;
|
|
397
|
+
}
|
|
398
|
+
function canonicalizeJpeg(bytes) {
|
|
399
|
+
if (bytes[0] !== 0xff || bytes[1] !== 0xd8)
|
|
400
|
+
throw new Error('malformed JPEG: no SOI');
|
|
401
|
+
const kept = [new Uint8Array([0xff, 0xd8])];
|
|
402
|
+
let i = 2;
|
|
403
|
+
let inScan = false;
|
|
404
|
+
while (i < bytes.length) {
|
|
405
|
+
if (bytes[i] !== 0xff) {
|
|
406
|
+
// Entropy-coded data between SOS and the next marker. Copied verbatim —
|
|
407
|
+
// it is the image.
|
|
408
|
+
if (!inScan)
|
|
409
|
+
throw new Error('malformed JPEG: expected a marker');
|
|
410
|
+
const start = i;
|
|
411
|
+
while (i < bytes.length && bytes[i] !== 0xff)
|
|
412
|
+
i++;
|
|
413
|
+
kept.push(bytes.subarray(start, i));
|
|
414
|
+
continue;
|
|
415
|
+
}
|
|
416
|
+
// Fill bytes: any run of 0xFF before a marker. One is emitted.
|
|
417
|
+
while (i < bytes.length && bytes[i] === 0xff)
|
|
418
|
+
i++;
|
|
419
|
+
if (i >= bytes.length)
|
|
420
|
+
throw new Error('malformed JPEG: marker ran off the end');
|
|
421
|
+
const marker = bytes[i++];
|
|
422
|
+
// 0x00 is a stuffed byte inside the scan, not a marker; RSTn and TEM are
|
|
423
|
+
// standalone. All three are part of the image and carry no payload.
|
|
424
|
+
if ((inScan && marker === 0x00) || (marker >= 0xd0 && marker <= 0xd7) || marker === 0x01) {
|
|
425
|
+
kept.push(new Uint8Array([0xff, marker]));
|
|
426
|
+
continue;
|
|
427
|
+
}
|
|
428
|
+
if (marker === 0xd9) {
|
|
429
|
+
// EOI. Stop here rather than copying on: the relay refuses trailing
|
|
430
|
+
// bytes after EOI, and that is where a stripped-EXIF editor leaves them.
|
|
431
|
+
kept.push(new Uint8Array([0xff, 0xd9]));
|
|
432
|
+
return concatBytes(kept);
|
|
433
|
+
}
|
|
434
|
+
if (marker === 0xd8)
|
|
435
|
+
throw new Error('malformed JPEG: a second SOI');
|
|
436
|
+
if (i + 2 > bytes.length)
|
|
437
|
+
throw new Error('malformed JPEG: truncated segment length');
|
|
438
|
+
const length = (bytes[i] << 8) | bytes[i + 1];
|
|
439
|
+
if (length < 2)
|
|
440
|
+
throw new Error('malformed JPEG: bad segment length');
|
|
441
|
+
const end = i + length;
|
|
442
|
+
if (end > bytes.length)
|
|
443
|
+
throw new Error('malformed JPEG: truncated segment');
|
|
444
|
+
if (keepJpegSegment(marker, bytes.subarray(i + 2, end))) {
|
|
445
|
+
kept.push(new Uint8Array([0xff, marker]), bytes.subarray(i, end));
|
|
446
|
+
}
|
|
447
|
+
i = end;
|
|
448
|
+
inScan = marker === 0xda;
|
|
449
|
+
}
|
|
450
|
+
throw new Error('malformed JPEG: no EOI');
|
|
451
|
+
}
|
|
452
|
+
function concatBytes(parts) {
|
|
453
|
+
let size = 0;
|
|
454
|
+
for (const part of parts)
|
|
455
|
+
size += part.length;
|
|
456
|
+
const out = new Uint8Array(size);
|
|
457
|
+
let at = 0;
|
|
458
|
+
for (const part of parts) {
|
|
459
|
+
out.set(part, at);
|
|
460
|
+
at += part.length;
|
|
461
|
+
}
|
|
462
|
+
return out;
|
|
463
|
+
}
|
|
464
|
+
/**
|
|
465
|
+
* Strip an image down to what the relay will store — SHA-25.
|
|
466
|
+
*
|
|
467
|
+
* Buzz refuses media carrying metadata, and refuses it *structurally* rather
|
|
468
|
+
* than by scrubbing it: `validate_image_metadata_free` returns
|
|
469
|
+
* `MetadataForbidden` and the whole upload 422s. Its video path names the piece
|
|
470
|
+
* that was missing — "only the canonical primary stream produced by the **client
|
|
471
|
+
* sanitizer** is permitted" — and until this there was no client sanitizer, in
|
|
472
|
+
* either app. An unmodified screenshot was refused, every time, because capture
|
|
473
|
+
* tools write `pHYs` and a `tEXt` software tag.
|
|
474
|
+
*
|
|
475
|
+
* ## Chunks are dropped, never re-encoded
|
|
476
|
+
*
|
|
477
|
+
* The obvious implementation is a canvas round trip, and it does not work: the
|
|
478
|
+
* browser's encoder **adds an ICC profile back**, which the relay refuses
|
|
479
|
+
* identically. Dropping chunks is also lossless — every chunk removed here is
|
|
480
|
+
* ancillary by the format's own definition — where a re-encode would quietly
|
|
481
|
+
* degrade a screenshot to make it acceptable.
|
|
482
|
+
*
|
|
483
|
+
* ## PNG and JPEG only
|
|
484
|
+
*
|
|
485
|
+
* GIF and WebP are accepted by the relay and are **passed through untouched**.
|
|
486
|
+
* Their metadata is not a droppable chunk: WebP records EXIF/ICC/XMP presence
|
|
487
|
+
* in `VP8X` flags that have to stay consistent with the chunks, and GIF hides
|
|
488
|
+
* it in extension blocks. Rewriting either wrongly produces a corrupt image,
|
|
489
|
+
* which is worse than the refusal it replaces — so they keep today's behaviour
|
|
490
|
+
* and the relay's own words. Screenshots are PNG or JPEG, which is the case
|
|
491
|
+
* that was actually costing anything.
|
|
492
|
+
*
|
|
493
|
+
* Throws on malformed input rather than returning the bytes unchanged: an image
|
|
494
|
+
* this cannot parse is one it cannot vouch for, and uploading it anyway would
|
|
495
|
+
* turn a clear failure here into an opaque 422 later.
|
|
496
|
+
*/
|
|
497
|
+
export function canonicalizeImage(bytes) {
|
|
498
|
+
const view = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
|
|
499
|
+
/*
|
|
500
|
+
Sniffed from the bytes, with no `contentType` argument at all. The MIME a
|
|
501
|
+
caller has is the browser's guess from a file extension — a `.png` that is
|
|
502
|
+
really a JPEG is ordinary — and this has the actual bytes in hand. Taking
|
|
503
|
+
the parameter would invite trusting it.
|
|
504
|
+
*/
|
|
505
|
+
if (PNG_SIGNATURE.every((byte, at) => view[at] === byte))
|
|
506
|
+
return canonicalizePng(view);
|
|
507
|
+
if (view[0] === 0xff && view[1] === 0xd8)
|
|
508
|
+
return canonicalizeJpeg(view);
|
|
509
|
+
return view;
|
|
510
|
+
}
|
|
185
511
|
//# sourceMappingURL=media.js.map
|
package/dist/media.js.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"media.js","sourceRoot":"","sources":["../src/media.ts"],"names":[],"mappings":"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"}
|
|
1
|
+
{"version":3,"file":"media.js","sourceRoot":"","sources":["../src/media.ts"],"names":[],"mappings":"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"}
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@estiva-app/protocol",
|
|
3
|
-
"version": "0.
|
|
3
|
+
"version": "0.19.0",
|
|
4
4
|
"description": "The Estiva wire format: Buzz-shaped Nostr event builders, NIP-01 ids, NIP-19 naddr, NIP-98 HTTP auth, and the relay clients. Speaks the protocol; interprets nothing.",
|
|
5
5
|
"license": "MIT",
|
|
6
6
|
"type": "module",
|
package/src/index.ts
CHANGED
|
@@ -47,7 +47,7 @@
|
|
|
47
47
|
/** Bumped by hand with the version in package.json — `test/version.test.ts`
|
|
48
48
|
* pins the two together. It exists so "the upgrade reached the app" can be
|
|
49
49
|
* checked by grepping a built bundle rather than by trusting a lockfile. */
|
|
50
|
-
export const PROTOCOL_VERSION = '0.
|
|
50
|
+
export const PROTOCOL_VERSION = '0.19.0'
|
|
51
51
|
|
|
52
52
|
export {
|
|
53
53
|
// types
|
|
@@ -240,4 +240,10 @@ export {
|
|
|
240
240
|
type FetchedBlob,
|
|
241
241
|
sha256FromMediaUrl,
|
|
242
242
|
fetchBlob,
|
|
243
|
+
sha256Of,
|
|
244
|
+
uploadBlob,
|
|
245
|
+
imetaFor,
|
|
246
|
+
canonicalizeImage,
|
|
247
|
+
type UploadedBlob,
|
|
248
|
+
type BlobUploadFetchLike,
|
|
243
249
|
} from './media.js'
|
package/src/media.ts
CHANGED
|
@@ -15,6 +15,8 @@
|
|
|
15
15
|
import type { NostrTag, SignedEvent, UnsignedEvent } from './events.js'
|
|
16
16
|
import { KIND, toNostrSeconds } from './events.js'
|
|
17
17
|
import { authorizationHeaderFor } from './nip98.js'
|
|
18
|
+
import { sha256 } from '@noble/hashes/sha256'
|
|
19
|
+
import { bytesToHex } from '@noble/hashes/utils'
|
|
18
20
|
|
|
19
21
|
/** What a Blossom authorization permits. One verb per event. */
|
|
20
22
|
export type BlossomVerb = 'upload' | 'get' | 'list' | 'delete'
|
|
@@ -212,8 +214,17 @@ export type BlobFetchLike = (
|
|
|
212
214
|
init: { method: string; headers: Record<string, string> },
|
|
213
215
|
) => Promise<BlobResponseLike>
|
|
214
216
|
|
|
215
|
-
/**
|
|
216
|
-
|
|
217
|
+
/**
|
|
218
|
+
* The platform `fetch`, in the two shapes this file asks of it.
|
|
219
|
+
*
|
|
220
|
+
* An intersection rather than two declarations, because there is one global and
|
|
221
|
+
* TypeScript will not let a module name it twice. It really does accept both
|
|
222
|
+
* calls — a GET with no body and a PUT with bytes — so an overloaded type is
|
|
223
|
+
* the accurate description rather than a convenience.
|
|
224
|
+
*
|
|
225
|
+
* Read inside a function, so importing this module touches no global.
|
|
226
|
+
*/
|
|
227
|
+
declare const fetch: BlobFetchLike & BlobUploadFetchLike
|
|
217
228
|
|
|
218
229
|
/** What came back, and what it is. */
|
|
219
230
|
export interface FetchedBlob {
|
|
@@ -274,3 +285,373 @@ export async function fetchBlob(args: {
|
|
|
274
285
|
contentType: response.headers.get('content-type') ?? 'application/octet-stream',
|
|
275
286
|
}
|
|
276
287
|
}
|
|
288
|
+
|
|
289
|
+
/**
|
|
290
|
+
* A blob's identity: its sha256, lowercase hex.
|
|
291
|
+
*
|
|
292
|
+
* `@noble/hashes` rather than `crypto.subtle`, which is async, absent from
|
|
293
|
+
* older Node without a flag, and unavailable on an insecure origin. This
|
|
294
|
+
* package already hashes every event id with it.
|
|
295
|
+
*/
|
|
296
|
+
export function sha256Of(bytes: ArrayBuffer | Uint8Array): string {
|
|
297
|
+
return bytesToHex(sha256(bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes)))
|
|
298
|
+
}
|
|
299
|
+
|
|
300
|
+
/** What the relay hands back once it holds the bytes — BUD-02 descriptor. */
|
|
301
|
+
export interface UploadedBlob {
|
|
302
|
+
/** Where the bytes are. Already rewritten for the tenant, so it goes straight into `imeta`. */
|
|
303
|
+
url: string
|
|
304
|
+
sha256: string
|
|
305
|
+
size: number
|
|
306
|
+
/** MIME **as the relay stored it**. `imeta`'s `m` must equal this exactly. */
|
|
307
|
+
type: string
|
|
308
|
+
/** `<width>x<height>`, computed by the relay rather than by the client. */
|
|
309
|
+
dim?: string
|
|
310
|
+
/** The relay's generated thumbnail, when it made one. */
|
|
311
|
+
thumb?: string
|
|
312
|
+
}
|
|
313
|
+
|
|
314
|
+
/**
|
|
315
|
+
* A transport that can send bytes.
|
|
316
|
+
*
|
|
317
|
+
* A third shape, and for the third reason: {@link FetchLike} sends a string
|
|
318
|
+
* body, {@link BlobFetchLike} sends none and reads bytes, this one sends bytes
|
|
319
|
+
* and reads a string. One type that did all three would be loose enough to let
|
|
320
|
+
* any of them be called wrongly.
|
|
321
|
+
*/
|
|
322
|
+
export type BlobUploadFetchLike = (
|
|
323
|
+
url: string,
|
|
324
|
+
init: { method: string; headers: Record<string, string>; body: ArrayBuffer },
|
|
325
|
+
) => Promise<{ status: number; text(): Promise<string> }>
|
|
326
|
+
|
|
327
|
+
/**
|
|
328
|
+
* Put a file on the relay — CON-12's write half, BUD-01/BUD-11.
|
|
329
|
+
*
|
|
330
|
+
* **The upload must land before the message that names it.** Ingest runs
|
|
331
|
+
* `verify_imeta_blobs` and refuses a message whose blob it does not already
|
|
332
|
+
* hold, so this is not an optimisation to reorder — it is the only order that
|
|
333
|
+
* works. A dangling attachment reference cannot be published at all, which is
|
|
334
|
+
* a constraint worth being glad about.
|
|
335
|
+
*
|
|
336
|
+
* The hash is computed here rather than read off the response, because it is
|
|
337
|
+
* what the authorization has to name: BUD-11 requires the `x` tag to match, so
|
|
338
|
+
* the client must know the digest *before* it may ask permission to send the
|
|
339
|
+
* bytes. `x-sha-256` carries it again on the PUT, where the relay checks the
|
|
340
|
+
* bytes against it rather than trusting either side's arithmetic.
|
|
341
|
+
*
|
|
342
|
+
* Takes bytes rather than a `File`: `File` is a DOM type, this package builds
|
|
343
|
+
* without `lib.dom`, and a caller that has one passes `await file.arrayBuffer()`.
|
|
344
|
+
*
|
|
345
|
+
* Throws with the relay's own words. What that means is the caller's to decide.
|
|
346
|
+
*/
|
|
347
|
+
export async function uploadBlob(args: {
|
|
348
|
+
/** The relay origin. `/upload` is appended. */
|
|
349
|
+
relayUrl: string
|
|
350
|
+
bytes: ArrayBuffer
|
|
351
|
+
/** The MIME to send. The relay stores its own answer, which wins — see {@link UploadedBlob.type}. */
|
|
352
|
+
contentType?: string
|
|
353
|
+
/** Display name. Goes in the authorization's human-readable reason, nowhere else. */
|
|
354
|
+
filename?: string
|
|
355
|
+
sign: (unsigned: UnsignedEvent) => Promise<SignedEvent>
|
|
356
|
+
pubkey: string
|
|
357
|
+
transport?: BlobUploadFetchLike
|
|
358
|
+
/** Skip {@link canonicalizeImage}. Default `true`; see the note below. */
|
|
359
|
+
canonicalize?: boolean
|
|
360
|
+
}): Promise<UploadedBlob> {
|
|
361
|
+
/*
|
|
362
|
+
Canonicalized first, and the hash taken after — SHA-25.
|
|
363
|
+
|
|
364
|
+
The relay refuses media carrying metadata, so an unmodified screenshot 422s:
|
|
365
|
+
capture tools write a `pHYs` and a `tEXt` software tag, and neither is on
|
|
366
|
+
Buzz's rendering allowlist. Doing it here rather than asking each caller to
|
|
367
|
+
remember means there is one place the relay's rule is understood, which is
|
|
368
|
+
the same argument that put `uploadBlob` in this package at all.
|
|
369
|
+
|
|
370
|
+
The order is forced. `x` in the authorization, `x-sha-256` on the PUT and
|
|
371
|
+
`x` in the `imeta` must all be the digest of the bytes the relay actually
|
|
372
|
+
stores, so hashing before stripping would name a blob that never existed.
|
|
373
|
+
|
|
374
|
+
`canonicalize: false` is for a caller that has already done it, or is
|
|
375
|
+
sending something this does not understand and does not want touched. It is
|
|
376
|
+
not a way round a refusal: the relay's answer does not change.
|
|
377
|
+
*/
|
|
378
|
+
const canonical =
|
|
379
|
+
args.canonicalize === false
|
|
380
|
+
? args.bytes instanceof Uint8Array
|
|
381
|
+
? args.bytes
|
|
382
|
+
: new Uint8Array(args.bytes)
|
|
383
|
+
: canonicalizeImage(args.bytes)
|
|
384
|
+
/*
|
|
385
|
+
A standalone `ArrayBuffer`, because the transport's `body` is one and a
|
|
386
|
+
`Uint8Array` may be a window onto a larger buffer — sending `.buffer` would
|
|
387
|
+
upload whatever else is in it. One copy, against a network PUT.
|
|
388
|
+
*/
|
|
389
|
+
const payload = canonical.buffer.slice(
|
|
390
|
+
canonical.byteOffset,
|
|
391
|
+
canonical.byteOffset + canonical.byteLength,
|
|
392
|
+
) as ArrayBuffer
|
|
393
|
+
const digest = sha256Of(payload)
|
|
394
|
+
const auth = await args.sign(
|
|
395
|
+
buildBlossomAuth(args.pubkey, Date.now(), {
|
|
396
|
+
verb: 'upload',
|
|
397
|
+
sha256: digest,
|
|
398
|
+
reason: args.filename ? `Upload ${args.filename}` : 'Upload attachment',
|
|
399
|
+
}),
|
|
400
|
+
)
|
|
401
|
+
|
|
402
|
+
const send = args.transport ?? fetch
|
|
403
|
+
const response = await send(`${args.relayUrl.replace(/\/+$/, '')}/upload`, {
|
|
404
|
+
method: 'PUT',
|
|
405
|
+
headers: {
|
|
406
|
+
authorization: blossomAuthHeader(auth),
|
|
407
|
+
// BUD-11 makes this mandatory on PUT /upload.
|
|
408
|
+
'x-sha-256': digest,
|
|
409
|
+
'content-type': args.contentType || 'application/octet-stream',
|
|
410
|
+
},
|
|
411
|
+
body: payload,
|
|
412
|
+
})
|
|
413
|
+
|
|
414
|
+
const body = await response.text()
|
|
415
|
+
if (response.status < 200 || response.status >= 300) {
|
|
416
|
+
throw new Error(`upload failed: ${response.status} ${body.slice(0, 200)}`)
|
|
417
|
+
}
|
|
418
|
+
|
|
419
|
+
let descriptor: Partial<UploadedBlob>
|
|
420
|
+
try {
|
|
421
|
+
descriptor = JSON.parse(body) as Partial<UploadedBlob>
|
|
422
|
+
} catch {
|
|
423
|
+
throw new Error('upload returned no blob descriptor')
|
|
424
|
+
}
|
|
425
|
+
// `url` is the relay's own, already rewritten for the tenant — assembling a
|
|
426
|
+
// host here would produce something `validate_imeta_tags` rejects as
|
|
427
|
+
// non-local on any deployment whose tenant host is not the configured one.
|
|
428
|
+
if (!descriptor.url || !descriptor.sha256) throw new Error('upload returned no blob descriptor')
|
|
429
|
+
return {
|
|
430
|
+
url: descriptor.url,
|
|
431
|
+
sha256: descriptor.sha256,
|
|
432
|
+
size: descriptor.size ?? args.bytes.byteLength,
|
|
433
|
+
type: descriptor.type ?? args.contentType ?? 'application/octet-stream',
|
|
434
|
+
dim: descriptor.dim,
|
|
435
|
+
thumb: descriptor.thumb,
|
|
436
|
+
}
|
|
437
|
+
}
|
|
438
|
+
|
|
439
|
+
/**
|
|
440
|
+
* An uploaded blob as the `imeta` that references it.
|
|
441
|
+
*
|
|
442
|
+
* Shared because the mapping has one trap in it: `m` and `x` must be the
|
|
443
|
+
* **relay's** answers, not the client's. `validate_imeta_tags` compares them
|
|
444
|
+
* against what it stored, and a browser that re-encoded a file on the way in —
|
|
445
|
+
* or simply guessed a MIME from an extension — publishes a message the relay
|
|
446
|
+
* refuses, with nothing to say which field was wrong.
|
|
447
|
+
*/
|
|
448
|
+
export function imetaFor(blob: UploadedBlob, extra?: { alt?: string; filename?: string }): Imeta {
|
|
449
|
+
return {
|
|
450
|
+
url: blob.url,
|
|
451
|
+
m: blob.type,
|
|
452
|
+
x: blob.sha256,
|
|
453
|
+
size: blob.size,
|
|
454
|
+
dim: blob.dim,
|
|
455
|
+
thumb: blob.thumb,
|
|
456
|
+
alt: extra?.alt,
|
|
457
|
+
filename: extra?.filename,
|
|
458
|
+
}
|
|
459
|
+
}
|
|
460
|
+
|
|
461
|
+
/* ────────────────────────────────────────────────────────────────────────────
|
|
462
|
+
Canonicalizing an image before it is uploaded — SHA-25
|
|
463
|
+
──────────────────────────────────────────────────────────────────────────── */
|
|
464
|
+
|
|
465
|
+
/**
|
|
466
|
+
* PNG ancillary chunks the relay treats as rendering rather than metadata.
|
|
467
|
+
*
|
|
468
|
+
* Exactly `known_rendering` in `buzz-media`'s `validate_png_metadata_free`.
|
|
469
|
+
* **`pHYs` is not on it**, deliberately: the relay's comment calls arbitrary
|
|
470
|
+
* values an identity channel, and nearly every screen-capture tool writes one.
|
|
471
|
+
* That single omission is why an ordinary screenshot is refused.
|
|
472
|
+
*/
|
|
473
|
+
const PNG_RENDERING_CHUNKS: ReadonlySet<string> = new Set([
|
|
474
|
+
'cHRM', 'gAMA', 'sBIT', 'sRGB', 'bKGD', 'hIST', 'tRNS', 'sPLT', 'acTL', 'fcTL', 'fdAT',
|
|
475
|
+
])
|
|
476
|
+
|
|
477
|
+
/**
|
|
478
|
+
* `tEXt` keywords the relay exempts — Buzz agent/team snapshot manifests.
|
|
479
|
+
*
|
|
480
|
+
* A deliberate product payload rather than metadata, so it is kept. Stripping
|
|
481
|
+
* it would leave a `.agent.png` that still looks like an image and silently no
|
|
482
|
+
* longer carries the thing it exists to carry, which is worse than a refusal.
|
|
483
|
+
*/
|
|
484
|
+
const PNG_SNAPSHOT_KEYWORDS = ['buzz_agent_snapshot', 'buzz_team_snapshot'] as const
|
|
485
|
+
|
|
486
|
+
const PNG_SIGNATURE = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]
|
|
487
|
+
|
|
488
|
+
/** A `tEXt` payload is `<keyword>\0<text>`. Only an allowlisted keyword survives. */
|
|
489
|
+
function isSnapshotText(payload: Uint8Array): boolean {
|
|
490
|
+
return PNG_SNAPSHOT_KEYWORDS.some((keyword) => {
|
|
491
|
+
if (payload.length <= keyword.length || payload[keyword.length] !== 0) return false
|
|
492
|
+
for (let i = 0; i < keyword.length; i++) if (payload[i] !== keyword.charCodeAt(i)) return false
|
|
493
|
+
return true
|
|
494
|
+
})
|
|
495
|
+
}
|
|
496
|
+
|
|
497
|
+
function canonicalizePng(bytes: Uint8Array): Uint8Array {
|
|
498
|
+
const kept: Uint8Array[] = [new Uint8Array(PNG_SIGNATURE)]
|
|
499
|
+
let i = PNG_SIGNATURE.length
|
|
500
|
+
let sawSnapshot = false
|
|
501
|
+
let sawIend = false
|
|
502
|
+
|
|
503
|
+
while (i < bytes.length) {
|
|
504
|
+
if (i + 12 > bytes.length) throw new Error('malformed PNG: truncated chunk header')
|
|
505
|
+
const length = (bytes[i] << 24) | (bytes[i + 1] << 16) | (bytes[i + 2] << 8) | bytes[i + 3]
|
|
506
|
+
const type = String.fromCharCode(bytes[i + 4], bytes[i + 5], bytes[i + 6], bytes[i + 7])
|
|
507
|
+
const end = i + 12 + length
|
|
508
|
+
if (length < 0 || end > bytes.length) throw new Error(`malformed PNG: truncated ${type} chunk`)
|
|
509
|
+
|
|
510
|
+
// Bit 5 of the first byte: lowercase means ancillary, and ancillary means
|
|
511
|
+
// droppable. Critical chunks are the image and are never touched.
|
|
512
|
+
const ancillary = (bytes[i + 4] & 0x20) !== 0
|
|
513
|
+
let keep = !ancillary || PNG_RENDERING_CHUNKS.has(type)
|
|
514
|
+
if (type === 'tEXt') {
|
|
515
|
+
// One snapshot manifest survives; a second is a metadata channel again.
|
|
516
|
+
keep = !sawSnapshot && isSnapshotText(bytes.subarray(i + 8, end - 4))
|
|
517
|
+
if (keep) sawSnapshot = true
|
|
518
|
+
}
|
|
519
|
+
if (keep) kept.push(bytes.subarray(i, end))
|
|
520
|
+
|
|
521
|
+
i = end
|
|
522
|
+
if (type === 'IEND') {
|
|
523
|
+
sawIend = true
|
|
524
|
+
break // Anything after IEND is trailing data, which the relay refuses.
|
|
525
|
+
}
|
|
526
|
+
}
|
|
527
|
+
if (!sawIend) throw new Error('malformed PNG: no IEND')
|
|
528
|
+
return concatBytes(kept)
|
|
529
|
+
}
|
|
530
|
+
|
|
531
|
+
/**
|
|
532
|
+
* A JPEG segment the relay accepts.
|
|
533
|
+
*
|
|
534
|
+
* `APP0` and `APP14` are allowed only in their canonical colour-header forms —
|
|
535
|
+
* accepting an arbitrary payload under those markers would leave exactly the
|
|
536
|
+
* side channel the ban is for. `APP1`–`APP13`, `APP15` and `COM` are refused
|
|
537
|
+
* outright, and `APP1` is where EXIF lives.
|
|
538
|
+
*/
|
|
539
|
+
function keepJpegSegment(marker: number, payload: Uint8Array): boolean {
|
|
540
|
+
if (marker === 0xe0) {
|
|
541
|
+
const jfif = payload.length >= 14 && String.fromCharCode(...payload.subarray(0, 5)) === 'JFIF\0'
|
|
542
|
+
return jfif && payload.length === 14 + 3 * payload[12] * payload[13]
|
|
543
|
+
}
|
|
544
|
+
if (marker === 0xee) {
|
|
545
|
+
return payload.length === 12 && String.fromCharCode(...payload.subarray(0, 5)) === 'Adobe'
|
|
546
|
+
}
|
|
547
|
+
if ((marker >= 0xe1 && marker <= 0xed) || marker === 0xef || marker === 0xfe) return false
|
|
548
|
+
return true
|
|
549
|
+
}
|
|
550
|
+
|
|
551
|
+
function canonicalizeJpeg(bytes: Uint8Array): Uint8Array {
|
|
552
|
+
if (bytes[0] !== 0xff || bytes[1] !== 0xd8) throw new Error('malformed JPEG: no SOI')
|
|
553
|
+
const kept: Uint8Array[] = [new Uint8Array([0xff, 0xd8])]
|
|
554
|
+
let i = 2
|
|
555
|
+
let inScan = false
|
|
556
|
+
|
|
557
|
+
while (i < bytes.length) {
|
|
558
|
+
if (bytes[i] !== 0xff) {
|
|
559
|
+
// Entropy-coded data between SOS and the next marker. Copied verbatim —
|
|
560
|
+
// it is the image.
|
|
561
|
+
if (!inScan) throw new Error('malformed JPEG: expected a marker')
|
|
562
|
+
const start = i
|
|
563
|
+
while (i < bytes.length && bytes[i] !== 0xff) i++
|
|
564
|
+
kept.push(bytes.subarray(start, i))
|
|
565
|
+
continue
|
|
566
|
+
}
|
|
567
|
+
// Fill bytes: any run of 0xFF before a marker. One is emitted.
|
|
568
|
+
while (i < bytes.length && bytes[i] === 0xff) i++
|
|
569
|
+
if (i >= bytes.length) throw new Error('malformed JPEG: marker ran off the end')
|
|
570
|
+
const marker = bytes[i++]
|
|
571
|
+
|
|
572
|
+
// 0x00 is a stuffed byte inside the scan, not a marker; RSTn and TEM are
|
|
573
|
+
// standalone. All three are part of the image and carry no payload.
|
|
574
|
+
if ((inScan && marker === 0x00) || (marker >= 0xd0 && marker <= 0xd7) || marker === 0x01) {
|
|
575
|
+
kept.push(new Uint8Array([0xff, marker]))
|
|
576
|
+
continue
|
|
577
|
+
}
|
|
578
|
+
if (marker === 0xd9) {
|
|
579
|
+
// EOI. Stop here rather than copying on: the relay refuses trailing
|
|
580
|
+
// bytes after EOI, and that is where a stripped-EXIF editor leaves them.
|
|
581
|
+
kept.push(new Uint8Array([0xff, 0xd9]))
|
|
582
|
+
return concatBytes(kept)
|
|
583
|
+
}
|
|
584
|
+
if (marker === 0xd8) throw new Error('malformed JPEG: a second SOI')
|
|
585
|
+
|
|
586
|
+
if (i + 2 > bytes.length) throw new Error('malformed JPEG: truncated segment length')
|
|
587
|
+
const length = (bytes[i] << 8) | bytes[i + 1]
|
|
588
|
+
if (length < 2) throw new Error('malformed JPEG: bad segment length')
|
|
589
|
+
const end = i + length
|
|
590
|
+
if (end > bytes.length) throw new Error('malformed JPEG: truncated segment')
|
|
591
|
+
|
|
592
|
+
if (keepJpegSegment(marker, bytes.subarray(i + 2, end))) {
|
|
593
|
+
kept.push(new Uint8Array([0xff, marker]), bytes.subarray(i, end))
|
|
594
|
+
}
|
|
595
|
+
i = end
|
|
596
|
+
inScan = marker === 0xda
|
|
597
|
+
}
|
|
598
|
+
throw new Error('malformed JPEG: no EOI')
|
|
599
|
+
}
|
|
600
|
+
|
|
601
|
+
function concatBytes(parts: readonly Uint8Array[]): Uint8Array {
|
|
602
|
+
let size = 0
|
|
603
|
+
for (const part of parts) size += part.length
|
|
604
|
+
const out = new Uint8Array(size)
|
|
605
|
+
let at = 0
|
|
606
|
+
for (const part of parts) {
|
|
607
|
+
out.set(part, at)
|
|
608
|
+
at += part.length
|
|
609
|
+
}
|
|
610
|
+
return out
|
|
611
|
+
}
|
|
612
|
+
|
|
613
|
+
/**
|
|
614
|
+
* Strip an image down to what the relay will store — SHA-25.
|
|
615
|
+
*
|
|
616
|
+
* Buzz refuses media carrying metadata, and refuses it *structurally* rather
|
|
617
|
+
* than by scrubbing it: `validate_image_metadata_free` returns
|
|
618
|
+
* `MetadataForbidden` and the whole upload 422s. Its video path names the piece
|
|
619
|
+
* that was missing — "only the canonical primary stream produced by the **client
|
|
620
|
+
* sanitizer** is permitted" — and until this there was no client sanitizer, in
|
|
621
|
+
* either app. An unmodified screenshot was refused, every time, because capture
|
|
622
|
+
* tools write `pHYs` and a `tEXt` software tag.
|
|
623
|
+
*
|
|
624
|
+
* ## Chunks are dropped, never re-encoded
|
|
625
|
+
*
|
|
626
|
+
* The obvious implementation is a canvas round trip, and it does not work: the
|
|
627
|
+
* browser's encoder **adds an ICC profile back**, which the relay refuses
|
|
628
|
+
* identically. Dropping chunks is also lossless — every chunk removed here is
|
|
629
|
+
* ancillary by the format's own definition — where a re-encode would quietly
|
|
630
|
+
* degrade a screenshot to make it acceptable.
|
|
631
|
+
*
|
|
632
|
+
* ## PNG and JPEG only
|
|
633
|
+
*
|
|
634
|
+
* GIF and WebP are accepted by the relay and are **passed through untouched**.
|
|
635
|
+
* Their metadata is not a droppable chunk: WebP records EXIF/ICC/XMP presence
|
|
636
|
+
* in `VP8X` flags that have to stay consistent with the chunks, and GIF hides
|
|
637
|
+
* it in extension blocks. Rewriting either wrongly produces a corrupt image,
|
|
638
|
+
* which is worse than the refusal it replaces — so they keep today's behaviour
|
|
639
|
+
* and the relay's own words. Screenshots are PNG or JPEG, which is the case
|
|
640
|
+
* that was actually costing anything.
|
|
641
|
+
*
|
|
642
|
+
* Throws on malformed input rather than returning the bytes unchanged: an image
|
|
643
|
+
* this cannot parse is one it cannot vouch for, and uploading it anyway would
|
|
644
|
+
* turn a clear failure here into an opaque 422 later.
|
|
645
|
+
*/
|
|
646
|
+
export function canonicalizeImage(bytes: ArrayBuffer | Uint8Array): Uint8Array {
|
|
647
|
+
const view = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes)
|
|
648
|
+
/*
|
|
649
|
+
Sniffed from the bytes, with no `contentType` argument at all. The MIME a
|
|
650
|
+
caller has is the browser's guess from a file extension — a `.png` that is
|
|
651
|
+
really a JPEG is ordinary — and this has the actual bytes in hand. Taking
|
|
652
|
+
the parameter would invite trusting it.
|
|
653
|
+
*/
|
|
654
|
+
if (PNG_SIGNATURE.every((byte, at) => view[at] === byte)) return canonicalizePng(view)
|
|
655
|
+
if (view[0] === 0xff && view[1] === 0xd8) return canonicalizeJpeg(view)
|
|
656
|
+
return view
|
|
657
|
+
}
|