diff --git a/app/lib/features/chat/files/files_thumbnail.dart b/app/lib/features/chat/files/files_thumbnail.dart index 7d2ddd49..e80f882d 100644 --- a/app/lib/features/chat/files/files_thumbnail.dart +++ b/app/lib/features/chat/files/files_thumbnail.dart @@ -1,7 +1,9 @@ import 'package:flutter/material.dart'; +import 'package:flutter/foundation.dart'; import '../data/directory_listing.dart'; import 'files_icons.dart'; +import 'files_thumbnail_image.dart'; import 'files_preview.dart'; import 'files_urls.dart'; @@ -34,7 +36,7 @@ class FileThumbnail extends StatefulWidget { class _FileThumbnailState extends State { ImageProvider? _provider; - String? _url; + ImageProvider? _source; int? _decode; // Keep the shared image cache unchanged. Scrolled-out thumbnails release @@ -56,15 +58,14 @@ class _FileThumbnailState extends State { final decode = filesThumbnailDecodeSize( MediaQuery.devicePixelRatioOf(context), ); - if (_url != urls.view.toString() || _decode != decode) { + final ImageProvider source = kIsWeb + ? NetworkImage(urls.view.toString()) + : FileThumbnailImage(urls.view); + if (_source != source || _decode != decode) { _provider?.evict(); - _url = urls.view.toString(); + _source = source; _decode = decode; - _provider = ResizeImage.resizeIfNeeded( - decode, - decode, - NetworkImage(_url!), - ); + _provider = ResizeImage.resizeIfNeeded(decode, decode, source); } final scheme = Theme.of(context).colorScheme; final placeholder = Container( @@ -86,6 +87,9 @@ class _FileThumbnailState extends State { fit: BoxFit.cover, semanticLabel: entry.name, + frameBuilder: kIsWeb + ? null + : (_, child, frame, _) => frame == null ? placeholder : child, loadingBuilder: (_, child, progress) => progress == null ? child : placeholder, errorBuilder: (_, _, _) => icon, diff --git a/app/lib/features/chat/files/files_thumbnail_image.dart b/app/lib/features/chat/files/files_thumbnail_image.dart new file mode 100644 index 00000000..613f0dde --- /dev/null +++ b/app/lib/features/chat/files/files_thumbnail_image.dart @@ -0,0 +1,79 @@ +import 'dart:ui' as ui; + +import 'package:flutter/foundation.dart'; +import 'package:flutter/painting.dart'; + +import '../../../core/session/server_session.dart'; +import '../../artifacts/ui/artifact_viewer_fetch.dart'; + +typedef ThumbnailHeaders = Map Function(Uri uri); + +/// Native thumbnail transport shares the viewer's scoped, no-redirect fetch. +/// Cache keys retain only the address and credential snapshot, never photo bytes. +class FileThumbnailImage extends ImageProvider { + FileThumbnailImage( + this.uri, { + this.fetch = fetchArtifact, + ThumbnailHeaders headers = ServerSession.headersFor, + }) : _headers = headers, + _credentials = Map.unmodifiable(headers(uri)); + + final Uri uri; + final ArtifactFetch fetch; + final ThumbnailHeaders _headers; + final Map _credentials; + + @override + Future obtainKey(ImageConfiguration configuration) => + SynchronousFuture(this); + + @override + ImageStreamCompleter loadImage( + FileThumbnailImage key, + ImageDecoderCallback decode, + ) => MultiFrameImageStreamCompleter( + codec: key._load(decode), + scale: 1, + debugLabel: 'Authenticated file thumbnail', + ); + + void _checkCredentials() { + if (!mapEquals(_credentials, _headers(uri))) { + throw StateError('The thumbnail sign-in changed. Reload the view.'); + } + } + + Future _load(ImageDecoderCallback decode) async { + _checkCredentials(); + final response = await fetch(uri); + _checkCredentials(); + if (!response.ok) { + throw NetworkImageLoadException(statusCode: response.status, uri: uri); + } + final buffer = await ui.ImmutableBuffer.fromUint8List(response.bytes); + return decode(buffer); + } + + @override + bool operator ==(Object other) => + other is FileThumbnailImage && + other.uri == uri && + other.fetch == fetch && + mapEquals(other._credentials, _credentials); + + @override + int get hashCode { + final names = _credentials.keys.toList()..sort(); + return Object.hash( + uri, + fetch, + Object.hashAll( + names.map((name) => Object.hash(name, _credentials[name])), + ), + ); + } + + // Widget/error diagnostics must never print credential values. + @override + String toString() => 'FileThumbnailImage'; +} diff --git a/app/test/features/chat/files/files_thumbnail_image_test.dart b/app/test/features/chat/files/files_thumbnail_image_test.dart new file mode 100644 index 00000000..a0a0bab5 --- /dev/null +++ b/app/test/features/chat/files/files_thumbnail_image_test.dart @@ -0,0 +1,182 @@ +import 'dart:async'; +import 'dart:io'; +import 'dart:typed_data'; +import 'dart:ui' as ui; + +import 'package:flutter/material.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/core/session/server_session.dart'; +import 'package:pipelines_app/features/artifacts/ui/artifact_viewer_fetch.dart'; +import 'package:pipelines_app/features/chat/data/directory_listing.dart'; +import 'package:pipelines_app/features/chat/files/files_thumbnail.dart'; +import 'package:pipelines_app/features/chat/files/files_thumbnail_image.dart'; +import 'package:shared_preferences/shared_preferences.dart'; + +Future imageFrom(ImageProvider provider) async { + final result = Completer(); + final stream = provider.resolve(ImageConfiguration.empty); + final listener = ImageStreamListener( + (info, _) => result.complete(info.image.clone()), + onError: (Object error, StackTrace? stack) => result.completeError(error), + ); + stream.addListener(listener); + try { + return await result.future; + } finally { + stream.removeListener(listener); + await provider.evict(); + } +} + +void main() { + TestWidgetsFlutterBinding.ensureInitialized(); + setUp(() => SharedPreferences.setMockInitialValues({})); + tearDown(() { + ServerSession.clearSelection(); + PaintingBinding.instance.imageCache.clear(); + PaintingBinding.instance.imageCache.clearLiveImages(); + }); + + test('cache identity follows credentials without exposing them', () { + final uri = Uri.parse('https://machine.test/files?path=image.png'); + var headers = {'Cookie': 'private-cookie-a'}; + Map reader(Uri _) => headers; + final first = FileThumbnailImage(uri, headers: reader); + expect(FileThumbnailImage(uri, headers: reader), first); + expect(first.toString(), isNot(contains('private-cookie-a'))); + headers = {'Cookie': 'private-cookie-b'}; + final changed = FileThumbnailImage(uri, headers: reader); + expect(changed, isNot(first)); + expect(changed.hashCode, isNot(first.hashCode)); + }); + + test( + 'native thumbnails authenticate their own origin and refuse redirects', + () async { + final previous = HttpOverrides.current; + HttpOverrides.global = null; + final trusted = await HttpServer.bind(InternetAddress.loopbackIPv4, 0); + final other = await HttpServer.bind(InternetAddress.loopbackIPv4, 0); + final uri = Uri.parse( + 'http://127.0.0.1:${trusted.port}/files?path=image.png', + ); + final observed = []; + var forwarded = 0; + trusted.listen((request) async { + observed.add(request.headers.value('cookie')); + request.response.statusCode = HttpStatus.found; + request.response.headers.set( + 'Location', + 'http://127.0.0.1:${other.port}/stolen', + ); + await request.response.close(); + }); + other.listen((request) async { + forwarded++; + await request.response.close(); + }); + try { + SharedPreferences.setMockInitialValues({ + 'pipelines.session.v2.peer.cookie': 'pipelines_session=peer-only', + }); + await ServerSession.activateServer(id: 'peer', endpoints: [uri]); + await expectLater( + imageFrom(FileThumbnailImage(uri)), + throwsA(isA()), + ); + expect(observed, ['pipelines_session=peer-only']); + expect(forwarded, 0); + } finally { + await trusted.close(force: true); + await other.close(force: true); + HttpOverrides.global = previous; + } + }, + ); + + test('a changed login cannot populate the old thumbnail cache key', () async { + var headers = {'Cookie': 'first'}; + final response = Completer(); + final requested = Completer(); + final provider = FileThumbnailImage( + Uri.parse('https://machine.test/files'), + headers: (_) => headers, + fetch: (_) { + requested.complete(); + return response.future; + }, + ); + final rejected = expectLater(imageFrom(provider), throwsStateError); + await requested.future; + headers = {'Cookie': 'second'}; + response.complete(ArtifactFetchResult(status: 200, bytes: Uint8List(0))); + await rejected; + final key = await provider.obtainKey(ImageConfiguration.empty); + expect(PaintingBinding.instance.imageCache.containsKey(key), false); + }); + + test( + 'large images decode at the existing cap and evict their cache entry', + () async { + final recorder = ui.PictureRecorder(); + Canvas(recorder).drawRect( + const Rect.fromLTWH(0, 0, 800, 800), + Paint()..color = Colors.blue, + ); + final picture = recorder.endRecording(); + final original = await picture.toImage(800, 800); + final bytes = (await original.toByteData( + format: ui.ImageByteFormat.png, + ))!.buffer.asUint8List(); + original.dispose(); + picture.dispose(); + final provider = ResizeImage( + FileThumbnailImage( + Uri.parse('https://machine.test/files'), + headers: (_) => const {}, + fetch: (_) async => ArtifactFetchResult(status: 200, bytes: bytes), + ), + width: filesThumbnailDecodeSize(10), + height: filesThumbnailDecodeSize(10), + ); + final decoded = await imageFrom(provider); + expect((decoded.width, decoded.height), (224, 224)); + decoded.dispose(); + final key = await provider.obtainKey(ImageConfiguration.empty); + expect(PaintingBinding.instance.imageCache.containsKey(key), false); + }, + ); + + testWidgets('same file gets a fresh provider after its login changes', ( + tester, + ) async { + await ServerSession.activateServer( + id: 'peer', + endpoints: [Uri.parse('ws://peer.test/connect')], + ); + ServerSession.cookie = 'pipelines_session=first'; + const entry = DirectoryEntry( + name: 'image.png', + path: '/image.png', + isDir: false, + isGitRepo: false, + hidden: false, + ); + Future pump() async { + await tester.pumpWidget( + MaterialApp( + home: FileThumbnail(entry: entry, endpoint: 'ws://peer.test/connect'), + ), + ); + await tester.pumpAndSettle(); + } + + await pump(); + final first = tester.widget(find.byType(Image)).image; + ServerSession.cookie = 'pipelines_session=second'; + await pump(); + final second = tester.widget(find.byType(Image)).image; + expect(second, isNot(first)); + expect(tester.takeException(), isNull); + }); +}