Apple stel ook 'n ander manier voor om te verifieer of die verbindingsproses regte het om 'n blootgestelde XPC-metode aan te roep.
Wanneer 'n toepassing aksies as 'n bevoorregte gebruiker moet uitvoer, installeer dit gewoonlik 'n HelperTool as 'n XPC-diens as root wat vanaf die toepassing aangeroep kan word om daardie aksies uit te voer, eerder as om die toepassing as 'n bevoorregte gebruiker te laat loop. Die toepassing wat die diens aanroep, moet egter genoegsame magtiging hê.
ShouldAcceptNewConnection altyd JA
'n Voorbeeld kan gevind word in EvenBetterAuthorizationSample. In App/AppDelegate.m probeer dit om te verbinde met die HelperTool. En in HelperTool/HelperTool.m sal die funksie shouldAcceptNewConnectionnie enige van die vereistes wat voorheen aangedui is, kontroleer nie. Dit sal altyd JA teruggee:
- (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;
}
For more information about how to properly configure this check:
Toepassing regte
Daar is egter 'n bietjie autorisering aan die gang wanneer 'n metode van die HelperTool aangeroep word.
Die funksie applicationDidFinishLaunching van App/AppDelegate.m sal 'n leë autoriseringsverwysing skep nadat die toepassing begin het. Dit behoort altyd te werk.
Dan sal dit probeer om 'n paar regte by daardie autoriseringsverwysing te voeg deur setupAuthorizationRights aan te roep:
- (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];
}
Die funksie setupAuthorizationRights van Common/Common.m sal die regte van die aansoek in die auth-databasis /var/db/auth.db stoor. Let op hoe dit slegs die regte sal byvoeg wat nog nie in die databasis is nie:
+ (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.
}
}];
}
Die funksie enumerateRightsUsingBlock is die een wat gebruik word om toepassings se toestemmings te verkry, wat gedefinieer is 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);
}];
}
Dit beteken dat aan die einde van hierdie proses, die toestemmings wat binne commandInfo verklaar is, in /var/db/auth.db gestoor sal word. Let op hoe daar vir elke metode wat authentisering sal vereis, toestemming naam en die kCommandKeyAuthRightDefault gevind kan word. Laasgenoemde gee aan wie hierdie reg kan verkry.
Daar is verskillende skope om aan te dui wie toegang tot 'n reg kan hê. Sommige daarvan is gedefinieer in AuthorizationDB.h (jy kan almal daarvan hier vind), maar as 'n opsomming:
Naam
Waarde
Beskrywing
kAuthorizationRuleClassAllow
allow
Enigeen
kAuthorizationRuleClassDeny
deny
Niks
kAuthorizationRuleIsAdmin
is-admin
Huidige gebruiker moet 'n admin wees (binne admin groep)
kAuthorizationRuleAuthenticateAsSessionUser
authenticate-session-owner
Vra gebruiker om te autentiseer.
kAuthorizationRuleAuthenticateAsAdmin
authenticate-admin
Vra gebruiker om te autentiseer. Hy moet 'n admin wees (binne admin groep)
kAuthorizationRightRule
rule
Spesifiseer reëls
kAuthorizationComment
comment
Spesifiseer 'n paar ekstra kommentaar oor die reg
Regte Verifikasie
In HelperTool/HelperTool.m kontroleer die funksie readLicenseKeyAuthorization of die oproeper gemagtig is om so 'n metode uit te voer deur die funksie checkAuthorization aan te roep. Hierdie funksie sal kontroleer of die authData wat deur die oproepende proses gestuur is, 'n korrekte formaat het en dan sal dit kontroleer wat nodig is om die reg te verkry om die spesifieke metode aan te roep. As alles goed gaan, sal die teruggegee errornil wees:
- (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;
}
Let daarop dat om die vereistes te kontroleer om die regte te verkry om daardie metode aan te roep, die funksie authorizationRightForCommand net die voorheen kommentaar objek commandInfo sal kontroleer. Dan sal dit AuthorizationCopyRights aanroep om te kontroleer of dit die regte het om die funksie aan te roep (let daarop dat die vlae interaksie met die gebruiker toelaat).
In hierdie geval, om die funksie readLicenseKeyAuthorization aan te roep, is die kCommandKeyAuthRightDefault gedefinieer as @kAuthorizationRuleClassAllow. So enige iemand kan dit aanroep.
DB Inligting
Daar is genoem dat hierdie inligting gestoor word in /var/db/auth.db. Jy kan al die gestoor reëls lys met:
Jy kan alle die toestemmingskonfigurasieshier vind, maar die kombinasies wat nie gebruikersinteraksie sal vereis nie, sal wees:
'authenticate-user': 'false'
Dit is die mees direkte sleutel. As dit op false gestel is, spesifiseer dit dat 'n gebruiker nie hoef te autentiseer om hierdie reg te verkry nie.
Dit word gebruik in kombinasie met een van die 2 hieronder of om 'n groep aan te dui waartoe die gebruiker moet behoort.
'allow-root': 'true'
As 'n gebruiker as die wortelgebruiker (wat verhoogde regte het) werk, en hierdie sleutel op true gestel is, kan die wortelgebruiker moontlik hierdie reg verkry sonder verdere autentisering. Dit is egter tipies dat om 'n wortelgebruikerstatus te verkry, reeds autentisering vereis, so dit is nie 'n "geen autentisering" scenario vir die meeste gebruikers nie.
'session-owner': 'true'
As dit op true gestel is, sal die eienaar van die sessie (die tans ingelogde gebruiker) outomaties hierdie reg ontvang. Dit kan addisionele autentisering omseil as die gebruiker reeds ingelog is.
'shared': 'true'
Hierdie sleutel verleen nie regte sonder autentisering nie. In plaas daarvan, as dit op true gestel is, beteken dit dat sodra die reg geoutentiseer is, dit onder verskeie prosesse gedeel kan word sonder dat elkeen weer moet autentiseer. Maar die aanvanklike toekenning van die reg sal steeds autentisering vereis tensy dit gekombineer word met ander sleutels soos 'authenticate-user': 'false'.
Kontroleer of EvenBetterAuthorization gebruik word
As jy die funksie: [HelperTool checkAuthorization:command:] vind, is dit waarskynlik dat die proses die voorheen genoemde skema vir owerheid gebruik:
As hierdie funksie funksies aanroep soos AuthorizationCreateFromExternalForm, authorizationRightForCommand, AuthorizationCopyRights, AuhtorizationFree, gebruik dit EvenBetterAuthorizationSample.
Kontroleer die /var/db/auth.db om te sien of dit moontlik is om toestemmings te verkry om 'n paar bevoorregte aksies te bel sonder gebruikersinteraksie.
Protokol Kommunikasie
Dan moet jy die protokol skema vind om 'n kommunikasie met die XPC diens te kan tot stand bring.
Die funksie shouldAcceptNewConnection dui die protokol aan wat ge-exporteer word:
In hierdie geval het ons dieselfde as in EvenBetterAuthorizationSample, kontroleer hierdie lyn.
As jy die naam van die gebruikte protokol ken, is dit moontlik om sy kopdefinisie te dump met:
Lastly, we just need to know the naam van die blootgestelde Mach-diens in orde om 'n kommunikasie daarmee te vestig. Daar is verskeie maniere om dit te vind:
In die [HelperTool init] waar jy die Mach-diens kan sien wat gebruik word:
