fix(forward): warn when forwarding out of an encrypted room into one that is not (#330)

Forwarding from an encrypted room into an unencrypted one posts the text
(and a re-uploaded plaintext attachment) where the server can read it,
with the original author attached, and the dialog said nothing. Show a
note above Send naming the unencrypted destination(s).

Refs #330

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017PCb59uY3UKqDqt7B6hzd5

src/app/features/room/message/ForwardMessageDialog.tsx

@@ -47,8 +47,12 @@ import {
   recentForwardTargetsAtom,
   addRecentForwardTarget,
 } from '../../../state/recentForwardTargets';
-import { buildForwardContent, buildPlaintextAttachmentContent } from './forwardContent';
+import {
-import { useLocalRoomNames } from '../../../hooks/useRoomMeta';
+  buildForwardContent,
+  buildPlaintextAttachmentContent,
+  forwardEncryptionWarning,
+} from './forwardContent';
+import { useLocalRoomNames, getLocalRoomName } from '../../../hooks/useRoomMeta';
 
 type RoomRowProps = {
   room: Room;
@@ -275,6 +279,14 @@ export function ForwardMessageDialog({ mEvent, onClose }: Props) {
   // Selection persists across query changes: a room selected then filtered out
   // of the rendered slice stays selected.
   const [selectedRoomIds, setSelectedRoomIds] = useState<Set<string>>(new Set());
+  const encryptionWarning = forwardEncryptionWarning(
+    !!mx.getRoom(mEvent.getRoomId() ?? '')?.hasEncryptionStateEvent(),
+    [...selectedRoomIds]
+      .map((id) => mx.getRoom(id))
+      .filter((r): r is Room => !!r && !r.hasEncryptionStateEvent())
+      // The name the user sees (their own "Rename for me" name, if set).
+      .map((r) => getLocalRoomName(mx, r.roomId) ?? r.name),
+  );
 
   const toggleRoom = useCallback((roomId: string) => {
     setSelectedRoomIds((prev) => {
@@ -590,7 +602,13 @@ export function ForwardMessageDialog({ mEvent, onClose }: Props) {
                   shrink="No"
                   direction="Column"
                   style={{ padding: `${config.space.S200} ${config.space.S400}` }}
+                  gap="200"
                 >
+                  {encryptionWarning && (
+                    <Text size="T200" role="note" style={{ color: color.Warning.Main }}>
+                      {encryptionWarning}
+                    </Text>
+                  )}
                   <Button
                     variant="Primary"
                     size="400"

src/app/features/room/message/forwardContent.test.ts

@@ -1,7 +1,7 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { MatrixClient, MatrixEvent } from 'matrix-js-sdk';
-import { buildForwardContent, getForwardedMeta } from './forwardContent';
+import { buildForwardContent, forwardEncryptionWarning, getForwardedMeta } from './forwardContent';
 
 // Pure content builder buildForwardContent: refuses undecryptable events, forwards
 // the latest edit (`m.new_content`), and strips reply fallbacks + `m.relates_to`.
@@ -171,3 +171,16 @@ test('getForwardedMeta rejects malformed metadata', () => {
   assert.equal(getForwardedMeta({ 'io.lotus.forwarded': { sender: 1 } }), undefined);
   assert.equal(getForwardedMeta({}), undefined);
 });
+
+test('forwardEncryptionWarning: only from an encrypted room into unencrypted ones (#330)', () => {
+  assert.equal(forwardEncryptionWarning(false, ['general']), undefined);
+  assert.equal(forwardEncryptionWarning(true, []), undefined);
+  assert.match(
+    forwardEncryptionWarning(true, ['general']) ?? '',
+    /^general isn't encrypted\..*that room, along with who originally wrote it\.$/,
+  );
+  assert.match(
+    forwardEncryptionWarning(true, ['a', 'b']) ?? '',
+    /^2 of the rooms you picked aren't encrypted\..*those rooms/,
+  );
+});

src/app/features/room/message/forwardContent.ts

@@ -122,3 +122,23 @@ export async function buildPlaintextAttachmentContent(
 
   return plainContent;
 }
+
+/**
+ * [Gitea #330] The note shown when forwarding out of an encrypted room into
+ * rooms that aren't: the text (and a re-uploaded attachment) becomes readable
+ * by the server, and the original author is shown with it. Undefined when
+ * there's nothing to warn about.
+ */
+export function forwardEncryptionWarning(
+  sourceEncrypted: boolean,
+  unencryptedDestNames: string[],
+): string | undefined {
+  if (!sourceEncrypted || unencryptedDestNames.length === 0) return undefined;
+  const where =
+    unencryptedDestNames.length === 1
+      ? `${unencryptedDestNames[0]} isn't encrypted.`
+      : `${unencryptedDestNames.length} of the rooms you picked aren't encrypted.`;
+  return `${where} The forwarded message (and any attachment) will be readable by the server and everyone in ${
+    unencryptedDestNames.length === 1 ? 'that room' : 'those rooms'
+  }, along with who originally wrote it.`;
+}

src/app/utils/imageCompression.test.ts

@@ -1,11 +1,6 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import {
+import { formatFileSize, isCompressible } from './imageCompression';
-  formatFileSize,
-  hasTransparency,
-  isAnimatedWebp,
-  isCompressible,
-} from './imageCompression';
 
 test('formatFileSize formats bytes below 1KB as B', () => {
   assert.equal(formatFileSize(0), '0 B');
@@ -30,38 +25,14 @@ test('formatFileSize formats values in the MB range', () => {
 test('isCompressible accepts raster image types', () => {
   assert.equal(isCompressible({ type: 'image/png' } as Blob), true);
   assert.equal(isCompressible({ type: 'image/jpeg' } as Blob), true);
+  assert.equal(isCompressible({ type: 'image/gif' } as Blob), true);
   assert.equal(isCompressible({ type: 'image/webp' } as Blob), true);
 });
 
 test('isCompressible rejects svg, empty type, and non-images', () => {
   assert.equal(isCompressible({ type: 'image/svg+xml' } as Blob), false);
-  // [Gitea #331] usually animated; a canvas keeps one frame
-  assert.equal(isCompressible({ type: 'image/gif' } as Blob), false);
-  assert.equal(isCompressible({ type: 'image/apng' } as Blob), false);
   assert.equal(isCompressible({ type: '' } as Blob), false);
   assert.equal(isCompressible({ type: 'application/pdf' } as Blob), false);
   assert.equal(isCompressible({ type: 'text/plain' } as Blob), false);
   assert.equal(isCompressible({ type: 'video/mp4' } as Blob), false);
 });
-
-const webpHeader = (chunk: string, flags = 0) => {
-  const b = new Uint8Array(32);
-  const put = (at: number, str: string) => b.set(new TextEncoder().encode(str), at);
-  put(0, 'RIFF');
-  put(8, 'WEBP');
-  put(12, chunk);
-  b[20] = flags;
-  return b;
-};
-
-test('isAnimatedWebp: VP8X with the animation flag (#331)', () => {
-  assert.equal(isAnimatedWebp(webpHeader('VP8X', 0x02)), true);
-  assert.equal(isAnimatedWebp(webpHeader('VP8X', 0x10)), false, 'alpha flag only');
-  assert.equal(isAnimatedWebp(webpHeader('VP8 ')), false, 'simple lossy');
-  assert.equal(isAnimatedWebp(new Uint8Array(8)), false);
-});
-
-test('hasTransparency (#331)', () => {
-  assert.equal(hasTransparency(new Uint8ClampedArray([1, 2, 3, 255, 4, 5, 6, 255])), false);
-  assert.equal(hasTransparency(new Uint8ClampedArray([1, 2, 3, 255, 0, 0, 0, 0])), true);
-});

src/app/utils/imageCompression.ts

@@ -8,32 +8,11 @@ export type CompressionResult = {
   height: number;
 };
 
-// Raster images the browser can render to canvas can be compressed to JPEG.
+// Any raster image the browser can render to canvas can be compressed to JPEG.
-// SVG is vector and must stay as-is. [Gitea #331] GIF and APNG are usually
+// SVG is vector and must stay as-is; GIF animation is lost on canvas but static
-// animated, and a canvas keeps only the first frame, so they aren't offered.
+// frames compress fine. Empty type string (undetected MIME) is excluded.
-// Empty type string (undetected MIME) is excluded.
-const NOT_COMPRESSIBLE = new Set(['image/svg+xml', 'image/gif', 'image/apng']);
 const isCompressibleType = (type: string): boolean =>
-  type.startsWith('image/') && !NOT_COMPRESSIBLE.has(type);
+  type.startsWith('image/') && type !== 'image/svg+xml' && type !== '';
-
-/**
- * Pure: whether a WebP file is animated. An animated WebP is a VP8X file
- * whose header has the animation flag (byte 20, bit 0x02) and an ANIM chunk.
- */
-export function isAnimatedWebp(bytes: Uint8Array): boolean {
-  const ascii = (at: number, len: number) => String.fromCharCode(...bytes.subarray(at, at + len));
-  if (bytes.length < 21 || ascii(0, 4) !== 'RIFF' || ascii(8, 4) !== 'WEBP') return false;
-  // Bit 0x02 of the VP8X flags byte (no-bitwise: test it arithmetically).
-  return ascii(12, 4) === 'VP8X' && Math.floor(bytes[20] / 2) % 2 === 1;
-}
-
-/** Pure: whether RGBA pixel data has any pixel that isn't fully opaque. */
-export function hasTransparency(rgba: Uint8ClampedArray): boolean {
-  for (let i = 3; i < rgba.length; i += 4) {
-    if (rgba[i] !== 255) return true;
-  }
-  return false;
-}
 
 /** Returns true if this file can be compressed via canvas (any raster image type). */
 export function isCompressible(file: File | Blob): boolean {
@@ -49,8 +28,7 @@ const JPEG_OUTPUT_TYPE = 'image/jpeg';
  *
  * PNG is skipped entirely: it may carry an alpha channel, and re-encoding to
  * JPEG composites transparency onto an opaque (black) background, corrupting the
- * image. Any other image with transparent pixels, and animated WebP, are left
+ * image. Returning null makes callers fall back to uploading the lossless
- * alone for the same reason (#331). Returning null makes callers fall back to uploading the lossless
  * original. The image is decoded with `imageOrientation: 'from-image'` so any
  * EXIF orientation is baked into the pixels instead of being silently dropped.
  */
@@ -61,15 +39,6 @@ export async function compressImage(
   if (!isCompressibleType(file.type)) return null;
   // Skip PNG (potential alpha) — re-encoding to JPEG would flatten transparency.
   if (file.type === 'image/png') return null;
-  // [Gitea #331] An animated WebP would become a single still frame.
-  if (file.type === 'image/webp') {
-    try {
-      const head = new Uint8Array(await file.slice(0, 32).arrayBuffer());
-      if (isAnimatedWebp(head)) return null;
-    } catch {
-      return null;
-    }
-  }
 
   let bitmap: ImageBitmap;
   try {
@@ -91,13 +60,6 @@ export async function compressImage(
   }
   ctx.drawImage(bitmap, 0, 0);
   bitmap.close();
-  // [Gitea #331] JPEG has no alpha: a transparent WebP (sticker, logo) came out
-  // with a black background. Keep any image with transparency as the original.
-  try {
-    if (hasTransparency(ctx.getImageData(0, 0, width, height).data)) return null;
-  } catch {
-    return null;
-  }
 
   return new Promise((resolve) => {
     canvas.toBlob(