Podziel się swoimi sztuczkami hakowania, przesyłając PR-y doHackTricks i HackTricks Cloud repozytoriów na githubie.
Autoryzacja XPC
Apple proponuje również inną metodę uwierzytelniania, czy łączący proces ma uprawnienia do wywołania wystawionej metody XPC.
Kiedy aplikacja musi wykonywać działania jako uprzywilejowany użytkownik, zamiast uruchamiać aplikację jako uprzywilejowany użytkownik, zazwyczaj instaluje jako root HelperTool jako usługę XPC, którą można wywołać z aplikacji, aby wykonać te działania. Jednak aplikacja wywołująca usługę powinna mieć wystarczającą autoryzację.
ShouldAcceptNewConnection zawsze YES
Przykład można znaleźć w EvenBetterAuthorizationSample. W App/AppDelegate.m próbuje połączyć się z HelperTool. A w HelperTool/HelperTool.m funkcja shouldAcceptNewConnectionnie będzie sprawdzać żadnych wymagań wskazanych wcześniej. Zawsze zwróci 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;
}
Aby uzyskać więcej informacji na temat właściwej konfiguracji tego sprawdzenia:
Jednakże, gdy wywoływana jest metoda z HelperTool, zachodzi pewna autoryzacja.
Funkcja applicationDidFinishLaunching z App/AppDelegate.m utworzy puste odwołanie do autoryzacji po uruchomieniu aplikacji. To powinno zawsze działać.
Następnie spróbuje dodać pewne uprawnienia do tego odwołania do autoryzacji, wywołując 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];
}
Funkcja setupAuthorizationRights z pliku Common/Common.m zapisze w bazie danych autoryzacji /var/db/auth.db uprawnienia aplikacji. Zauważ, że dodane zostaną tylko te uprawnienia, które nie znajdują się jeszcze w bazie danych:
+ (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.
}
}];
}
Funkcja enumerateRightsUsingBlock jest używana do uzyskania uprawnień aplikacji, które są zdefiniowane w 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);
}];
}
To oznacza, że na końcu tego procesu uprawnienia zadeklarowane wewnątrz commandInfo zostaną przechowywane w /var/db/auth.db. Zauważ, że tam można znaleźć dla każdej metody, która będzie wymagała uwierzytelnienia, nazwę uprawnienia i kCommandKeyAuthRightDefault. Ten ostatni wskazuje, kto może uzyskać to uprawnienie.
Istnieją różne zakresy wskazujące, kto może uzyskać dostęp do uprawnienia. Niektóre z nich są zdefiniowane w AuthorizationDB.h (możesz znaleźć wszystkie z nich tutaj), ale podsumowując:
Nazwa
Wartość
Opis
kAuthorizationRuleClassAllow
allow
Każdy
kAuthorizationRuleClassDeny
deny
Nikt
kAuthorizationRuleIsAdmin
is-admin
Aktualny użytkownik musi być administratorem (wewnątrz grupy adminów)
kAuthorizationRuleAuthenticateAsSessionUser
authenticate-session-owner
Poproś użytkownika o uwierzytelnienie.
kAuthorizationRuleAuthenticateAsAdmin
authenticate-admin
Poproś użytkownika o uwierzytelnienie. Musi być administratorem (wewnątrz grupy adminów)
kAuthorizationRightRule
rule
Określ reguły
kAuthorizationComment
comment
Określ dodatkowe komentarze dotyczące uprawnienia
Weryfikacja Uprawnień
W HelperTool/HelperTool.m funkcja readLicenseKeyAuthorization sprawdza, czy wywołujący ma uprawnienia do wykonania takiej metody, wywołując funkcję checkAuthorization. Ta funkcja sprawdzi, czy authData wysłane przez proces wywołujący ma poprawny format, a następnie sprawdzi, co jest potrzebne do uzyskania uprawnienia do wywołania konkretnej metody. Jeśli wszystko przebiegnie pomyślnie, zwrócony error będzie 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;
}
Zauważ, że aby sprawdzić wymagania uzyskania prawidłowego do wywołania tej metody, funkcja authorizationRightForCommand po prostu sprawdzi wcześniej skomentowany obiekt commandInfo. Następnie wywoła AuthorizationCopyRights aby sprawdzić, czy ma uprawnienia do wywołania funkcji (zauważ, że flagi pozwalają na interakcję z użytkownikiem).
W tym przypadku, aby wywołać funkcję readLicenseKeyAuthorization, kCommandKeyAuthRightDefault jest zdefiniowane jako @kAuthorizationRuleClassAllow. Więc każdy może ją wywołać.
Informacje o bazie danych
Wspomniano, że te informacje są przechowywane w /var/db/auth.db. Możesz wyświetlić wszystkie przechowywane reguły za pomocą:
Możesz znaleźć wszystkie konfiguracje uprawnieńtutaj, ale kombinacje, które nie wymagają interakcji użytkownika, to:
'authenticate-user': 'false'
To jest najbardziej bezpośredni klucz. Jeśli ustawiony na false, oznacza, że użytkownik nie musi podawać uwierzytelnienia, aby uzyskać to prawo.
Jest używany w połączeniu z jednym z poniższych lub wskazując grupę, do której użytkownik musi należeć.
'allow-root': 'true'
Jeśli użytkownik działa jako użytkownik root (który ma podwyższone uprawnienia), a ten klucz jest ustawiony na true, użytkownik root może potencjalnie uzyskać to prawo bez dodatkowego uwierzytelnienia. Jednak zazwyczaj uzyskanie statusu użytkownika root już wymaga uwierzytelnienia, więc nie jest to scenariusz "bez uwierzytelnienia" dla większości użytkowników.
'session-owner': 'true'
Jeśli ustawiony na true, właściciel sesji (obecnie zalogowany użytkownik) automatycznie otrzyma to prawo. Może to ominąć dodatkowe uwierzytelnienie, jeśli użytkownik jest już zalogowany.
'shared': 'true'
Ten klucz nie nadaje praw bez uwierzytelnienia. Zamiast tego, jeśli ustawiony na true, oznacza to, że po uwierzytelnieniu prawa można udostępnić wielu procesom bez konieczności ponownego uwierzytelniania. Jednak początkowe nadanie prawa nadal będzie wymagać uwierzytelnienia, chyba że jest połączone z innymi kluczami, takimi jak 'authenticate-user': 'false'.
Sprawdzanie, czy jest używane EvenBetterAuthorization
Jeśli znajdziesz funkcję: [HelperTool checkAuthorization:command:], to prawdopodobnie proces używa wcześniej wspomnianego schematu autoryzacji:
Jeśli ta funkcja wywołuje funkcje takie jak AuthorizationCreateFromExternalForm, authorizationRightForCommand, AuthorizationCopyRights, AuhtorizationFree, to używa EvenBetterAuthorizationSample.
Sprawdź /var/db/auth.db, aby zobaczyć, czy możliwe jest uzyskanie uprawnień do wywołania pewnej uprzywilejowanej akcji bez interakcji użytkownika.
Komunikacja protokołowa
Następnie musisz znaleźć schemat protokołu, aby móc nawiązać komunikację z usługą XPC.
Funkcja shouldAcceptNewConnection wskazuje na eksportowany protokół:
W tym przypadku mamy to samo co w EvenBetterAuthorizationSample, sprawdź tę linię.
Znając nazwę używanego protokołu, możliwe jest wygenerowanie definicji nagłówka za pomocą:
