Milestone 5: deliver embedded RDP sessions and lifecycle hardening

third_party/FreeRDP/client/iOS/Models/Encryptor.m

@@ -0,0 +1,206 @@
+/*
+ Password Encryptor
+
+ Copyright 2013 Thincast Technologies GmbH, Author: Dorian Johnson
+
+ This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+ If a copy of the MPL was not distributed with this file, You can obtain one at
+ http://mozilla.org/MPL/2.0/.
+ */
+
+/* We try to use CommonCrypto as much as possible. PBKDF2 was added to CommonCrypto in iOS 5, so use
+ * OpenSSL only as a fallback to do PBKDF2 on pre iOS 5 systems. */
+
+#import "Encryptor.h"
+#import <CommonCrypto/CommonKeyDerivation.h>
+#import <CommonCrypto/CommonCryptor.h>
+#import <CommonCrypto/CommonDigest.h>
+#import <openssl/evp.h> // For PBKDF2 on < 5.0
+#include <fcntl.h>
+
+#pragma mark -
+
+@interface Encryptor (Private)
+- (NSData *)randomInitializationVector;
+@end
+
+@implementation Encryptor
+@synthesize plaintextPassword = _plaintext_password;
+
+- (id)initWithPassword:(NSString *)plaintext_password
+{
+	if (plaintext_password == nil)
+		return nil;
+
+	if (!(self = [super init]))
+		return nil;
+
+	_plaintext_password = [plaintext_password retain];
+	const char *plaintext_password_data =
+	    [plaintext_password length] ? [plaintext_password UTF8String] : " ";
+
+	if (!plaintext_password_data || !strlen(plaintext_password_data))
+		[NSException raise:NSInternalInconsistencyException
+		            format:@"%s: plaintext password data is zero length!", __func__];
+
+	uint8_t *derived_key = calloc(1, TSXEncryptorPBKDF2KeySize);
+
+	if (CCKeyDerivationPBKDF != nullptr)
+	{
+		int ret = CCKeyDerivationPBKDF(
+		    kCCPBKDF2, plaintext_password_data, strlen(plaintext_password_data) - 1,
+		    (const uint8_t *)TSXEncryptorPBKDF2Salt, TSXEncryptorPBKDF2SaltLen, kCCPRFHmacAlgSHA1,
+		    TSXEncryptorPBKDF2Rounds, derived_key, TSXEncryptorPBKDF2KeySize);
+		// NSLog(@"CCKeyDerivationPBKDF ret = %d; key: %@", ret, [NSData
+		// dataWithBytesNoCopy:derived_key length:TWEncryptorPBKDF2KeySize freeWhenDone:NO]);
+
+		if (ret)
+		{
+			NSLog(@"%s: CCKeyDerivationPBKDF ret == %d, indicating some sort of failure.", __func__,
+			      ret);
+			free(derived_key);
+			[self autorelease];
+			return nil;
+		}
+	}
+	else
+	{
+		// iOS 4.x or earlier -- use OpenSSL
+		unsigned long ret = PKCS5_PBKDF2_HMAC_SHA1(
+		    plaintext_password_data, (int)strlen(plaintext_password_data) - 1,
+		    (const unsigned char *)TSXEncryptorPBKDF2Salt, TSXEncryptorPBKDF2SaltLen,
+		    TSXEncryptorPBKDF2Rounds, TSXEncryptorPBKDF2KeySize, derived_key);
+		// NSLog(@"PKCS5_PBKDF2_HMAC_SHA1 ret = %lu; key: %@", ret, [NSData
+		// dataWithBytesNoCopy:derived_key length:TWEncryptorPBKDF2KeySize freeWhenDone:NO]);
+
+		if (ret != 1)
+		{
+			NSLog(@"%s: PKCS5_PBKDF2_HMAC_SHA1 ret == %lu, indicating some sort of failure.",
+			      __func__, ret);
+			free(derived_key);
+			[self release];
+			return nil;
+		}
+	}
+
+	_encryption_key = [[NSData alloc] initWithBytesNoCopy:derived_key
+	                                               length:TSXEncryptorPBKDF2KeySize
+	                                         freeWhenDone:YES];
+	return self;
+}
+
+#pragma mark -
+#pragma mark Encrypting/Decrypting data
+
+- (NSData *)encryptData:(NSData *)plaintext_data
+{
+	if (![plaintext_data length])
+		return nil;
+
+	NSData *iv = [self randomInitializationVector];
+	NSMutableData *encrypted_data = [NSMutableData
+	    dataWithLength:[iv length] + [plaintext_data length] + TSXEncryptorBlockCipherBlockSize];
+	[encrypted_data replaceBytesInRange:NSMakeRange(0, [iv length]) withBytes:[iv bytes]];
+
+	size_t data_out_moved = 0;
+	int ret = CCCrypt(kCCEncrypt, TSXEncryptorBlockCipherAlgo, TSXEncryptorBlockCipherOptions,
+	                  [_encryption_key bytes], TSXEncryptorBlockCipherKeySize, [iv bytes],
+	                  [plaintext_data bytes], [plaintext_data length],
+	                  [encrypted_data mutableBytes] + [iv length],
+	                  [encrypted_data length] - [iv length], &data_out_moved);
+
+	switch (ret)
+	{
+		case kCCSuccess:
+			[encrypted_data setLength:[iv length] + data_out_moved];
+			return encrypted_data;
+
+		default:
+			NSLog(
+			    @"%s: uncaught error, ret CCCryptorStatus = %d (plaintext len = %lu; buffer size = "
+			    @"%lu)",
+			    __func__, ret, (unsigned long)[plaintext_data length],
+			    (unsigned long)([encrypted_data length] - [iv length]));
+			return nil;
+	}
+
+	return nil;
+}
+
+- (NSData *)decryptData:(NSData *)encrypted_data
+{
+	if ([encrypted_data length] <= TSXEncryptorBlockCipherBlockSize)
+		return nil;
+
+	NSMutableData *plaintext_data =
+	    [NSMutableData dataWithLength:[encrypted_data length] + TSXEncryptorBlockCipherBlockSize];
+	size_t data_out_moved = 0;
+
+	int ret =
+	    CCCrypt(kCCDecrypt, TSXEncryptorBlockCipherAlgo, TSXEncryptorBlockCipherOptions,
+	            [_encryption_key bytes], TSXEncryptorBlockCipherKeySize, [encrypted_data bytes],
+	            [encrypted_data bytes] + TSXEncryptorBlockCipherBlockSize,
+	            [encrypted_data length] - TSXEncryptorBlockCipherBlockSize,
+	            [plaintext_data mutableBytes], [plaintext_data length], &data_out_moved);
+
+	switch (ret)
+	{
+		case kCCSuccess:
+			[plaintext_data setLength:data_out_moved];
+			return plaintext_data;
+
+		case kCCBufferTooSmall: // Our output buffer is big enough to decrypt valid data. This
+		                        // return code indicates malformed data.
+		case kCCAlignmentError: // Shouldn't get this, since we're using padding.
+		case kCCDecodeError:    // Wrong key.
+			return nil;
+
+		default:
+			NSLog(@"%s: uncaught error, ret CCCryptorStatus = %d (encrypted data len = %lu; buffer "
+			      @"size = %lu; dom = %lu)",
+			      __func__, ret, (unsigned long)[encrypted_data length],
+			      (unsigned long)[plaintext_data length], data_out_moved);
+			return nil;
+	}
+
+	return nil;
+}
+
+- (NSData *)encryptString:(NSString *)plaintext_string
+{
+	return [self encryptData:[plaintext_string dataUsingEncoding:NSUTF8StringEncoding]];
+}
+
+- (NSString *)decryptString:(NSData *)encrypted_string
+{
+	return [[[NSString alloc] initWithData:[self decryptData:encrypted_string]
+	                              encoding:NSUTF8StringEncoding] autorelease];
+}
+
+- (NSData *)randomInitializationVector
+{
+	NSMutableData *iv = [NSMutableData dataWithLength:TSXEncryptorBlockCipherBlockSize];
+	int fd;
+
+	if ((fd = open("/dev/urandom", O_RDONLY)) < 0)
+		return nil;
+
+	NSInteger bytes_needed = [iv length];
+	char *p = [iv mutableBytes];
+
+	while (bytes_needed)
+	{
+		long bytes_read = read(fd, p, bytes_needed);
+
+		if (bytes_read < 0)
+			continue;
+
+		p += bytes_read;
+		bytes_needed -= bytes_read;
+	}
+
+	close(fd);
+	return iv;
+}
+
+@end