From f415e0f6d2d541d96643952352d235abb81f217e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jonas=20Bj=C3=B6rkert?= Date: Fri, 20 Nov 2026 21:30:40 +0100 Subject: [PATCH] Pause Dexcom Share logins for 15 minutes after Share rejects the account or password, so a wrong password cannot lock the account --- RemoteShared/ShareClientExtension.swift | 44 ++++++++++++++++++++++++- Tests/ShareLoginBackoffTests.swift | 33 +++++++++++++++++++ 2 files changed, 76 insertions(+), 1 deletion(-) create mode 100644 Tests/ShareLoginBackoffTests.swift diff --git a/RemoteShared/ShareClientExtension.swift b/RemoteShared/ShareClientExtension.swift index c8b492b78..742e8d953 100644 --- a/RemoteShared/ShareClientExtension.swift +++ b/RemoteShared/ShareClientExtension.swift @@ -58,9 +58,51 @@ private var TrendTable: [String] = [ "RATE OUT OF RANGE", // 9 ] +/// Share locks an account after repeated bad logins, so a login it rejects for the account or +/// password blocks further logins with the same credentials for `interval`. Other failures are +/// tried again at the next fetch. +enum ShareLoginBackoff { + static let interval: TimeInterval = 15 * 60 + + private static let lock = NSLock() + private static var blocks: [String: (until: Date, code: String)] = [:] + + private static func key(_ username: String, _ password: String) -> String { + "\(username)\n\(password)" + } + + /// The rejection code while logins with these credentials are blocked, else nil. + static func blockedCode(username: String, password: String, now: Date = Date()) -> String? { + lock.lock() + defer { lock.unlock() } + guard let block = blocks[key(username, password)], now < block.until else { return nil } + return block.code + } + + static func block(username: String, password: String, code: String, now: Date = Date()) { + lock.lock() + defer { lock.unlock() } + blocks[key(username, password)] = (now.addingTimeInterval(interval), code) + } + + /// Share's codes for an unknown account, a wrong password or too many attempts. + static func rejectsCredentials(_ code: String) -> Bool { + [ + "AccountPasswordInvalid", "AccountNotFound", "SSO_AuthenticatePasswordInvalid", + "SSO_AuthenticateAccountNotFound", "SSO_AuthenticateMaxAttemptsExceeed", "SSO_AuthenticateMaxAttemptsExceeded", + ].contains(code) + } +} + public extension ShareClient { func fetchData(_ entries: Int, callback: @escaping (ShareError?, [ShareGlucoseData]?) -> Void) { - fetchLast(entries) { error, result in + if let code = ShareLoginBackoff.blockedCode(username: username, password: password) { + return callback(.loginError(errorCode: code), nil) + } + fetchLast(entries) { [username, password] error, result in + if case let .loginError(code)? = error, ShareLoginBackoff.rejectsCredentials(code) { + ShareLoginBackoff.block(username: username, password: password, code: code) + } guard error == nil, let result = result else { return callback(error ?? .fetchError, nil) } diff --git a/Tests/ShareLoginBackoffTests.swift b/Tests/ShareLoginBackoffTests.swift new file mode 100644 index 000000000..3770c66ac --- /dev/null +++ b/Tests/ShareLoginBackoffTests.swift @@ -0,0 +1,33 @@ +// LoopFollow +// ShareLoginBackoffTests.swift + +import Foundation +@testable import LoopFollow +import Testing + +struct ShareLoginBackoffTests { + private let start = Date(timeIntervalSince1970: 1_000_000) + + @Test("a rejected login blocks the same credentials for fifteen minutes") + func blocksSameCredentials() { + ShareLoginBackoff.block(username: "user-a", password: "wrong", code: "AccountPasswordInvalid", now: start) + #expect(ShareLoginBackoff.blockedCode(username: "user-a", password: "wrong", now: start.addingTimeInterval(899)) == "AccountPasswordInvalid") + #expect(ShareLoginBackoff.blockedCode(username: "user-a", password: "wrong", now: start.addingTimeInterval(900)) == nil) + } + + @Test("other credentials are not blocked") + func otherCredentials() { + ShareLoginBackoff.block(username: "user-b", password: "wrong", code: "AccountPasswordInvalid", now: start) + #expect(ShareLoginBackoff.blockedCode(username: "user-b", password: "corrected", now: start.addingTimeInterval(1)) == nil) + #expect(ShareLoginBackoff.blockedCode(username: "user-c", password: "wrong", now: start.addingTimeInterval(1)) == nil) + } + + @Test("only account and password rejections block") + func onlyRejections() { + #expect(ShareLoginBackoff.rejectsCredentials("SSO_AuthenticatePasswordInvalid")) + #expect(ShareLoginBackoff.rejectsCredentials("SSO_AuthenticateMaxAttemptsExceeed")) + #expect(ShareLoginBackoff.rejectsCredentials("AccountNotFound")) + #expect(!ShareLoginBackoff.rejectsCredentials("SSO_InternalError")) + #expect(!ShareLoginBackoff.rejectsCredentials("unknown")) + } +}