Uninstall Mac apps with every file they leave behind, and see why each belongs. Free up space, fine-tune macOS, and set up Terminal.
Swift cache-cleanercleanerclideveloper-toolsdisk-cleanupdisk-spaceduplicate-finderhomebrewliquid-glassmac-cleanermacosmacos-appmacos-golden-gatemacos-tahoemacos-tweaksswiftswiftuiterminal-themesuninstalluninstaller
The helper's checks on each request are tested
Țugui Dragoș3962e682f9e1
diff --git a/Packages/PeelCore/Sources/PeelPrivileged/HelperRequest.swift b/Packages/PeelCore/Sources/PeelPrivileged/HelperRequest.swiftnew file mode 100644index 00000000..d58377a3--- /dev/null+++ b/Packages/PeelCore/Sources/PeelPrivileged/HelperRequest.swift@@ -0,0 +1,39 @@+public import Darwin++/// The checks every request to the helper passes before any work, in the order they are made: what costs nothing+/// comes first, and the account behind the connection is asked last, once the request is known to be sound.+public enum HelperRequest {+ /// Limits on one request, so a client cannot hand the helper an unbounded amount of work. `PATH_MAX`+ /// counts the terminating NUL, so the longest real path is 1,023 bytes.+ public static let maximumItems = 10_000+ public static let maximumPathLength = 1_023++ public struct Caller: Sendable {+ public let user: uid_t+ public let homeDirectory: String++ public init(user: uid_t, homeDirectory: String) {+ self.user = user+ self.homeDirectory = homeDirectory+ }+ }++ public static func admit(+ version: Int,+ items: Int = 0,+ paths: [String] = [],+ caller: () -> Caller?+ ) -> Result<Caller, HelperRefusal> {+ guard version == HelperIdentity.protocolVersion else { return .failure(.outOfDate) }+ guard items <= maximumItems else { return .failure(.tooManyItems) }+ guard !paths.contains(where: isTooLong) else { return .failure(.pathTooLong) }+ guard let caller = caller() else { return .failure(.notAllowed) }+ return .success(caller)+ }++ public static func isTooLong(_ path: String) -> Bool {+ path.utf8.count > maximumPathLength+ }+}++extension HelperRefusal: Error {}diff --git a/Packages/PeelCore/Tests/PeelCoreTests/HelperRequestTests.swift b/Packages/PeelCore/Tests/PeelCoreTests/HelperRequestTests.swiftnew file mode 100644index 00000000..b4bf1748--- /dev/null+++ b/Packages/PeelCore/Tests/PeelCoreTests/HelperRequestTests.swift@@ -0,0 +1,57 @@+import Foundation+import PeelPrivileged+import Testing++struct HelperRequestTests {+ private let someone = HelperRequest.Caller(user: 501, homeDirectory: "/Users/someone")++ private func admit(+ version: Int = HelperIdentity.protocolVersion,+ items: Int = 0,+ paths: [String] = [],+ asked: inout Int+ ) -> Result<HelperRequest.Caller, HelperRefusal> {+ HelperRequest.admit(version: version, items: items, paths: paths) {+ asked += 1+ return someone+ }+ }++ @Test func refusesAnotherVersionBeforeAskingWhoIsCalling() {+ var asked = 0+ #expect(throws: HelperRefusal.outOfDate) {+ try admit(version: HelperIdentity.protocolVersion - 1, asked: &asked).get()+ }+ #expect(asked == 0)+ }++ @Test func refusesTooManyItemsBeforeAskingWhoIsCalling() {+ var asked = 0+ #expect(throws: HelperRefusal.tooManyItems) {+ try admit(items: HelperRequest.maximumItems + 1, asked: &asked).get()+ }+ #expect(asked == 0)+ #expect((try? admit(items: HelperRequest.maximumItems, asked: &asked).get()) != nil)+ }++ @Test func refusesAPathLongerThanAnyRealOneBeforeAskingWhoIsCalling() {+ var asked = 0+ let longest = "/" + String(repeating: "a", count: HelperRequest.maximumPathLength - 1)+ #expect(throws: HelperRefusal.pathTooLong) { try admit(paths: ["/tmp", longest + "a"], asked: &asked).get() }+ #expect(asked == 0)+ #expect((try? admit(paths: [longest], asked: &asked).get()) != nil)+ }++ @Test func refusesAnAccountThatIsNotAllowed() {+ #expect(throws: HelperRefusal.notAllowed) {+ try HelperRequest.admit(version: HelperIdentity.protocolVersion) { nil }.get()+ }+ }++ @Test func answersWithTheCallerOfASoundRequest() throws {+ var asked = 0+ let caller = try admit(items: 3, paths: ["/Library/Caches/org.example.app"], asked: &asked).get()+ #expect(caller.user == 501)+ #expect(asked == 1)+ }+}diff --git a/PeelHelper/HelperService.swift b/PeelHelper/HelperService.swiftindex 831a9d8b..08ed4021 100644--- a/PeelHelper/HelperService.swift+++ b/PeelHelper/HelperService.swift@@ -10,27 +10,17 @@ final class HelperService: NSObject, PeelHelperProtocol {self.lifetime = lifetime}- /// Limits on one request, so a client cannot hand the helper an unbounded amount of work. `PATH_MAX`- /// counts the terminating NUL, so the longest real path is 1,023 bytes.- private static let maximumItems = 10_000- private static let maximumPathLength = 1_023-- private struct Caller {- let user: uid_t- let homeDirectory: String- }-/// The account behind the connection the message came on, and its home folder. Nil when that account is not/// an administrator or its home folder cannot be found. It is asked for each message, so an account that stops/// being an administrator is refused from its next request. It says whose connection it is, not which process/// sent the message: `xpc_connection_create(3)` warns that a client can hand its connection to another process.- private static func caller() -> Caller? {+ private static func caller() -> HelperRequest.Caller? {guardlet user = NSXPCConnection.current()?.effectiveUserIdentifier,UserAuthorization.isAdministrator(user),let home = UserAuthorization.homeDirectory(of: user)else { return nil }- return Caller(user: user, homeDirectory: home)+ return HelperRequest.Caller(user: user, homeDirectory: home)}private func tracked(_ finish: @escaping @Sendable (String?) -> Void) -> @Sendable (String?) -> Void {@@ -40,10 +30,6 @@ final class HelperService: NSObject, PeelHelperProtocol {}}- private static func speaksThisVersion(_ version: Int) -> Bool {- version == HelperIdentity.protocolVersion- }-func protocolVersion(withReply reply: @escaping @Sendable (Int) -> Void) {reply(HelperIdentity.protocolVersion)}@@ -55,11 +41,14 @@ final class HelperService: NSObject, PeelHelperProtocol {lifetime.requestFinished()}func refuse(_ reason: String) {- reply([:], Dictionary(paths.prefix(Self.maximumItems).map { ($0, reason) }) { first, _ in first })+ reply([:], Dictionary(paths.prefix(HelperRequest.maximumItems).map { ($0, reason) }) { first, _ in first })+ }+ let caller: HelperRequest.Caller+ do {+ caller = try HelperRequest.admit(version: version, items: paths.count, caller: Self.caller).get()+ } catch {+ return refuse(error.rawValue)}- guard Self.speaksThisVersion(version) else { return refuse(HelperRefusal.outOfDate.rawValue) }- guard paths.count <= Self.maximumItems else { return refuse(HelperRefusal.tooManyItems.rawValue) }- guard let caller = Self.caller() else { return refuse(HelperRefusal.notAllowed.rawValue) }let policy = PrivilegedPathPolicy(homeDirectory: caller.homeDirectory)guard let trash = policy.openTrash(ownedBy: caller.user) else { return refuse(HelperRefusal.noTrash.rawValue) }@@ -67,7 +56,7 @@ final class HelperService: NSObject, PeelHelperProtocol {var failed: [String: String] = [:]var items: [(path: String, item: OpenItem)] = []for path in paths {- guard path.utf8.count <= Self.maximumPathLength else {+ guard !HelperRequest.isTooLong(path) else {failed[path] = HelperRefusal.pathTooLong.rawValuecontinue}@@ -87,11 +76,13 @@ final class HelperService: NSObject, PeelHelperProtocol {func restoreItem(version: Int, fromTrashPath trashPath: String, toPath destination: String, withReply finish: @escaping @Sendable (String?) -> Void) {lifetime.requestStarted()let reply = tracked(finish)- guard Self.speaksThisVersion(version) else { return reply(HelperRefusal.outOfDate.rawValue) }- guard trashPath.utf8.count <= Self.maximumPathLength, destination.utf8.count <= Self.maximumPathLength else {- return reply(HelperRefusal.pathTooLong.rawValue)+ let caller: HelperRequest.Caller+ do {+ let paths = [trashPath, destination]+ caller = try HelperRequest.admit(version: version, paths: paths, caller: Self.caller).get()+ } catch {+ return reply(error.rawValue)}- guard let caller = Self.caller() else { return reply(HelperRefusal.notAllowed.rawValue) }let policy = PrivilegedPathPolicy(homeDirectory: caller.homeDirectory)guard@@ -125,8 +116,12 @@ final class HelperService: NSObject, PeelHelperProtocol {func moveLedgerToTrash(version: Int, withReply finish: @escaping @Sendable (String?) -> Void) {lifetime.requestStarted()let reply = tracked(finish)- guard Self.speaksThisVersion(version) else { return reply(HelperRefusal.outOfDate.rawValue) }- guard let caller = Self.caller() else { return reply(HelperRefusal.notAllowed.rawValue) }+ let caller: HelperRequest.Caller+ do {+ caller = try HelperRequest.admit(version: version, caller: Self.caller).get()+ } catch {+ return reply(error.rawValue)+ }guard let trash = PrivilegedPathPolicy(homeDirectory: caller.homeDirectory).openTrash(ownedBy: caller.user) else {return reply(HelperRefusal.noTrash.rawValue)}@@ -139,8 +134,9 @@ final class HelperService: NSObject, PeelHelperProtocol {func runDaemonCommand(version: Int, command: String, label: String, withReply finish: @escaping @Sendable (String?) -> Void) {lifetime.requestStarted()let reply = tracked(finish)- guard Self.speaksThisVersion(version) else { return reply(HelperRefusal.outOfDate.rawValue) }- guard Self.caller() != nil else { return reply(HelperRefusal.notAllowed.rawValue) }+ if case .failure(let refusal) = HelperRequest.admit(version: version, caller: Self.caller) {+ return reply(refusal.rawValue)+ }guard let command = DaemonCommand(rawValue: command), PrivilegedPathPolicy.allowsDaemon(label) else {return reply(HelperRefusal.invalidRequest.rawValue)}