Skip to content

armgit / peel

Public Imported from GitHub
0

Uninstall Mac apps with every file they leave behind, and see why each belongs. Free up space, fine-tune macOS, and set up Terminal.

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.swift
new file mode 100644
index 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.swift
new file mode 100644
index 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.swift
index 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? {
guard
let 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.rawValue
continue
}
@@ -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)
}