A Apple também propõe outra maneira de autenticar se o processo de conexão tem permissões para chamar um método XPC exposto.
Quando um aplicativo precisa executar ações como um usuário privilegiado, em vez de executar o aplicativo como um usuário privilegiado, geralmente instala como root um HelperTool como um serviço XPC que pode ser chamado pelo aplicativo para realizar essas ações. No entanto, o aplicativo que chama o serviço deve ter autorização suficiente.
ShouldAcceptNewConnection sempre YES
Um exemplo pode ser encontrado em EvenBetterAuthorizationSample. Em App/AppDelegate.m ele tenta conectar ao HelperTool. E em HelperTool/HelperTool.m a função shouldAcceptNewConnectionnão verificará nenhum dos requisitos indicados anteriormente. Ela sempre retornará 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 mais informações sobre como configurar corretamente esta verificação:
No entanto, há alguma autorização ocorrendo quando um método do HelperTool é chamado.
A função applicationDidFinishLaunching de App/AppDelegate.m criará uma referência de autorização vazia após o início do aplicativo. Isso deve sempre funcionar.
Em seguida, tentará adicionar alguns direitos a essa referência de autorização chamando 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];
}
A função setupAuthorizationRights do Common/Common.m armazenará no banco de dados de autenticação /var/db/auth.db os direitos da aplicação. Note que ela só adicionará os direitos que ainda não estão no banco de dados:
+ (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.
}
}];
}
A função enumerateRightsUsingBlock é a que é usada para obter as permissões das aplicações, que são definidas em 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);
}];
}
Isso significa que, ao final deste processo, as permissões declaradas dentro de commandInfo serão armazenadas em /var/db/auth.db. Note como lá você pode encontrar para cada método que irá requerer autenticação, nome da permissão e o kCommandKeyAuthRightDefault. Este último indica quem pode obter esse direito.
Existem diferentes escopos para indicar quem pode acessar um direito. Alguns deles estão definidos em AuthorizationDB.h (você pode encontrar todos eles aqui), mas como resumo:
Nome
Valor
Descrição
kAuthorizationRuleClassAllow
allow
Qualquer um
kAuthorizationRuleClassDeny
deny
Ninguém
kAuthorizationRuleIsAdmin
is-admin
O usuário atual precisa ser um admin (dentro do grupo de admin)
kAuthorizationRuleAuthenticateAsSessionUser
authenticate-session-owner
Pedir ao usuário para autenticar.
kAuthorizationRuleAuthenticateAsAdmin
authenticate-admin
Pedir ao usuário para autenticar. Ele precisa ser um admin (dentro do grupo de admin)
kAuthorizationRightRule
rule
Especificar regras
kAuthorizationComment
comment
Especificar alguns comentários extras sobre o direito
Verificação de Direitos
Em HelperTool/HelperTool.m, a função readLicenseKeyAuthorization verifica se o chamador está autorizado a executar tal método chamando a função checkAuthorization. Esta função verificará se o authData enviado pelo processo chamador tem um formato correto e então verificará o que é necessário para obter o direito de chamar o método específico. Se tudo correr bem, o error retornado 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 os requisitos para obter o direito de chamar esse método, a função authorizationRightForCommand apenas verificará o objeto comentado anteriormente commandInfo. Em seguida, chamará AuthorizationCopyRights para verificar se possui os direitos para chamar a função (note que as flags permitem interação com o usuário).
Neste caso, para chamar a função readLicenseKeyAuthorization, o kCommandKeyAuthRightDefault é definido como @kAuthorizationRuleClassAllow. Assim, qualquer um pode chamá-la.
Informações do DB
Foi mencionado que essas informações são armazenadas em /var/db/auth.db. Você pode listar todas as regras armazenadas com:
Você pode encontrar todas as configurações de permissõesaqui, mas as combinações que não exigirão interação do usuário seriam:
'authenticate-user': 'false'
Esta é a chave mais direta. Se definida como false, especifica que um usuário não precisa fornecer autenticação para obter este direito.
Isso é usado em combinação com uma das 2 abaixo ou indicando um grupo ao qual o usuário deve pertencer.
'allow-root': 'true'
Se um usuário estiver operando como o usuário root (que possui permissões elevadas), e esta chave estiver definida como true, o usuário root poderia potencialmente obter este direito sem mais autenticação. No entanto, tipicamente, alcançar o status de usuário root já requer autenticação, então este não é um cenário de "sem autenticação" para a maioria dos usuários.
'session-owner': 'true'
Se definida como true, o proprietário da sessão (o usuário atualmente logado) obteria automaticamente este direito. Isso pode contornar a autenticação adicional se o usuário já estiver logado.
'shared': 'true'
Esta chave não concede direitos sem autenticação. Em vez disso, se definida como true, significa que uma vez que o direito tenha sido autenticado, ele pode ser compartilhado entre vários processos sem que cada um precise re-autenticar. Mas a concessão inicial do direito ainda exigiria autenticação, a menos que combinada com outras chaves como 'authenticate-user': 'false'.
Você pode usar este script para obter os direitos interessantes:
Verificando se EvenBetterAuthorization está em uso
Se você encontrar a função: [HelperTool checkAuthorization:command:] é provável que o processo esteja usando o esquema de autorização mencionado anteriormente:
Isso, se essa função estiver chamando funções como AuthorizationCreateFromExternalForm, authorizationRightForCommand, AuthorizationCopyRights, AuhtorizationFree, está usando EvenBetterAuthorizationSample.
Verifique o /var/db/auth.db para ver se é possível obter permissões para chamar alguma ação privilegiada sem interação do usuário.
Comunicação de Protocolo
Em seguida, você precisa encontrar o esquema de protocolo para poder estabelecer uma comunicação com o serviço XPC.
A função shouldAcceptNewConnection indica o protocolo que está sendo exportado:
Neste caso, temos o mesmo que no EvenBetterAuthorizationSample, verifique esta linha.
Sabendo o nome do protocolo utilizado, é possível extrair sua definição de cabeçalho com:
