Apple, bağlanan işlemin açık bir XPC yöntemini çağırma izinlerine sahip olup olmadığını doğrulamanın başka bir yolunu da önerir.
Bir uygulama ayrılmış bir kullanıcı olarak eylemleri gerçekleştirmesi gerektiğinde, genellikle uygulamayı ayrıcalıklı bir kullanıcı olarak çalıştırmak yerine, bu eylemleri gerçekleştirmek için uygulamadan çağrılabilecek bir XPC hizmeti olarak kök olarak bir HelperTool kurar. Ancak, hizmeti çağıran uygulamanın yeterli yetkilendirmeye sahip olması gerekir.
ShouldAcceptNewConnection her zaman EVET
Bir örnek EvenBetterAuthorizationSample içinde bulunabilir. App/AppDelegate.m dosyasında HelperTool ile bağlanmaya çalışır. Ve HelperTool/HelperTool.m dosyasında shouldAcceptNewConnectiondaha önce belirtilen gereksinimlerin hiçbirini kontrol etmeyecek. Her zaman EVET döndürecektir:
- (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;
}
Daha fazla bilgi için bu kontrolü doğru bir şekilde yapılandırma hakkında:
Ancak, HelperTool'dan bir yöntem çağrıldığında bazı yetkilendirmeler gerçekleşiyor.
App/AppDelegate.m dosyasındaki applicationDidFinishLaunching fonksiyonu, uygulama başlatıldıktan sonra boş bir yetkilendirme referansı oluşturacaktır. Bu her zaman çalışmalıdır.
Ardından, setupAuthorizationRights çağrısını yaparak o yetkilendirme referansına bazı haklar eklemeye çalışacaktır:
- (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];
}
Fonksiyon setupAuthorizationRights, Common/Common.m dosyasından, uygulamanın haklarını /var/db/auth.db yetki veritabanında saklayacaktır. Veritabanında henüz bulunmayan hakları yalnızca ekleyeceğine dikkat edin:
+ (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.
}
}];
}
Fonksiyon enumerateRightsUsingBlock, commandInfo içinde tanımlanan uygulama izinlerini almak için kullanılır:
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);
}];
}
Bu, bu sürecin sonunda commandInfo içinde belirtilen izinlerin /var/db/auth.db içinde saklanacağı anlamına gelir. Her yöntem için kimlik doğrulaması gerektiren, izin adı ve kCommandKeyAuthRightDefault bulabileceğinizi unutmayın. Sonuncusu bu hakkı kimin alabileceğini gösterir.
Bir hakkın kimler tarafından erişilebileceğini belirtmek için farklı kapsamlar vardır. Bunlardan bazıları AuthorizationDB.h içinde tanımlanmıştır (hepsini burada bulabilirsiniz), ancak özet olarak:
Ad
Değer
Açıklama
kAuthorizationRuleClassAllow
allow
Herkes
kAuthorizationRuleClassDeny
deny
Hiç kimse
kAuthorizationRuleIsAdmin
is-admin
Mevcut kullanıcı bir admin olmalıdır (admin grubunda)
HelperTool/HelperTool.m içinde readLicenseKeyAuthorization fonksiyonu, çağrının böyle bir yöntemiçalıştırmak için yetkili olup olmadığını kontrol eder ve checkAuthorization fonksiyonunu çağırır. Bu fonksiyon, çağıran süreç tarafından gönderilen authData'nın doğru formatta olup olmadığını kontrol eder ve ardından belirli bir yöntemi çağırmak için neye ihtiyaç olduğunu kontrol eder. Her şey yolunda giderse, dönen errornil olacaktır:
- (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;
}
Not edin ki o yöntemi çağırmak için gereksinimleri kontrol etmek amacıyla authorizationRightForCommand fonksiyonu sadece daha önce yorumlanan commandInfo nesnesini kontrol edecektir. Ardından, AuthorizationCopyRights fonksiyonunu çağırarak fonksiyonu çağırma haklarına sahip olup olmadığını kontrol edecektir (bayrakların kullanıcı ile etkileşime izin verdiğini unutmayın).
Bu durumda, readLicenseKeyAuthorization fonksiyonunu çağırmak için kCommandKeyAuthRightDefault@kAuthorizationRuleClassAllow olarak tanımlanmıştır. Yani herkes bunu çağırabilir.
DB Bilgileri
Bu bilginin /var/db/auth.db içinde saklandığı belirtilmiştir. Saklanan tüm kuralları listelemek için:
Tüm izin yapılandırmalarınıburadan bulabilirsiniz, ancak kullanıcı etkileşimi gerektirmeyen kombinasyonlar şunlardır:
'authenticate-user': 'false'
Bu en doğrudan anahtardır. false olarak ayarlandığında, bir kullanıcının bu hakkı elde etmek için kimlik doğrulaması sağlaması gerekmediğini belirtir.
Bu, aşağıdaki 2 anahtardan biriyle veya kullanıcının ait olması gereken bir grubu belirtmek için birlikte kullanılır.
'allow-root': 'true'
Bir kullanıcı root kullanıcı olarak çalışıyorsa (yükseltilmiş izinlere sahiptir) ve bu anahtar true olarak ayarlandıysa, root kullanıcı potansiyel olarak bu hakkı daha fazla kimlik doğrulaması olmadan elde edebilir. Ancak, genellikle root kullanıcı statüsüne ulaşmak zaten kimlik doğrulaması gerektirdiğinden, bu çoğu kullanıcı için "kimlik doğrulaması yok" senaryosu değildir.
'session-owner': 'true'
true olarak ayarlandığında, oturumun sahibi (şu anda oturum açmış kullanıcı) otomatik olarak bu hakkı alır. Kullanıcı zaten oturum açmışsa, bu ek kimlik doğrulamasını atlayabilir.
'shared': 'true'
Bu anahtar kimlik doğrulaması olmadan hak vermez. Bunun yerine, true olarak ayarlandığında, hak kimlik doğrulaması yapıldıktan sonra, her birinin yeniden kimlik doğrulaması yapmasına gerek kalmadan birden fazla süreç arasında paylaşılabileceği anlamına gelir. Ancak, hakkın başlangıçta verilmesi yine de kimlik doğrulaması gerektirecektir, aksi takdirde 'authenticate-user': 'false' gibi diğer anahtarlarla birleştirilmelidir.
İlginç hakları elde etmek için bu betiği kullanabilirsiniz:
EvenBetterAuthorization'ın Kullanılıp Kullanılmadığını Kontrol Etme
Eğer [HelperTool checkAuthorization:command:] fonksiyonunu bulursanız, muhtemelen süreç daha önce bahsedilen yetkilendirme şemasını kullanıyordur:
Bu durumda, eğer bu fonksiyon AuthorizationCreateFromExternalForm, authorizationRightForCommand, AuthorizationCopyRights, AuhtorizationFree gibi fonksiyonları çağırıyorsa, EvenBetterAuthorizationSample kullanılıyor demektir.
Kullanıcı etkileşimi olmadan bazı ayrıcalıklı eylemleri çağırmak için izin almanın mümkün olup olmadığını görmek için /var/db/auth.db dosyasını kontrol edin.
Protokol İletişimi
Sonra, XPC servisi ile iletişim kurabilmek için protokol şemasını bulmanız gerekiyor.
