SIMAccess.m   [plain text]

/*
* Copyright (c) 2018-2019 Apple Inc. All rights reserved.
*
* @APPLE_LICENSE_HEADER_START@
*
* This file contains Original Code and/or Modifications of Original Code
* as defined in and that are subject to the Apple Public Source License
* Version 2.0 (the 'License'). You may not use this file except in
* compliance with the License. Please obtain a copy of the License at
* http://www.opensource.apple.com/apsl/ and read it before using this
* file.
*
* The Original Code and all software distributed under the License are
* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
* Please see the License for the specific language governing rights and
* limitations under the License.
*
* @APPLE_LICENSE_HEADER_END@
*/

/*
* SIMAccess.m
* - C wrapper functions over ObjC interface the SIM module
*/

#include "SIMAccessPrivate.h"
#include "SIMAccess.h"
#include "symbol_scope.h"
#include "myCFUtil.h"
#include "EAPLog.h"

#import <Foundation/Foundation.h>

#if TARGET_OS_IPHONE

#include <CoreTelephony/CTServerConnectionPriv.h>
#include <CoreTelephony/CTServerConnectionSubscriber.h>
#import <CoreTelephony/CoreTelephonyClient.h>
#import <CoreTelephony/CoreTelephonyClient+Subscriber.h>
#import <CoreTelephony/CoreTelephonyClientSubscriberDelegate.h>

STATIC CTXPCServiceSubscriptionContext *
SubscriptionContextUserPreferredGet(CoreTelephonyClient *coreTelephonyclient)
{
NSError *error = nil;
CTXPCServiceSubscriptionContext *userPreferredSubscriptionCtx = nil;
CTXPCServiceSubscriptionInfo *subscriptionInfo = nil;

subscriptionInfo = [coreTelephonyclient getSubscriptionInfoWithError:&error];
if (error) {
/* failed to get the subscription contexts */
EAPLOG_FL(LOG_ERR,
"CoreTelephonyClient.getSubscriptionInfoWithError failed with "
"error: %@", error);
return nil;
}
if (!subscriptionInfo && (!subscriptionInfo.subscriptions || subscriptionInfo.subscriptions.count == 0)) {
/* received nil or zero subscription contexts */
EAPLOG_FL(LOG_ERR, "failed to get the subscription contexts");
return nil;
}
for (CTXPCServiceSubscriptionContext *subscriptionContext in subscriptionInfo.subscriptions) {
if (subscriptionContext) {
if (subscriptionContext.userDataPreferred && [subscriptionContext.userDataPreferred boolValue]) {
userPreferredSubscriptionCtx = subscriptionContext;
break;
}
}
}
return userPreferredSubscriptionCtx;
}

STATIC CTXPCServiceSubscriptionContext *
SubscriptionContextMatchingSlotGet(CoreTelephonyClient *coreTelephonyclient, NSUUID *uuid)
{
NSError *error = nil;
CTXPCServiceSubscriptionContext *matchingSubscriptionCtx = nil;
CTXPCServiceSubscriptionInfo *subscriptionInfo = nil;

subscriptionInfo = [coreTelephonyclient getSubscriptionInfoWithError:&error];
if (error) {
/* failed to get the subscription contexts */
EAPLOG_FL(LOG_ERR,
"CoreTelephonyClient.getSubscriptionInfoWithError failed with "
"error: %@", error);
return nil;
}
if (!subscriptionInfo && (!subscriptionInfo.subscriptions || subscriptionInfo.subscriptions.count == 0)) {
/* received nil or zero subscription contexts */
EAPLOG_FL(LOG_ERR, "failed to get the subscription contexts");
return nil;
}
for (CTXPCServiceSubscriptionContext *subscriptionContext in subscriptionInfo.subscriptions) {
if (subscriptionContext) {
if (subscriptionContext.uuid && [subscriptionContext.uuid isEqual:uuid]) {
matchingSubscriptionCtx = subscriptionContext;
break;
}
}
}
return matchingSubscriptionCtx;
}

CFStringRef
_SIMCopyIMSI(CFDictionaryRef properties)
{
@autoreleasepool {
NSError *error = nil;
NSString *imsi = nil;
CTXPCServiceSubscriptionContext *preferredSubscriptionCtx = nil;
CFStringRef slotUUID = NULL;

CoreTelephonyClient *coreTelephonyclient = [[CoreTelephonyClient alloc] init];
if (!coreTelephonyclient) {
/* failed to get the instance of Core Telephony Client */
EAPLOG_FL(LOG_ERR, "failed to get the CoreTelephonyClient instance");
return NULL;
}
if (properties != NULL) {
slotUUID = isA_CFString(CFDictionaryGetValue(properties,
kCTSimSupportUICCAuthenticationSlotUUIDKey));
}
if (slotUUID) {
/* carrier Wi-Fi calling case */
NSUUID *uuid = [[NSUUID alloc] initWithUUIDString:(__bridge NSString *)slotUUID];
preferredSubscriptionCtx = SubscriptionContextMatchingSlotGet(coreTelephonyclient, uuid);
} else {
/* carrier hotspot case */
preferredSubscriptionCtx = SubscriptionContextUserPreferredGet(coreTelephonyclient);
}
if (!preferredSubscriptionCtx) {
EAPLOG_FL(LOG_ERR, "failed to get the preferred subscription context");
return NULL;
}
if (preferredSubscriptionCtx) {
imsi = [coreTelephonyclient copyMobileSubscriberIdentity:preferredSubscriptionCtx error:&error];
if (error) {
/* failed to read IMSI */
EAPLOG_FL(LOG_ERR,
"CoreTelephonyClient.copyMobileSubscriberIdentity failed with "
"error: %@", error);
return NULL;
}
return (__bridge_retained CFStringRef)imsi;
}
return NULL;
}
}

CFStringRef
_SIMCopyRealm(CFDictionaryRef properties)
{
@autoreleasepool {
NSError *error = nil;
NSString *mcc = nil;
NSString *mnc = nil;
NSString *realm = nil;
CTXPCServiceSubscriptionContext *preferredSubscriptionCtx = nil;
CFStringRef slotUUID = NULL;

CoreTelephonyClient *coreTelephonyclient = [[CoreTelephonyClient alloc] init];
if (!coreTelephonyclient) {
EAPLOG_FL(LOG_ERR, "failed to get the CoreTelephonyClient instance");
return NULL;
}
if (properties != NULL) {
slotUUID = isA_CFString(CFDictionaryGetValue(properties,
kCTSimSupportUICCAuthenticationSlotUUIDKey));
}
if (slotUUID) {
/* carrier Wi-Fi calling case */
NSUUID *uuid = [[NSUUID alloc] initWithUUIDString:(__bridge NSString *)slotUUID];
preferredSubscriptionCtx = SubscriptionContextMatchingSlotGet(coreTelephonyclient, uuid);
} else {
/* carrier hotspot case */
preferredSubscriptionCtx = SubscriptionContextUserPreferredGet(coreTelephonyclient);
}
if (!preferredSubscriptionCtx) {
EAPLOG_FL(LOG_ERR, "failed to get the preferred subscription context");
return NULL;
}
if (preferredSubscriptionCtx) {
mcc = [coreTelephonyclient copyMobileSubscriberCountryCode:preferredSubscriptionCtx error:&error];
if (error) {
EAPLOG_FL(LOG_ERR,
"CoreTelephonyClient.copyMobileSubscriberCountryCode failed with "
"error: %@", error);
return NULL;
}
mnc = [coreTelephonyclient copyMobileSubscriberNetworkCode:preferredSubscriptionCtx error:&error];
if (error) {
EAPLOG_FL(LOG_ERR,
"CoreTelephonyClient.copyMobileSubscriberNetworkCode failed with "
"error: %@", error);
return NULL;
}
if (mcc && mnc) {
if (mnc.length == 2) {
mnc = [NSString stringWithFormat:@"0%@", mnc];
}
realm = [NSString stringWithFormat:@"wlan.mnc%@.mcc%@.3gppnetwork.org" , mnc, mcc];
return (__bridge_retained CFStringRef)realm;
}
}
return NULL;
}
}

Boolean
_SIMIsOOBPseudonymSupported(Boolean *isSupported)
{
@autoreleasepool {
NSError *error = nil;
CTXPCServiceSubscriptionContext *userPreferredSubscriptionCtx = nil;
CTIdentityProtectionType protection_type;

*isSupported = FALSE;
CoreTelephonyClient *coreTelephonyClient = [[CoreTelephonyClient alloc] init];
if (coreTelephonyClient == nil) {
EAPLOG_FL(LOG_ERR, "failed to get the CoreTelephonyClient instance");
return FALSE;
}
userPreferredSubscriptionCtx = SubscriptionContextUserPreferredGet(coreTelephonyClient);
if (userPreferredSubscriptionCtx == nil) {
EAPLOG_FL(LOG_ERR, "failed to get the user preferred subscription context");
return FALSE;
}
protection_type = [coreTelephonyClient context:userPreferredSubscriptionCtx
supportedIdentityProtectionFor:kCTEncryptedIdentityWiFiHotspot error:&error];
if (error) {
EAPLOG_FL(LOG_ERR,
"CoreTelephonyClient.supportedIdentityProtectionFor failed with "
"error: %@", error);
return FALSE;
}
*isSupported = (protection_type == CTIdentityProtectionTypePseudonym);
return TRUE;
}
}

CFStringRef
_SIMCopyOOBPseudonym(void)
{
@autoreleasepool {
NSString *ret = nil;
NSError *error = nil;
CTXPCServiceSubscriptionContext *userPreferredSubscriptionCtx = nil;
CTIdentityProtectionType protection_type;

CoreTelephonyClient *coreTelephonyClient = [[CoreTelephonyClient alloc] init];
if (coreTelephonyClient == nil) {
EAPLOG_FL(LOG_ERR, "failed to get the CoreTelephonyClient instance");
return NULL;
}
userPreferredSubscriptionCtx = SubscriptionContextUserPreferredGet(coreTelephonyClient);
if (userPreferredSubscriptionCtx == nil) {
EAPLOG_FL(LOG_ERR, "failed to get the user preferred subscription context");
return NULL;
}
ret = [coreTelephonyClient context:userPreferredSubscriptionCtx
getPseudoIdentityFor:kCTEncryptedIdentityWiFiHotspot error:&error];
if (error) {
EAPLOG_FL(LOG_ERR,
"CoreTelephonyClient.getPseudoIdentityFor failed with "
"error: %@", error);
return NULL;
}
return (__bridge_retained CFStringRef)ret;
}
}

CFDictionaryRef
_SIMCopyEncryptedIMSIInfo(EAPType type)
{
@autoreleasepool {
NSError *error = nil;
NSString *imsi = nil;
NSString *imsi_with_prefix = nil;
NSString *imsi_to_encrypt = nil;
NSString *realm = nil;
CTXPCServiceSubscriptionContext *userPreferredSubscriptionCtx = nil;
NSDictionary *ret_encrypted = nil;

CoreTelephonyClient *coreTelephonyclient = [[CoreTelephonyClient alloc] init];
if (!coreTelephonyclient) {
EAPLOG_FL(LOG_ERR, "failed to get the CoreTelephonyClient instance");
return NULL;
}
userPreferredSubscriptionCtx = SubscriptionContextUserPreferredGet(coreTelephonyclient);
if (!userPreferredSubscriptionCtx) {
EAPLOG_FL(LOG_ERR, "failed to get the user preferred subscription context");
return NULL;
}
imsi = (__bridge_transfer NSString *)_SIMCopyIMSI(NULL);
if (!imsi) {
return NULL;
}
realm = (__bridge_transfer NSString *)_SIMCopyRealm(NULL);
switch(type) {
case kEAPTypeEAPSIM:
imsi_with_prefix = [NSString stringWithFormat:@"1%@", imsi];
break;
default:
case kEAPTypeEAPAKA:
imsi_with_prefix = [NSString stringWithFormat:@"0%@", imsi];
}
if (realm) {
imsi_to_encrypt = [NSString stringWithFormat:@"%@@%@", imsi_with_prefix, realm];
} else {
imsi_to_encrypt = imsi_with_prefix;
}

ret_encrypted = [coreTelephonyclient context:userPreferredSubscriptionCtx getEncryptedIdentity:imsi_to_encrypt error:&error];
if (error) {
EAPLOG_FL(LOG_ERR,
"CoreTelephonyClient.getEncryptedIdentity failed with "
"error: %@", error);
ret_encrypted = nil;
}
return (__bridge_retained CFDictionaryRef)ret_encrypted;
}
}

void
_SIMReportDecryptionError(CFDataRef encryptedIdentity)
{
@autoreleasepool {
NSError *error = nil;
CTXPCServiceSubscriptionContext *userPreferredSubscriptionCtx = nil;

CoreTelephonyClient *coreTelephonyclient = [[CoreTelephonyClient alloc] init];
if (!coreTelephonyclient) {
EAPLOG_FL(LOG_ERR, "failed to get the CoreTelephonyClient instance");
return;
}
userPreferredSubscriptionCtx = SubscriptionContextUserPreferredGet(coreTelephonyclient);
if (!userPreferredSubscriptionCtx) {
EAPLOG_FL(LOG_ERR, "failed to get the user preferred subscription context");
return;
}
if (userPreferredSubscriptionCtx) {
error = [coreTelephonyclient context:userPreferredSubscriptionCtx evaluateMobileSubscriberIdentity:(__bridge NSData*)encryptedIdentity];
if (error) {
EAPLOG_FL(LOG_ERR,
"CoreTelephonyClient.evaluateMobileSubscriberIdentity failed with "
"error: %@", error);
}
}
return;
}
}

CFDictionaryRef
_SIMCreateAuthResponse(CFStringRef slotUUID, CFDictionaryRef auth_params)
{
@autoreleasepool {
CTXPCServiceSubscriptionContext *preferredSubscriptionCtx = nil;
__block CFDictionaryRef retAuthInfo = NULL;

CoreTelephonyClient *coreTelephonyclient = [[CoreTelephonyClient alloc] init];
if (!coreTelephonyclient) {
EAPLOG_FL(LOG_ERR, "failed to get the CoreTelephonyClient instance");
return NULL;
}
if (slotUUID) {
/* carrier Wi-Fi calling case */
NSUUID *uuid = [[NSUUID alloc] initWithUUIDString:(__bridge NSString *)slotUUID];
preferredSubscriptionCtx = SubscriptionContextMatchingSlotGet(coreTelephonyclient, uuid);
} else {
/* carrier hotspot case */
preferredSubscriptionCtx = SubscriptionContextUserPreferredGet(coreTelephonyclient);
}
if (preferredSubscriptionCtx) {
__block dispatch_semaphore_t semaphore;

semaphore = dispatch_semaphore_create(0);
if (semaphore == NULL) {
EAPLOG_FL(LOG_ERR, "dispatch_semaphore_create() failed");
return NULL;
}
CTSubscriberAuthDataHolder* authInputParams =
[[CTSubscriberAuthDataHolder alloc] initWithData:(__bridge NSDictionary *)auth_params];
[coreTelephonyclient generateAuthenticationInfoUsingSim:preferredSubscriptionCtx
authParams:authInputParams completion:^(CTSubscriberAuthDataHolder *authInfo, NSError *error) {
if (error) {
EAPLOG_FL(LOG_ERR,
"CoreTelephonyClient.generateAuthenticationInfoUsingSim failed with "
"error: %@", error);
} else {
retAuthInfo = (__bridge_retained CFDictionaryRef)authInfo.data;
}
dispatch_semaphore_signal(semaphore);
}];
{
dispatch_time_t t;
#define WAIT_TIME_SECONDS 20
t = dispatch_time(DISPATCH_TIME_NOW, WAIT_TIME_SECONDS * NSEC_PER_SEC);
if (dispatch_semaphore_wait(semaphore, t) != 0) {
EAPLOG_FL(LOG_NOTICE,
"timed out while waiting for response");
}
}
}
return retAuthInfo;
}
}

/**
** SIMAuthenticate{SIM,AKA}
**/

STATIC CFDictionaryRef
make_gsm_request(const uint8_t * rand_p)
{
CFDictionaryRef dict;
const void * keys[2];
CFDataRef rand;
const void * values[2];

rand = CFDataCreate(NULL, rand_p, SIM_RAND_SIZE);
keys[0] = kCTSimSupportUICCAuthenticationTypeKey;
values[0] = kCTSimSupportUICCAuthenticationTypeEAPSIM;
keys[1] = kCTSimSupportUICCAuthenticationRandKey;
values[1] = rand;

dict = CFDictionaryCreate(NULL,
(const void * * )keys,
(const void * *)values,
sizeof(keys) / sizeof(keys[0]),
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
CFRelease(rand);
return (dict);
}

STATIC CFDictionaryRef
make_aka_request(CFDataRef rand, CFDataRef autn)
{
const void * keys[3];
const void * values[3];

keys[0] = kCTSimSupportUICCAuthenticationTypeKey;
values[0] = kCTSimSupportUICCAuthenticationTypeEAPAKA;
keys[1] = kCTSimSupportUICCAuthenticationRandKey;
values[1] = rand;
keys[2] = kCTSimSupportUICCAuthenticationAutnKey;
values[2] = autn;

return (CFDictionaryCreate(NULL,
(const void * * )keys,
(const void * *)values,
sizeof(keys) / sizeof(keys[0]),
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks));
}

STATIC bool
getKcSRESFromResponse(CFDictionaryRef response,
uint8_t * kc_p, uint8_t * sres_p)
{
CFDataRef data;
CFRange range;
bool ret = FALSE;

/* get the Kc bytes */
data = CFDictionaryGetValue(response,
kCTSimSupportUICCAuthenticationKcKey);
if (data == NULL) {
data = CFDictionaryGetValue(response,
kCTSimSupportSIMAuthenticationKc);
}
if (data == NULL || CFDataGetLength(data) != SIM_KC_SIZE) {
EAPLOG_FL(LOG_NOTICE, "bogus Kc value");
goto done;
}
range = CFRangeMake(0, SIM_KC_SIZE);
CFDataGetBytes(data, range, kc_p);

/* get the SRES bytes */
data = CFDictionaryGetValue(response,
kCTSimSupportUICCAuthenticationSresKey);
if (data == NULL) {
data = CFDictionaryGetValue(response,
kCTSimSupportSIMAuthenticationSres);
}
if (data == NULL || CFDataGetLength(data) != SIM_SRES_SIZE) {
EAPLOG_FL(LOG_NOTICE, "bogus SRES value");
goto done;
}
range = CFRangeMake(0, SIM_SRES_SIZE);
CFDataGetBytes(data, range, sres_p);
ret = TRUE;

done:
return (ret);
}

#define N_ATTEMPTS 3

STATIC CFDictionaryRef
SIMCreateAuthResponse(CFStringRef slotUUID, CFDictionaryRef request)
{
int i;
CFDictionaryRef response = NULL;

for (i = 0; i < N_ATTEMPTS; i++) {
response = _SIMCreateAuthResponse(slotUUID, request);
if (response) {
break;
}
}
return (response);
}

bool
SIMAuthenticateGSM(CFDictionaryRef properties, const uint8_t * rand_p, int count,
uint8_t * kc_p, uint8_t * sres_p)
{
int i;
bool ret = false;
CFStringRef slotUUID = NULL;

if (properties != NULL) {
slotUUID = isA_CFString(CFDictionaryGetValue(properties,
kCTSimSupportUICCAuthenticationSlotUUIDKey));
}
for (i = 0; i < count; i++) {
CFDictionaryRef request;
CFDictionaryRef response = NULL;

request = make_gsm_request(rand_p + SIM_RAND_SIZE * i);
response = SIMCreateAuthResponse(slotUUID, request);
CFRelease(request);
if (response != NULL) {
ret = getKcSRESFromResponse(response,
kc_p + SIM_KC_SIZE * i,
sres_p + SIM_SRES_SIZE * i);
CFRelease(response);
}
else {
EAPLOG_FL(LOG_NOTICE, "Could not access SIM");
ret = false;
}
if (ret == false) {
break;
}
}
return (ret);
}

/*
1) Success, UIM returns Res, Ck, and Ik
2) Sync failure, UIM returns Auts
3) Auth Reject, no returned parameters.
*/
STATIC void
AKAAuthResultsSetValuesWithResponse(AKAAuthResultsRef results,
CFDictionaryRef response)
{
CFDataRef ck;
CFDataRef ik;
CFDataRef res;

AKAAuthResultsInit(results);
ck = CFDictionaryGetValue(response,
kCTSimSupportUICCAuthenticationCkKey);
ik = CFDictionaryGetValue(response,
kCTSimSupportUICCAuthenticationIkKey);
res = CFDictionaryGetValue(response,
kCTSimSupportUICCAuthenticationResKey);
if (ck != NULL && ik != NULL && res != NULL) {
AKAAuthResultsSetCK(results, ck);
AKAAuthResultsSetIK(results, ik);
AKAAuthResultsSetRES(results, res);
}
else {
CFDataRef auts;

auts = CFDictionaryGetValue(response,
kCTSimSupportUICCAuthenticationAutsKey);
if (auts != NULL) {
AKAAuthResultsSetAUTS(results, auts);
}
}
return;
}

bool
SIMAuthenticateAKA(CFDictionaryRef properties, CFDataRef rand, CFDataRef autn, AKAAuthResultsRef results)
{
CFDictionaryRef request;
CFDictionaryRef response = NULL;
bool success = false;
CFStringRef slotUUID = NULL;

AKAAuthResultsInit(results);
if (properties != NULL) {
slotUUID = isA_CFString(CFDictionaryGetValue(properties,
kCTSimSupportUICCAuthenticationSlotUUIDKey));
}
request = make_aka_request(rand, autn);
response = SIMCreateAuthResponse(slotUUID, request);
CFRelease(request);
if (response != NULL) {
AKAAuthResultsSetValuesWithResponse(results, response);
CFRelease(response);
success = true;
}
else {
EAPLOG_FL(LOG_NOTICE, "Could not access SIM");
}
return (success);
}

#pragma mark - SIMStatusIndicator Interface

__attribute__((visibility("hidden")))
@interface SIMStatusIndicator : NSObject <CoreTelephonyClientSubscriberDelegate> {

}

@property (nonatomic, strong, nullable) CoreTelephonyClient *coreTelephonyClient;
@property (nonatomic, strong) dispatch_queue_t queue;
@property SIMAccessConnectionCallback callback;
@property CFRunLoopRef runloop;
@property CFStringRef runloopMode;
@property CFTypeRef applicationContext;

- (void) createConnection;

@end

#pragma mark -

@implementation SIMStatusIndicator

- (id)init {
if ((self = [super init])) {
EAPLOG_FL(LOG_NOTICE, "SIMStatusIndicator initialized.");
}
return self;
}

- (void) createConnection {
self.queue = dispatch_queue_create("SIM status indicator queue", NULL);
self.coreTelephonyClient = [[CoreTelephonyClient alloc] initWithQueue:_queue];
self.coreTelephonyClient.delegate = self;
}

#pragma mark CoreTelephonyClientSubscriberDelegate

- (void)simStatusDidChange:(CTXPCServiceSubscriptionContext *)context status:(NSString *)status {
static NSString *lastStatus = nil;

if (context && context.userDataPreferred && [context.userDataPreferred boolValue]) {
if ([status isEqualToString:lastStatus]) {
return;
}
lastStatus = status;
CFRunLoopPerformBlock(self.runloop, self.runloopMode,
^{
self.callback((__bridge CFTypeRef)self, (__bridge CFStringRef)status, (void *)self.applicationContext);
});
CFRunLoopWakeUp(self.runloop);
}
}

@end

CFTypeRef
_SIMAccessConnectionCreate(void)
{
@autoreleasepool {
SIMStatusIndicator *status_indicator = [[SIMStatusIndicator alloc] init];
[status_indicator createConnection];
return CFBridgingRetain(status_indicator);
}
}

void
_SIMAccessConnectionRegisterForNotification(CFTypeRef connection, SIMAccessConnectionCallback callback, void *info, CFRunLoopRef runLoop,
CFStringRef runloopMode) {
@autoreleasepool {
SIMStatusIndicator *indicator = (__bridge SIMStatusIndicator *)connection;
indicator.callback = callback;
indicator.runloop = runLoop;
indicator.runloopMode = runloopMode;
indicator.applicationContext = (CFTypeRef)info;
}
}

#endif /* TARGET_OS_IPHONE */

void
AKAAuthResultsSetCK(AKAAuthResultsRef results, CFDataRef ck)
{
my_FieldSetRetainedCFType(&results->ck, ck);
return;
}

void
AKAAuthResultsSetIK(AKAAuthResultsRef results, CFDataRef ik)
{
my_FieldSetRetainedCFType(&results->ik, ik);
return;
}

void
AKAAuthResultsSetRES(AKAAuthResultsRef results, CFDataRef res)
{
my_FieldSetRetainedCFType(&results->res, res);
return;
}

void
AKAAuthResultsSetAUTS(AKAAuthResultsRef results, CFDataRef auts)
{
my_FieldSetRetainedCFType(&results->auts, auts);
return;
}

void
AKAAuthResultsInit(AKAAuthResultsRef results)
{
bzero(results, sizeof(*results));
return;
}

void
AKAAuthResultsRelease(AKAAuthResultsRef results)
{
AKAAuthResultsSetCK(results, NULL);
AKAAuthResultsSetIK(results, NULL);
AKAAuthResultsSetRES(results, NULL);
AKAAuthResultsSetAUTS(results, NULL);
return;
}