diff --git a/app/lib/core/session/server_session.dart b/app/lib/core/session/server_session.dart index 797c4250..800fff3d 100644 --- a/app/lib/core/session/server_session.dart +++ b/app/lib/core/session/server_session.dart @@ -15,6 +15,48 @@ class ServerSession { ServerSession._(); static const _key = 'pipelines.session.cookie'; + static String? _serverId; + static Set _origins = {}; + static int _generation = 0; + static final Map _versions = {}; + + static String? get serverId => _serverId; + + static String _scopeKey(String id) => + 'pipelines.session.v2.${Uri.encodeComponent(id)}.cookie'; + + /// Selects one logical server. Aliases explicitly trust the same credential. + /// Clears the previous cookie synchronously, before loading this profile. + static Future activateServer({ + required String id, + required Iterable endpoints, + bool migrateLegacy = false, + }) async { + final origins = endpoints.map(loginUriFor).toSet(); + if (id.isEmpty || origins.isEmpty || origins.contains(null)) { + throw ArgumentError('A server needs an id and valid trusted endpoints.'); + } + final generation = ++_generation; + _serverId = id; + _origins = origins.cast(); + cookie = null; + final key = _scopeKey(id); + final version = _versions[key]; + try { + final prefs = await SharedPreferences.getInstance(); + if (_versions[key] != version) return; + var value = prefs.getString(key); + if (value == null && migrateLegacy && prefs.containsKey(_key)) { + value = prefs.getString(_key) ?? ''; + await prefs.setString(key, value); + } + if (_generation == generation && _versions[key] == version) { + cookie = value == null || value.isEmpty ? null : value; + } + } catch (_) { + // The newly selected profile stays signed out if storage is unavailable. + } + } /// The `name=value` session cookie, or null when signed out. static String? cookie; @@ -25,23 +67,44 @@ class ServerSession { return value == null || value.isEmpty ? const {} : {'Cookie': value}; } - static Future load() async { - try { - final prefs = await SharedPreferences.getInstance(); - cookie = prefs.getString(_key); - } catch (_) { - cookie = null; + /// Credentials are only sent to the selected profile's exact HTTP origins. + /// Legacy callers bind their single origin by checking or signing in first. + static Map headersFor(Uri endpoint) { + final origin = loginUriFor(endpoint); + if (origin == null || !_origins.contains(origin)) { + return const {}; } + return headers; } - static Future _save(String? value) async { - cookie = value; + static Future load() async { + final generation = ++_generation; + _serverId = null; + _origins = {}; + cookie = null; try { final prefs = await SharedPreferences.getInstance(); - if (value == null) { + if (_generation == generation) cookie = prefs.getString(_key); + } catch (_) {} + } + + static Future _save( + String? value, + String key, + int generation, + int version, + ) async { + if (_versions[key] != version) return; + if (_generation == generation) cookie = value; + try { + final prefs = await SharedPreferences.getInstance(); + if (_versions[key] != version) return; + if (value == null && key == _key) { await prefs.remove(_key); } else { - await prefs.setString(_key, value); + // An empty scoped value records an intentional sign-out and prevents + // subsequent legacy migration from reviving the old credential. + await prefs.setString(key, value ?? ''); } } catch (_) {} } @@ -52,21 +115,37 @@ class ServerSession { static Future signIn(Uri endpoint, String password) async { final login = loginUriFor(endpoint); if (login == null) return 'The server address has no web login.'; + if (_serverId != null && !_origins.contains(login)) { + return 'The server address is not a trusted alias of the selected server.'; + } + final generation = _generation; + final key = _serverId == null ? _key : _scopeKey(_serverId!); + final version = (_versions[key] ?? 0) + 1; + _versions[key] = version; final result = await impl.postLogin(login, password); if (result.cookie != null) { - await _save(result.cookie); + if (_serverId == null && _generation == generation) _origins = {login}; + await _save(result.cookie, key, generation, version); return null; } return result.error ?? 'Sign-in failed.'; } - static Future signOut() => _save(null); + static Future signOut() { + final key = _serverId == null ? _key : _scopeKey(_serverId!); + final version = (_versions[key] ?? 0) + 1; + _versions[key] = version; + return _save(null, key, _generation, version); + } /// Whether [endpoint]'s server accepts the kept session. static Future check(Uri endpoint) async { final login = loginUriFor(endpoint); if (login == null) return SessionState.unreachable; - final status = await impl.probeLogin(login, headers); + // A pre-profile client supplies its sole server through this API. Bind + // once, not on every probe, so probing another host cannot leak its cookie. + if (_serverId == null && _origins.isEmpty) _origins = {login}; + final status = await impl.probeLogin(login, headersFor(login)); if (status == null) return SessionState.unreachable; // The web login sends a signed-in visitor on; it shows its form otherwise. if (status >= 300 && status < 400) return SessionState.signedIn; @@ -85,7 +164,9 @@ Uri? loginUriFor(Uri endpoint) { 'ws' || 'http' => 'http', _ => null, }; - if (scheme == null || endpoint.host.isEmpty) return null; + if (scheme == null || endpoint.host.isEmpty || endpoint.userInfo.isNotEmpty) { + return null; + } return Uri( scheme: scheme, host: endpoint.host, diff --git a/app/lib/core/transport/channel_connect_io.dart b/app/lib/core/transport/channel_connect_io.dart index 1b79274b..5097e517 100644 --- a/app/lib/core/transport/channel_connect_io.dart +++ b/app/lib/core/transport/channel_connect_io.dart @@ -1,8 +1,37 @@ +import 'dart:io'; + import 'package:web_socket_channel/io.dart'; import 'package:web_socket_channel/web_socket_channel.dart'; import '../session/server_session.dart'; /// A native socket sends the kept session cookie with the upgrade. -WebSocketChannel connect(Uri uri) => - IOWebSocketChannel.connect(uri, headers: ServerSession.headers); +WebSocketChannel connect(Uri uri) { + final client = _HandshakeClient(); + final socket = WebSocket.connect( + uri.toString(), + headers: ServerSession.headersFor(uri), + customClient: client, + ).whenComplete(client.close); + return IOWebSocketChannel(socket); +} + +/// WebSocket.connect only uses openUrl on its custom client. Suppress automatic +/// redirects: the SDK's default redirect policy can forward cookies to another +/// port or a subdomain, neither of which is necessarily a trusted alias. +class _HandshakeClient implements HttpClient { + final _client = HttpClient(); + + @override + Future openUrl(String method, Uri url) async { + final request = await _client.openUrl(method, url); + request.followRedirects = false; + return request; + } + + @override + void close({bool force = false}) => _client.close(force: force); + + @override + dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation); +} diff --git a/app/lib/features/artifacts/ui/artifact_viewer_fetch_stub.dart b/app/lib/features/artifacts/ui/artifact_viewer_fetch_stub.dart index 524d72f8..bc884c2a 100644 --- a/app/lib/features/artifacts/ui/artifact_viewer_fetch_stub.dart +++ b/app/lib/features/artifacts/ui/artifact_viewer_fetch_stub.dart @@ -14,7 +14,7 @@ Future fetchArtifact(Uri uri) async { final request = await client.getUrl(uri); request.followRedirects = false; // A phone behind the web login carries its kept session. - ServerSession.headers.forEach(request.headers.set); + ServerSession.headersFor(uri).forEach(request.headers.set); final response = await request.close(); final bytes = BytesBuilder(copy: false); await for (final chunk in response) { diff --git a/app/lib/features/chat/data/upload/chat_upload_io.dart b/app/lib/features/chat/data/upload/chat_upload_io.dart index 56068d87..7eae6a49 100644 --- a/app/lib/features/chat/data/upload/chat_upload_io.dart +++ b/app/lib/features/chat/data/upload/chat_upload_io.dart @@ -16,7 +16,7 @@ Future postChatUpload( final request = await client.postUrl(uri); request.followRedirects = false; // A phone behind the web login carries its kept session. - ServerSession.headers.forEach(request.headers.set); + ServerSession.headersFor(uri).forEach(request.headers.set); request.headers ..set(chatUploadNameHeader, Uri.encodeComponent(name)) ..set(HttpHeaders.contentTypeHeader, mime) diff --git a/app/lib/features/updates/app_updates_io.dart b/app/lib/features/updates/app_updates_io.dart index c956eb17..82831138 100644 --- a/app/lib/features/updates/app_updates_io.dart +++ b/app/lib/features/updates/app_updates_io.dart @@ -16,8 +16,9 @@ Future installedVersionCode() async { Future _get(HttpClient client, Uri uri) async { final request = await client.getUrl(uri); + request.followRedirects = false; // The updates sit behind the same web login the app signed in to. - ServerSession.headers.forEach(request.headers.set); + ServerSession.headersFor(uri).forEach(request.headers.set); final response = await request.close(); if (response.statusCode == 401 || response.statusCode == 302) { await response.drain(); diff --git a/app/notes/server-credential-scopes.md b/app/notes/server-credential-scopes.md new file mode 100644 index 00000000..0ec95cd5 --- /dev/null +++ b/app/notes/server-credential-scopes.md @@ -0,0 +1,10 @@ +# Logical-server credential scopes + +- Call `await ServerSession.activateServer(id: ..., endpoints: ..., migrateLegacy: false)` before connecting a selected profile. `serverId` reports its id. Aliases explicitly share that profile's cookie; the id, not the hostname, owns persistence. +- `headersFor(Uri)` allows only exact HTTP-normalized scheme/host/port aliases, rejects userinfo and unsupported schemes, and returns no cookie for other origins. WebSocket, artifact, upload and update IO consumers use it. WebSocket and update redirects are disabled to prevent redirect-based cookie forwarding. +- Scoped preference keys are `pipelines.session.v2.${Uri.encodeComponent(id)}.cookie`. Empty values persist sign-out, preventing legacy re-import. Migration is opt-in and only imports when no scoped value exists; migration and scoped sign-out leave the legacy key untouched. +- `load()` resets the selected profile and trust configuration. Legacy `.cookie` and `.headers` remain available; pre-profile requests bind their one trusted origin through `check` or successful `signIn`. +- Activation clears the active cookie before awaiting storage. Generation guards prevent stale activation/login responses from publishing across profile switches. Late login persists only its initiating profile; signing out cancels pending login writes for that profile. +- Focused coverage includes aliases, origin rejection, shared-host profile isolation, signed-out profiles, explicit one-time migration, concurrent activation, late login, sign-out races, actual native request headers, and update/WebSocket redirect rejection. Fixtures use loopback HTTP/WebSocket listeners only; no production or device mutations. + +Checks: `flutter test --no-pub test/core/session test/core/transport test/features/updates/app_updates_test.dart` passed (30 tests); `flutter analyze --no-pub` reported no issues; `git diff --check` passed. Device behavior and deployment were not tested. diff --git a/app/test/core/session/server_session_profiles_test.dart b/app/test/core/session/server_session_profiles_test.dart new file mode 100644 index 00000000..4af41534 --- /dev/null +++ b/app/test/core/session/server_session_profiles_test.dart @@ -0,0 +1,218 @@ +import 'dart:async'; +import 'dart:io'; + +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/core/session/server_session.dart'; +import 'package:shared_preferences/shared_preferences.dart'; + +const legacyKey = 'pipelines.session.cookie'; +String profileKey(String id) => + 'pipelines.session.v2.${Uri.encodeComponent(id)}.cookie'; + +void main() { + final primary = Uri.parse('wss://primary.example/connect'); + final backup = Uri.parse('ws://backup.example:8081/connect'); + + setUp(() async { + SharedPreferences.setMockInitialValues({}); + await ServerSession.load(); + }); + + Future activate(String id, {bool migrateLegacy = false}) => + ServerSession.activateServer( + id: id, + endpoints: [primary, backup], + migrateLegacy: migrateLegacy, + ); + + test( + 'only exact trusted HTTP-normalized alias origins receive cookies', + () async { + SharedPreferences.setMockInitialValues({profileKey('a'): 'session=a'}); + await activate('a'); + for (final endpoint in [ + primary, + backup, + Uri.parse('https://PRIMARY.example:443/files/data'), + Uri.parse('http://backup.example:8081/upload'), + ]) { + expect(ServerSession.headersFor(endpoint), {'Cookie': 'session=a'}); + } + for (final endpoint in [ + Uri.parse('https://external.example/files'), + Uri.parse('https://child.primary.example/files'), + Uri.parse('https://primary.example:8443/files'), + Uri.parse('http://primary.example/files'), + Uri.parse('https://user:password@primary.example/files'), + Uri.parse('ftp://primary.example/files'), + Uri.parse('/files'), + ]) { + expect( + ServerSession.headersFor(endpoint), + isEmpty, + reason: '$endpoint', + ); + } + }, + ); + + test( + 'profiles sharing aliases still have isolated persisted sessions', + () async { + SharedPreferences.setMockInitialValues({ + profileKey('a'): 'session=a', + profileKey('b'): 'session=b', + }); + await activate('a'); + expect(ServerSession.serverId, 'a'); + final switching = activate('b'); + expect(ServerSession.cookie, isNull); + await switching; + expect(ServerSession.headersFor(primary), {'Cookie': 'session=b'}); + await activate('new'); + expect(ServerSession.cookie, isNull); + expect(ServerSession.headersFor(primary), isEmpty); + await activate('a'); + expect(ServerSession.cookie, 'session=a'); + }, + ); + + test( + 'sign out changes only the selected profile and preserves legacy', + () async { + SharedPreferences.setMockInitialValues({ + legacyKey: 'session=legacy', + profileKey('a'): 'session=a', + profileKey('b'): 'session=b', + }); + await activate('a'); + await ServerSession.signOut(); + expect(ServerSession.headersFor(primary), isEmpty); + await activate('b'); + expect(ServerSession.cookie, 'session=b'); + await activate('a', migrateLegacy: true); + expect(ServerSession.cookie, isNull); + final prefs = await SharedPreferences.getInstance(); + expect(prefs.getString(legacyKey), 'session=legacy'); + await ServerSession.load(); + expect(ServerSession.serverId, isNull); + expect(ServerSession.cookie, 'session=legacy'); + }, + ); + + test( + 'legacy migration is explicit and never replaces a saved value', + () async { + SharedPreferences.setMockInitialValues({legacyKey: 'session=legacy'}); + await activate('unrelated'); + expect(ServerSession.cookie, isNull); + await activate('legacy-server', migrateLegacy: true); + expect(ServerSession.cookie, 'session=legacy'); + final prefs = await SharedPreferences.getInstance(); + await prefs.setString(legacyKey, 'session=changed'); + await activate('legacy-server', migrateLegacy: true); + expect(ServerSession.cookie, 'session=legacy'); + expect(prefs.getString(legacyKey), 'session=changed'); + }, + ); + + test( + 'concurrent activation only publishes the most recent selection', + () async { + SharedPreferences.setMockInitialValues({ + profileKey('a'): 'session=a', + profileKey('b'): 'session=b', + }); + await Future.wait([activate('a'), activate('b')]); + expect(ServerSession.serverId, 'b'); + expect(ServerSession.cookie, 'session=b'); + }, + ); + + test( + 'invalid aliases are rejected without changing the current scope', + () async { + await activate('a'); + for (final endpoints in >[ + [], + [Uri.parse('file:///tmp/test')], + [Uri.parse('https://user@primary.example')], + ]) { + await expectLater( + ServerSession.activateServer(id: 'bad', endpoints: endpoints), + throwsArgumentError, + ); + expect(ServerSession.serverId, 'a'); + } + }, + ); + + test( + 'sign-in rejects addresses outside the selected trusted group', + () async { + await activate('a'); + expect( + await ServerSession.signIn( + Uri.parse('https://other.example'), + 'unused', + ), + contains('not a trusted alias'), + ); + expect(ServerSession.cookie, isNull); + }, + ); + + test('late A login saves A without changing the active B session', () async { + final server = await HttpServer.bind(InternetAddress.loopbackIPv4, 0); + addTearDown(() => server.close(force: true)); + final endpoint = Uri.parse('http://127.0.0.1:${server.port}/connect'); + final received = Completer(); + final release = Completer(); + final handled = Completer(); + server.listen((request) async { + await request.drain(); + received.complete(); + await release.future; + request.response.cookies.add(Cookie('pipelines_session', 'late-a')); + request.response.statusCode = HttpStatus.found; + await request.response.close(); + handled.complete(); + }); + SharedPreferences.setMockInitialValues({profileKey('b'): 'session=b'}); + await ServerSession.activateServer(id: 'a', endpoints: [endpoint]); + final signingIn = ServerSession.signIn(endpoint, 'fixture-password'); + await received.future; + await activate('b'); + release.complete(); + expect(await signingIn, isNull); + await handled.future; + expect(ServerSession.serverId, 'b'); + expect(ServerSession.cookie, 'session=b'); + await ServerSession.activateServer(id: 'a', endpoints: [endpoint]); + expect(ServerSession.cookie, 'pipelines_session=late-a'); + }); + + test('sign out cancels a pending login for the same profile', () async { + final server = await HttpServer.bind(InternetAddress.loopbackIPv4, 0); + addTearDown(() => server.close(force: true)); + final endpoint = Uri.parse('http://127.0.0.1:${server.port}/connect'); + final received = Completer(); + final release = Completer(); + server.listen((request) async { + await request.drain(); + received.complete(); + await release.future; + request.response.cookies.add(Cookie('pipelines_session', 'too-late')); + await request.response.close(); + }); + await ServerSession.activateServer(id: 'a', endpoints: [endpoint]); + final signingIn = ServerSession.signIn(endpoint, 'fixture-password'); + await received.future; + await ServerSession.signOut(); + release.complete(); + await signingIn; + expect(ServerSession.cookie, isNull); + await ServerSession.activateServer(id: 'a', endpoints: [endpoint]); + expect(ServerSession.cookie, isNull); + }); +} diff --git a/app/test/core/session/server_session_requests_test.dart b/app/test/core/session/server_session_requests_test.dart new file mode 100644 index 00000000..f25255f0 --- /dev/null +++ b/app/test/core/session/server_session_requests_test.dart @@ -0,0 +1,138 @@ +import 'dart:io'; +import 'dart:typed_data'; + +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/core/session/server_session.dart'; +import 'package:pipelines_app/core/transport/channel_connect_io.dart' as socket; +import 'package:pipelines_app/features/artifacts/ui/artifact_viewer_fetch_stub.dart' + as artifacts; +import 'package:pipelines_app/features/chat/data/upload/chat_upload_io.dart' + as upload; +import 'package:pipelines_app/features/updates/app_updates_io.dart' as updates; +import 'package:shared_preferences/shared_preferences.dart'; + +void main() { + late HttpServer trusted; + late HttpServer external; + late Uri trustedUri; + late Uri externalUri; + late Map> cookies; + + setUp(() async { + cookies = {}; + trusted = await HttpServer.bind(InternetAddress.loopbackIPv4, 0); + external = await HttpServer.bind(InternetAddress.loopbackIPv4, 0); + trustedUri = Uri.parse('http://127.0.0.1:${trusted.port}/'); + externalUri = Uri.parse('http://127.0.0.1:${external.port}/'); + for (final server in [trusted, external]) { + server.listen((request) async { + final name = '${server.port}${request.uri.path}'; + cookies + .putIfAbsent(name, () => []) + .add(request.headers.value(HttpHeaders.cookieHeader)); + if (request.uri.path == '/socket') { + final channel = await WebSocketTransformer.upgrade(request); + await channel.close(); + return; + } + await request.drain(); + if (request.uri.path == '/redirect/version.json' || + request.uri.path == '/redirect/socket') { + request.response.statusCode = HttpStatus.temporaryRedirect; + request.response.headers.set( + HttpHeaders.locationHeader, + externalUri.resolve(request.uri.path.split('/').last).toString(), + ); + } else if (request.uri.path == '/login') { + request.response.statusCode = HttpStatus.found; + } else { + request.response.write('{"versionCode":1,"apk":"app.apk"}'); + } + await request.response.close(); + }); + } + SharedPreferences.setMockInitialValues({ + 'pipelines.session.v2.fixture.cookie': 'pipelines_session=fixture', + 'pipelines.session.cookie': 'pipelines_session=legacy', + }); + await ServerSession.load(); + await ServerSession.activateServer(id: 'fixture', endpoints: [trustedUri]); + }); + + tearDown(() async { + await trusted.close(force: true); + await external.close(force: true); + }); + + test('native requests authenticate only the selected exact origin', () async { + for (final uri in [trustedUri, externalUri]) { + await ServerSession.check(uri); + await artifacts.fetchArtifact(uri.resolve('artifact')); + await upload.postChatUpload( + uri.resolve('upload'), + name: 'fixture.txt', + mime: 'text/plain', + bytes: Uint8List.fromList([1, 2]), + ); + await updates.fetchLatest(uri); + final channel = socket.connect( + uri.resolve('socket').replace(scheme: 'ws'), + ); + await channel.ready; + await channel.stream.drain(); + await channel.sink.close(); + for (final path in [ + '/login', + '/artifact', + '/upload', + '/version.json', + '/socket', + ]) { + expect(cookies['${uri.port}$path'], [ + uri == trustedUri ? 'pipelines_session=fixture' : null, + ], reason: '$uri $path'); + } + } + }); + + test('updates do not follow redirects with a credential attached', () async { + await expectLater( + updates.fetchLatest(trustedUri.resolve('redirect/')), + throwsA(isA()), + ); + expect(cookies['${trusted.port}/redirect/version.json'], [ + 'pipelines_session=fixture', + ]); + expect(cookies['${external.port}/version.json'], isNull); + }); + + test( + 'websocket handshakes do not follow credential-bearing redirects', + () async { + final channel = socket.connect( + trustedUri.resolve('redirect/socket').replace(scheme: 'ws'), + ); + // Both the channel stream and ready report a failed handshake. + final streamDone = expectLater(channel.stream, emitsError(anything)); + await expectLater(channel.ready, throwsA(anything)); + await streamDone; + expect(cookies['${trusted.port}/redirect/socket'], [ + 'pipelines_session=fixture', + ]); + expect(cookies['${external.port}/socket'], isNull); + }, + ); + + test( + 'load unbinds origins; legacy checking binds just its one server', + () async { + await ServerSession.load(); + expect(ServerSession.serverId, isNull); + expect(ServerSession.headersFor(trustedUri), isEmpty); + await ServerSession.check(trustedUri); + await ServerSession.check(externalUri); + expect(cookies['${trusted.port}/login'], ['pipelines_session=legacy']); + expect(cookies['${external.port}/login'], [null]); + }, + ); +}