Files
Oliver c75403b3ed Session auth (#904)
* use session auth rather than token auth

* Add unit tests for login

* Ensure user cannot reuse login after logout

* handle logout mid session

* Additional unit tests

* ensure sensitive data is redacted from sentry

* Handle session disconnect

* Additional tweaks

* Update pubspec.lock

* Update release_notes.md

* Bump version number

* Adjust login button

* Clear stored session when host changes

* Improved redacting of sensitive info

* Improved handling of local session storage

* prevent failed migration from logging as complete

* Fix for error raised in overlapping requests

* replace userInfo on successful response

* handle empty response

* Improved session comparison

* Add UI testing
2026-11-02 19:15:27 +11:00

430 lines
12 KiB
Dart

/*
* A minimal in-process InvenTree server, for testing authentication
* without a running server.
*
* Implements just enough of the InvenTree API and the allauth "headless"
* (browser client) API to connect, login (optionally with MFA) and logout,
* including session and CSRF cookie handling.
*
* Individual endpoints can be overridden (once, or always) to simulate
* error conditions, and all received requests are recorded.
*/
import "dart:async";
import "dart:convert";
import "dart:io";
class FakeRequest {
FakeRequest({
required this.method,
required this.path,
required this.query,
required this.rawQuery,
required this.headers,
required this.cookies,
required this.body,
});
final String method;
final String path;
// Decoded query parameters, and the query string as received
final Map<String, String> query;
final String rawQuery;
// Header names are lower case
final Map<String, String> headers;
final Map<String, String> cookies;
final String body;
Map<String, dynamic> get json {
try {
return jsonDecode(body) as Map<String, dynamic>;
} catch (_) {
return {};
}
}
@override
String toString() => "${method} ${path}";
}
class FakeResponse {
FakeResponse(
this.status, {
this.body,
this.rawBody,
this.setCookies = const [],
this.dropConnection = false,
});
// Close the connection without sending a response
FakeResponse.drop() : this(0, dropConnection: true);
final int status;
final Object? body;
// Raw (non-JSON) response body, e.g. an HTML error page
final String? rawBody;
final List<String> setCookies;
final bool dropConnection;
}
typedef FakeHandler = FutureOr<FakeResponse> Function(FakeRequest request);
class FakeInvenTreeServer {
FakeInvenTreeServer._(this._server, this.apiVersion);
static Future<FakeInvenTreeServer> start({int apiVersion = 568}) async {
final server = await HttpServer.bind(InternetAddress.loopbackIPv4, 0);
final fake = FakeInvenTreeServer._(server, apiVersion);
server.listen(fake._handle);
return fake;
}
final HttpServer _server;
final int apiVersion;
String get url => "http://127.0.0.1:${_server.port}/";
// Accepted credentials (username -> password)
final Map<String, String> users = {"user": "password", "mfa": "password"};
// Users which require a TOTP code after their password
final Set<String> mfaUsers = {"mfa"};
// TOTP code accepted for MFA users
String validCode = "123456";
// Authenticator types offered in the pending MFA flow
List<String> mfaTypes = ["totp", "recovery_codes"];
// After a valid MFA code, ask whether to trust the device (mfa_trust flow)
bool offerTrust = false;
// Login methods reported by auth/v1/config
List<String> loginMethods = ["username"];
// Requests received, in order
final List<FakeRequest> requests = [];
// Active sessions (session ID -> username)
final Map<String, String> sessions = {};
// Partially authenticated sessions, waiting for an MFA code
final Map<String, String> _pending = {};
// Pending sessions which have entered a valid code, waiting for mfa_trust
final Set<String> _trustPending = {};
int _counter = 0;
final Map<String, List<FakeHandler>> _once = {};
final Map<String, FakeHandler> _always = {};
Future<void> close() => _server.close(force: true);
// Override the next request for [method] [path] (path relative to the server root)
void once(String method, String path, FakeHandler handler) {
_once.putIfAbsent("${method} /${path}", () => []).add(handler);
}
// Override all requests for [method] [path]
void always(String method, String path, FakeHandler handler) {
_always["${method} /${path}"] = handler;
}
// Requests received for [method] [path]
List<FakeRequest> received(String method, String path) => requests
.where((r) => r.method == method && r.path == "/${path}")
.toList();
// End all sessions (e.g. expired, or ended from another device)
void endAllSessions() {
sessions.clear();
_pending.clear();
}
String _newId(String prefix) {
_counter++;
return "${prefix}-${_server.port}-${_counter}";
}
Future<void> _handle(HttpRequest request) async {
final Map<String, String> headers = {};
request.headers.forEach((name, values) {
headers[name.toLowerCase()] = values.join(", ");
});
final Map<String, String> cookies = {};
for (final cookie in request.cookies) {
cookies[cookie.name] = cookie.value;
}
final fake = FakeRequest(
method: request.method,
path: request.uri.path,
query: request.uri.queryParameters,
rawQuery: request.uri.query,
headers: headers,
cookies: cookies,
body: await utf8.decoder.bind(request).join(),
);
requests.add(fake);
final String key = "${fake.method} ${fake.path}";
FakeResponse response;
if (_once[key]?.isNotEmpty ?? false) {
response = await _once[key]!.removeAt(0)(fake);
} else if (_always.containsKey(key)) {
response = await _always[key]!(fake);
} else {
response = _default(fake);
}
if (response.dropConnection) {
final socket = await request.response.detachSocket(writeHeaders: false);
socket.destroy();
return;
}
request.response.statusCode = response.status;
request.response.headers.contentType = response.rawBody == null
? ContentType.json
: ContentType.html;
for (final cookie in response.setCookies) {
request.response.headers.add(HttpHeaders.setCookieHeader, cookie);
}
if (response.rawBody != null) {
request.response.write(response.rawBody);
} else if (response.body != null) {
request.response.write(jsonEncode(response.body));
}
await request.response.close();
}
String? _user(FakeRequest request) =>
sessions[request.cookies["sessionid"] ?? ""];
// Django CSRF check for "unsafe" requests
bool _csrfValid(FakeRequest request) {
final String cookie = request.cookies["csrftoken"] ?? "";
return cookie.isNotEmpty &&
request.headers["x-csrftoken"] == cookie &&
request.headers["origin"] == Uri.parse(url).origin;
}
Map<String, dynamic> _authenticated(String username) => {
"status": 200,
"data": {
"user": {"username": username},
"methods": [],
},
"meta": {"is_authenticated": true},
};
Map<String, dynamic> _flows({
bool mfaPending = false,
bool trustPending = false,
}) => {
"status": 401,
"data": {
"flows": [
{"id": "login"},
if (mfaPending)
{"id": "mfa_authenticate", "is_pending": true, "types": mfaTypes},
if (trustPending) {"id": "mfa_trust", "is_pending": true},
],
},
"meta": {"is_authenticated": false},
};
// Start a new (authenticated) session, rotating the CSRF token as Django does
FakeResponse _login(String username) {
final String sessionId = _newId("session");
sessions[sessionId] = username;
return FakeResponse(
200,
body: _authenticated(username),
setCookies: [
"sessionid=${sessionId}; HttpOnly; Path=/; SameSite=Lax",
"csrftoken=${_newId("csrf")}; Path=/; SameSite=Lax",
],
);
}
FakeResponse _default(FakeRequest request) {
final bool unsafe = !["GET", "HEAD", "OPTIONS"].contains(request.method);
if (unsafe && !_csrfValid(request)) {
return FakeResponse(
403,
body: {"detail": "CSRF Failed: CSRF token missing."},
);
}
final String? user = _user(request);
switch ("${request.method} ${request.path}") {
case "GET /api/":
return FakeResponse(
200,
body: {
"server": "InvenTree",
"version": "1.0.0",
"instance": "Fake Server",
"apiVersion": apiVersion,
},
);
case "GET /api/auth/v1/config":
return FakeResponse(
200,
body: {
"status": 200,
"data": {
"account": {"login_methods": loginMethods},
"socialaccount": {"providers": []},
"mfa": {
"supported_types": ["totp", "recovery_codes"],
},
},
},
);
case "GET /api/auth/v1/auth/session":
if (user != null) {
return FakeResponse(200, body: _authenticated(user));
}
// Issue a CSRF token, if the client does not already have one
return FakeResponse(
401,
body: _flows(),
setCookies: request.cookies.containsKey("csrftoken")
? []
: ["csrftoken=${_newId("csrf")}; Path=/; SameSite=Lax"],
);
case "DELETE /api/auth/v1/auth/session":
sessions.remove(request.cookies["sessionid"]);
return FakeResponse(
401,
body: _flows(),
setCookies: [
"sessionid=; expires=Thu, 01 Jan 1970 00:00:00 GMT; Max-Age=0; Path=/",
],
);
case "POST /api/auth/v1/auth/login":
final Map<String, dynamic> data = request.json;
final String login = (data["username"] ?? data["email"] ?? "")
.toString();
if (!users.containsKey(login) || users[login] != data["password"]) {
return FakeResponse(
400,
body: {
"status": 400,
"errors": [
{
"message":
"The username and/or password you specified are not correct.",
"code": "username_password_mismatch",
"param": "password",
},
],
},
);
}
if (mfaUsers.contains(login)) {
final String pendingId = _newId("pending");
_pending[pendingId] = login;
return FakeResponse(
401,
body: _flows(mfaPending: true),
setCookies: ["sessionid=${pendingId}; HttpOnly; Path=/"],
);
}
return _login(login);
case "POST /api/auth/v1/auth/2fa/authenticate":
final String? pendingUser = _pending[request.cookies["sessionid"]];
if (pendingUser == null) {
return FakeResponse(409, body: {"status": 409});
}
if (request.json["code"] != validCode) {
return FakeResponse(
400,
body: {
"status": 400,
"errors": [
{"message": "Incorrect code.", "code": "incorrect_code"},
],
},
);
}
if (offerTrust) {
_trustPending.add(request.cookies["sessionid"]!);
return FakeResponse(401, body: _flows(trustPending: true));
}
_pending.remove(request.cookies["sessionid"]);
return _login(pendingUser);
case "POST /api/auth/v1/auth/2fa/trust":
final String sessionId = request.cookies["sessionid"] ?? "";
if (!_trustPending.remove(sessionId)) {
return FakeResponse(409, body: {"status": 409});
}
return _login(_pending.remove(sessionId)!);
case "GET /api/user/me/":
if (user == null) {
return _unauthenticated();
}
return FakeResponse(200, body: {"pk": 1, "username": user});
case "GET /api/user/me/roles/":
if (user == null) {
return _unauthenticated();
}
return FakeResponse(200, body: {"roles": {}, "permissions": {}});
case "GET /api/plugins/":
return FakeResponse(200, body: []);
}
if (user == null) {
return _unauthenticated();
}
// Any other (authenticated) request - echo back the request data
return FakeResponse(
request.method == "POST" ? 201 : 200,
body: {"method": request.method, "path": request.path},
);
}
FakeResponse _unauthenticated() => FakeResponse(
401,
body: {"detail": "Authentication credentials were not provided."},
);
}