Apple propone anche un altro modo per autenticare se il processo di connessione ha autorizzazioni per chiamare un metodo XPC esposto.
Quando un'applicazione ha bisogno di eseguire azioni come utente privilegiato, invece di eseguire l'app come utente privilegiato, di solito installa come root un HelperTool come servizio XPC che potrebbe essere chiamato dall'app per eseguire tali azioni. Tuttavia, l'app che chiama il servizio dovrebbe avere abbastanza autorizzazione.
ShouldAcceptNewConnection sempre YES
Un esempio può essere trovato in EvenBetterAuthorizationSample. In App/AppDelegate.m cerca di connettersi al HelperTool. E in HelperTool/HelperTool.m la funzione shouldAcceptNewConnectionnon verificherà nessuno dei requisiti indicati in precedenza. Restituirà sempre 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;
}
Per ulteriori informazioni su come configurare correttamente questo controllo:
Tuttavia, vi è un processo di autorizzazione in corso quando viene chiamato un metodo da HelperTool.
La funzione applicationDidFinishLaunching da App/AppDelegate.m creerà un riferimento di autorizzazione vuoto dopo che l'app è stata avviata. Questo dovrebbe sempre funzionare.
Successivamente, cercherà di aggiungere alcuni diritti a tale riferimento di autorizzazione chiamando 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 funzione setupAuthorizationRights da Common/Common.m memorizzerà nel database di autorizzazione /var/db/auth.db i diritti dell'applicazione. Nota come aggiungerà solo i diritti che non sono ancora nel database:
+ (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 funzione enumerateRightsUsingBlock è quella utilizzata per ottenere i permessi delle applicazioni, che sono definiti in 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);
}];
}
Questo significa che alla fine di questo processo, le autorizzazioni dichiarate all'interno di commandInfo verranno memorizzate in /var/db/auth.db. Nota come puoi trovare per ogni metodo che richiederà autenticazione, il nome dell'autorizzazione e il kCommandKeyAuthRightDefault. Quest'ultimo indica chi può ottenere questo diritto.
Ci sono diversi ambiti per indicare chi può accedere a un diritto. Alcuni di essi sono definiti in AuthorizationDB.h (puoi trovarli tutti qui), ma in sintesi:
Nome
Valore
Descrizione
kAuthorizationRuleClassAllow
allow
Chiunque
kAuthorizationRuleClassDeny
deny
Nessuno
kAuthorizationRuleIsAdmin
is-admin
L'utente corrente deve essere un amministratore (all'interno del gruppo admin)
kAuthorizationRuleAuthenticateAsSessionUser
authenticate-session-owner
Chiedi all'utente di autenticarsi.
kAuthorizationRuleAuthenticateAsAdmin
authenticate-admin
Chiedi all'utente di autenticarsi. Deve essere un amministratore (all'interno del gruppo admin)
kAuthorizationRightRule
rule
Specifica le regole
kAuthorizationComment
comment
Specifica alcuni commenti aggiuntivi sul diritto
Verifica dei Diritti
In HelperTool/HelperTool.m la funzione readLicenseKeyAuthorization controlla se il chiamante è autorizzato a eseguire tale metodo chiamando la funzione checkAuthorization. Questa funzione verificherà che i dati di autenticazione inviati dal processo chiamante abbiano un formato corretto e quindi verificherà cosa è necessario per ottenere il diritto di chiamare il metodo specifico. Se tutto va bene, l'errore restituito sarà 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;
}
Nota che per verificare i requisiti per ottenere il diritto di chiamare quel metodo, la funzione authorizationRightForCommand controllerà semplicemente l'oggetto precedentemente commentato commandInfo. Successivamente, chiamerà AuthorizationCopyRights per verificare se ha i diritti per chiamare la funzione (nota che i flag consentono l'interazione con l'utente).
In questo caso, per chiamare la funzione readLicenseKeyAuthorization, il kCommandKeyAuthRightDefault è definito come @kAuthorizationRuleClassAllow. Quindi chiunque può chiamarlo.
Informazioni sul Database
È stato menzionato che queste informazioni sono memorizzate in /var/db/auth.db. Puoi elencare tutte le regole memorizzate con:
Puoi trovare tutte le configurazioni dei permessiqui, ma le combinazioni che non richiedono interazione dell'utente sarebbero:
'authenticate-user': 'false'
Questo è il campo più diretto. Se impostato su false, specifica che un utente non deve fornire autenticazione per ottenere questo diritto.
Viene utilizzato in combinazione con uno dei 2 seguenti o indicando un gruppo a cui l'utente deve appartenere.
'allow-root': 'true'
Se un utente sta operando come utente root (che ha permessi elevati) e questo campo è impostato su true, l'utente root potrebbe potenzialmente ottenere questo diritto senza ulteriore autenticazione. Tuttavia, tipicamente, raggiungere lo stato di utente root richiede già un'autenticazione, quindi non si tratta di uno scenario "senza autenticazione" per la maggior parte degli utenti.
'session-owner': 'true'
Se impostato su true, il proprietario della sessione (l'utente attualmente loggato) otterrebbe automaticamente questo diritto. Ciò potrebbe bypassare ulteriori autenticazioni se l'utente è già loggato.
'shared': 'true'
Questo campo non concede diritti senza autenticazione. Invece, se impostato su true, significa che una volta che il diritto è stato autenticato, può essere condiviso tra più processi senza che ognuno debba ri-autenticarsi. Tuttavia, il conferimento iniziale del diritto richiederebbe comunque l'autenticazione a meno che non sia combinato con altri campi come 'authenticate-user': 'false'.
Se trovi la funzione: [HelperTool checkAuthorization:command:] probabilmente il processo sta utilizzando lo schema di autorizzazione precedentemente menzionato:
Quindi, se questa funzione chiama funzioni come AuthorizationCreateFromExternalForm, authorizationRightForCommand, AuthorizationCopyRights, AuhtorizationFree, sta utilizzando EvenBetterAuthorizationSample.
Controlla il /var/db/auth.db per vedere se è possibile ottenere autorizzazioni per chiamare alcune azioni privilegiate senza interazione dell'utente.
Comunicazione del Protocollo
Successivamente, è necessario trovare lo schema del protocollo per poter stabilire una comunicazione con il servizio XPC.
La funzione shouldAcceptNewConnection indica il protocollo in fase di esportazione:
In questo caso, abbiamo lo stesso di EvenBetterAuthorizationSample, controlla questa linea.
Conoscendo il nome del protocollo utilizzato, è possibile scaricare la definizione dell'header con:
Infine, abbiamo solo bisogno di conoscere il nome del Mach Service esposto per stabilire una comunicazione con esso. Ci sono diversi modi per trovarlo:
Nel [HelperTool init] dove è possibile vedere il Mach Service in uso:
