MercurialMYCrypto / file revision
summary | shortlog | changelog | graph | tags | branches | files | changeset | file | latest | revisions | annotate | diff | raw
MYCryptor.m
author snej@snej.local
Sat Apr 04 22:56:13 2009 -0700 (2009-04-04)
changeset 1 60e4cbbb5128
child 2 8982b8fada63
permissions -rw-r--r--
Code cleanup, more header comments. 
     1 //

     2 //  Cryptor.m

     3 //  MYCrypto

     4 //

     5 //  Created by Jens Alfke on 3/21/09.

     6 //  Copyright 2009 Jens Alfke. All rights reserved.

     7 //

     8 

     9 #import "MYCryptor.h"

    10 #import "MYDigest.h"

    11 #import "Test.h"

    12 

    13 #if USE_IPHONE_API

    14 #import <Security/SecRandom.h>

    15 #else

    16 #import "MYCrypto_Private.h"

    17 #import "MYKeychain.h"

    18 #import <stdlib.h>

    19 #endif

    20 

    21 

    22 NSString* const CryptorErrorDomain = @"CCCryptor";

    23 

    24 #if !USE_IPHONE_API

    25 static BOOL generateRandomBytes(CSSM_CSP_HANDLE module, uint32_t lengthInBytes, void *dstBytes);

    26 #endif

    27 

    28 

    29 @interface MYCryptor ()

    30 @property (readwrite, retain) NSError *error;

    31 @end

    32 

    33 

    34 

    35 @implementation MYCryptor

    36 

    37 

    38 + (NSData*) randomKeyOfLength: (size_t)length {

    39     NSParameterAssert(length<100000);

    40     uint8_t *bytes = malloc(length);

    41     if (!bytes) return nil;

    42 #if USE_IPHONE_API

    43     BOOL ok = SecRandomCopyBytes(kSecRandomDefault, length,bytes) >= 0;

    44 #else

    45     BOOL ok = generateRandomBytes([[MYKeychain defaultKeychain] CSPHandle], length, bytes);

    46 #endif

    47     if (ok)

    48         return [NSData dataWithBytesNoCopy: bytes length: length freeWhenDone: YES];

    49     else {

    50         free(bytes);

    51         return nil;

    52     }

    53 }

    54 

    55 + (NSData*) keyOfLength: (size_t)lengthInBits fromPassphrase: (NSString*)passphrase

    56 {

    57     size_t lengthInBytes = (lengthInBits + 7)/8;

    58     MYDigest *digest = [[passphrase dataUsingEncoding: NSUTF8StringEncoding] my_SHA256Digest];

    59     if (lengthInBytes <= digest.length)

    60         return [digest.asData subdataWithRange: NSMakeRange(0,lengthInBytes)];

    61     else

    62         return nil;

    63 }

    64 

    65 

    66 - (id) initWithKey: (NSData*)key

    67          algorithm: (CCAlgorithm)algorithm

    68          operation: (CCOperation)op {

    69     self = [super init];

    70     if (self) {

    71         NSParameterAssert(key);

    72         _key = [key copy];

    73         _operation = op;

    74         _algorithm = algorithm;

    75         _options = kCCOptionPKCS7Padding;

    76     }

    77     return self;

    78 }

    79 

    80 - (id) initEncryptorWithKey: (NSData*)key algorithm: (CCAlgorithm)algorithm {

    81     return [self initWithKey: key algorithm: algorithm operation: kCCEncrypt];

    82 }

    83 

    84 - (id) initDecryptorWithKey: (NSData*)key algorithm: (CCAlgorithm)algorithm {

    85     return [self initWithKey: key algorithm: algorithm operation: kCCDecrypt];

    86 }

    87 

    88 - (void) dealloc

    89 {

    90     if (_cryptor)

    91         CCCryptorRelease(_cryptor);

    92     [_key autorelease];

    93     [_output autorelease];

    94     [_outputStream release];

    95     [super dealloc];

    96 }

    97 

    98 

    99 @synthesize key=_key, algorithm=_algorithm, options=_options,

   100     outputStream=_outputStream, error=_error;

   101 

   102 

   103 - (BOOL) _check: (CCCryptorStatus)status {

   104     if (status == kCCSuccess)

   105         return YES;

   106     else {

   107         Warn(@"MYCryptor: CCCryptor error %i", status);

   108         self.error = [NSError errorWithDomain: CryptorErrorDomain code: status userInfo: nil];

   109         return NO;

   110     }

   111 }

   112 

   113 

   114 - (BOOL) _outputBytes: (const void*)bytes length: (size_t)length {

   115     if (_outputStream) {

   116         NSInteger written = [_outputStream write: bytes maxLength: length];

   117         if (written < 0) {

   118             self.error = _outputStream.streamError;

   119             if (_error)

   120                 Warn(@"MYCryptor: NSOutputStream error %@", _error);

   121             else

   122                 [self _check: kMYCryptorErrorOutputStreamChoked];

   123             return NO;

   124         } else if (written < length) {

   125             [self _check: kMYCryptorErrorOutputStreamChoked];

   126             return NO;

   127         }

   128     } else if (length > 0) {

   129         [_output appendBytes: bytes length: length];

   130     }

   131     return YES;

   132 }

   133 

   134 

   135 - (BOOL) _start {

   136     if (!_cryptor && !_error) {

   137         if ([self _check: CCCryptorCreate(_operation, _algorithm, _options,

   138                                           _key.bytes, _key.length, NULL, &_cryptor)]) {

   139             _output = [[NSMutableData alloc] initWithCapacity: 1024];

   140         }

   141     }

   142     return !_error;

   143 }

   144 

   145 

   146 - (BOOL) addBytes: (const void*)bytes length: (size_t)length {

   147     if (length > 0) {

   148         NSParameterAssert(bytes!=NULL);

   149         if(!_error && (_cryptor || [self _start])) {

   150             size_t outputLength = CCCryptorGetOutputLength(_cryptor,length,false);

   151             void *output = malloc(outputLength);

   152             if ([self _check: CCCryptorUpdate(_cryptor, bytes, length,

   153                                               output, outputLength, &outputLength)]) {

   154                 [self _outputBytes: output length: outputLength];

   155             }

   156             free(output);

   157         }

   158     }

   159     return !_error;

   160 }

   161 

   162 - (BOOL) addData: (NSData*)data

   163 {

   164     return [self addBytes: data.bytes length: data.length];

   165 }

   166 

   167 - (BOOL) addString: (NSString*)str {

   168     return [self addData: [str dataUsingEncoding: NSUTF8StringEncoding]];

   169 }

   170 

   171 

   172 - (BOOL) addFromStream: (NSInputStream*)input

   173 {

   174     uint8_t inputBuffer[1024];

   175     size_t avail;

   176     while (!_error && input.hasBytesAvailable) {

   177         avail = sizeof(inputBuffer);

   178         NSInteger nRead = [input read: inputBuffer maxLength: sizeof(inputBuffer)];

   179         if (nRead < 0) {

   180             self.error = input.streamError;

   181             return NO;

   182         } else if (nRead == 0) {

   183             break;

   184         } else if (![self addBytes: inputBuffer length: nRead])

   185             return NO;

   186     }

   187     return YES;

   188 }

   189 

   190 

   191 - (BOOL) finish

   192 {

   193     if(!_error && (_cryptor || [self _start])) {

   194         size_t outputLength = 100; //CCCryptorGetOutputLength(_cryptor,1,true);

   195         void *output = malloc(outputLength);

   196         if ([self _check: CCCryptorFinal(_cryptor, output, outputLength, &outputLength)]) {

   197             [self _outputBytes: output length: outputLength];

   198         }

   199         free(output);

   200     }

   201     CCCryptorRelease(_cryptor);

   202     _cryptor = NULL;

   203     return !_error;

   204 }

   205 

   206 

   207 - (NSData*) outputData {

   208     if (_cryptor) [self finish];

   209     if(_error) {

   210         [_output release];

   211         _output = nil;

   212     }

   213     return _output;

   214 }

   215 

   216 - (NSString*) outputString {

   217     NSData *output = self.outputData;

   218     if (output) {

   219         NSString *str = [[NSString alloc] initWithData: output encoding: NSUTF8StringEncoding];

   220         return [str autorelease];

   221     } else

   222         return nil;

   223 }

   224 

   225 

   226 // NSStream delegate method

   227 - (void)stream:(NSStream *)stream handleEvent:(NSStreamEvent)eventCode {

   228     switch (eventCode) {

   229         case NSStreamEventHasBytesAvailable:

   230             [self addFromStream: (NSInputStream*)stream];

   231             break;

   232         case NSStreamEventEndEncountered:

   233             [self finish];

   234             break;

   235         case NSStreamEventErrorOccurred:

   236             if (!_error)

   237                 self.error = stream.streamError;

   238             break;

   239         default:

   240             break;

   241     }

   242 }

   243 

   244 

   245 

   246 @end

   247 

   248 

   249 

   250 

   251 #if !USE_IPHONE_API

   252 static BOOL generateRandomBytes(CSSM_CSP_HANDLE module, uint32_t lengthInBytes, void *dstBytes) {

   253     // Adapted from code in Keychain.framework's KeychainUtils.m by Wade Tregaskis.

   254     CSSM_CC_HANDLE ccHandle;

   255     if (!checkcssm(CSSM_CSP_CreateRandomGenContext(module, CSSM_ALGID_APPLE_YARROW, NULL,

   256                                                   lengthInBytes, &ccHandle),

   257                    @"CSSM_CSP_CreateRandomGenContext"))

   258         return NO;

   259     CSSM_DATA data = {.Data=dstBytes, .Length=lengthInBytes};

   260     BOOL ok = checkcssm(CSSM_GenerateRandom(ccHandle, &data), @"CSSM_GenerateRandom");

   261     CSSM_DeleteContext(ccHandle);

   262     return ok;

   263 }

   264 #endif

   265 

   266 

   267 

   268 

   269 TestCase(MYCryptor) {

   270     // Encryption:

   271     NSData *key = [MYCryptor randomKeyOfLength: kCCKeySizeAES256];

   272     Log(@"Key = %@",key);

   273     MYCryptor *enc = [[MYCryptor alloc] initEncryptorWithKey: key algorithm: kCCAlgorithmAES128];

   274     CAssert(enc);

   275     CAssert([enc addString: @"This is a test. "]);

   276     CAssert([enc addString: @"This is only a test."]);

   277     CAssertEqual(enc.error, nil);

   278     NSData *encrypted = enc.outputData;

   279     CAssertEqual(enc.error, nil);

   280     CAssert(encrypted.length > 0);

   281     [enc release];

   282     Log(@"Encrypted = %@", encrypted);

   283     

   284     // Decryption:

   285     MYCryptor *dec = [[MYCryptor alloc] initDecryptorWithKey: key algorithm: kCCAlgorithmAES128];

   286     CAssert(dec);

   287     CAssert([dec addData: encrypted]);

   288     NSString *decrypted = dec.outputString;

   289     CAssertEqual(dec.error, nil);

   290     [dec release];

   291     Log(@"Decrypted = '%@'", decrypted);

   292     CAssertEqual(decrypted, @"This is a test. This is only a test.");

   293     

   294     // Encryption to stream:

   295     key = [MYCryptor randomKeyOfLength: kCCKeySizeAES256];

   296     Log(@"Key = %@",key);

   297     enc = [[MYCryptor alloc] initEncryptorWithKey: key algorithm: kCCAlgorithmAES128];

   298     CAssert(enc);

   299     enc.outputStream = [NSOutputStream outputStreamToMemory];

   300     [enc.outputStream open];

   301     CAssert([enc addString: @"This is a test. "]);

   302     CAssert([enc addString: @"This is only a test."]);

   303     CAssert([enc finish]);

   304     CAssertEqual(enc.error, nil);

   305     encrypted = [[enc.outputStream propertyForKey: NSStreamDataWrittenToMemoryStreamKey] retain];

   306     CAssert(encrypted.length > 0);

   307     [enc release];

   308     Log(@"Encrypted = %@", encrypted);

   309     

   310     dec = [[MYCryptor alloc] initDecryptorWithKey: key algorithm: kCCAlgorithmAES128];

   311     CAssert(dec);

   312     dec.outputStream = [NSOutputStream outputStreamToMemory];

   313     [dec.outputStream open];

   314     CAssert([dec addData: encrypted]);

   315     CAssert([dec finish]);

   316     CAssertEqual(dec.error, nil);

   317     NSData *decryptedData = [dec.outputStream propertyForKey: NSStreamDataWrittenToMemoryStreamKey];

   318     [dec release];

   319     decrypted = [[NSString alloc] initWithData: decryptedData

   320                                                       encoding: NSUTF8StringEncoding];

   321     Log(@"Decrypted = '%@'", decrypted);

   322     CAssertEqual(decrypted, @"This is a test. This is only a test.");

   323     [encrypted release];

   324     [decrypted release];

   325 }
MYCrypto