KeychainCircle/KCSRPContext.m

   1 //
   2 //  SRPSession.m
   3 //  Security
   4 //
   5 //
   6
   7
   8 #import <Foundation/Foundation.h>
   9 #import "KCSRPContext.h"
  10
  11 #include <os/base.h>
  12
  13 #include <corecrypto/ccsrp.h>
  14 #include <corecrypto/ccsha2.h>
  15 #include <corecrypto/ccdh_gp.h>
  16 #include <corecrypto/ccder.h>
  17
  18 #import "NSError+KCCreationHelpers.h"
  19
  20 static const NSStringEncoding srpStringEncoding = NSUTF8StringEncoding;
  21
  22 @interface KCSRPContext ()
  23 @property (readwrite) ccsrp_ctx* context;
  24 @property (readwrite) struct ccrng_state *rng;
  25 @property (readwrite) NSString* user;
  26 @end
  27
  28 @implementation KCSRPContext
  29
  30 + (KCSRPContext*) createWithUser: (NSString*) user
  31                     digestInfo: (const struct ccdigest_info *) di
  32                          group: (ccsrp_const_gp_t) gp
  33                   randomSource: (struct ccrng_state *) rng {
  34     return [[self alloc] initWithUser:user
  35                            digestInfo:di
  36                                 group:gp
  37                          randomSource:rng];
  38 }
  39
  40 - (NSData*) dataForPassword: (NSString*) password {
  41     return [password dataUsingEncoding:srpStringEncoding];
  42 }
  43
  44 -  (nullable const char *) userNameString {
  45     return [self.user cStringUsingEncoding:srpStringEncoding];
  46 }
  47
  48 - (instancetype) initWithUser: (NSString*) user
  49                    digestInfo: (const struct ccdigest_info *) di
  50                         group: (ccsrp_const_gp_t) gp
  51                  randomSource: (struct ccrng_state *) rng
  52 {
  53     self = [super init];
  54
  55     self.context = malloc(ccsrp_sizeof_srp(di, gp));
  56     ccsrp_ctx_init(self.context, di, gp);
  57
  58     self.user = user;
  59     self.rng = rng;
  60
  61     return self;
  62 }
  63
  64 - (void) finalize {
  65     ccsrp_ctx_clear(ccsrp_ctx_di(self.context),
  66                     ccsrp_ctx_gp(self.context),
  67                     self.context);
  68
  69     free(self.context);
  70 }
  71
  72 - (NSData*) getKey {
  73     size_t key_length = 0;
  74     const void * key = ccsrp_get_session_key(self.context, &key_length);
  75
  76     return key ? [NSData dataWithBytesNoCopy:(void *)key length:key_length freeWhenDone:false] : nil;
  77 }
  78
  79 - (bool) isAuthenticated {
  80     return ccsrp_is_authenticated(self.context);
  81 }
  82
  83 @end
  84
  85
  86 @implementation KCSRPClientContext
  87
  88 - (NSData*) copyStart: (NSError**) error {
  89     NSMutableData* A_data = [NSMutableData dataWithLength: ccsrp_exchange_size(self.context)];
  90
  91     int result = ccsrp_client_start_authentication(self.context, self.rng, A_data.mutableBytes);
  92     if (!CoreCryptoError(result, error, @"Start packet copy failed: %d", result)) {
  93         A_data = NULL;
  94     }
  95
  96     return A_data;
  97 }
  98
  99 static bool ExactDataSizeRequirement(NSData* data, NSUInteger expectedLength, NSError**error, NSString* name) {
 100     return RequirementError(data.length == expectedLength, error, @"%@ incorrect size, Expected %ld, got %ld", name, (unsigned long)expectedLength, (unsigned long)data.length);
 101 }
 102
 103 - (nullable NSData*) copyResposeToChallenge: (NSData*) B_data
 104                                    password: (NSString*) password
 105                                        salt: (NSData*) salt
 106                                       error: (NSError**) error {
 107
 108     if (!ExactDataSizeRequirement(B_data, ccsrp_exchange_size(self.context), error, @"challenge data"))
 109         return nil;
 110
 111     NSMutableData* M_data = [NSMutableData dataWithLength: ccsrp_session_size(self.context)];
 112     NSData* passwordData = [self dataForPassword: password];
 113
 114     int result = ccsrp_client_process_challenge(self.context,
 115                                                 [self userNameString],
 116                                                 passwordData.length,
 117                                                 passwordData.bytes,
 118                                                 salt.length,
 119                                                 salt.bytes,
 120                                                 B_data.bytes,
 121                                                 M_data.mutableBytes);
 122
 123     if (!CoreCryptoError(result, error, @"Challenge processing failed: %d", result)) {
 124         M_data = NULL;
 125     }
 126
 127     return M_data;
 128 }
 129
 130 - (bool) verifyConfirmation: (NSData*) HAMK_data
 131                       error: (NSError**) error {
 132     if (!ExactDataSizeRequirement(HAMK_data, ccsrp_session_size(self.context), error, @"confirmation data"))
 133         return nil;
 134
 135     return ccsrp_client_verify_session(self.context, HAMK_data.bytes);
 136 }
 137
 138 @end
 139
 140 @interface KCSRPServerContext ()
 141 @property (readwrite) NSData* verifier;
 142 @end
 143
 144 @implementation KCSRPServerContext
 145
 146 - (bool) resetWithPassword: (NSString*) password
 147                      error: (NSError**) error {
 148     const int salt_length = 16;
 149
 150     NSMutableData* salt = [NSMutableData dataWithLength: salt_length];
 151     NSMutableData* verifier = [NSMutableData dataWithLength: ccsrp_ctx_sizeof_n(self.context)];
 152
 153     NSData* passwordData = [self dataForPassword: password];
 154
 155     int generateResult = ccsrp_generate_salt_and_verification(self.context,
 156                                                               self.rng,
 157                                                               [self userNameString],
 158                                                               passwordData.length,
 159                                                               passwordData.bytes,
 160                                                               salt.length,
 161                                                               salt.mutableBytes,
 162                                                               verifier.mutableBytes);
 163
 164     if (!CoreCryptoError(generateResult, error, @"Error generating SRP salt/verifier")) {
 165         return false;
 166     }
 167
 168     self.verifier = verifier;
 169     self->_salt = salt;
 170
 171     return true;
 172 }
 173
 174 - (instancetype) initWithUser: (NSString*)user
 175                      password: (NSString*)password
 176                    digestInfo: (const struct ccdigest_info *) di
 177                         group: (ccsrp_const_gp_t) gp
 178                  randomSource: (struct ccrng_state *) rng {
 179     self = [super initWithUser: user
 180                     digestInfo: di
 181                          group: gp
 182                   randomSource: rng];
 183
 184     if (![self resetWithPassword:password error:nil]) {
 185         return nil;
 186     }
 187
 188     return self;
 189 }
 190
 191 - (instancetype) initWithUser: (NSString*) user
 192                          salt: (NSData*) salt
 193                      verifier: (NSData*) verifier
 194                    digestInfo: (const struct ccdigest_info *) di
 195                         group: (ccsrp_const_gp_t) gp
 196                  randomSource: (struct ccrng_state *) rng {
 197     self = [super initWithUser: user
 198                     digestInfo: di
 199                          group: gp
 200                   randomSource: rng];
 201
 202     self.verifier = verifier;
 203     self->_salt = salt;
 204
 205     return self;
 206 }
 207
 208
 209 - (NSData*) copyChallengeFor: (NSData*) A_data
 210                        error: (NSError**) error {
 211     if (!ExactDataSizeRequirement(A_data, ccsrp_exchange_size(self.context), error, @"start data"))
 212         return nil;
 213
 214     NSMutableData* B_data = [NSMutableData dataWithLength: ccsrp_exchange_size(self.context)];
 215
 216     int result = ccsrp_server_start_authentication(self.context, self.rng,
 217                                                    [self userNameString],
 218                                                    self.salt.length, self.salt.bytes,
 219                                                    self.verifier.bytes, A_data.bytes,
 220                                                    B_data.mutableBytes);
 221
 222     if (!CoreCryptoError(result, error, @"Server start authentication failed: %d", result)) {
 223         B_data = NULL;
 224     }
 225
 226     return B_data;
 227 }
 228
 229 - (NSData*) copyConfirmationFor: (NSData*) M_data
 230                           error: (NSError**) error {
 231     if (!ExactDataSizeRequirement(M_data, ccsrp_session_size(self.context), error, @"response data"))
 232         return nil;
 233
 234     NSMutableData* HAMK_data = [NSMutableData dataWithLength: ccsrp_session_size(self.context)];
 235
 236     bool verify = ccsrp_server_verify_session(self.context, M_data.bytes, HAMK_data.mutableBytes);
 237
 238     if (!CoreCryptoError(!verify, error, @"SRP verification failed")) {
 239         HAMK_data = NULL;
 240     }
 241
 242     return HAMK_data;
 243 }
 244
 245 @end