Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2025-01-09 11:48:51 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-ipc-inter-process-communication/macos-xpc-authorization.md
carlospolop 466ebcbb16 f
2023-06-05 20:30:03 +02:00

16 KiB
Raw Blame History

Autorización XPC de macOS

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥

Autorización XPC

Apple también propone otra forma de autenticar si el proceso que se conecta tiene permisos para llamar a un método XPC expuesto.

Cuando una aplicación necesita ejecutar acciones como usuario privilegiado, en lugar de ejecutar la aplicación como usuario privilegiado, generalmente instala como root un HelperTool como un servicio XPC que puede ser llamado desde la aplicación para realizar esas acciones. Sin embargo, la aplicación que llama al servicio debe tener suficiente autorización.

ShuoldAcceptNewConnection siempre YES

Se puede encontrar un ejemplo en EvenBetterAuthorizationSample. En App/AppDelegate.m intenta conectarse al HelperTool. Y en HelperTool/HelperTool.m, la función shouldAcceptNewConnection no comprobará 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 obtener más información sobre cómo configurar correctamente esta comprobación:

{% content-ref url="macos-xpc-connecting-process-check.md" %} macos-xpc-connecting-process-check.md {% endcontent-ref %}

Derechos de la aplicación

Sin embargo, hay cierta autorización que ocurre 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 iniciado. 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 autorización /var/db/auth.db los permisos de la aplicación. Observa cómo solo agregará los permisos 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, los cuales 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. Observe cómo allí puede encontrar para cada método que requiere autenticación, el nombre del permiso y el kCommandKeyAuthRightDefault. Este último indica quién puede obtener este permiso.

Existen diferentes ámbitos para indicar quién puede acceder a un permiso. Algunos de ellos están definidos en AuthorizationDB.h (puede encontrar todos ellos aquí), pero como resumen:

NombreValorDescripción
kAuthorizationRuleClassAllowallowCualquiera
kAuthorizationRuleClassDenydenyNadie
kAuthorizationRuleIsAdminis-adminEl usuario actual debe ser un administrador (dentro del grupo de administradores)
kAuthorizationRuleAuthenticateAsSessionUserauthenticate-session-ownerPreguntar al usuario para autenticarse.
kAuthorizationRuleAuthenticateAsAdminauthenticate-adminPreguntar al usuario para autenticarse. Necesita ser un administrador (dentro del grupo de administradores)
kAuthorizationRightRuleruleEspecificar reglas
kAuthorizationCommentcommentEspecificar algunos comentarios adicionales sobre el permiso

Verificación de permisos

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 verificará que los datos de autenticación enviados por el proceso que llama tengan un formato correcto y luego verificará lo que se necesita para obtener el permiso 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;
}

Ten en cuenta que para verificar los requisitos para obtener el derecho de llamar a ese método, la función authorizationRightForCommand simplemente verificará el objeto previamente comentado commandInfo. Luego, llamará a AuthorizationCopyRights para verificar si tiene los derechos para llamar a la función (ten en cuenta que las banderas permiten la interacción con el usuario).

En este caso, para llamar a la función readLicenseKeyAuthorization, se define kCommandKeyAuthRightDefault como @kAuthorizationRuleClassAllow. Por lo tanto, cualquiera puede llamarla.

Información de la base de datos

Se mencionó que esta información se almacena en /var/db/auth.db. Puedes listar todas las reglas almacenadas con:

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

Entonces, puedes leer quién puede acceder al derecho con:

security authorizationdb read com.apple.safaridriver.allow
☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥