Apple también propone otra forma de autenticar si el proceso de conexión tiene permisos para llamar a un método XPC expuesto.
Cuando una aplicación necesita ejecutar acciones como un usuario privilegiado, en lugar de ejecutar la aplicación como un usuario privilegiado, generalmente instala como root un HelperTool como un servicio XPC que podría ser llamado desde la aplicación para realizar esas acciones. Sin embargo, la aplicación que llama al servicio debe tener suficiente autorización.
ShouldAcceptNewConnection siempre YES
Un ejemplo se puede encontrar en EvenBetterAuthorizationSample. En App/AppDelegate.m intenta conectarse al HelperTool. Y en HelperTool/HelperTool.m la función shouldAcceptNewConnectionno verificará ninguno de los requisitos indicados anteriormente. Siempre devolverá 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;
}
Para más información sobre cómo configurar correctamente esta verificación:
Sin embargo, hay alguna autorización en curso cuando se llama a un método del HelperTool.
La función applicationDidFinishLaunching de App/AppDelegate.m creará una referencia de autorización vacía después de que la aplicación haya comenzado. Esto siempre debería funcionar.
Luego, intentará agregar algunos derechos a esa referencia de autorización llamando a 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 función setupAuthorizationRights de Common/Common.m almacenará en la base de datos de autenticación /var/db/auth.db los derechos de la aplicación. Tenga en cuenta que solo agregará los derechos que aún no están en la base de datos:
+ (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 función enumerateRightsUsingBlock es la que se utiliza para obtener los permisos de las aplicaciones, que están definidos en 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);
}];
}
Esto significa que al final de este proceso, los permisos declarados dentro de commandInfo se almacenarán en /var/db/auth.db. Nota cómo allí puedes encontrar para cada método que requiere autenticación, nombre del permiso y el kCommandKeyAuthRightDefault. Este último indica quién puede obtener este derecho.
Hay diferentes ámbitos para indicar quién puede acceder a un derecho. Algunos de ellos están definidos en AuthorizationDB.h (puedes encontrar todos ellos aquí), pero como resumen:
Nombre
Valor
Descripción
kAuthorizationRuleClassAllow
allow
Cualquiera
kAuthorizationRuleClassDeny
deny
Nadie
kAuthorizationRuleIsAdmin
is-admin
El usuario actual necesita ser un administrador (dentro del grupo de administradores)
kAuthorizationRuleAuthenticateAsSessionUser
authenticate-session-owner
Pedir al usuario que se autentique.
kAuthorizationRuleAuthenticateAsAdmin
authenticate-admin
Pedir al usuario que se autentique. Necesita ser un administrador (dentro del grupo de administradores)
kAuthorizationRightRule
rule
Especificar reglas
kAuthorizationComment
comment
Especificar algunos comentarios adicionales sobre el derecho
Verificación de Derechos
En HelperTool/HelperTool.m, la función readLicenseKeyAuthorization verifica si el llamador está autorizado para ejecutar tal método llamando a la función checkAuthorization. Esta función comprobará que los authData enviados por el proceso llamador tienen un formato correcto y luego verificará qué se necesita para obtener el derecho para llamar al método específico. Si todo va bien, el error devuelto será 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;
}
Note que para verificar los requisitos para obtener el derecho a llamar a ese método, la función authorizationRightForCommand solo verificará el objeto comentado previamente commandInfo. Luego, llamará a AuthorizationCopyRights para verificar si tiene los derechos para llamar a la función (note que las flags permiten la interacción con el usuario).
En este caso, para llamar a la función readLicenseKeyAuthorization, el kCommandKeyAuthRightDefault se define como @kAuthorizationRuleClassAllow. Así que cualquiera puede llamarlo.
Información de la DB
Se mencionó que esta información se almacena en /var/db/auth.db. Puede listar todas las reglas almacenadas con:
Puedes encontrar todas las configuraciones de permisosaquí, pero las combinaciones que no requerirán interacción del usuario serían:
'authenticate-user': 'false'
Esta es la clave más directa. Si se establece en false, especifica que un usuario no necesita proporcionar autenticación para obtener este derecho.
Esto se utiliza en combinación con uno de los 2 a continuación o indicando un grupo al que el usuario debe pertenecer.
'allow-root': 'true'
Si un usuario está operando como el usuario root (que tiene permisos elevados), y esta clave está establecida en true, el usuario root podría potencialmente obtener este derecho sin más autenticación. Sin embargo, típicamente, llegar a un estado de usuario root ya requiere autenticación, por lo que este no es un escenario de "sin autenticación" para la mayoría de los usuarios.
'session-owner': 'true'
Si se establece en true, el propietario de la sesión (el usuario actualmente conectado) obtendría automáticamente este derecho. Esto podría eludir la autenticación adicional si el usuario ya ha iniciado sesión.
'shared': 'true'
Esta clave no otorga derechos sin autenticación. En cambio, si se establece en true, significa que una vez que el derecho ha sido autenticado, puede ser compartido entre múltiples procesos sin que cada uno necesite re-autenticarse. Pero la concesión inicial del derecho aún requeriría autenticación a menos que se combine con otras claves como 'authenticate-user': 'false'.
Si encuentras la función: [HelperTool checkAuthorization:command:] probablemente el proceso esté utilizando el esquema mencionado anteriormente para la autorización:
Esto, si esta función está llamando a funciones como AuthorizationCreateFromExternalForm, authorizationRightForCommand, AuthorizationCopyRights, AuhtorizationFree, está utilizando EvenBetterAuthorizationSample.
Revisa el /var/db/auth.db para ver si es posible obtener permisos para llamar a alguna acción privilegiada sin interacción del usuario.
Protocol Communication
Luego, necesitas encontrar el esquema del protocolo para poder establecer una comunicación con el servicio XPC.
La función shouldAcceptNewConnection indica el protocolo que se está exportando:
En este caso, tenemos lo mismo que en EvenBetterAuthorizationSample, revisa esta línea.
Sabiendo el nombre del protocolo utilizado, es posible volcar su definición de encabezado con:
Por último, solo necesitamos conocer el nombre del Servicio Mach expuesto para establecer una comunicación con él. Hay varias formas de encontrar esto:
En el [HelperTool init] donde puedes ver el Servicio Mach que se está utilizando:
