@appzung/react-native-code-push 5.7.1

package/ios/CodePush/JWT/Core/Algorithms/RSFamily/RSKeys/JWTCryptoKey.m

@@ -0,0 +1,230 @@
+//
+//  JWTCryptoKey.m
+//  JWT
+//
+//  Created by Lobanov Dmitry on 04.02.17.
+//  Copyright © 2017 JWTIO. All rights reserved.
+//
+
+#import "JWTCryptoKey.h"
+#import "JWTCryptoSecurity.h"
+#import "JWTBase64Coder.h"
+@interface JWTCryptoKeyBuilder()
++ (NSString *)keyTypeRSA;
++ (NSString *)keyTypeEC;
+@property (assign, nonatomic, readwrite) BOOL public;
+@property (assign, nonatomic, readwrite) NSString *keyType;
+@property (nonatomic, readonly) BOOL withKeyTypeRSA;
+@property (nonatomic, readonly) BOOL withKeyTypeEC;
+@end
+@implementation JWTCryptoKeyBuilder
++ (NSString *)keyTypeRSA {
+    return @"RSA";
+}
++ (NSString *)keyTypeEC {
+    return @"EC";
+}
+- (instancetype)keyTypeRSA {
+    self.keyType = [self.class keyTypeRSA];
+    return self;
+}
+- (instancetype)keyTypeEC {
+    self.keyType = [self.class keyTypeEC];
+    return self;
+}
+- (BOOL)withKeyTypeRSA {
+    return [self.keyType isEqualToString:self.class.keyTypeRSA];
+}
+- (BOOL)withKeyTypeEC {
+    return [self.keyType isEqualToString:self.class.keyTypeEC];
+}
+@end
+@interface JWTCryptoKey ()
+@property (copy, nonatomic, readwrite) NSString *tag;
+@property (assign, nonatomic, readwrite) SecKeyRef key;
+@property (copy, nonatomic, readwrite) NSData *rawKey;
+@end
+@interface JWTCryptoKey (Class)
++ (NSString *)uniqueTag;
+@end
+@implementation JWTCryptoKey (Class)
++ (NSString *)uniqueTag {
+    return [[NSUUID UUID].UUIDString stringByReplacingOccurrencesOfString:@"-" withString:@""].lowercaseString;
+}
+@end
+@implementation JWTCryptoKey (Parameters)
++ (NSString *)parametersKeyBuilder {
+    return NSStringFromSelector(_cmd);
+}
+@end
+@interface JWTCryptoKey (ParametersExtraction)
+- (NSString *)extractedSecKeyTypeWithParameters:(NSDictionary *)parameters;
+- (JWTCryptoKeyBuilder *)extractedBuilderWithParameters:(NSDictionary *)parameters;
+@end
+// Consider that both methods in this category should return non-nullable values
+@implementation JWTCryptoKey (ParametersExtraction)
+// Parameters are nil at that moment, could be used later for some purposes
+- (JWTCryptoKeyBuilder *)extractedBuilderWithParameters:(NSDictionary *)parameters {
+    return (JWTCryptoKeyBuilder *)parameters[[self.class parametersKeyBuilder]] ?: [JWTCryptoKeyBuilder new].keyTypeRSA;
+}
+// Parameters are nil at that moment, could be used later for some purposes
+- (NSString *)extractedSecKeyTypeWithParameters:(NSDictionary *)parameters {
+    JWTCryptoKeyBuilder *builder = [self extractedBuilderWithParameters:parameters];
+    NSString *result = nil;
+    if (builder.withKeyTypeEC) {
+        result = [JWTCryptoSecurity keyTypeEC];
+    }
+    return result ?: [JWTCryptoSecurity keyTypeRSA];
+}
+@end
+@implementation JWTCryptoKey
+- (instancetype)initWithData:(NSData *)data parameters:(NSDictionary *)parameters error:(NSError *__autoreleasing*)error {
+    return [super init];
+}
+- (instancetype)initWithBase64String:(NSString *)base64String parameters:(NSDictionary *)parameters error:(NSError *__autoreleasing*)error {
+    return [self initWithData:[JWTBase64Coder dataWithBase64UrlEncodedString:base64String] parameters:parameters error:error];
+}
+- (instancetype)initWithPemEncoded:(NSString *)encoded parameters:(NSDictionary *)parameters error:(NSError *__autoreleasing*)error {
+    //TODO: check correctness.
+    //maybe use clean initWithBase64String and remove ?: encoded tail.
+    NSString *clean = [JWTCryptoSecurity keyFromPemFileContent:encoded] ?: encoded;//[JWTCryptoSecurity stringByRemovingPemHeadersFromString:encoded];
+    return [self initWithBase64String:clean parameters:parameters error:error];
+}
+- (instancetype)initWithPemAtURL:(NSURL *)url parameters:(NSDictionary *)parameters error:(NSError *__autoreleasing*)error {
+    // contents of url
+    NSError *contentsExtractingError = nil;
+    NSString *pemEncoded = [NSString stringWithContentsOfURL:url encoding:NSUTF8StringEncoding error:&contentsExtractingError];
+    if (error && contentsExtractingError) {
+        *error = contentsExtractingError;
+        return nil;
+    }
+    return [self initWithPemEncoded:pemEncoded parameters:parameters error:error];
+}
+@end
+@implementation JWTCryptoKeyPublic
+- (instancetype)initWithData:(NSData *)data parameters:(NSDictionary *)parameters error:(NSError *__autoreleasing*)error {
+    self = [super initWithData:data parameters:parameters error:error];
+    if (self) {
+        self.tag = [self.class uniqueTag];
+
+        if (!data) {
+            return nil;
+        }
+
+        NSError *removingHeaderError = nil;
+        // asks builder
+        
+        JWTCryptoKeyBuilder *builder = [self extractedBuilderWithParameters:parameters];
+        NSData *keyData = data;
+        if (builder.withKeyTypeRSA) {
+        keyData = [JWTCryptoSecurity dataByRemovingPublicKeyHeader:data error:&removingHeaderError];
+            if (!keyData || removingHeaderError) {
+                if (error && removingHeaderError != nil) {
+                    *error = removingHeaderError;
+                }
+                return nil;
+            }
+        }
+        
+        if (builder.withKeyTypeEC) {
+            // unknown here.
+            // process keyData before passing it to JWTCryptoSecurity+addKey... method. 
+        }
+
+        NSError *addKeyError = nil;
+        
+        self.key = [JWTCryptoSecurity addKeyWithData:keyData asPublic:YES tag:self.tag type:[self extractedSecKeyTypeWithParameters:parameters] error:&addKeyError];
+        if (!self.key || addKeyError) {
+            if (error && addKeyError != nil) {
+                *error = removingHeaderError;
+            }
+            return nil;
+        }
+    }
+    return self;
+}
+- (instancetype)initWithCertificateData:(NSData *)certificateData parameters:(NSDictionary *)parameters error:(NSError *__autoreleasing*)error {
+    SecKeyRef key = [JWTCryptoSecurity publicKeyFromCertificate:certificateData];
+    if (!key) {
+        // error: Public certificate incorrect.
+        return nil;
+    }
+
+    if (self = [super init]) {
+        self.key = key;
+    }
+
+    return self;
+}
+- (instancetype)initWithCertificateBase64String:(NSString *)certificate parameters:(NSDictionary *)parameters error:(NSError *__autoreleasing*)error {
+    // cleanup certificate if needed.
+    // call initWithCertificateData:(NSData *)certificateData
+    NSData *certificateData = nil;
+    return [self initWithCertificateData:certificateData parameters:parameters error:error];
+}
+@end
+
+@implementation JWTCryptoKeyPrivate
+- (instancetype)initWithData:(NSData *)data parameters:(NSDictionary *)parameters error:(NSError *__autoreleasing*)error {
+    self = [super initWithData:data parameters:parameters error:error];
+    if (self) {
+        self.tag = [self.class uniqueTag];
+        NSError *addKeyError = nil;
+        if (!data) {
+            // error: no data?
+            // or put it in superclass?
+            return nil;
+        }
+        self.key = [JWTCryptoSecurity addKeyWithData:data asPublic:NO tag:self.tag type:[self extractedSecKeyTypeWithParameters:parameters] error:&addKeyError];
+        if (!self.key || addKeyError) {
+            if (error && addKeyError) {
+                *error = addKeyError;
+            }
+            return nil;
+        }
+    }
+    return self;
+}
+// Exists
+- (instancetype)initWithP12AtURL:(NSURL *)url withPassphrase:(NSString *)passphrase parameters:(NSDictionary *)parameters error:(NSError *__autoreleasing*)error {
+    // take data.
+    // cleanup if needed.
+    NSData *data = [NSData dataWithContentsOfURL:url];
+    return [self initWithP12Data:data withPassphrase:passphrase parameters:parameters error:error];
+}
+- (instancetype)initWithP12Data:(NSData *)p12Data withPassphrase:(NSString *)passphrase parameters:(NSDictionary *)parameters error:(NSError *__autoreleasing*)error {
+    if (p12Data == nil) {
+        return nil;
+    }
+
+    // cleanup if needed.
+    SecIdentityRef identity = nil;
+    SecTrustRef trust = nil;
+    [JWTCryptoSecurity extractIdentityAndTrustFromPKCS12:(__bridge CFDataRef)p12Data password:(__bridge CFStringRef)passphrase identity:&identity trust:&trust];
+    BOOL identityAndTrust = identity && trust;
+
+    if (identityAndTrust) {
+        self = [super init];
+        SecKeyRef privateKey;
+        SecIdentityCopyPrivateKey(identity, &privateKey);
+        if (self) {
+            self.key = privateKey;
+        }
+    }
+
+    if (identity) {
+        CFRelease(identity);
+    }
+
+    if (trust) {
+        CFRelease(trust);
+    }
+
+    if (!identityAndTrust) {
+        //error: no identity and trust.
+        return nil;
+    }
+
+    return self;
+}
+@end

package/ios/CodePush/JWT/Core/Algorithms/RSFamily/RSKeys/JWTCryptoKeyExtractor.h

@@ -0,0 +1,31 @@
+//
+//  JWTCryptoKeyExtractor.h
+//  JWT
+//
+//  Created by Lobanov Dmitry on 04.02.17.
+//  Copyright © 2017 JWTIO. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import <Security/Security.h>
+
+@protocol JWTCryptoKeyProtocol;
+@protocol JWTCryptoKeyExtractorProtocol <NSObject>
+@optional
+- (id<JWTCryptoKeyProtocol>)keyFromString:(NSString *)string parameters:(NSDictionary *)parameters error:(NSError *__autoreleasing*)error;
+- (id<JWTCryptoKeyProtocol>)keyFromData:(NSData *)data parameters:(NSDictionary *)parameters error:(NSError *__autoreleasing*)error;
+@end
+
+@interface JWTCryptoKeyExtractor : NSObject <JWTCryptoKeyExtractorProtocol>
+@property (copy, nonatomic, readonly) NSString *type;
++ (NSString *)type;
++ (NSString *)parametersKeyCertificatePassphrase;
+@end
+
+@interface JWTCryptoKeyExtractor (ClassCluster)
++ (instancetype)publicKeyWithCertificate;
++ (instancetype)privateKeyInP12;
++ (instancetype)publicKeyWithPEMBase64;
++ (instancetype)privateKeyWithPEMBase64;
++ (instancetype)createWithType:(NSString *)type;
+@end

package/ios/CodePush/JWT/Core/Algorithms/RSFamily/RSKeys/JWTCryptoKeyExtractor.m

@@ -0,0 +1,113 @@
+//
+//  JWTCryptoKeyExtractor.m
+//  JWT
+//
+//  Created by Lobanov Dmitry on 04.02.17.
+//  Copyright © 2017 JWTIO. All rights reserved.
+//
+
+#import "JWTCryptoKeyExtractor.h"
+#import "JWTCryptoKey.h"
+#import "JWTBase64Coder.h"
+
+@implementation JWTCryptoKeyExtractor
+- (NSString *)type {
+    return self.class.type;
+}
++ (NSString *)type {
+	return NSStringFromClass(self);
+}
++ (NSString *)parametersKeyCertificatePassphrase {
+    return NSStringFromSelector(_cmd);
+}
+- (id<JWTCryptoKeyProtocol>)keyFromData:(NSData *)data parameters:(NSDictionary *)parameters error:(NSError *__autoreleasing *)error {
+#pragma message "Not Implemented"
+    if (error) {
+        *error = [NSError errorWithDomain:@"io.jwt.crypto.rsa" code:-100 userInfo:@{
+                                                                                    NSLocalizedDescriptionKey : @"Method not implemented"
+                                                                                    }];
+    }
+    return nil;
+}
+- (id<JWTCryptoKeyProtocol>)keyFromString:(NSString *)string parameters:(NSDictionary *)parameters error:(NSError *__autoreleasing *)error {
+    if (error) {
+        *error = [NSError errorWithDomain:@"io.jwt.crypto.rsa" code:-100 userInfo:@{
+                                                                           NSLocalizedDescriptionKey : @"Method not implemented"
+                                                                           }];
+    }
+    return nil;
+}
+@end
+
+@interface JWTCryptoKeyExtractor_Public_Pem_Certificate : JWTCryptoKeyExtractor @end
+
+@implementation JWTCryptoKeyExtractor_Public_Pem_Certificate
+- (id<JWTCryptoKeyProtocol>)keyFromData:(NSData *)data parameters:(NSDictionary *)parameters error:(NSError *__autoreleasing *)error {
+    return [[JWTCryptoKeyPublic alloc] initWithCertificateData:data parameters:parameters error:error];
+}
+@end
+
+@interface JWTCryptoKeyExtractor_Private_P12 : JWTCryptoKeyExtractor @end
+
+@implementation JWTCryptoKeyExtractor_Private_P12
+- (id<JWTCryptoKeyProtocol>)keyFromData:(NSData *)data parameters:(NSDictionary *)parameters error:(NSError *__autoreleasing *)error {
+    NSString *certificatePassphrase = parameters[self.class.parametersKeyCertificatePassphrase];
+    if ([certificatePassphrase isEqual:[NSNull null]]) {
+        certificatePassphrase = nil;
+    }
+    return [[JWTCryptoKeyPrivate alloc] initWithP12Data:data withPassphrase:certificatePassphrase parameters:parameters error:error];
+}
+@end
+
+@interface JWTCryptoKeyExtractor_Public_Pem_Key : JWTCryptoKeyExtractor @end
+
+@implementation JWTCryptoKeyExtractor_Public_Pem_Key
+- (id<JWTCryptoKeyProtocol>)keyFromData:(NSData *)data parameters:(NSDictionary *)parameters error:(NSError *__autoreleasing *)error {
+    return [self keyFromString:[JWTBase64Coder base64UrlEncodedStringWithData:data] parameters:parameters error:error];
+}
+- (id<JWTCryptoKeyProtocol>)keyFromString:(NSString *)string parameters:(NSDictionary *)parameters error:(NSError *__autoreleasing *)error {
+    return [[JWTCryptoKeyPublic alloc] initWithPemEncoded:string parameters:parameters error:error];
+}
+@end
+
+@interface JWTCryptoKeyExtractor_Private_Pem_Key : JWTCryptoKeyExtractor @end
+
+@implementation JWTCryptoKeyExtractor_Private_Pem_Key
+- (id<JWTCryptoKeyProtocol>)keyFromData:(NSData *)data parameters:(NSDictionary *)parameters error:(NSError *__autoreleasing *)error {
+    return [self keyFromString:[JWTBase64Coder base64UrlEncodedStringWithData:data] parameters:parameters error:error];
+}
+- (id<JWTCryptoKeyProtocol>)keyFromString:(NSString *)string parameters:(NSDictionary *)parameters error:(NSError *__autoreleasing *)error {
+    return [[JWTCryptoKeyPrivate alloc] initWithPemEncoded:string parameters:parameters error:error];
+}
+@end
+
+@implementation JWTCryptoKeyExtractor (ClassCluster)
++ (instancetype)publicKeyWithCertificate {
+    return [JWTCryptoKeyExtractor_Public_Pem_Certificate new];
+}
++ (instancetype)privateKeyInP12 {
+    return [JWTCryptoKeyExtractor_Private_P12 new];
+}
++ (instancetype)publicKeyWithPEMBase64 {
+    return [JWTCryptoKeyExtractor_Public_Pem_Key new];
+}
++ (instancetype)privateKeyWithPEMBase64 {
+    return [JWTCryptoKeyExtractor_Private_Pem_Key new];
+}
++ (NSArray *)availableExtractors {
+    return @[
+             [self publicKeyWithCertificate],
+             [self privateKeyInP12],
+             [self publicKeyWithPEMBase64],
+             [self privateKeyWithPEMBase64]
+             ];
+}
++ (NSDictionary *)typesAndExtractors {
+    static NSDictionary *dictionary = nil;
+    return dictionary ?: (dictionary = [[NSDictionary alloc] initWithObjects:[self availableExtractors] forKeys:[[self availableExtractors] valueForKey:@"type"]],
+                          dictionary);
+}
++ (instancetype)createWithType:(NSString *)type {
+	return [self typesAndExtractors][type];
+}
+@end

package/ios/CodePush/JWT/Core/Algorithms/RSFamily/RSKeys/JWTCryptoSecurity.h

@@ -0,0 +1,38 @@
+//
+//  JWTCryptoSecurity.h
+//  JWT
+//
+//  Created by Lobanov Dmitry on 04.02.17.
+//  Copyright © 2017 JWTIO. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import <Security/Security.h>
+// Thanks for https://github.com/TakeScoop/SwiftyRSA!
+@interface JWTCryptoSecurity : NSObject
++ (NSString *)keyTypeRSA;
++ (NSString *)keyTypeEC;
++ (SecKeyRef)addKeyWithData:(NSData *)data asPublic:(BOOL)public tag:(NSString *)tag type:(NSString *)type error:(NSError *__autoreleasing*)error;
++ (SecKeyRef)addKeyWithData:(NSData *)data asPublic:(BOOL)public tag:(NSString *)tag error:(NSError *__autoreleasing*)error;
++ (SecKeyRef)keyByTag:(NSString *)tag error:(NSError *__autoreleasing*)error;
++ (void)removeKeyByTag:(NSString *)tag error:(NSError *__autoreleasing*)error;
+@end
+
+@interface JWTCryptoSecurity (Certificates)
++ (OSStatus)extractIdentityAndTrustFromPKCS12:(CFDataRef)inPKCS12Data password:(CFStringRef)password identity:(SecIdentityRef *)outIdentity trust:(SecTrustRef *)outTrust;
++ (SecKeyRef)publicKeyFromCertificate:(NSData *)certificateData;
+@end
+
+@interface JWTCryptoSecurity (Pem)
++ (NSString *)certificateFromPemFileContent:(NSString *)content;
++ (NSString *)keyFromPemFileContent:(NSString *)content;
++ (NSArray *)itemsFromPemFileContent:(NSString *)content byRegex:(NSRegularExpression *)expression;
++ (NSString *)certificateFromPemFileWithName:(NSString *)name;
++ (NSString *)keyFromPemFileWithName:(NSString *)name;
++ (NSArray *)itemsFromPemFileWithName:(NSString *)name byRegex:(NSRegularExpression *)expression;
++ (NSString *)stringByRemovingPemHeadersFromString:(NSString *)string;
+@end
+
+@interface JWTCryptoSecurity (PublicKey)
++ (NSData *)dataByRemovingPublicKeyHeader:(NSData *)data error:(NSError *__autoreleasing*)error;
+@end