├── .DS_Store ├── EncryptionTools ├── .DS_Store ├── Openssl编程.pdf ├── EncryptionTools │ ├── .DS_Store │ ├── Encryptions │ │ ├── .DS_Store │ │ ├── RSAEncrypt │ │ │ ├── RSA.h │ │ │ └── RSA.m │ │ ├── Hash │ │ │ ├── NSString+Hash.h │ │ │ └── NSString+Hash.m │ │ ├── Base64.h │ │ ├── NSString+Encryption │ │ │ ├── NSString+Encryption.h │ │ │ └── NSString+Encryption.m │ │ ├── CocoaSecurity.h │ │ ├── Base64.m │ │ └── CocoaSecurity.m │ ├── ViewController.h │ ├── AppDelegate.h │ ├── main.m │ ├── Assets.xcassets │ │ └── AppIcon.appiconset │ │ │ └── Contents.json │ ├── Info.plist │ ├── Base.lproj │ │ ├── LaunchScreen.storyboard │ │ └── Main.storyboard │ ├── AppDelegate.m │ └── ViewController.m └── EncryptionTools.xcodeproj │ ├── project.xcworkspace │ └── contents.xcworkspacedata │ └── project.pbxproj ├── .gitignore └── README.md /.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mddios/EncryptionTools/HEAD/.DS_Store -------------------------------------------------------------------------------- /EncryptionTools/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mddios/EncryptionTools/HEAD/EncryptionTools/.DS_Store -------------------------------------------------------------------------------- /EncryptionTools/Openssl编程.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mddios/EncryptionTools/HEAD/EncryptionTools/Openssl编程.pdf -------------------------------------------------------------------------------- /EncryptionTools/EncryptionTools/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mddios/EncryptionTools/HEAD/EncryptionTools/EncryptionTools/.DS_Store -------------------------------------------------------------------------------- /EncryptionTools/EncryptionTools/Encryptions/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mddios/EncryptionTools/HEAD/EncryptionTools/EncryptionTools/Encryptions/.DS_Store -------------------------------------------------------------------------------- /EncryptionTools/EncryptionTools.xcodeproj/project.xcworkspace/contents.xcworkspacedata: -------------------------------------------------------------------------------- 1 | 2 | 4 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /EncryptionTools/EncryptionTools/ViewController.h: -------------------------------------------------------------------------------- 1 | // 2 | // ViewController.h 3 | // EncryptionTools 4 | // 5 | // Created by mdd on 16/5/17. 6 | // Copyright © 2016年 com.personal. All rights reserved. 7 | // 8 | 9 | #import 10 | 11 | @interface ViewController : UIViewController 12 | 13 | 14 | @end 15 | 16 | -------------------------------------------------------------------------------- /EncryptionTools/EncryptionTools/AppDelegate.h: -------------------------------------------------------------------------------- 1 | // 2 | // AppDelegate.h 3 | // EncryptionTools 4 | // 5 | // Created by mdd on 16/5/17. 6 | // Copyright © 2016年 com.personal. All rights reserved. 7 | // 8 | 9 | #import 10 | 11 | @interface AppDelegate : UIResponder 12 | 13 | @property (strong, nonatomic) UIWindow *window; 14 | 15 | 16 | @end 17 | 18 | -------------------------------------------------------------------------------- /EncryptionTools/EncryptionTools/main.m: -------------------------------------------------------------------------------- 1 | // 2 | // main.m 3 | // EncryptionTools 4 | // 5 | // Created by mdd on 16/5/17. 6 | // Copyright © 2016年 com.personal. All rights reserved. 7 | // 8 | 9 | #import 10 | #import "AppDelegate.h" 11 | 12 | int main(int argc, char * argv[]) { 13 | @autoreleasepool { 14 | return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class])); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /EncryptionTools/EncryptionTools/Assets.xcassets/AppIcon.appiconset/Contents.json: -------------------------------------------------------------------------------- 1 | { 2 | "images" : [ 3 | { 4 | "idiom" : "iphone", 5 | "size" : "29x29", 6 | "scale" : "2x" 7 | }, 8 | { 9 | "idiom" : "iphone", 10 | "size" : "29x29", 11 | "scale" : "3x" 12 | }, 13 | { 14 | "idiom" : "iphone", 15 | "size" : "40x40", 16 | "scale" : "2x" 17 | }, 18 | { 19 | "idiom" : "iphone", 20 | "size" : "40x40", 21 | "scale" : "3x" 22 | }, 23 | { 24 | "idiom" : "iphone", 25 | "size" : "60x60", 26 | "scale" : "2x" 27 | }, 28 | { 29 | "idiom" : "iphone", 30 | "size" : "60x60", 31 | "scale" : "3x" 32 | } 33 | ], 34 | "info" : { 35 | "version" : 1, 36 | "author" : "xcode" 37 | } 38 | } -------------------------------------------------------------------------------- /EncryptionTools/EncryptionTools/Encryptions/RSAEncrypt/RSA.h: -------------------------------------------------------------------------------- 1 | /* 2 | @author: ideawu 3 | @link: https://github.com/ideawu/Objective-C-RSA 4 | */ 5 | 6 | #import 7 | 8 | @interface RSA : NSObject 9 | 10 | // return base64 encoded string 11 | + (NSString *)encryptString:(NSString *)str publicKey:(NSString *)pubKey; 12 | // return raw data 13 | + (NSData *)encryptData:(NSData *)data publicKey:(NSString *)pubKey; 14 | // return base64 encoded string 15 | // enc with private key NOT working YET! 16 | //+ (NSString *)encryptString:(NSString *)str privateKey:(NSString *)privKey; 17 | // return raw data 18 | //+ (NSData *)encryptData:(NSData *)data privateKey:(NSString *)privKey; 19 | 20 | // decrypt base64 encoded string, convert result to string(not base64 encoded) 21 | + (NSString *)decryptString:(NSString *)str publicKey:(NSString *)pubKey; 22 | + (NSData *)decryptData:(NSData *)data publicKey:(NSString *)pubKey; 23 | + (NSString *)decryptString:(NSString *)str privateKey:(NSString *)privKey; 24 | + (NSData *)decryptData:(NSData *)data privateKey:(NSString *)privKey; 25 | 26 | @end 27 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Xcode 2 | # 3 | # gitignore contributors: remember to update Global/Xcode.gitignore, Objective-C.gitignore & Swift.gitignore 4 | 5 | ## Build generated 6 | build/ 7 | DerivedData 8 | 9 | ## Various settings 10 | *.pbxuser 11 | !default.pbxuser 12 | *.mode1v3 13 | !default.mode1v3 14 | *.mode2v3 15 | !default.mode2v3 16 | *.perspectivev3 17 | !default.perspectivev3 18 | xcuserdata 19 | 20 | ## Other 21 | *.xccheckout 22 | *.moved-aside 23 | *.xcuserstate 24 | *.xcscmblueprint 25 | 26 | ## Obj-C/Swift specific 27 | *.hmap 28 | *.ipa 29 | 30 | # CocoaPods 31 | # 32 | # We recommend against adding the Pods directory to your .gitignore. However 33 | # you should judge for yourself, the pros and cons are mentioned at: 34 | # https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control 35 | # 36 | # Pods/ 37 | 38 | # Carthage 39 | # 40 | # Add this line if you want to avoid checking in source code from Carthage dependencies. 41 | # Carthage/Checkouts 42 | 43 | Carthage/Build 44 | 45 | # fastlane 46 | # 47 | # It is recommended to not store the screenshots in the git repo. Instead, use fastlane to re-generate the 48 | # screenshots whenever they are needed. 49 | # For more information about the recommended setup visit: 50 | # https://github.com/fastlane/fastlane/blob/master/docs/Gitignore.md 51 | 52 | fastlane/report.xml 53 | fastlane/screenshots 54 | -------------------------------------------------------------------------------- /EncryptionTools/EncryptionTools/Info.plist: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | CFBundleDevelopmentRegion 6 | en 7 | CFBundleExecutable 8 | $(EXECUTABLE_NAME) 9 | CFBundleIdentifier 10 | $(PRODUCT_BUNDLE_IDENTIFIER) 11 | CFBundleInfoDictionaryVersion 12 | 6.0 13 | CFBundleName 14 | $(PRODUCT_NAME) 15 | CFBundlePackageType 16 | APPL 17 | CFBundleShortVersionString 18 | 1.0 19 | CFBundleSignature 20 | ???? 21 | CFBundleVersion 22 | 1 23 | LSRequiresIPhoneOS 24 | 25 | UILaunchStoryboardName 26 | LaunchScreen 27 | UIMainStoryboardFile 28 | Main 29 | UIRequiredDeviceCapabilities 30 | 31 | armv7 32 | 33 | UISupportedInterfaceOrientations 34 | 35 | UIInterfaceOrientationPortrait 36 | UIInterfaceOrientationLandscapeLeft 37 | UIInterfaceOrientationLandscapeRight 38 | 39 | 40 | 41 | -------------------------------------------------------------------------------- /EncryptionTools/EncryptionTools/Encryptions/Hash/NSString+Hash.h: -------------------------------------------------------------------------------- 1 | // 2 | // NSString+Hash.h 3 | // Encryptions 4 | // 5 | // Created by mdd on 15/5/17. 6 | // Copyright © 2015年 com.personal. All rights reserved. 7 | // 8 | 9 | #import 10 | 11 | @interface NSString (Hash) 12 | 13 | /** 14 | 返回结果：32长度(128位，16字节，16进制字符输出则为32字节长度) 终端命令：md5 -s "123" 15 | */ 16 | - (NSString *)md5Hash; 17 | 18 | /** 19 | 返回结果：40长度 终端命令：echo -n "123" | openssl sha -sha1 20 | */ 21 | - (NSString *)sha1Hash; 22 | 23 | /** 24 | 返回结果：56长度 终端命令：echo -n "123" | openssl sha -sha224 25 | */ 26 | - (NSString *)sha224Hash; 27 | 28 | /** 29 | 返回结果：64长度 终端命令：echo -n "123" | openssl sha -sha256 30 | */ 31 | - (NSString *)sha256Hash; 32 | 33 | /** 34 | 返回结果：96长度 终端命令：echo -n "123" | openssl sha -sha384 35 | */ 36 | - (NSString *)sha384Hash; 37 | 38 | /** 39 | 返回结果：128长度 终端命令：echo -n "123" | openssl sha -sha512 40 | */ 41 | - (NSString *)sha512Hash; 42 | 43 | #pragma mark - HMAC 44 | 45 | /// 返回结果：32长度 终端命令：echo -n "123" | openssl dgst -md5 -hmac "123" 46 | - (NSString *)hmacMD5WithKey:(NSString *)key; 47 | 48 | /// 返回结果：40长度 echo -n "123" | openssl sha -sha1 -hmac "123" 49 | - (NSString *)hmacSHA1WithKey:(NSString *)key; 50 | - (NSString *)hmacSHA224WithKey:(NSString *)key; 51 | - (NSString *)hmacSHA256WithKey:(NSString *)key; 52 | - (NSString *)hmacSHA384WithKey:(NSString *)key; 53 | - (NSString *)hmacSHA512WithKey:(NSString *)key; 54 | @end 55 | -------------------------------------------------------------------------------- /EncryptionTools/EncryptionTools/Base.lproj/LaunchScreen.storyboard: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | -------------------------------------------------------------------------------- /EncryptionTools/EncryptionTools/Encryptions/Base64.h: -------------------------------------------------------------------------------- 1 | // 2 | // Base64.h 3 | // 4 | // Version 1.2 5 | // 6 | // Created by Nick Lockwood on 12/01/2012. 7 | // Copyright (C) 2012 Charcoal Design 8 | // 9 | // Distributed under the permissive zlib License 10 | // Get the latest version from here: 11 | // 12 | // https://github.com/nicklockwood/Base64 13 | // 14 | // This software is provided 'as-is', without any express or implied 15 | // warranty. In no event will the authors be held liable for any damages 16 | // arising from the use of this software. 17 | // 18 | // Permission is granted to anyone to use this software for any purpose, 19 | // including commercial applications, and to alter it and redistribute it 20 | // freely, subject to the following restrictions: 21 | // 22 | // 1. The origin of this software must not be misrepresented; you must not 23 | // claim that you wrote the original software. If you use this software 24 | // in a product, an acknowledgment in the product documentation would be 25 | // appreciated but is not required. 26 | // 27 | // 2. Altered source versions must be plainly marked as such, and must not be 28 | // misrepresented as being the original software. 29 | // 30 | // 3. This notice may not be removed or altered from any source distribution. 31 | // 32 | 33 | #import 34 | 35 | 36 | @interface NSData (Base64) 37 | 38 | + (NSData *)dataWithBase64EncodedString:(NSString *)string; 39 | - (NSString *)base64EncodedStringWithWrapWidth:(NSUInteger)wrapWidth; 40 | - (NSString *)base64EncodedString; 41 | 42 | @end 43 | 44 | 45 | @interface NSString (Base64) 46 | 47 | + (NSString *)stringWithBase64EncodedString:(NSString *)string; 48 | - (NSString *)base64EncodedStringWithWrapWidth:(NSUInteger)wrapWidth; 49 | - (NSString *)base64EncodedString; 50 | - (NSString *)base64DecodedString; 51 | - (NSData *)base64DecodedData; 52 | 53 | @end 54 | -------------------------------------------------------------------------------- /EncryptionTools/EncryptionTools/AppDelegate.m: -------------------------------------------------------------------------------- 1 | // 2 | // AppDelegate.m 3 | // EncryptionTools 4 | // 5 | // Created by mdd on 16/5/17. 6 | // Copyright © 2016年 com.personal. All rights reserved. 7 | // 8 | 9 | #import "AppDelegate.h" 10 | 11 | @interface AppDelegate () 12 | 13 | @end 14 | 15 | @implementation AppDelegate 16 | 17 | 18 | - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions { 19 | // Override point for customization after application launch. 20 | return YES; 21 | } 22 | 23 | - (void)applicationWillResignActive:(UIApplication *)application { 24 | // Sent when the application is about to move from active to inactive state. This can occur for certain types of temporary interruptions (such as an incoming phone call or SMS message) or when the user quits the application and it begins the transition to the background state. 25 | // Use this method to pause ongoing tasks, disable timers, and throttle down OpenGL ES frame rates. Games should use this method to pause the game. 26 | } 27 | 28 | - (void)applicationDidEnterBackground:(UIApplication *)application { 29 | // Use this method to release shared resources, save user data, invalidate timers, and store enough application state information to restore your application to its current state in case it is terminated later. 30 | // If your application supports background execution, this method is called instead of applicationWillTerminate: when the user quits. 31 | } 32 | 33 | - (void)applicationWillEnterForeground:(UIApplication *)application { 34 | // Called as part of the transition from the background to the inactive state; here you can undo many of the changes made on entering the background. 35 | } 36 | 37 | - (void)applicationDidBecomeActive:(UIApplication *)application { 38 | // Restart any tasks that were paused (or not yet started) while the application was inactive. If the application was previously in the background, optionally refresh the user interface. 39 | } 40 | 41 | - (void)applicationWillTerminate:(UIApplication *)application { 42 | // Called when the application is about to terminate. Save data if appropriate. See also applicationDidEnterBackground:. 43 | } 44 | 45 | @end 46 | -------------------------------------------------------------------------------- /EncryptionTools/EncryptionTools/Base.lproj/Main.storyboard: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | -------------------------------------------------------------------------------- /EncryptionTools/EncryptionTools/Encryptions/NSString+Encryption/NSString+Encryption.h: -------------------------------------------------------------------------------- 1 | // 2 | // NSString+Encryption.h 3 | // EncryptionTools 4 | // 5 | // Created by mdd on 16/4/2. 6 | // Copyright © 2016年 com.personal. All rights reserved. 7 | // 8 | 9 | #import 10 | #import 11 | #import 12 | 13 | /// 默认使用kCCOptionPKCS7Padding填充 14 | #define kPaddingMode kCCOptionPKCS7Padding 15 | 16 | @interface NSString (Encryption) 17 | 18 | #pragma mark - AES加密 19 | 20 | /** 21 | AES-CBC模式加密，默认模式 22 | @param key Hex形式，密钥支持128 192 256bit，16、24、32字节，转换为16进制字符串长度为32、48、64，长度错误将抛出异常 23 | @param iv 进制字符串形式；初始化向量iv为16字节。如果为nil，则初始化向量为0 24 | @return 加密结果为base64编码 25 | */ 26 | - (NSString *)aesEncryptWithHexKey:(NSString *)key hexIv:(NSString *)iv; 27 | 28 | /** 29 | AES-CBC模式加密，默认模式 30 | @param key 密钥支持128 192 256bit，16、24、32字节，长度错误将抛出异常 31 | @param iv 进制字符串形式；初始化向量iv为16字节。如果为nil，则初始化向量为0 32 | @return 加密结果为base64编码 33 | */ 34 | - (NSString *)aesEncryptWithKey:(NSString *)key iv:(NSString *)iv; 35 | 36 | /** 37 | AES-CBC模式加密，默认模式 38 | @param data 要加密的数据 39 | @param key 密钥支持128 192 256bit，16、24、32字节，长度错误将抛出异常 40 | @param iv 初始化向量iv为16字节。如果为nil，则初始化向量为0 41 | @return 加密结果为NSData形式 42 | */ 43 | - (NSData *)aesEncryptWithDataKey:(NSData *)key dataIv:(NSData *)iv; 44 | 45 | /** 46 | AES-ECB模式加密 47 | @param key Hex形式，密钥支持128 192 256bit，16、24、32字节，转换为16进制字符串长度为32、48、64，长度错误将抛出异常 48 | @return 加密结果为base64编码 49 | */ 50 | - (NSString *)aesECBEncryptWithHexKey:(NSString *)key; 51 | 52 | /** 53 | AES-ECB模式加密 54 | @param key base64形式，密钥支持128 192 256bit，16、24、32字节，转换为16进制字符串长度为32、48、64，长度错误将抛出异常 55 | @return 加密结果为base64编码 56 | */ 57 | - (NSString *)aesECBEncryptWithBase64Key:(NSString *)key; 58 | 59 | /** 60 | AES-ECB模式加密 61 | @param key 字符串形式，密钥支持128 192 256bit，16、24、32字节，长度错误将抛出异常 62 | @return 加密结果为base64编码 63 | */ 64 | - (NSString *)aesECBEncryptWithKey:(NSString *)key; 65 | 66 | /** 67 | AES-ECB模式加密 68 | @param key 密钥支持128 192 256bit，16、24、32字节，长度错误将抛出异常 69 | */ 70 | - (NSData *)aesECBEncryptWithDataKey:(NSData *)key; 71 | 72 | #pragma mark - AES解密 73 | 74 | /** 75 | AES-CBC模式解密，要求NSString为base64的结果 76 | @param key 密钥支持128 192 256bit，16、24、32字节，长度错误将抛出异常 77 | @param iv 进制字符串形式；初始化向量iv为16字节。如果为nil，则初始化向量为0 78 | */ 79 | - (NSString *)aesBase64StringDecryptWithHexKey:(NSString *)key hexIv:(NSString *)iv; 80 | 81 | /** 82 | AES-CBC模式解密 83 | @param key 密钥支持128 192 256bit，16、24、32字节，长度错误将抛出异常 84 | @param iv 初始化向量iv为16字节。如果为nil，则初始化向量为0 85 | */ 86 | + (NSData *)aesDecryptWithData:(NSData *)data dataKey:(NSData *)key dataIv:(NSData *)iv; 87 | 88 | /* 89 | ECB模式解密，要求输入为Base64格式的nsstring，返回为NSString 90 | */ 91 | - (NSString *)aesECBBase64StringDecryptWithHexKey:(NSString *)key; 92 | 93 | /* 94 | ECB模式解密，要求输入为Base64格式，返回为NSString 95 | */ 96 | - (NSString *)aesECBBase64StringDecryptWithBase64Key:(NSString *)key; 97 | 98 | /* 99 | ECB模式解密，返回为NSData 100 | */ 101 | + (NSData *)aesECBDecryptWithData:(NSData *)data withDataKey:(NSData *)key; 102 | 103 | 104 | ///* 105 | // ECB模式解密，返回base64编码 106 | // */ 107 | //- (NSString *)aesECBDecryptWithHexKey:(NSString *)key; 108 | // 109 | ///* 110 | // ECB模式解密，返回NSData 111 | // */ 112 | //- (NSData *)aesECBDecryptWithDataKey:(NSData *)key; 113 | 114 | #pragma mark - DES加密 115 | 116 | /* 117 | DES加密 key为NSString形式 结果返回base64编码 118 | */ 119 | - (NSString *)desEncryptWithKey:(NSString *)key; 120 | 121 | /* 122 | DES加密 key为NSData形式 结果返回NSData 123 | */ 124 | - (NSData *)desEncryptWithDataKey:(NSData *)key; 125 | 126 | #pragma mark - DES解密 127 | 128 | /* 129 | DES解密，字符串必须为base64格式，key为字符串形式 130 | */ 131 | - (NSString *)desDecryptWithKey:(NSString *)key; 132 | 133 | /* 134 | DES解密 135 | */ 136 | + (NSData *)desDecryptWithData:(NSData *)data dataKey:(NSData *)key; 137 | 138 | @end 139 | 140 | 141 | 142 | -------------------------------------------------------------------------------- /EncryptionTools/EncryptionTools/Encryptions/CocoaSecurity.h: -------------------------------------------------------------------------------- 1 | /* 2 | CocoaSecurity 1.1 3 | 4 | Created by Kelp on 12/5/12. 5 | Copyright (c) 2012 Kelp http://kelp.phate.org/ 6 | MIT License 7 | 8 | CocoaSecurity is core. It provides AES encrypt, AES decrypt, Hash(MD5, HmacMD5, SHA1~SHA512, HmacSHA1~HmacSHA512) messages. 9 | */ 10 | 11 | #import 12 | #import 13 | 14 | 15 | #pragma mark - CocoaSecurityResult 16 | @interface CocoaSecurityResult : NSObject 17 | 18 | @property (strong, nonatomic, readonly) NSData *data; 19 | @property (strong, nonatomic, readonly) NSString *utf8String; 20 | @property (strong, nonatomic, readonly) NSString *hex; 21 | @property (strong, nonatomic, readonly) NSString *hexLower; 22 | @property (strong, nonatomic, readonly) NSString *base64; 23 | 24 | - (id)initWithBytes:(unsigned char[])initData length:(NSUInteger)length; 25 | 26 | @end 27 | 28 | 29 | #pragma mark - CocoaSecurity 30 | @interface CocoaSecurity : NSObject 31 | #pragma mark - AES Encrypt 32 | + (CocoaSecurityResult *)aesEncrypt:(NSString *)data key:(NSString *)key; 33 | + (CocoaSecurityResult *)aesEncrypt:(NSString *)data hexKey:(NSString *)key hexIv:(NSString *)iv; 34 | + (CocoaSecurityResult *)aesEncrypt:(NSString *)data key:(NSData *)key iv:(NSData *)iv; 35 | + (CocoaSecurityResult *)aesEncryptWithData:(NSData *)data key:(NSData *)key iv:(NSData *)iv; 36 | #pragma mark AES Decrypt 37 | + (CocoaSecurityResult *)aesDecryptWithBase64:(NSString *)data key:(NSString *)key; 38 | + (CocoaSecurityResult *)aesDecryptWithBase64:(NSString *)data hexKey:(NSString *)key hexIv:(NSString *)iv; 39 | + (CocoaSecurityResult *)aesDecryptWithBase64:(NSString *)data key:(NSData *)key iv:(NSData *)iv; 40 | + (CocoaSecurityResult *)aesDecryptWithData:(NSData *)data key:(NSData *)key iv:(NSData *)iv; 41 | 42 | #pragma mark - MD5 43 | + (CocoaSecurityResult *)md5:(NSString *)hashString; 44 | + (CocoaSecurityResult *)md5WithData:(NSData *)hashData; 45 | #pragma mark HMAC-MD5 46 | + (CocoaSecurityResult *)hmacMd5:(NSString *)hashString hmacKey:(NSString *)key; 47 | + (CocoaSecurityResult *)hmacMd5WithData:(NSData *)hashData hmacKey:(NSString *)key; 48 | 49 | #pragma mark - SHA 50 | + (CocoaSecurityResult *)sha1:(NSString *)hashString; 51 | + (CocoaSecurityResult *)sha1WithData:(NSData *)hashData; 52 | + (CocoaSecurityResult *)sha224:(NSString *)hashString; 53 | + (CocoaSecurityResult *)sha224WithData:(NSData *)hashData; 54 | + (CocoaSecurityResult *)sha256:(NSString *)hashString; 55 | + (CocoaSecurityResult *)sha256WithData:(NSData *)hashData; 56 | + (CocoaSecurityResult *)sha384:(NSString *)hashString; 57 | + (CocoaSecurityResult *)sha384WithData:(NSData *)hashData; 58 | + (CocoaSecurityResult *)sha512:(NSString *)hashString; 59 | + (CocoaSecurityResult *)sha512WithData:(NSData *)hashData; 60 | #pragma mark HMAC-SHA 61 | + (CocoaSecurityResult *)hmacSha1:(NSString *)hashString hmacKey:(NSString *)key; 62 | + (CocoaSecurityResult *)hmacSha1WithData:(NSData *)hashData hmacKey:(NSString *)key; 63 | + (CocoaSecurityResult *)hmacSha224:(NSString *)hashString hmacKey:(NSString *)key; 64 | + (CocoaSecurityResult *)hmacSha224WithData:(NSData *)hashData hmacKey:(NSString *)key; 65 | + (CocoaSecurityResult *)hmacSha256:(NSString *)hashString hmacKey:(NSString *)key; 66 | + (CocoaSecurityResult *)hmacSha256WithData:(NSData *)hashData hmacKey:(NSString *)key; 67 | + (CocoaSecurityResult *)hmacSha384:(NSString *)hashString hmacKey:(NSString *)key; 68 | + (CocoaSecurityResult *)hmacSha384WithData:(NSData *)hashData hmacKey:(NSString *)key; 69 | + (CocoaSecurityResult *)hmacSha512:(NSString *)hashString hmacKey:(NSString *)key; 70 | + (CocoaSecurityResult *)hmacSha512WithData:(NSData *)hashData hmacKey:(NSString *)key; 71 | @end 72 | 73 | 74 | #pragma mark - CocoaSecurityEncoder 75 | @interface CocoaSecurityEncoder : NSObject 76 | - (NSString *)base64:(NSData *)data; 77 | - (NSString *)hex:(NSData *)data useLower:(BOOL)isOutputLower; 78 | @end 79 | 80 | 81 | #pragma mark - CocoaSecurityDecoder 82 | @interface CocoaSecurityDecoder : NSObject 83 | - (NSData *)base64:(NSString *)data; 84 | - (NSData *)hex:(NSString *)data; 85 | @end 86 | -------------------------------------------------------------------------------- /EncryptionTools/EncryptionTools/Encryptions/Base64.m: -------------------------------------------------------------------------------- 1 | // 2 | // Base64.m 3 | // 4 | // Version 1.2 5 | // 6 | // Created by Nick Lockwood on 12/01/2012. 7 | // Copyright (C) 2012 Charcoal Design 8 | // 9 | // Distributed under the permissive zlib License 10 | // Get the latest version from here: 11 | // 12 | // https://github.com/nicklockwood/Base64 13 | // 14 | // This software is provided 'as-is', without any express or implied 15 | // warranty. In no event will the authors be held liable for any damages 16 | // arising from the use of this software. 17 | // 18 | // Permission is granted to anyone to use this software for any purpose, 19 | // including commercial applications, and to alter it and redistribute it 20 | // freely, subject to the following restrictions: 21 | // 22 | // 1. The origin of this software must not be misrepresented; you must not 23 | // claim that you wrote the original software. If you use this software 24 | // in a product, an aacknowledgment in the product documentation would be 25 | // appreciated but is not required. 26 | // 27 | // 2. Altered source versions must be plainly marked as such, and must not be 28 | // misrepresented as being the original software. 29 | // 30 | // 3. This notice may not be removed or altered from any source distribution. 31 | // 32 | 33 | #import "Base64.h" 34 | 35 | 36 | #pragma GCC diagnostic ignored "-Wselector" 37 | 38 | 39 | #import 40 | #if !__has_feature(objc_arc) 41 | #error This library requires automatic reference counting 42 | #endif 43 | 44 | 45 | @implementation NSData (Base64) 46 | 47 | + (NSData *)dataWithBase64EncodedString:(NSString *)string 48 | { 49 | if (![string length]) return nil; 50 | 51 | NSData *decoded = nil; 52 | 53 | #if /*__MAC_OS_X_VERSION_MIN_REQUIRED < __MAC_10_9 ||*/ __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_7_0 54 | NSLog(@"%d",__IPHONE_OS_VERSION_MIN_REQUIRED); 55 | if (![NSData instancesRespondToSelector:@selector(initWithBase64EncodedString:options:)]) 56 | { 57 | decoded = [[self alloc] initWithBase64Encoding:[string stringByReplacingOccurrencesOfString:@"[^A-Za-z0-9+/=]" withString:@"" options:NSRegularExpressionSearch range:NSMakeRange(0, [string length])]]; 58 | } 59 | else 60 | 61 | #endif 62 | 63 | { 64 | decoded = [[self alloc] initWithBase64EncodedString:string options:NSDataBase64DecodingIgnoreUnknownCharacters]; 65 | } 66 | 67 | return [decoded length]? decoded: nil; 68 | } 69 | 70 | - (NSString *)base64EncodedStringWithWrapWidth:(NSUInteger)wrapWidth 71 | { 72 | if (![self length]) return nil; 73 | 74 | NSString *encoded = nil; 75 | 76 | #if __MAC_OS_X_VERSION_MIN_REQUIRED < __MAC_10_9 || __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_7_0 77 | 78 | if (![NSData instancesRespondToSelector:@selector(base64EncodedStringWithOptions:)]) 79 | { 80 | encoded = [self base64Encoding]; 81 | } 82 | else 83 | 84 | #endif 85 | 86 | { 87 | switch (wrapWidth) 88 | { 89 | case 64: 90 | { 91 | return [self base64EncodedStringWithOptions:NSDataBase64Encoding64CharacterLineLength]; 92 | } 93 | case 76: 94 | { 95 | return [self base64EncodedStringWithOptions:NSDataBase64Encoding76CharacterLineLength]; 96 | } 97 | default: 98 | { 99 | encoded = [self base64EncodedStringWithOptions:(NSDataBase64EncodingOptions)0]; 100 | } 101 | } 102 | } 103 | 104 | if (!wrapWidth || wrapWidth >= [encoded length]) 105 | { 106 | return encoded; 107 | } 108 | 109 | wrapWidth = (wrapWidth / 4) * 4; 110 | NSMutableString *result = [NSMutableString string]; 111 | for (NSUInteger i = 0; i < [encoded length]; i+= wrapWidth) 112 | { 113 | if (i + wrapWidth >= [encoded length]) 114 | { 115 | [result appendString:[encoded substringFromIndex:i]]; 116 | break; 117 | } 118 | [result appendString:[encoded substringWithRange:NSMakeRange(i, wrapWidth)]]; 119 | [result appendString:@"\r\n"]; 120 | } 121 | 122 | return result; 123 | } 124 | 125 | - (NSString *)base64EncodedString 126 | { 127 | return [self base64EncodedStringWithWrapWidth:0]; 128 | } 129 | 130 | @end 131 | 132 | 133 | @implementation NSString (Base64) 134 | 135 | + (NSString *)stringWithBase64EncodedString:(NSString *)string 136 | { 137 | NSData *data = [NSData dataWithBase64EncodedString:string]; 138 | if (data) 139 | { 140 | return [[self alloc] initWithData:data encoding:NSUTF8StringEncoding]; 141 | } 142 | return nil; 143 | } 144 | 145 | - (NSString *)base64EncodedStringWithWrapWidth:(NSUInteger)wrapWidth 146 | { 147 | NSData *data = [self dataUsingEncoding:NSUTF8StringEncoding allowLossyConversion:YES]; 148 | return [data base64EncodedStringWithWrapWidth:wrapWidth]; 149 | } 150 | 151 | - (NSString *)base64EncodedString 152 | { 153 | NSData *data = [self dataUsingEncoding:NSUTF8StringEncoding allowLossyConversion:YES]; 154 | return [data base64EncodedString]; 155 | } 156 | 157 | - (NSString *)base64DecodedString 158 | { 159 | return [NSString stringWithBase64EncodedString:self]; 160 | } 161 | 162 | - (NSData *)base64DecodedData 163 | { 164 | return [NSData dataWithBase64EncodedString:self]; 165 | } 166 | 167 | @end 168 | -------------------------------------------------------------------------------- /EncryptionTools/EncryptionTools/Encryptions/Hash/NSString+Hash.m: -------------------------------------------------------------------------------- 1 | // 2 | // NSString+Hash.m 3 | // Encryptions 4 | // 5 | // Created by mdd on 15/5/17. 6 | // Copyright © 2015年 com.personal. All rights reserved. 7 | // 8 | 9 | #import "NSString+Hash.h" 10 | #import 11 | #import 12 | 13 | @implementation NSString (Hash) 14 | 15 | #pragma mark - md5 16 | - (NSString *)md5Hash { 17 | const char *plain = self.UTF8String; 18 | unsigned char *digest; 19 | digest = malloc(CC_MD5_DIGEST_LENGTH); 20 | 21 | CC_MD5(plain, (CC_LONG)strlen(plain), digest); 22 | 23 | NSString *encode = [self stringFromBytes:digest length:CC_MD5_DIGEST_LENGTH]; 24 | free(digest); 25 | return encode; 26 | } 27 | 28 | - (NSString *)sha1Hash { 29 | const char *plain = self.UTF8String; 30 | unsigned char *digest; 31 | digest = malloc(CC_SHA1_DIGEST_LENGTH); 32 | 33 | CC_SHA1(plain, (CC_LONG)strlen(plain), digest); 34 | 35 | NSString *encode = [self stringFromBytes:digest length:CC_SHA1_DIGEST_LENGTH]; 36 | free(digest); 37 | return encode; 38 | } 39 | 40 | - (NSString *)sha224Hash { 41 | const char *str = self.UTF8String; 42 | unsigned char *digest; 43 | digest = malloc(CC_SHA224_DIGEST_LENGTH); 44 | 45 | CC_SHA224(str, (CC_LONG)strlen(str), digest); 46 | 47 | NSString *encode = [self stringFromBytes:digest length:CC_SHA224_DIGEST_LENGTH]; 48 | free(digest); 49 | return encode; 50 | } 51 | 52 | - (NSString *)sha256Hash { 53 | const char *str = self.UTF8String; 54 | unsigned char *digest; 55 | digest = malloc(CC_SHA256_DIGEST_LENGTH); 56 | 57 | CC_SHA256(str, (CC_LONG)strlen(str), digest); 58 | 59 | NSString *encode = [self stringFromBytes:digest length:CC_SHA256_DIGEST_LENGTH]; 60 | free(digest); 61 | return encode; 62 | } 63 | 64 | - (NSString *)sha384Hash { 65 | const char *str = self.UTF8String; 66 | unsigned char *digest; 67 | digest = malloc(CC_SHA384_DIGEST_LENGTH); 68 | 69 | CC_SHA384(str, (CC_LONG)strlen(str), digest); 70 | 71 | NSString *encode = [self stringFromBytes:digest length:CC_SHA384_DIGEST_LENGTH]; 72 | free(digest); 73 | return encode; 74 | } 75 | 76 | - (NSString *)sha512Hash { 77 | const char *str = self.UTF8String; 78 | unsigned char *digest; 79 | digest = malloc(CC_SHA512_DIGEST_LENGTH); 80 | 81 | CC_SHA512(str, (CC_LONG)strlen(str), digest); 82 | 83 | NSString *encode = [self stringFromBytes:digest length:CC_SHA512_DIGEST_LENGTH]; 84 | free(digest); 85 | return encode; 86 | } 87 | 88 | #pragma mark - HMAC 89 | - (NSString *)hmacMD5WithKey:(NSString *)key { 90 | const char *keyData = key.UTF8String; 91 | const char *strData = self.UTF8String; 92 | uint8_t buffer[CC_MD5_DIGEST_LENGTH]; 93 | 94 | CCHmac(kCCHmacAlgMD5, keyData, strlen(keyData), strData, strlen(strData), buffer); 95 | 96 | return [self stringFromBytes:buffer length:CC_MD5_DIGEST_LENGTH]; 97 | } 98 | 99 | - (NSString *)hmacSHA1WithKey:(NSString *)key { 100 | NSData *hashData = [self dataUsingEncoding:NSUTF8StringEncoding]; 101 | 102 | unsigned char *digest; 103 | digest = malloc(CC_SHA1_DIGEST_LENGTH); 104 | const char *cKey = [key cStringUsingEncoding:NSUTF8StringEncoding]; 105 | CCHmac(kCCHmacAlgSHA1, cKey, strlen(cKey), [hashData bytes], [hashData length], digest); 106 | 107 | NSString *encode = [self stringFromBytes:digest length:CC_SHA1_DIGEST_LENGTH]; 108 | free(digest); 109 | cKey = nil; 110 | return encode; 111 | } 112 | 113 | - (NSString *)hmacSHA224WithKey:(NSString *)key { 114 | NSData *hashData = [self dataUsingEncoding:NSUTF8StringEncoding]; 115 | 116 | unsigned char *digest; 117 | digest = malloc(CC_SHA224_DIGEST_LENGTH); 118 | const char *cKey = [key cStringUsingEncoding:NSUTF8StringEncoding]; 119 | CCHmac(kCCHmacAlgSHA224, cKey, strlen(cKey), [hashData bytes], [hashData length], digest); 120 | 121 | NSString *encode = [self stringFromBytes:digest length:CC_SHA224_DIGEST_LENGTH]; 122 | free(digest); 123 | cKey = nil; 124 | return encode; 125 | } 126 | 127 | - (NSString *)hmacSHA256WithKey:(NSString *)key { 128 | NSData *hashData = [self dataUsingEncoding:NSUTF8StringEncoding]; 129 | 130 | unsigned char *digest; 131 | digest = malloc(CC_SHA256_DIGEST_LENGTH); 132 | const char *cKey = [key cStringUsingEncoding:NSUTF8StringEncoding]; 133 | CCHmac(kCCHmacAlgSHA256, cKey, strlen(cKey), [hashData bytes], [hashData length], digest); 134 | 135 | NSString *encode = [self stringFromBytes:digest length:CC_SHA256_DIGEST_LENGTH]; 136 | free(digest); 137 | cKey = nil; 138 | return encode; 139 | } 140 | 141 | - (NSString *)hmacSHA384WithKey:(NSString *)key { 142 | NSData *hashData = [self dataUsingEncoding:NSUTF8StringEncoding]; 143 | 144 | unsigned char *digest; 145 | digest = malloc(CC_SHA384_DIGEST_LENGTH); 146 | const char *cKey = [key cStringUsingEncoding:NSUTF8StringEncoding]; 147 | CCHmac(kCCHmacAlgSHA256, cKey, strlen(cKey), [hashData bytes], [hashData length], digest); 148 | 149 | NSString *encode = [self stringFromBytes:digest length:CC_SHA384_DIGEST_LENGTH]; 150 | free(digest); 151 | cKey = nil; 152 | return encode; 153 | } 154 | 155 | - (NSString *)hmacSHA512WithKey:(NSString *)key { 156 | NSData *hashData = [self dataUsingEncoding:NSUTF8StringEncoding]; 157 | 158 | unsigned char *digest; 159 | digest = malloc(CC_SHA512_DIGEST_LENGTH); 160 | const char *cKey = [key cStringUsingEncoding:NSUTF8StringEncoding]; 161 | CCHmac(kCCHmacAlgSHA512, cKey, strlen(cKey), [hashData bytes], [hashData length], digest); 162 | 163 | NSString *encode = [self stringFromBytes:digest length:CC_SHA512_DIGEST_LENGTH]; 164 | free(digest); 165 | cKey = nil; 166 | return encode; 167 | } 168 | 169 | #pragma mark - Bytes转字符串 170 | /** 171 | 字符大小写可以通过修改“%02X”中的x修改,下面采用的是大写 172 | */ 173 | - (NSString *)stringFromBytes:(uint8_t *)bytes length:(int)length { 174 | NSMutableString *strM = [NSMutableString string]; 175 | 176 | for (int i = 0; i < length; i++) { 177 | [strM appendFormat:@"%02X", bytes[i]]; 178 | } 179 | 180 | return [strM copy]; 181 | } 182 | 183 | 184 | @end 185 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # EncryptionTools 2 | 加密工具： Base64 MD5 SHA1 SHA224 SHA256 SHA384 HMAC(SHA1~SHA512) AES DES RSA 3 | 4 | `NSString+Hash.m`与`NSString+Hash.h`文件实现了`MD5 SHA1 SHA224 SHA256 SHA384 HMAC(SHA1~SHA512)`可以单独拷贝出来使用 5 | 6 | `NSString+Encryption.m`与`NSString+Encryption.h`文件实现了AES DES RSA加密解密，也可以单独拷贝出来使用 7 | 8 | ## 更新NSString+Hash 9 | hmacSHA有笔误，错把 `const char *cKey = [key cStringUsingEncoding:NSUTF8StringEncoding];`写为`const char *cKey = [self cStringUsingEncoding:NSUTF8StringEncoding];`，感谢简书 @靓模袭地球 10 | 11 | --- 12 | 13 | --- 14 | 15 | ## 一、Base64编码 16 | Base64编码要求把3个8位字节`（3*8=24）`转化为4个6位的字节`（4*6=24）`，之后在6位的前面补两个0，形成8位一个字节的形式，这样每一个字节的有效位为6位，则取值范围0~63`0 ~ (2^6 - 1)`。如果最后剩下的字符不到3个字节，则用0填充，输出字符使用'='，因此我们看到Base64末尾会有1到2个'='。另外标准还要求每76个字符要插入换行(不过，这个视具体情况定)。 17 | 18 | iOS7之后苹果有自己的Base64编码解码API，NSData的扩展：`NSData (NSDataBase64Encoding)` 19 | 20 | 21 | #### 两种存储方式 22 | * 可见字符串形式 23 | 24 | 为了保证所输出的每一个编码字节都是可读字符，而不是0~63这些数字，Base64制作了一个码表，就像ASCII码表一样，每一个Base64码值都有对应的字符。64个可读字符从0到63非别是`A-Z、a-z、0-9、+、/`，这也是Base64名字的由来。 25 | 26 | * 以16进制形式 27 | 28 | 即NSData形式保存，Base64编码结果为字符，而这些字符又对应ASCII码表的码值，NSData就是存储ASCII码表的码值。 29 | 30 | 31 | #### 下面举个例子，并以苹果提供的API来详细介绍Base64编码解码过程： 32 | 33 | 假设我们对字符串"123"进行Base64编码，"123"对应的16进制是313233，二进制为`00110001、00110010、00110011`，将其变为4*6结果即下表中的第一行。然后根据Base64的码表，它们分别对应表中的第二行。那么"123"编码的最终结果即为MTIz，以字符串的形式保存。然后根据MTIz对应ASCII码值，以NSData形式存储，如表中的第三行。 34 | 35 | 转换为4*6结果 | 00001100 | 00010011 | 00001000 | 00110011 36 | ----|-------- | ---------- | --------- | -------- 37 | Base64对应字符|M | T | I | z 38 | 对应ASCII码值(16进制)|4d |54 | 49 |7a 39 | 40 | 上面的过程通过代码实现如下： 41 | 42 | ``` 43 | // 1 待编码的原始字符串 44 | NSString *plainStr = @"123"; 45 | // 2 将其转换成NSData保存，那么"123"对应的ASCII码表码值是31、32、33（16进制） 46 | NSData *plainData = [plainStr dataUsingEncoding:NSUTF8StringEncoding]; 47 | // 3.1 将其进行Base64编码，且结果以字符串形式保存，对应表中的第二行 48 | NSString *baseStr = [plainData base64EncodedStringWithOptions:0]; 49 | // 3.2 将其进行Base64编码，且结果以NSData形式保存 50 | NSData *base64Data = [plainData base64EncodedDataWithOptions:0]; 51 | ``` 52 | 另外对于参数NSDataBase64EncodingOptions选项，有多种取值 53 | 54 | * NSDataBase64Encoding64CharacterLineLength：每64个字符插入\r或\n 55 | * NSDataBase64Encoding76CharacterLineLength：每76个字符插入\r或\n，标准中有要求是76个字符要换行，不过具体还是自己定 56 | * NSDataBase64EncodingEndLineWithCarriageReturn：插入字符为\r 57 | * NSDataBase64EncodingEndLineWithLineFeed：插入字符为\n 58 | 59 | 前两个选项为是否允许插入字符，以及多少个字符长度插入，两个可以选其一或者都不选。后两个选项代表要插入的具体字符。比如我们想76个字符后插入一个\r则可以`NSDataBase64Encoding76CharacterLineLength | NSDataBase64EncodingEndLineWithCarriageReturn`。而在上面举的例子中选项为0，则代表不插入字符。 60 | 61 | #### 第三方框架 62 | 在iOS7之前我们一般用的都是第三方框架，比如nicklockwood写的[https://github.com/nicklockwood/Base64](https://github.com/nicklockwood/Base64)还有Google的GTMBase64，虽然苹果有了自己的实现，但是许多其它的加密框架都用到了它，所以还是要了解一下，另外它还提供任意长度字符插入`\r\n`，而苹果只能是64或76长度。 63 | 64 | ## 二、MD5、SHA1、SHA256、SHA512、HMAC实现 65 | 主要用于验证，防止信息被修改。介绍请参照[http://www.jianshu.com/p/003b85fd3e36](http://www.jianshu.com/p/003b85fd3e36)。 66 | 67 | 具体的实现参考第三方框架：[https://github.com/kelp404/CocoaSecurity](https://github.com/kelp404/CocoaSecurity)。非常全面，不过不是太方便，比如想要获得MD5结果 68 | 69 | ``` 70 | NSString *plainStr = @"123"; 71 | CocoaSecurityResult *md5 = [CocoaSecurity md5:plainStr]; 72 | // 获取md5结果 73 | NSString *md5Str = md5.hexLower; 74 | ``` 75 | 76 | 不能直接plainStr.MD5Hash就获得字符串形式的结果，这里我封装了一个，可以参见工程中的NSString+Hash类[https://github.com/mddios/EncryptionTools](https://github.com/mddios/EncryptionTools),可以直接对字符串进行操作，类似`plainStr.MD5Hash、plainStr.sha1Hash···plainStr.sha256Hash···`，非常方便。 77 | 78 | 比如对@"123"哈希，下面用上面提到的两种方法举例: 79 | 80 | ``` 81 | - (void)hashTest { 82 | NSString *plainStr = @"123"; 83 | // md5 84 | CocoaSecurityResult *md5 = [CocoaSecurity md5:plainStr]; 85 | NSLog(@"md5:%lu---%@---%@",plainStr.md5Hash.length, plainStr.md5Hash,md5.hex); 86 | // 40 87 | CocoaSecurityResult *sha1 = [CocoaSecurity sha1:plainStr]; 88 | NSLog(@"sha1:%lu---%@---%@",plainStr.sha1Hash.length, plainStr.sha1Hash,sha1.hex); 89 | // 56 90 | CocoaSecurityResult *sha224 = [CocoaSecurity sha224:plainStr]; 91 | NSLog(@"sha224:%lu---%@---%@",plainStr.sha224Hash.length,plainStr.sha224Hash,sha224.hex); 92 | // 64 93 | CocoaSecurityResult *sha256 = [CocoaSecurity sha256:plainStr]; 94 | NSLog(@"sha256:%lu---%@---%@",plainStr.sha256Hash.length,plainStr.sha256Hash,sha256.hex); 95 | // 96 96 | CocoaSecurityResult *sha384 = [CocoaSecurity sha384:plainStr]; 97 | NSLog(@"sha384:%lu---%@---%@",plainStr.sha384Hash.length,plainStr.sha384Hash,sha384.hex); 98 | // 128 99 | CocoaSecurityResult *sha512 = [CocoaSecurity sha512:plainStr]; 100 | NSLog(@"sha512:%lu---%@---%@",plainStr.sha512Hash.length,plainStr.sha512Hash,sha512.hex); 101 | 102 | // hmac 103 | CocoaSecurityResult *hmacmd5 = [CocoaSecurity hmacMd5:plainStr hmacKey:plainStr]; 104 | NSLog(@"hmacmd5:%lu---%@---%@",[plainStr hmacMD5WithKey:plainStr].length,[plainStr hmacMD5WithKey:plainStr],hmacmd5.hex); 105 | } 106 | ``` 107 | 108 | * 在电脑终端来获取结果 109 | 110 | 封装的代码中`NSString+Hash.h`头文件，有具体列出终端命令方法，如下： 111 | 112 | ``` 113 | /// 返回结果：32长度 终端命令：md5 -s "123" 114 | - (NSString *)md5Hash; 115 | 116 | /// 返回结果：40长度 终端命令：echo -n "123" | openssl sha -sha1 117 | - (NSString *)sha1Hash; 118 | 119 | /// 返回结果：56长度 终端命令：echo -n "123" | openssl sha -sha224 120 | - (NSString *)sha224Hash; 121 | 122 | /// 返回结果：64长度 终端命令：echo -n "123" | openssl sha -sha256 123 | - (NSString *)sha256Hash; 124 | 125 | /// 返回结果：96长度 终端命令：echo -n "123" | openssl sha -sha384 126 | - (NSString *)sha384Hash; 127 | 128 | /// 返回结果：128长度 终端命令：echo -n "123" | openssl sha -sha512 129 | - (NSString *)sha512Hash; 130 | 131 | #pragma mark - HMAC 132 | 133 | /// 返回结果：32长度 终端命令：echo -n "123" | openssl dgst -md5 -hmac "123" 134 | - (NSString *)hmacMD5WithKey:(NSString *)key; 135 | 136 | /// 返回结果：40长度 echo -n "123" | openssl sha -sha1 -hmac "123" 137 | - (NSString *)hmacSHA1WithKey:(NSString *)key; 138 | - (NSString *)hmacSHA224WithKey:(NSString *)key; 139 | - (NSString *)hmacSHA256WithKey:(NSString *)key; 140 | - (NSString *)hmacSHA384WithKey:(NSString *)key; 141 | - (NSString *)hmacSHA512WithKey:(NSString *)key; 142 | ``` 143 | 144 | 145 | * 关于MD5加盐，只是多了下面第一行 146 | 147 | ``` 148 | plainStr = [plainStr stringByAppendingString:salt]; 149 | NSString *md5Str = plainStr.md5Hash; 150 | ``` 151 | 152 | 博客： 153 | 154 | * [http://www.jianshu.com/p/185a581e7afa](http://www.jianshu.com/p/185a581e7afa) 155 | * [http://www.cnblogs.com/mddblog/p/5512708.html](http://www.cnblogs.com/mddblog/p/5512708.html) 156 | -------------------------------------------------------------------------------- /EncryptionTools/EncryptionTools/ViewController.m: -------------------------------------------------------------------------------- 1 | // 2 | // ViewController.m 3 | // EncryptionTools 4 | // 5 | // Created by mdd on 16/5/17. 6 | // Copyright © 2016年 com.personal. All rights reserved. 7 | // 8 | 9 | #import "ViewController.h" 10 | #import "NSString+Hash.h" 11 | #import "CocoaSecurity.h" 12 | #import "NSString+Encryption.h" 13 | #import "RSA.h" 14 | 15 | @interface ViewController () 16 | @property (nonatomic, strong) NSData *data; 17 | @end 18 | 19 | @implementation ViewController 20 | 21 | - (void)viewDidLoad { 22 | [super viewDidLoad]; 23 | // [self base64Test]; 24 | 25 | [self hashTest]; 26 | 27 | // [self aesCBCTest]; 28 | // [self aesECBTest]; 29 | // [self desTest]; 30 | // 31 | // [self rsaTest]; 32 | // [self blockTest]; 33 | } 34 | 35 | - (void)base64Test { 36 | // 1 待编码的原始字符串 37 | NSString *plainStr = @"123"; 38 | // 2 将其转换成NSData保存，那么"123"对应的ASCII码表码值是31、32、33（16进制） 39 | NSData *plainData = [plainStr dataUsingEncoding:NSUTF8StringEncoding]; 40 | // 3.1 将其进行Base64编码，且结果以字符串形式保存 41 | NSString *baseStr = [plainData base64EncodedStringWithOptions:NSDataBase64Encoding64CharacterLineLength]; 42 | // 3.2 将其进行Base64编码，且结果以NSData形式保存 43 | NSData *base64Data = [plainData base64EncodedDataWithOptions:0]; 44 | 45 | NSLog(@"%@---%@---%@---%@", plainData,base64Data,[NSString stringWithUTF8String:[base64Data bytes]],baseStr); 46 | } 47 | 48 | - (void)hashTest { 49 | NSString *plainStr = @"123"; 50 | NSString *key = @"456"; 51 | // md5 52 | CocoaSecurityResult *md5 = [CocoaSecurity md5:plainStr]; 53 | NSLog(@"md5:%lu---%@---%@",plainStr.md5Hash.length, plainStr.md5Hash,md5.hex); 54 | // 40 55 | CocoaSecurityResult *sha1 = [CocoaSecurity sha1:plainStr]; 56 | NSLog(@"sha1:%lu---%@---%@",plainStr.sha1Hash.length, plainStr.sha1Hash,sha1.hex); 57 | // 56 58 | CocoaSecurityResult *sha224 = [CocoaSecurity sha224:plainStr]; 59 | NSLog(@"sha224:%lu---%@---%@",plainStr.sha224Hash.length,plainStr.sha224Hash,sha224.hex); 60 | // 64 61 | CocoaSecurityResult *sha256 = [CocoaSecurity sha256:plainStr]; 62 | NSLog(@"sha256:%lu---%@---%@",plainStr.sha256Hash.length,plainStr.sha256Hash,sha256.hex); 63 | // 96 64 | CocoaSecurityResult *sha384 = [CocoaSecurity sha384:plainStr]; 65 | NSLog(@"sha384:%lu---%@---%@",plainStr.sha384Hash.length,plainStr.sha384Hash,sha384.hex); 66 | // 128 67 | CocoaSecurityResult *sha512 = [CocoaSecurity sha512:plainStr]; 68 | NSLog(@"sha512:%lu---%@---%@",plainStr.sha512Hash.length,plainStr.sha512Hash,sha512.hex); 69 | 70 | /// hmac 71 | CocoaSecurityResult *hmacmd5 = [CocoaSecurity hmacMd5:plainStr hmacKey:key]; 72 | NSLog(@"hmacmd5:%lu---%@---%@",[plainStr hmacMD5WithKey:plainStr].length,[plainStr hmacMD5WithKey:key],hmacmd5.hex); 73 | 74 | CocoaSecurityResult *hmacSHA1 = [CocoaSecurity hmacSha1:plainStr hmacKey:key]; 75 | NSLog(@"hmacmd5:%lu---%@---%@",[plainStr hmacSHA1WithKey:key].length,[plainStr hmacSHA1WithKey:key],hmacSHA1.hex); 76 | } 77 | 78 | - (void)blockTest { 79 | NSString *str = @"123"; 80 | 81 | CocoaSecurityResult *md5 = [CocoaSecurity md5:str]; 82 | CocoaSecurityResult *result1 = [CocoaSecurity md5WithData:md5.data]; 83 | CocoaSecurityResult *result2 = [CocoaSecurity md5:md5.hexLower]; 84 | 85 | NSLog(@"%@ -- %@",[md5.hexLower dataUsingEncoding:NSUTF8StringEncoding],md5.data); 86 | NSLog(@"%@", result1.hexLower); 87 | NSLog(@"%@", result2.hexLower); 88 | } 89 | 90 | - (void)aesCBCTest { 91 | NSString *plainText = @"123"; 92 | 93 | NSString *key128 = @"0123456789ABCDEF"; 94 | // 16进制字符串 95 | NSString *key128Hex = @"30313233343536373839414243444546"; 96 | 97 | NSString *iv = @"0123456789ABCDEF"; 98 | // 16进制字符串 99 | NSString *ivHex = @"30313233343536373839414243444546"; 100 | 101 | CocoaSecurityResult *result = [CocoaSecurity aesEncrypt:plainText hexKey:key128Hex hexIv:ivHex]; 102 | 103 | NSString *aesBase64 = [plainText aesEncryptWithKey:key128 iv:iv]; 104 | NSData *aesData = [plainText aesEncryptWithDataKey:[key128 dataUsingEncoding:NSUTF8StringEncoding] dataIv:[iv dataUsingEncoding:NSUTF8StringEncoding]]; 105 | NSLog(@"SecurityResult加密：\r\n%@ --- %@",result.base64,result.hexLower); 106 | NSLog(@"NSString+Encryption加密：\r\n%@ --- %@",aesBase64,aesData); 107 | 108 | // 解密 109 | NSString *decryptStr = [aesBase64 aesBase64StringDecryptWithHexKey:key128Hex hexIv:ivHex]; 110 | NSData *data = [NSString aesDecryptWithData:aesData dataKey:[key128 dataUsingEncoding:NSUTF8StringEncoding] dataIv:[iv dataUsingEncoding:NSUTF8StringEncoding]]; 111 | NSLog(@"解密：%@ --- %@",decryptStr,data); 112 | } 113 | 114 | - (void)aesECBTest { 115 | NSString *plainText = @"123"; 116 | 117 | NSString *key128 = @"0123456789ABCDEF"; 118 | NSString *key128Hex = @"30313233343536373839414243444546"; 119 | 120 | NSString *aesBase64 = [plainText aesECBEncryptWithKey:key128]; 121 | NSData *aesData = [plainText aesECBEncryptWithDataKey:[key128 dataUsingEncoding:NSUTF8StringEncoding]]; 122 | NSLog(@"加密：%@ --- %@",aesBase64, aesData); 123 | 124 | // 解密 125 | NSString *decStr = [aesBase64 aesECBBase64StringDecryptWithHexKey:key128Hex]; 126 | NSData *decData = [NSString aesECBDecryptWithData:aesData withDataKey:[key128 dataUsingEncoding:NSUTF8StringEncoding]]; 127 | NSLog(@"解密：%@---%@",decStr, decData); 128 | } 129 | 130 | - (void)desTest { 131 | NSString *plainText = @"123"; 132 | 133 | NSString *key = @"01234567"; 134 | NSString *desBase64 = [plainText desEncryptWithKey:key]; 135 | NSData *keydata = [key dataUsingEncoding:NSUTF8StringEncoding]; 136 | NSData *desData = [plainText desEncryptWithDataKey:keydata]; 137 | 138 | NSLog(@"DES加密：%@ --- %@",desBase64,desData); 139 | 140 | NSString *decryptStr = [desBase64 desDecryptWithKey:key]; 141 | NSData *data = [NSString desDecryptWithData:desData dataKey:keydata]; 142 | NSLog(@"解密：%@ --- %@",decryptStr,data); 143 | } 144 | 145 | - (void)rsaTest { 146 | NSString *plainText = @"123"; 147 | NSString *privateKey = @"\ 148 | -----BEGIN PRIVATE KEY-----\ 149 | MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAM7GhkiwVsUx5HQ5\ 150 | adz+wXkDcaPQFaygKVBbcEqC8xDzlldUIzruDpci2XmxJbYTIxoh5Dy1GwzQcjig\ 151 | K+U4yNJWB3JmaptR9pkOgNg9bakNsuowOv+jV4rFimyxsDIfpkPIl5M4S73IXtdS\ 152 | wiKWiTNzQP2L649zzKn+8thM8MkRAgMBAAECgYAVQx69zLwvbND0Do9PNTcJzYva\ 153 | 72O7K4D0DWL/lnWOEa4s7q7suVvwuJmqRMf+7/rVDhUdFPZiG/ES142L9YnYv7XB\ 154 | NlhZsT80gcGWzh1MO3hqIwZQbbLq4FwU+YH3uyNPeh9w4dVm4VzzSS3KFW6/Hmiw\ 155 | HyhtkduOf7eGf+kgXQJBAPHVuiWW7ddcvTxgmtLWakHcX/zsddzENrR1ZSioFFQI\ 156 | +OoL7xK7Fp108rpEW+RvVTJYk3NDkxvc5m3rn+yKl0MCQQDa4xZ/S6RNGHGIRiFk\ 157 | gkNJoRFh5pYVT6ZzqYLb/9Ny/LuGV0F7XmftRA0paXsNsjdns2a4o9r6tarABKq0\ 158 | EAcbAkA5q/uJbVXpDx+931fswd9zN2fYvFdbP5vAK2LlcDfw1nbt8cygzecVw8cC\ 159 | 7rxvXLGXoRIA4fOaKHL3ccKguWhbAkBGh1ePatMlGFQ0wcwus5500hZkwkTn1wNe\ 160 | T2df9f2vFmpiLilmVBQOqpfHGTrSPfOGUZMuuXVsxS6gsqBCZsuzAkAh+/VXDXxh\ 161 | wR7FY8GSfmIq5+7QWjv5nvvqUMtg/WQ3JBl6iGh8ABZg1C8dnhZOmIjGLYVn3EhG\ 162 | 74zuyawizSHa\ 163 | -----END PRIVATE KEY-----\ 164 | "; 165 | 166 | NSString *publicKey = @"\ 167 | -----BEGIN PUBLIC KEY-----\ 168 | MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDOxoZIsFbFMeR0OWnc/sF5A3Gj\ 169 | 0BWsoClQW3BKgvMQ85ZXVCM67g6XItl5sSW2EyMaIeQ8tRsM0HI4oCvlOMjSVgdy\ 170 | ZmqbUfaZDoDYPW2pDbLqMDr/o1eKxYpssbAyH6ZDyJeTOEu9yF7XUsIilokzc0D9\ 171 | i+uPc8yp/vLYTPDJEQIDAQAB\ 172 | -----END PUBLIC KEY-----\ 173 | "; 174 | 175 | NSString *encWithPubKey = [RSA encryptString:plainText publicKey:publicKey]; 176 | NSString *decWithPrivKey = [RSA decryptString:encWithPubKey privateKey:privateKey]; 177 | 178 | NSLog(@"RSA:%@ --- %@",encWithPubKey,decWithPrivKey); 179 | } 180 | 181 | @end 182 | 183 | 184 | 185 | 186 | -------------------------------------------------------------------------------- /EncryptionTools/EncryptionTools/Encryptions/NSString+Encryption/NSString+Encryption.m: -------------------------------------------------------------------------------- 1 | // 2 | // NSString+Encryption.m 3 | // EncryptionTools 4 | // 5 | // Created by mdd on 16/4/2. 6 | // Copyright © 2016年 com.personal. All rights reserved. 7 | // 8 | 9 | #import "NSString+Encryption.h" 10 | #import "NSString+Hash.h" 11 | 12 | @implementation NSString (Encryption) 13 | 14 | #pragma mark - AES加密 15 | 16 | /* 17 | 默认CBC模式，返回base64编码 18 | */ 19 | - (NSString *)aesEncryptWithHexKey:(NSString *)key hexIv:(NSString *)iv { 20 | NSData *aesKey = [key dataFromHexString]; 21 | if (iv == nil) { 22 | // 32长度 23 | iv = @"00000000000000000000000000000000"; 24 | } 25 | NSData *aesIv = [iv dataFromHexString]; 26 | NSData *resultData = [self aesEncryptWithDataKey:aesKey dataIv:aesIv]; 27 | return [resultData base64EncodedStringWithOptions:0]; 28 | } 29 | 30 | /* 31 | 默认CBC模式，返回base64编码 32 | */ 33 | - (NSString *)aesEncryptWithKey:(NSString *)key iv:(NSString *)iv { 34 | NSData *aesKey = [key dataUsingEncoding:NSUTF8StringEncoding]; 35 | if (iv == nil) { 36 | // 32长度 37 | iv = @"00000000000000000000000000000000"; 38 | } 39 | NSData *aesIv = [iv dataUsingEncoding:NSUTF8StringEncoding]; 40 | NSData *resultData = [self aesEncryptWithDataKey:aesKey dataIv:aesIv]; 41 | return [resultData base64EncodedStringWithOptions:0]; 42 | } 43 | 44 | /* 45 | CBC模式，返回NSData 46 | */ 47 | - (NSData *)aesEncryptWithDataKey:(NSData *)key dataIv:(NSData *)iv { 48 | return [self aesEncryptOrDecrypt:kCCEncrypt data:[self dataUsingEncoding:NSUTF8StringEncoding] dataKey:key dataIv:iv mode:kPaddingMode]; 49 | } 50 | 51 | /* 52 | ECB模式，返回base64编码 53 | */ 54 | - (NSString *)aesECBEncryptWithHexKey:(NSString *)key { 55 | NSData *aesKey = [key dataFromHexString]; 56 | NSData *resultData = [self aesECBEncryptWithDataKey:aesKey]; 57 | return [resultData base64EncodedStringWithOptions:0]; 58 | } 59 | 60 | /* 61 | ECB模式，返回base64编码 62 | */ 63 | - (NSString *)aesECBEncryptWithKey:(NSString *)key { 64 | NSData *aesKey = [key dataUsingEncoding:NSUTF8StringEncoding]; 65 | NSData *resultData = [self aesECBEncryptWithDataKey:aesKey]; 66 | return [resultData base64EncodedStringWithOptions:0]; 67 | } 68 | 69 | /* 70 | ECB模式，返回base64 71 | */ 72 | - (NSString *)aesECBEncryptWithBase64Key:(NSString *)key { 73 | NSData *aesKey = [[NSData alloc] initWithBase64EncodedString:key options:NSDataBase64DecodingIgnoreUnknownCharacters]; 74 | NSData *resultData = [self aesECBEncryptWithDataKey:aesKey]; 75 | return [resultData base64EncodedStringWithOptions:0]; 76 | } 77 | 78 | /* 79 | ECB模式，返回NSData 80 | */ 81 | - (NSData *)aesECBEncryptWithDataKey:(NSData *)key { 82 | NSData *aesIv = [@"00000000000000000000000000000000" dataFromHexString]; 83 | return [self aesEncryptOrDecrypt:kCCEncrypt data:[self dataUsingEncoding:NSUTF8StringEncoding] dataKey:key dataIv:aesIv mode:kPaddingMode | kCCOptionECBMode]; 84 | } 85 | 86 | #pragma mark - AES解密 87 | 88 | /* 89 | 默认CBC模式解密，默认string为base64格式 90 | */ 91 | - (NSString *)aesBase64StringDecryptWithHexKey:(NSString *)key hexIv:(NSString *)iv { 92 | NSData *aesKey = [key dataFromHexString]; 93 | if (iv == nil) { 94 | // 32长度 95 | iv = @"00000000000000000000000000000000"; 96 | } 97 | NSData *aesIv = [iv dataFromHexString]; 98 | NSData *data = [[NSData alloc] initWithBase64EncodedString:self options:0]; 99 | NSData *resultData = [NSString aesDecryptWithData:data dataKey:aesKey dataIv:aesIv]; 100 | return [[NSString alloc] initWithData:resultData encoding:NSUTF8StringEncoding]; 101 | } 102 | 103 | /* 104 | CBC模式解密，返回NSData 105 | */ 106 | + (NSData *)aesDecryptWithData:(NSData *)data dataKey:(NSData *)key dataIv:(NSData *)iv { 107 | return [[NSString alloc] aesEncryptOrDecrypt:kCCDecrypt data:data dataKey:key dataIv:iv mode:kPaddingMode]; 108 | } 109 | 110 | /* 111 | ECB模式解密，要求输入为Base64格式，返回为NSString 112 | */ 113 | - (NSString *)aesECBBase64StringDecryptWithHexKey:(NSString *)key { 114 | NSData *aesKey = [key dataFromHexString]; 115 | NSData *data = [[NSData alloc] initWithBase64EncodedString:self options:0]; 116 | NSData *resultData = [NSString aesECBDecryptWithData:data withDataKey:aesKey]; 117 | return [[NSString alloc] initWithData:resultData encoding:NSUTF8StringEncoding]; 118 | } 119 | 120 | /* 121 | ECB模式解密，要求输入为Base64格式，返回为NSString 122 | */ 123 | - (NSString *)aesECBBase64StringDecryptWithBase64Key:(NSString *)key { 124 | NSData *aesKey = [[NSData alloc] initWithBase64EncodedString:key options:NSDataBase64DecodingIgnoreUnknownCharacters]; 125 | NSData *data = [[NSData alloc] initWithBase64EncodedString:self options:0]; 126 | NSData *resultData = [NSString aesECBDecryptWithData:data withDataKey:aesKey]; 127 | return [[NSString alloc] initWithData:resultData encoding:NSUTF8StringEncoding]; 128 | } 129 | 130 | /* 131 | ECB模式解密，返回为NSData 132 | */ 133 | + (NSData *)aesECBDecryptWithData:(NSData *)data withDataKey:(NSData *)key{ 134 | NSData *aesIv = [@"00000000000000000000000000000000" dataFromHexString]; 135 | return [[NSString alloc] aesEncryptOrDecrypt:kCCDecrypt data:data dataKey:key dataIv:aesIv mode:kPaddingMode | kCCOptionECBMode]; 136 | } 137 | 138 | ///* 139 | // ECB模式解密，返回base64编码 140 | // */ 141 | //- (NSString *)aesECBDecryptWithHexKey:(NSString *)key { 142 | // NSData *aesKey = [key dataFromHexString]; 143 | // NSData *resultData = [self aesECBEncryptWithDataKey:aesKey]; 144 | // return [[NSString alloc] initWithData:resultData encoding:NSUTF8StringEncoding];; 145 | //} 146 | // 147 | ///* 148 | // ECB模式解密，返回NSData 149 | // */ 150 | //- (NSData *)aesECBDecryptWithDataKey:(NSData *)key { 151 | // NSData *aesIv = [@"00000000000000000000000000000000" dataFromHexString]; 152 | // return [self aesEncryptOrDecrypt:kCCDecrypt data:[self dataUsingEncoding:NSUTF8StringEncoding] dataKey:key dataIv:aesIv mode:kPaddingMode | kCCOptionECBMode]; 153 | //} 154 | 155 | 156 | - (NSData *)aesEncryptOrDecrypt:(CCOperation)option data:(NSData *)data dataKey:(NSData *)key dataIv:(NSData *)iv mode:(int)mode{ 157 | // check length of key and iv 158 | if ([iv length] != 16) { 159 | @throw [NSException exceptionWithName:@"Encrypt" 160 | reason:@"Length of iv is wrong. Length of iv should be 16(128bits)" 161 | userInfo:nil]; 162 | } 163 | if ([key length] != 16 && [key length] != 24 && [key length] != 32 ) { 164 | @throw [NSException exceptionWithName:@"Encrypt" 165 | reason:@"Length of key is wrong. Length of iv should be 16, 24 or 32(128, 192 or 256bits)" 166 | userInfo:nil]; 167 | } 168 | 169 | // setup output buffer 170 | size_t bufferSize = [data length] + kCCBlockSizeAES128; 171 | void *buffer = malloc(bufferSize); 172 | 173 | // do encrypt 174 | size_t encryptedSize = 0; 175 | CCCryptorStatus cryptStatus = CCCrypt(option, 176 | kCCAlgorithmAES128, 177 | mode, 178 | [key bytes], // Key 179 | [key length], // kCCKeySizeAES 180 | [iv bytes], // IV 181 | [data bytes], 182 | [data length], 183 | buffer, 184 | bufferSize, 185 | &encryptedSize); 186 | NSData *resultData = nil; 187 | if (cryptStatus == kCCSuccess) { 188 | NSData *resultData = [NSData dataWithBytes:buffer length:encryptedSize]; 189 | free(buffer); 190 | return resultData; 191 | } else { 192 | free(buffer); 193 | @throw [NSException exceptionWithName:@"Encrypt" 194 | reason:@"Encrypt Error!" 195 | userInfo:nil]; 196 | return resultData; 197 | } 198 | return resultData; 199 | } 200 | 201 | #pragma mark - DES加密 202 | 203 | /* 204 | DES加密 key为NSString形式 结果返回base64编码 205 | */ 206 | - (NSString *)desEncryptWithKey:(NSString *)key { 207 | NSData *desKey = [key dataUsingEncoding:NSUTF8StringEncoding]; 208 | NSData *resultData = [self desEncryptWithDataKey:desKey]; 209 | return [resultData base64EncodedStringWithOptions:0]; 210 | } 211 | 212 | /* 213 | DES加密 key为NSData形式 结果返回NSData 214 | */ 215 | - (NSData *)desEncryptWithDataKey:(NSData *)key { 216 | return [self desEncryptOrDecrypt:kCCEncrypt data:[self dataUsingEncoding:NSUTF8StringEncoding] dataKey:key mode:kPaddingMode | kCCOptionECBMode]; 217 | } 218 | 219 | #pragma mark - DES解密 220 | 221 | - (NSString *)desDecryptWithKey:(NSString *)key { 222 | NSData *desKey = [key dataUsingEncoding:NSUTF8StringEncoding]; 223 | NSData *data = [[NSData alloc] initWithBase64EncodedString:self options:0]; 224 | NSData *resultData = [NSString desDecryptWithData:data dataKey:desKey]; 225 | return [[NSString alloc] initWithData:resultData encoding:NSUTF8StringEncoding]; 226 | } 227 | 228 | + (NSData *)desDecryptWithData:(NSData *)data dataKey:(NSData *)key { 229 | return [[NSString alloc] desEncryptOrDecrypt:kCCDecrypt data:data dataKey:key mode:kPaddingMode | kCCOptionECBMode]; 230 | } 231 | 232 | - (NSData *)desEncryptOrDecrypt:(CCOperation)option data:(NSData *)data dataKey:(NSData *)key mode:(int)mode{ 233 | // if ([key length] != 16 && [key length] != 24 && [key length] != 32 ) { 234 | // @throw [NSException exceptionWithName:@"Encrypt" 235 | // reason:@"Length of key is wrong. Length of iv should be 16, 24 or 32(128, 192 or 256bits)" 236 | // userInfo:nil]; 237 | // } 238 | 239 | // setup output buffer 240 | size_t bufferSize = [data length] + kCCBlockSizeDES; 241 | void *buffer = malloc(bufferSize); 242 | 243 | // do encrypt 244 | size_t encryptedSize = 0; 245 | CCCryptorStatus cryptStatus = CCCrypt(option, 246 | kCCAlgorithmDES, 247 | mode, 248 | [key bytes], // Key 249 | kCCKeySizeDES, // kCCKeySizeAES 250 | NULL, // IV 251 | [data bytes], 252 | [data length], 253 | buffer, 254 | bufferSize, 255 | &encryptedSize); 256 | NSData *resultData = nil; 257 | if (cryptStatus == kCCSuccess) { 258 | NSData *resultData = [NSData dataWithBytes:buffer length:encryptedSize]; 259 | free(buffer); 260 | return resultData; 261 | } else { 262 | free(buffer); 263 | @throw [NSException exceptionWithName:@"Encrypt" 264 | reason:@"Encrypt Error!" 265 | userInfo:nil]; 266 | return resultData; 267 | } 268 | return resultData; 269 | } 270 | 271 | /** 272 | hex形式的字符串转换为data 273 | */ 274 | - (NSData *)dataFromHexString { 275 | 276 | if (self.length == 0) { 277 | return nil; 278 | } 279 | 280 | static const unsigned char HexDecodeChars[] = { 281 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 282 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 283 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 284 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 285 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, //49 286 | 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, //59 287 | 0, 0, 0, 0, 0, 10, 11, 12, 13, 14, 288 | 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, //79 289 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 290 | 0, 0, 0, 0, 0, 0, 0, 10, 11, 12, //99 291 | 13, 14, 15 292 | }; 293 | 294 | // convert data(NSString) to CString 295 | const char *source = [self cStringUsingEncoding:NSUTF8StringEncoding]; 296 | // malloc buffer 297 | unsigned char *buffer; 298 | NSUInteger length = strlen(source) / 2; 299 | buffer = malloc(length); 300 | for (NSUInteger index = 0; index < length; index++) { 301 | buffer[index] = (HexDecodeChars[source[index * 2]] << 4) + (HexDecodeChars[source[index * 2 + 1]]); 302 | } 303 | // init result NSData 304 | NSData *result = [NSData dataWithBytes:buffer length:length]; 305 | free(buffer); 306 | source = nil; 307 | 308 | return result; 309 | } 310 | 311 | @end 312 | 313 | 314 | -------------------------------------------------------------------------------- /EncryptionTools/EncryptionTools/Encryptions/RSAEncrypt/RSA.m: -------------------------------------------------------------------------------- 1 | /* 2 | @author: ideawu 3 | @link: https://github.com/ideawu/Objective-C-RSA 4 | */ 5 | 6 | #import "RSA.h" 7 | #import 8 | 9 | @implementation RSA 10 | 11 | /* 12 | static NSString *base64_encode(NSString *str){ 13 | NSData* data = [str dataUsingEncoding:NSUTF8StringEncoding]; 14 | if(!data){ 15 | return nil; 16 | } 17 | return base64_encode_data(data); 18 | } 19 | */ 20 | 21 | static NSString *base64_encode_data(NSData *data){ 22 | data = [data base64EncodedDataWithOptions:0]; 23 | NSString *ret = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding]; 24 | return ret; 25 | } 26 | 27 | static NSData *base64_decode(NSString *str){ 28 | NSData *data = [[NSData alloc] initWithBase64EncodedString:str options:NSDataBase64DecodingIgnoreUnknownCharacters]; 29 | return data; 30 | } 31 | 32 | + (NSData *)stripPublicKeyHeader:(NSData *)d_key{ 33 | // Skip ASN.1 public key header 34 | if (d_key == nil) return(nil); 35 | 36 | unsigned long len = [d_key length]; 37 | if (!len) return(nil); 38 | 39 | unsigned char *c_key = (unsigned char *)[d_key bytes]; 40 | unsigned int idx = 0; 41 | 42 | if (c_key[idx++] != 0x30) return(nil); 43 | 44 | if (c_key[idx] > 0x80) idx += c_key[idx] - 0x80 + 1; 45 | else idx++; 46 | 47 | // PKCS #1 rsaEncryption szOID_RSA_RSA 48 | static unsigned char seqiod[] = 49 | { 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 50 | 0x01, 0x05, 0x00 }; 51 | if (memcmp(&c_key[idx], seqiod, 15)) return(nil); 52 | 53 | idx += 15; 54 | 55 | if (c_key[idx++] != 0x03) return(nil); 56 | 57 | if (c_key[idx] > 0x80) idx += c_key[idx] - 0x80 + 1; 58 | else idx++; 59 | 60 | if (c_key[idx++] != '\0') return(nil); 61 | 62 | // Now make a new NSData from this buffer 63 | return([NSData dataWithBytes:&c_key[idx] length:len - idx]); 64 | } 65 | 66 | //credit: http://hg.mozilla.org/services/fx-home/file/tip/Sources/NetworkAndStorage/CryptoUtils.m#l1036 67 | + (NSData *)stripPrivateKeyHeader:(NSData *)d_key{ 68 | // Skip ASN.1 private key header 69 | if (d_key == nil) return(nil); 70 | 71 | unsigned long len = [d_key length]; 72 | if (!len) return(nil); 73 | 74 | unsigned char *c_key = (unsigned char *)[d_key bytes]; 75 | unsigned int idx = 22; //magic byte at offset 22 76 | 77 | if (0x04 != c_key[idx++]) return nil; 78 | 79 | //calculate length of the key 80 | unsigned int c_len = c_key[idx++]; 81 | int det = c_len & 0x80; 82 | if (!det) { 83 | c_len = c_len & 0x7f; 84 | } else { 85 | int byteCount = c_len & 0x7f; 86 | if (byteCount + idx > len) { 87 | //rsa length field longer than buffer 88 | return nil; 89 | } 90 | unsigned int accum = 0; 91 | unsigned char *ptr = &c_key[idx]; 92 | idx += byteCount; 93 | while (byteCount) { 94 | accum = (accum << 8) + *ptr; 95 | ptr++; 96 | byteCount--; 97 | } 98 | c_len = accum; 99 | } 100 | 101 | // Now make a new NSData from this buffer 102 | return [d_key subdataWithRange:NSMakeRange(idx, c_len)]; 103 | } 104 | 105 | + (SecKeyRef)addPublicKey:(NSString *)key{ 106 | NSRange spos = [key rangeOfString:@"-----BEGIN PUBLIC KEY-----"]; 107 | NSRange epos = [key rangeOfString:@"-----END PUBLIC KEY-----"]; 108 | if(spos.location != NSNotFound && epos.location != NSNotFound){ 109 | NSUInteger s = spos.location + spos.length; 110 | NSUInteger e = epos.location; 111 | NSRange range = NSMakeRange(s, e-s); 112 | key = [key substringWithRange:range]; 113 | } 114 | key = [key stringByReplacingOccurrencesOfString:@"\r" withString:@""]; 115 | key = [key stringByReplacingOccurrencesOfString:@"\n" withString:@""]; 116 | key = [key stringByReplacingOccurrencesOfString:@"\t" withString:@""]; 117 | key = [key stringByReplacingOccurrencesOfString:@" " withString:@""]; 118 | 119 | // This will be base64 encoded, decode it. 120 | NSData *data = base64_decode(key); 121 | data = [RSA stripPublicKeyHeader:data]; 122 | if(!data){ 123 | return nil; 124 | } 125 | 126 | //a tag to read/write keychain storage 127 | NSString *tag = @"RSAUtil_PubKey"; 128 | NSData *d_tag = [NSData dataWithBytes:[tag UTF8String] length:[tag length]]; 129 | 130 | // Delete any old lingering key with the same tag 131 | NSMutableDictionary *publicKey = [[NSMutableDictionary alloc] init]; 132 | [publicKey setObject:(__bridge id) kSecClassKey forKey:(__bridge id)kSecClass]; 133 | [publicKey setObject:(__bridge id) kSecAttrKeyTypeRSA forKey:(__bridge id)kSecAttrKeyType]; 134 | [publicKey setObject:d_tag forKey:(__bridge id)kSecAttrApplicationTag]; 135 | SecItemDelete((__bridge CFDictionaryRef)publicKey); 136 | 137 | // Add persistent version of the key to system keychain 138 | [publicKey setObject:data forKey:(__bridge id)kSecValueData]; 139 | [publicKey setObject:(__bridge id) kSecAttrKeyClassPublic forKey:(__bridge id) 140 | kSecAttrKeyClass]; 141 | [publicKey setObject:[NSNumber numberWithBool:YES] forKey:(__bridge id) 142 | kSecReturnPersistentRef]; 143 | 144 | CFTypeRef persistKey = nil; 145 | OSStatus status = SecItemAdd((__bridge CFDictionaryRef)publicKey, &persistKey); 146 | if (persistKey != nil){ 147 | CFRelease(persistKey); 148 | } 149 | if ((status != noErr) && (status != errSecDuplicateItem)) { 150 | return nil; 151 | } 152 | 153 | [publicKey removeObjectForKey:(__bridge id)kSecValueData]; 154 | [publicKey removeObjectForKey:(__bridge id)kSecReturnPersistentRef]; 155 | [publicKey setObject:[NSNumber numberWithBool:YES] forKey:(__bridge id)kSecReturnRef]; 156 | [publicKey setObject:(__bridge id) kSecAttrKeyTypeRSA forKey:(__bridge id)kSecAttrKeyType]; 157 | 158 | // Now fetch the SecKeyRef version of the key 159 | SecKeyRef keyRef = nil; 160 | status = SecItemCopyMatching((__bridge CFDictionaryRef)publicKey, (CFTypeRef *)&keyRef); 161 | if(status != noErr){ 162 | return nil; 163 | } 164 | return keyRef; 165 | } 166 | 167 | + (SecKeyRef)addPrivateKey:(NSString *)key{ 168 | NSRange spos; 169 | NSRange epos; 170 | spos = [key rangeOfString:@"-----BEGIN RSA PRIVATE KEY-----"]; 171 | if(spos.length > 0){ 172 | epos = [key rangeOfString:@"-----END RSA PRIVATE KEY-----"]; 173 | }else{ 174 | spos = [key rangeOfString:@"-----BEGIN PRIVATE KEY-----"]; 175 | epos = [key rangeOfString:@"-----END PRIVATE KEY-----"]; 176 | } 177 | if(spos.location != NSNotFound && epos.location != NSNotFound){ 178 | NSUInteger s = spos.location + spos.length; 179 | NSUInteger e = epos.location; 180 | NSRange range = NSMakeRange(s, e-s); 181 | key = [key substringWithRange:range]; 182 | } 183 | key = [key stringByReplacingOccurrencesOfString:@"\r" withString:@""]; 184 | key = [key stringByReplacingOccurrencesOfString:@"\n" withString:@""]; 185 | key = [key stringByReplacingOccurrencesOfString:@"\t" withString:@""]; 186 | key = [key stringByReplacingOccurrencesOfString:@" " withString:@""]; 187 | 188 | // This will be base64 encoded, decode it. 189 | NSData *data = base64_decode(key); 190 | data = [RSA stripPrivateKeyHeader:data]; 191 | if(!data){ 192 | return nil; 193 | } 194 | 195 | //a tag to read/write keychain storage 196 | NSString *tag = @"RSAUtil_PrivKey"; 197 | NSData *d_tag = [NSData dataWithBytes:[tag UTF8String] length:[tag length]]; 198 | 199 | // Delete any old lingering key with the same tag 200 | NSMutableDictionary *privateKey = [[NSMutableDictionary alloc] init]; 201 | [privateKey setObject:(__bridge id) kSecClassKey forKey:(__bridge id)kSecClass]; 202 | [privateKey setObject:(__bridge id) kSecAttrKeyTypeRSA forKey:(__bridge id)kSecAttrKeyType]; 203 | [privateKey setObject:d_tag forKey:(__bridge id)kSecAttrApplicationTag]; 204 | SecItemDelete((__bridge CFDictionaryRef)privateKey); 205 | 206 | // Add persistent version of the key to system keychain 207 | [privateKey setObject:data forKey:(__bridge id)kSecValueData]; 208 | [privateKey setObject:(__bridge id) kSecAttrKeyClassPrivate forKey:(__bridge id) 209 | kSecAttrKeyClass]; 210 | [privateKey setObject:[NSNumber numberWithBool:YES] forKey:(__bridge id) 211 | kSecReturnPersistentRef]; 212 | 213 | CFTypeRef persistKey = nil; 214 | OSStatus status = SecItemAdd((__bridge CFDictionaryRef)privateKey, &persistKey); 215 | if (persistKey != nil){ 216 | CFRelease(persistKey); 217 | } 218 | if ((status != noErr) && (status != errSecDuplicateItem)) { 219 | return nil; 220 | } 221 | 222 | [privateKey removeObjectForKey:(__bridge id)kSecValueData]; 223 | [privateKey removeObjectForKey:(__bridge id)kSecReturnPersistentRef]; 224 | [privateKey setObject:[NSNumber numberWithBool:YES] forKey:(__bridge id)kSecReturnRef]; 225 | [privateKey setObject:(__bridge id) kSecAttrKeyTypeRSA forKey:(__bridge id)kSecAttrKeyType]; 226 | 227 | // Now fetch the SecKeyRef version of the key 228 | SecKeyRef keyRef = nil; 229 | status = SecItemCopyMatching((__bridge CFDictionaryRef)privateKey, (CFTypeRef *)&keyRef); 230 | if(status != noErr){ 231 | return nil; 232 | } 233 | return keyRef; 234 | } 235 | 236 | /* START: Encryption & Decryption with RSA private key */ 237 | 238 | + (NSData *)encryptData:(NSData *)data withKeyRef:(SecKeyRef) keyRef{ 239 | const uint8_t *srcbuf = (const uint8_t *)[data bytes]; 240 | size_t srclen = (size_t)data.length; 241 | 242 | size_t block_size = SecKeyGetBlockSize(keyRef) * sizeof(uint8_t); 243 | void *outbuf = malloc(block_size); 244 | size_t src_block_size = block_size - 11; 245 | 246 | NSMutableData *ret = [[NSMutableData alloc] init]; 247 | for(int idx=0; idx src_block_size){ 251 | data_len = src_block_size; 252 | } 253 | 254 | size_t outlen = block_size; 255 | OSStatus status = noErr; 256 | status = SecKeyEncrypt(keyRef, 257 | kSecPaddingPKCS1, 258 | srcbuf + idx, 259 | data_len, 260 | outbuf, 261 | &outlen 262 | ); 263 | if (status != 0) { 264 | NSLog(@"SecKeyEncrypt fail. Error Code: %d", status); 265 | ret = nil; 266 | break; 267 | }else{ 268 | [ret appendBytes:outbuf length:outlen]; 269 | } 270 | } 271 | 272 | free(outbuf); 273 | CFRelease(keyRef); 274 | return ret; 275 | } 276 | 277 | + (NSString *)encryptString:(NSString *)str privateKey:(NSString *)privKey{ 278 | NSData *data = [RSA encryptData:[str dataUsingEncoding:NSUTF8StringEncoding] privateKey:privKey]; 279 | NSString *ret = base64_encode_data(data); 280 | return ret; 281 | } 282 | 283 | + (NSData *)encryptData:(NSData *)data privateKey:(NSString *)privKey{ 284 | if(!data || !privKey){ 285 | return nil; 286 | } 287 | SecKeyRef keyRef = [RSA addPrivateKey:privKey]; 288 | if(!keyRef){ 289 | return nil; 290 | } 291 | return [RSA encryptData:data withKeyRef:keyRef]; 292 | } 293 | 294 | + (NSData *)decryptData:(NSData *)data withKeyRef:(SecKeyRef) keyRef{ 295 | const uint8_t *srcbuf = (const uint8_t *)[data bytes]; 296 | size_t srclen = (size_t)data.length; 297 | 298 | size_t block_size = SecKeyGetBlockSize(keyRef) * sizeof(uint8_t); 299 | UInt8 *outbuf = malloc(block_size); 300 | size_t src_block_size = block_size; 301 | 302 | NSMutableData *ret = [[NSMutableData alloc] init]; 303 | for(int idx=0; idx src_block_size){ 307 | data_len = src_block_size; 308 | } 309 | 310 | size_t outlen = block_size; 311 | OSStatus status = noErr; 312 | status = SecKeyDecrypt(keyRef, 313 | kSecPaddingNone, 314 | srcbuf + idx, 315 | data_len, 316 | outbuf, 317 | &outlen 318 | ); 319 | if (status != 0) { 320 | NSLog(@"SecKeyEncrypt fail. Error Code: %d", status); 321 | ret = nil; 322 | break; 323 | }else{ 324 | //the actual decrypted data is in the middle, locate it! 325 | int idxFirstZero = -1; 326 | int idxNextZero = (int)outlen; 327 | for ( int i = 0; i < outlen; i++ ) { 328 | if ( outbuf[i] == 0 ) { 329 | if ( idxFirstZero < 0 ) { 330 | idxFirstZero = i; 331 | } else { 332 | idxNextZero = i; 333 | break; 334 | } 335 | } 336 | } 337 | 338 | [ret appendBytes:&outbuf[idxFirstZero+1] length:idxNextZero-idxFirstZero-1]; 339 | } 340 | } 341 | 342 | free(outbuf); 343 | CFRelease(keyRef); 344 | return ret; 345 | } 346 | 347 | 348 | + (NSString *)decryptString:(NSString *)str privateKey:(NSString *)privKey{ 349 | NSData *data = [[NSData alloc] initWithBase64EncodedString:str options:NSDataBase64DecodingIgnoreUnknownCharacters]; 350 | data = [RSA decryptData:data privateKey:privKey]; 351 | NSString *ret = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding]; 352 | return ret; 353 | } 354 | 355 | + (NSData *)decryptData:(NSData *)data privateKey:(NSString *)privKey{ 356 | if(!data || !privKey){ 357 | return nil; 358 | } 359 | SecKeyRef keyRef = [RSA addPrivateKey:privKey]; 360 | if(!keyRef){ 361 | return nil; 362 | } 363 | return [RSA decryptData:data withKeyRef:keyRef]; 364 | } 365 | 366 | /* END: Encryption & Decryption with RSA private key */ 367 | 368 | /* START: Encryption & Decryption with RSA public key */ 369 | 370 | + (NSString *)encryptString:(NSString *)str publicKey:(NSString *)pubKey{ 371 | NSData *data = [RSA encryptData:[str dataUsingEncoding:NSUTF8StringEncoding] publicKey:pubKey]; 372 | NSString *ret = base64_encode_data(data); 373 | return ret; 374 | } 375 | 376 | + (NSData *)encryptData:(NSData *)data publicKey:(NSString *)pubKey{ 377 | if(!data || !pubKey){ 378 | return nil; 379 | } 380 | SecKeyRef keyRef = [RSA addPublicKey:pubKey]; 381 | if(!keyRef){ 382 | return nil; 383 | } 384 | return [RSA encryptData:data withKeyRef:keyRef]; 385 | } 386 | 387 | + (NSString *)decryptString:(NSString *)str publicKey:(NSString *)pubKey{ 388 | NSData *data = [[NSData alloc] initWithBase64EncodedString:str options:NSDataBase64DecodingIgnoreUnknownCharacters]; 389 | data = [RSA decryptData:data publicKey:pubKey]; 390 | NSString *ret = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding]; 391 | return ret; 392 | } 393 | 394 | + (NSData *)decryptData:(NSData *)data publicKey:(NSString *)pubKey{ 395 | if(!data || !pubKey){ 396 | return nil; 397 | } 398 | SecKeyRef keyRef = [RSA addPublicKey:pubKey]; 399 | if(!keyRef){ 400 | return nil; 401 | } 402 | return [RSA decryptData:data withKeyRef:keyRef]; 403 | } 404 | 405 | /* END: Encryption & Decryption with RSA public key */ 406 | 407 | @end 408 | -------------------------------------------------------------------------------- /EncryptionTools/EncryptionTools.xcodeproj/project.pbxproj: -------------------------------------------------------------------------------- 1 | // !$*UTF8*$! 2 | { 3 | archiveVersion = 1; 4 | classes = { 5 | }; 6 | objectVersion = 46; 7 | objects = { 8 | 9 | /* Begin PBXBuildFile section */ 10 | 60638A701CEB154C0039DE1A /* main.m in Sources */ = {isa = PBXBuildFile; fileRef = 60638A6F1CEB154C0039DE1A /* main.m */; }; 11 | 60638A731CEB154C0039DE1A /* AppDelegate.m in Sources */ = {isa = PBXBuildFile; fileRef = 60638A721CEB154C0039DE1A /* AppDelegate.m */; }; 12 | 60638A761CEB154D0039DE1A /* ViewController.m in Sources */ = {isa = PBXBuildFile; fileRef = 60638A751CEB154D0039DE1A /* ViewController.m */; }; 13 | 60638A791CEB154D0039DE1A /* Main.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 60638A771CEB154D0039DE1A /* Main.storyboard */; }; 14 | 60638A7B1CEB154D0039DE1A /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 60638A7A1CEB154D0039DE1A /* Assets.xcassets */; }; 15 | 60638A7E1CEB154D0039DE1A /* LaunchScreen.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 60638A7C1CEB154D0039DE1A /* LaunchScreen.storyboard */; }; 16 | 60638A911CEDBB5C0039DE1A /* Base64.m in Sources */ = {isa = PBXBuildFile; fileRef = 60638A8E1CEDBB5C0039DE1A /* Base64.m */; }; 17 | 60638A921CEDBB5C0039DE1A /* CocoaSecurity.m in Sources */ = {isa = PBXBuildFile; fileRef = 60638A901CEDBB5C0039DE1A /* CocoaSecurity.m */; }; 18 | 60638A981CEEF71D0039DE1A /* NSString+Hash.m in Sources */ = {isa = PBXBuildFile; fileRef = 60638A971CEEF71D0039DE1A /* NSString+Hash.m */; }; 19 | 6069CA651CF2D50A00FDC811 /* README.md in Sources */ = {isa = PBXBuildFile; fileRef = 6069CA641CF2D50A00FDC811 /* README.md */; }; 20 | 6088B0E71D0020B600BF676A /* NSString+Encryption.m in Sources */ = {isa = PBXBuildFile; fileRef = 6088B0E61D0020B600BF676A /* NSString+Encryption.m */; }; 21 | 6088B0EE1D0D5E2B00BF676A /* RSA.m in Sources */ = {isa = PBXBuildFile; fileRef = 6088B0ED1D0D5E2B00BF676A /* RSA.m */; }; 22 | /* End PBXBuildFile section */ 23 | 24 | /* Begin PBXFileReference section */ 25 | 60638A6B1CEB154C0039DE1A /* EncryptionTools.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = EncryptionTools.app; sourceTree = BUILT_PRODUCTS_DIR; }; 26 | 60638A6F1CEB154C0039DE1A /* main.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = main.m; sourceTree = ""; }; 27 | 60638A711CEB154C0039DE1A /* AppDelegate.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = AppDelegate.h; sourceTree = ""; }; 28 | 60638A721CEB154C0039DE1A /* AppDelegate.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = AppDelegate.m; sourceTree = ""; }; 29 | 60638A741CEB154C0039DE1A /* ViewController.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ViewController.h; sourceTree = ""; }; 30 | 60638A751CEB154D0039DE1A /* ViewController.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = ViewController.m; sourceTree = ""; }; 31 | 60638A781CEB154D0039DE1A /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/Main.storyboard; sourceTree = ""; }; 32 | 60638A7A1CEB154D0039DE1A /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = ""; }; 33 | 60638A7D1CEB154D0039DE1A /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/LaunchScreen.storyboard; sourceTree = ""; }; 34 | 60638A7F1CEB154D0039DE1A /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = ""; }; 35 | 60638A8D1CEDBB5C0039DE1A /* Base64.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Base64.h; sourceTree = ""; }; 36 | 60638A8E1CEDBB5C0039DE1A /* Base64.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = Base64.m; sourceTree = ""; }; 37 | 60638A8F1CEDBB5C0039DE1A /* CocoaSecurity.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CocoaSecurity.h; sourceTree = ""; }; 38 | 60638A901CEDBB5C0039DE1A /* CocoaSecurity.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = CocoaSecurity.m; sourceTree = ""; }; 39 | 60638A961CEEF71D0039DE1A /* NSString+Hash.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSString+Hash.h"; sourceTree = ""; }; 40 | 60638A971CEEF71D0039DE1A /* NSString+Hash.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSString+Hash.m"; sourceTree = ""; }; 41 | 6069CA641CF2D50A00FDC811 /* README.md */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = net.daringfireball.markdown; name = README.md; path = ../../README.md; sourceTree = ""; }; 42 | 6088B0E51D0020B600BF676A /* NSString+Encryption.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSString+Encryption.h"; sourceTree = ""; }; 43 | 6088B0E61D0020B600BF676A /* NSString+Encryption.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSString+Encryption.m"; sourceTree = ""; }; 44 | 6088B0EC1D0D5E2B00BF676A /* RSA.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RSA.h; sourceTree = ""; }; 45 | 6088B0ED1D0D5E2B00BF676A /* RSA.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RSA.m; sourceTree = ""; }; 46 | /* End PBXFileReference section */ 47 | 48 | /* Begin PBXFrameworksBuildPhase section */ 49 | 60638A681CEB154C0039DE1A /* Frameworks */ = { 50 | isa = PBXFrameworksBuildPhase; 51 | buildActionMask = 2147483647; 52 | files = ( 53 | ); 54 | runOnlyForDeploymentPostprocessing = 0; 55 | }; 56 | /* End PBXFrameworksBuildPhase section */ 57 | 58 | /* Begin PBXGroup section */ 59 | 60638A621CEB154C0039DE1A = { 60 | isa = PBXGroup; 61 | children = ( 62 | 60638A6D1CEB154C0039DE1A /* EncryptionTools */, 63 | 60638A6C1CEB154C0039DE1A /* Products */, 64 | ); 65 | sourceTree = ""; 66 | }; 67 | 60638A6C1CEB154C0039DE1A /* Products */ = { 68 | isa = PBXGroup; 69 | children = ( 70 | 60638A6B1CEB154C0039DE1A /* EncryptionTools.app */, 71 | ); 72 | name = Products; 73 | sourceTree = ""; 74 | }; 75 | 60638A6D1CEB154C0039DE1A /* EncryptionTools */ = { 76 | isa = PBXGroup; 77 | children = ( 78 | 60638A711CEB154C0039DE1A /* AppDelegate.h */, 79 | 60638A721CEB154C0039DE1A /* AppDelegate.m */, 80 | 60638A741CEB154C0039DE1A /* ViewController.h */, 81 | 60638A751CEB154D0039DE1A /* ViewController.m */, 82 | 60638A8C1CEDBB5C0039DE1A /* Encryptions */, 83 | 60638A771CEB154D0039DE1A /* Main.storyboard */, 84 | 60638A7A1CEB154D0039DE1A /* Assets.xcassets */, 85 | 60638A7C1CEB154D0039DE1A /* LaunchScreen.storyboard */, 86 | 60638A7F1CEB154D0039DE1A /* Info.plist */, 87 | 60638A6E1CEB154C0039DE1A /* Supporting Files */, 88 | ); 89 | path = EncryptionTools; 90 | sourceTree = ""; 91 | }; 92 | 60638A6E1CEB154C0039DE1A /* Supporting Files */ = { 93 | isa = PBXGroup; 94 | children = ( 95 | 6069CA641CF2D50A00FDC811 /* README.md */, 96 | 60638A6F1CEB154C0039DE1A /* main.m */, 97 | ); 98 | name = "Supporting Files"; 99 | sourceTree = ""; 100 | }; 101 | 60638A8C1CEDBB5C0039DE1A /* Encryptions */ = { 102 | isa = PBXGroup; 103 | children = ( 104 | 6088B0E81D080E1000BF676A /* RSAEncrypt */, 105 | 60638A951CEEF71D0039DE1A /* Hash */, 106 | 6088B0E41D0020A700BF676A /* NSString+Encryption */, 107 | 60638A8D1CEDBB5C0039DE1A /* Base64.h */, 108 | 60638A8E1CEDBB5C0039DE1A /* Base64.m */, 109 | 60638A8F1CEDBB5C0039DE1A /* CocoaSecurity.h */, 110 | 60638A901CEDBB5C0039DE1A /* CocoaSecurity.m */, 111 | ); 112 | path = Encryptions; 113 | sourceTree = ""; 114 | }; 115 | 60638A951CEEF71D0039DE1A /* Hash */ = { 116 | isa = PBXGroup; 117 | children = ( 118 | 60638A961CEEF71D0039DE1A /* NSString+Hash.h */, 119 | 60638A971CEEF71D0039DE1A /* NSString+Hash.m */, 120 | ); 121 | path = Hash; 122 | sourceTree = ""; 123 | }; 124 | 6088B0E41D0020A700BF676A /* NSString+Encryption */ = { 125 | isa = PBXGroup; 126 | children = ( 127 | 6088B0E51D0020B600BF676A /* NSString+Encryption.h */, 128 | 6088B0E61D0020B600BF676A /* NSString+Encryption.m */, 129 | ); 130 | path = "NSString+Encryption"; 131 | sourceTree = ""; 132 | }; 133 | 6088B0E81D080E1000BF676A /* RSAEncrypt */ = { 134 | isa = PBXGroup; 135 | children = ( 136 | 6088B0EC1D0D5E2B00BF676A /* RSA.h */, 137 | 6088B0ED1D0D5E2B00BF676A /* RSA.m */, 138 | ); 139 | path = RSAEncrypt; 140 | sourceTree = ""; 141 | }; 142 | /* End PBXGroup section */ 143 | 144 | /* Begin PBXNativeTarget section */ 145 | 60638A6A1CEB154C0039DE1A /* EncryptionTools */ = { 146 | isa = PBXNativeTarget; 147 | buildConfigurationList = 60638A821CEB154D0039DE1A /* Build configuration list for PBXNativeTarget "EncryptionTools" */; 148 | buildPhases = ( 149 | 60638A671CEB154C0039DE1A /* Sources */, 150 | 60638A681CEB154C0039DE1A /* Frameworks */, 151 | 60638A691CEB154C0039DE1A /* Resources */, 152 | ); 153 | buildRules = ( 154 | ); 155 | dependencies = ( 156 | ); 157 | name = EncryptionTools; 158 | productName = EncryptionTools; 159 | productReference = 60638A6B1CEB154C0039DE1A /* EncryptionTools.app */; 160 | productType = "com.apple.product-type.application"; 161 | }; 162 | /* End PBXNativeTarget section */ 163 | 164 | /* Begin PBXProject section */ 165 | 60638A631CEB154C0039DE1A /* Project object */ = { 166 | isa = PBXProject; 167 | attributes = { 168 | LastUpgradeCheck = 0730; 169 | ORGANIZATIONNAME = com.personal; 170 | TargetAttributes = { 171 | 60638A6A1CEB154C0039DE1A = { 172 | CreatedOnToolsVersion = 7.3; 173 | }; 174 | }; 175 | }; 176 | buildConfigurationList = 60638A661CEB154C0039DE1A /* Build configuration list for PBXProject "EncryptionTools" */; 177 | compatibilityVersion = "Xcode 3.2"; 178 | developmentRegion = English; 179 | hasScannedForEncodings = 0; 180 | knownRegions = ( 181 | en, 182 | Base, 183 | ); 184 | mainGroup = 60638A621CEB154C0039DE1A; 185 | productRefGroup = 60638A6C1CEB154C0039DE1A /* Products */; 186 | projectDirPath = ""; 187 | projectRoot = ""; 188 | targets = ( 189 | 60638A6A1CEB154C0039DE1A /* EncryptionTools */, 190 | ); 191 | }; 192 | /* End PBXProject section */ 193 | 194 | /* Begin PBXResourcesBuildPhase section */ 195 | 60638A691CEB154C0039DE1A /* Resources */ = { 196 | isa = PBXResourcesBuildPhase; 197 | buildActionMask = 2147483647; 198 | files = ( 199 | 60638A7E1CEB154D0039DE1A /* LaunchScreen.storyboard in Resources */, 200 | 60638A7B1CEB154D0039DE1A /* Assets.xcassets in Resources */, 201 | 60638A791CEB154D0039DE1A /* Main.storyboard in Resources */, 202 | ); 203 | runOnlyForDeploymentPostprocessing = 0; 204 | }; 205 | /* End PBXResourcesBuildPhase section */ 206 | 207 | /* Begin PBXSourcesBuildPhase section */ 208 | 60638A671CEB154C0039DE1A /* Sources */ = { 209 | isa = PBXSourcesBuildPhase; 210 | buildActionMask = 2147483647; 211 | files = ( 212 | 60638A981CEEF71D0039DE1A /* NSString+Hash.m in Sources */, 213 | 60638A761CEB154D0039DE1A /* ViewController.m in Sources */, 214 | 60638A911CEDBB5C0039DE1A /* Base64.m in Sources */, 215 | 6069CA651CF2D50A00FDC811 /* README.md in Sources */, 216 | 60638A921CEDBB5C0039DE1A /* CocoaSecurity.m in Sources */, 217 | 60638A731CEB154C0039DE1A /* AppDelegate.m in Sources */, 218 | 6088B0EE1D0D5E2B00BF676A /* RSA.m in Sources */, 219 | 6088B0E71D0020B600BF676A /* NSString+Encryption.m in Sources */, 220 | 60638A701CEB154C0039DE1A /* main.m in Sources */, 221 | ); 222 | runOnlyForDeploymentPostprocessing = 0; 223 | }; 224 | /* End PBXSourcesBuildPhase section */ 225 | 226 | /* Begin PBXVariantGroup section */ 227 | 60638A771CEB154D0039DE1A /* Main.storyboard */ = { 228 | isa = PBXVariantGroup; 229 | children = ( 230 | 60638A781CEB154D0039DE1A /* Base */, 231 | ); 232 | name = Main.storyboard; 233 | sourceTree = ""; 234 | }; 235 | 60638A7C1CEB154D0039DE1A /* LaunchScreen.storyboard */ = { 236 | isa = PBXVariantGroup; 237 | children = ( 238 | 60638A7D1CEB154D0039DE1A /* Base */, 239 | ); 240 | name = LaunchScreen.storyboard; 241 | sourceTree = ""; 242 | }; 243 | /* End PBXVariantGroup section */ 244 | 245 | /* Begin XCBuildConfiguration section */ 246 | 60638A801CEB154D0039DE1A /* Debug */ = { 247 | isa = XCBuildConfiguration; 248 | buildSettings = { 249 | ALWAYS_SEARCH_USER_PATHS = NO; 250 | CLANG_ANALYZER_NONNULL = YES; 251 | CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; 252 | CLANG_CXX_LIBRARY = "libc++"; 253 | CLANG_ENABLE_MODULES = YES; 254 | CLANG_ENABLE_OBJC_ARC = YES; 255 | CLANG_WARN_BOOL_CONVERSION = YES; 256 | CLANG_WARN_CONSTANT_CONVERSION = YES; 257 | CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; 258 | CLANG_WARN_EMPTY_BODY = YES; 259 | CLANG_WARN_ENUM_CONVERSION = YES; 260 | CLANG_WARN_INT_CONVERSION = YES; 261 | CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; 262 | CLANG_WARN_UNREACHABLE_CODE = YES; 263 | CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; 264 | "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer"; 265 | COPY_PHASE_STRIP = NO; 266 | DEBUG_INFORMATION_FORMAT = dwarf; 267 | ENABLE_STRICT_OBJC_MSGSEND = YES; 268 | ENABLE_TESTABILITY = YES; 269 | GCC_C_LANGUAGE_STANDARD = gnu99; 270 | GCC_DYNAMIC_NO_PIC = NO; 271 | GCC_NO_COMMON_BLOCKS = YES; 272 | GCC_OPTIMIZATION_LEVEL = 0; 273 | GCC_PREPROCESSOR_DEFINITIONS = ( 274 | "DEBUG=1", 275 | "$(inherited)", 276 | ); 277 | GCC_WARN_64_TO_32_BIT_CONVERSION = YES; 278 | GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; 279 | GCC_WARN_UNDECLARED_SELECTOR = YES; 280 | GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; 281 | GCC_WARN_UNUSED_FUNCTION = YES; 282 | GCC_WARN_UNUSED_VARIABLE = YES; 283 | IPHONEOS_DEPLOYMENT_TARGET = 9.3; 284 | MTL_ENABLE_DEBUG_INFO = YES; 285 | ONLY_ACTIVE_ARCH = YES; 286 | SDKROOT = iphoneos; 287 | }; 288 | name = Debug; 289 | }; 290 | 60638A811CEB154D0039DE1A /* Release */ = { 291 | isa = XCBuildConfiguration; 292 | buildSettings = { 293 | ALWAYS_SEARCH_USER_PATHS = NO; 294 | CLANG_ANALYZER_NONNULL = YES; 295 | CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; 296 | CLANG_CXX_LIBRARY = "libc++"; 297 | CLANG_ENABLE_MODULES = YES; 298 | CLANG_ENABLE_OBJC_ARC = YES; 299 | CLANG_WARN_BOOL_CONVERSION = YES; 300 | CLANG_WARN_CONSTANT_CONVERSION = YES; 301 | CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; 302 | CLANG_WARN_EMPTY_BODY = YES; 303 | CLANG_WARN_ENUM_CONVERSION = YES; 304 | CLANG_WARN_INT_CONVERSION = YES; 305 | CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; 306 | CLANG_WARN_UNREACHABLE_CODE = YES; 307 | CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; 308 | "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer"; 309 | COPY_PHASE_STRIP = NO; 310 | DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; 311 | ENABLE_NS_ASSERTIONS = NO; 312 | ENABLE_STRICT_OBJC_MSGSEND = YES; 313 | GCC_C_LANGUAGE_STANDARD = gnu99; 314 | GCC_NO_COMMON_BLOCKS = YES; 315 | GCC_WARN_64_TO_32_BIT_CONVERSION = YES; 316 | GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; 317 | GCC_WARN_UNDECLARED_SELECTOR = YES; 318 | GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; 319 | GCC_WARN_UNUSED_FUNCTION = YES; 320 | GCC_WARN_UNUSED_VARIABLE = YES; 321 | IPHONEOS_DEPLOYMENT_TARGET = 9.3; 322 | MTL_ENABLE_DEBUG_INFO = NO; 323 | SDKROOT = iphoneos; 324 | VALIDATE_PRODUCT = YES; 325 | }; 326 | name = Release; 327 | }; 328 | 60638A831CEB154D0039DE1A /* Debug */ = { 329 | isa = XCBuildConfiguration; 330 | buildSettings = { 331 | ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; 332 | INFOPLIST_FILE = EncryptionTools/Info.plist; 333 | LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks"; 334 | PRODUCT_BUNDLE_IDENTIFIER = com.personal.mdd.EncryptionTools; 335 | PRODUCT_NAME = "$(TARGET_NAME)"; 336 | }; 337 | name = Debug; 338 | }; 339 | 60638A841CEB154D0039DE1A /* Release */ = { 340 | isa = XCBuildConfiguration; 341 | buildSettings = { 342 | ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; 343 | INFOPLIST_FILE = EncryptionTools/Info.plist; 344 | LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks"; 345 | PRODUCT_BUNDLE_IDENTIFIER = com.personal.mdd.EncryptionTools; 346 | PRODUCT_NAME = "$(TARGET_NAME)"; 347 | }; 348 | name = Release; 349 | }; 350 | /* End XCBuildConfiguration section */ 351 | 352 | /* Begin XCConfigurationList section */ 353 | 60638A661CEB154C0039DE1A /* Build configuration list for PBXProject "EncryptionTools" */ = { 354 | isa = XCConfigurationList; 355 | buildConfigurations = ( 356 | 60638A801CEB154D0039DE1A /* Debug */, 357 | 60638A811CEB154D0039DE1A /* Release */, 358 | ); 359 | defaultConfigurationIsVisible = 0; 360 | defaultConfigurationName = Release; 361 | }; 362 | 60638A821CEB154D0039DE1A /* Build configuration list for PBXNativeTarget "EncryptionTools" */ = { 363 | isa = XCConfigurationList; 364 | buildConfigurations = ( 365 | 60638A831CEB154D0039DE1A /* Debug */, 366 | 60638A841CEB154D0039DE1A /* Release */, 367 | ); 368 | defaultConfigurationIsVisible = 0; 369 | defaultConfigurationName = Release; 370 | }; 371 | /* End XCConfigurationList section */ 372 | }; 373 | rootObject = 60638A631CEB154C0039DE1A /* Project object */; 374 | } 375 | -------------------------------------------------------------------------------- /EncryptionTools/EncryptionTools/Encryptions/CocoaSecurity.m: -------------------------------------------------------------------------------- 1 | // 2 | // CocoaSecurity.m 3 | // 4 | // Created by Kelp on 12/5/12. 5 | // Copyright (c) 2012 Kelp http://kelp.phate.org/ 6 | // MIT License 7 | // 8 | 9 | #import "CocoaSecurity.h" 10 | #import 11 | #import 12 | #import "Base64.h" 13 | 14 | #pragma mark - CocoaSecurity 15 | @implementation CocoaSecurity 16 | 17 | 18 | #pragma mark - AES Encrypt 19 | // default AES Encrypt, key -> SHA384(key).sub(0, 32), iv -> SHA384(key).sub(32, 16) 20 | + (CocoaSecurityResult *)aesEncrypt:(NSString *)data key:(NSString *)key 21 | { 22 | CocoaSecurityResult * sha = [self sha384:key]; 23 | NSData *aesKey = [sha.data subdataWithRange:NSMakeRange(0, 32)]; 24 | NSData *aesIv = [sha.data subdataWithRange:NSMakeRange(32, 16)]; 25 | 26 | return [self aesEncrypt:data key:aesKey iv:aesIv]; 27 | } 28 | #pragma mark AES Encrypt 128, 192, 256 29 | + (CocoaSecurityResult *)aesEncrypt:(NSString *)data hexKey:(NSString *)key hexIv:(NSString *)iv 30 | { 31 | CocoaSecurityDecoder *decoder = [CocoaSecurityDecoder new]; 32 | NSData *aesKey = [decoder hex:key]; 33 | NSData *aesIv = [decoder hex:iv]; 34 | 35 | return [self aesEncrypt:data key:aesKey iv:aesIv]; 36 | } 37 | + (CocoaSecurityResult *)aesEncrypt:(NSString *)data key:(NSData *)key iv:(NSData *)iv 38 | { 39 | return [self aesEncryptWithData:[data dataUsingEncoding:NSUTF8StringEncoding] key:key iv:iv]; 40 | } 41 | + (CocoaSecurityResult *)aesEncryptWithData:(NSData *)data key:(NSData *)key iv:(NSData *)iv 42 | { 43 | // check length of key and iv 44 | if ([iv length] != 16) { 45 | @throw [NSException exceptionWithName:@"Cocoa Security" 46 | reason:@"Length of iv is wrong. Length of iv should be 16(128bits)" 47 | userInfo:nil]; 48 | } 49 | if ([key length] != 16 && [key length] != 24 && [key length] != 32 ) { 50 | @throw [NSException exceptionWithName:@"Cocoa Security" 51 | reason:@"Length of key is wrong. Length of iv should be 16, 24 or 32(128, 192 or 256bits)" 52 | userInfo:nil]; 53 | } 54 | 55 | // setup output buffer 56 | size_t bufferSize = [data length] + kCCBlockSizeAES128; 57 | void *buffer = malloc(bufferSize); 58 | 59 | // do encrypt 60 | size_t encryptedSize = 0; 61 | CCCryptorStatus cryptStatus = CCCrypt(kCCEncrypt, 62 | kCCAlgorithmAES128, 63 | kCCOptionPKCS7Padding, 64 | [key bytes], // Key 65 | [key length], // kCCKeySizeAES 66 | [iv bytes], // IV 67 | [data bytes], 68 | [data length], 69 | buffer, 70 | bufferSize, 71 | &encryptedSize); 72 | if (cryptStatus == kCCSuccess) { 73 | CocoaSecurityResult *result = [[CocoaSecurityResult alloc] initWithBytes:buffer length:encryptedSize]; 74 | free(buffer); 75 | 76 | return result; 77 | } 78 | else { 79 | free(buffer); 80 | @throw [NSException exceptionWithName:@"Cocoa Security" 81 | reason:@"Encrypt Error!" 82 | userInfo:nil]; 83 | return nil; 84 | } 85 | } 86 | #pragma mark - AES Decrypt 87 | // default AES Decrypt, key -> SHA384(key).sub(0, 32), iv -> SHA384(key).sub(32, 16) 88 | + (CocoaSecurityResult *)aesDecryptWithBase64:(NSString *)data key:(NSString *)key 89 | { 90 | CocoaSecurityResult * sha = [self sha384:key]; 91 | NSData *aesKey = [sha.data subdataWithRange:NSMakeRange(0, 32)]; 92 | NSData *aesIv = [sha.data subdataWithRange:NSMakeRange(32, 16)]; 93 | 94 | return [self aesDecryptWithBase64:data key:aesKey iv:aesIv]; 95 | } 96 | #pragma mark AES Decrypt 128, 192, 256 97 | + (CocoaSecurityResult *)aesDecryptWithBase64:(NSString *)data hexKey:(NSString *)key hexIv:(NSString *)iv 98 | { 99 | CocoaSecurityDecoder *decoder = [CocoaSecurityDecoder new]; 100 | NSData *aesKey = [decoder hex:key]; 101 | NSData *aesIv = [decoder hex:iv]; 102 | 103 | return [self aesDecryptWithBase64:data key:aesKey iv:aesIv]; 104 | } 105 | + (CocoaSecurityResult *)aesDecryptWithBase64:(NSString *)data key:(NSData *)key iv:(NSData *)iv 106 | { 107 | CocoaSecurityDecoder *decoder = [CocoaSecurityDecoder new]; 108 | return [self aesDecryptWithData:[decoder base64:data] key:key iv:iv]; 109 | } 110 | + (CocoaSecurityResult *)aesDecryptWithData:(NSData *)data key:(NSData *)key iv:(NSData *)iv 111 | { 112 | // check length of key and iv 113 | if ([iv length] != 16) { 114 | @throw [NSException exceptionWithName:@"Cocoa Security" 115 | reason:@"Length of iv is wrong. Length of iv should be 16(128bits)" 116 | userInfo:nil]; 117 | } 118 | if ([key length] != 16 && [key length] != 24 && [key length] != 32 ) { 119 | @throw [NSException exceptionWithName:@"Cocoa Security" 120 | reason:@"Length of key is wrong. Length of iv should be 16, 24 or 32(128, 192 or 256bits)" 121 | userInfo:nil]; 122 | } 123 | 124 | // setup output buffer 125 | size_t bufferSize = [data length] + kCCBlockSizeAES128; 126 | void *buffer = malloc(bufferSize); 127 | 128 | // do encrypt 129 | size_t encryptedSize = 0; 130 | CCCryptorStatus cryptStatus = CCCrypt(kCCDecrypt, 131 | kCCAlgorithmAES128, 132 | kCCOptionPKCS7Padding, 133 | [key bytes], // Key 134 | [key length], // kCCKeySizeAES 135 | [iv bytes], // IV 136 | [data bytes], 137 | [data length], 138 | buffer, 139 | bufferSize, 140 | &encryptedSize); 141 | if (cryptStatus == kCCSuccess) { 142 | CocoaSecurityResult *result = [[CocoaSecurityResult alloc] initWithBytes:buffer length:encryptedSize]; 143 | free(buffer); 144 | 145 | return result; 146 | } 147 | else { 148 | free(buffer); 149 | @throw [NSException exceptionWithName:@"Cocoa Security" 150 | reason:@"Decrypt Error!" 151 | userInfo:nil]; 152 | return nil; 153 | } 154 | } 155 | 156 | 157 | #pragma mark - MD5 158 | + (CocoaSecurityResult *)md5:(NSString *)hashString 159 | { 160 | return [self md5WithData:[hashString dataUsingEncoding:NSUTF8StringEncoding]]; 161 | } 162 | + (CocoaSecurityResult *)md5WithData:(NSData *)hashData 163 | { 164 | unsigned char *digest; 165 | digest = malloc(CC_MD5_DIGEST_LENGTH); 166 | 167 | CC_MD5([hashData bytes], (CC_LONG)[hashData length], digest); 168 | CocoaSecurityResult *result = [[CocoaSecurityResult alloc] initWithBytes:digest length:CC_MD5_DIGEST_LENGTH]; 169 | free(digest); 170 | 171 | return result; 172 | } 173 | #pragma mark - HMAC-MD5 174 | + (CocoaSecurityResult *)hmacMd5:(NSString *)hashString hmacKey:(NSString *)key 175 | { 176 | return [self hmacMd5WithData:[hashString dataUsingEncoding:NSUTF8StringEncoding] hmacKey:key]; 177 | } 178 | + (CocoaSecurityResult *)hmacMd5WithData:(NSData *)hashData hmacKey:(NSString *)key 179 | { 180 | unsigned char *digest; 181 | digest = malloc(CC_MD5_DIGEST_LENGTH); 182 | const char *cKey = [key cStringUsingEncoding:NSUTF8StringEncoding]; 183 | 184 | CCHmac(kCCHmacAlgMD5, cKey, strlen(cKey), [hashData bytes], [hashData length], digest); 185 | CocoaSecurityResult *result = [[CocoaSecurityResult alloc] initWithBytes:digest length:CC_MD5_DIGEST_LENGTH]; 186 | free(digest); 187 | cKey = nil; 188 | 189 | return result; 190 | } 191 | 192 | 193 | #pragma mark - SHA1 194 | + (CocoaSecurityResult *)sha1:(NSString *)hashString 195 | { 196 | return [self sha1WithData:[hashString dataUsingEncoding:NSUTF8StringEncoding]]; 197 | } 198 | + (CocoaSecurityResult *)sha1WithData:(NSData *)hashData 199 | { 200 | unsigned char *digest; 201 | digest = malloc(CC_SHA1_DIGEST_LENGTH); 202 | 203 | CC_SHA1([hashData bytes], (CC_LONG)[hashData length], digest); 204 | CocoaSecurityResult *result = [[CocoaSecurityResult alloc] initWithBytes:digest length:CC_SHA1_DIGEST_LENGTH]; 205 | free(digest); 206 | 207 | return result; 208 | } 209 | #pragma mark SHA224 210 | + (CocoaSecurityResult *)sha224:(NSString *)hashString 211 | { 212 | return [self sha224WithData:[hashString dataUsingEncoding:NSUTF8StringEncoding]]; 213 | } 214 | + (CocoaSecurityResult *)sha224WithData:(NSData *)hashData 215 | { 216 | unsigned char *digest; 217 | digest = malloc(CC_SHA224_DIGEST_LENGTH); 218 | 219 | CC_SHA224([hashData bytes], (CC_LONG)[hashData length], digest); 220 | CocoaSecurityResult *result = [[CocoaSecurityResult alloc] initWithBytes:digest length:CC_SHA224_DIGEST_LENGTH]; 221 | free(digest); 222 | 223 | return result; 224 | } 225 | #pragma mark SHA256 226 | + (CocoaSecurityResult *)sha256:(NSString *)hashString 227 | { 228 | return [self sha256WithData:[hashString dataUsingEncoding:NSUTF8StringEncoding]]; 229 | } 230 | + (CocoaSecurityResult *)sha256WithData:(NSData *)hashData 231 | { 232 | unsigned char *digest; 233 | digest = malloc(CC_SHA256_DIGEST_LENGTH); 234 | 235 | CC_SHA256([hashData bytes], (CC_LONG)[hashData length], digest); 236 | CocoaSecurityResult *result = [[CocoaSecurityResult alloc] initWithBytes:digest length:CC_SHA256_DIGEST_LENGTH]; 237 | free(digest); 238 | 239 | return result; 240 | } 241 | #pragma mark SHA384 242 | + (CocoaSecurityResult *)sha384:(NSString *)hashString 243 | { 244 | return [self sha384WithData:[hashString dataUsingEncoding:NSUTF8StringEncoding]]; 245 | } 246 | + (CocoaSecurityResult *)sha384WithData:(NSData *)hashData 247 | { 248 | unsigned char *digest; 249 | digest = malloc(CC_SHA384_DIGEST_LENGTH); 250 | 251 | CC_SHA384([hashData bytes], (CC_LONG)[hashData length], digest); 252 | CocoaSecurityResult *result = [[CocoaSecurityResult alloc] initWithBytes:digest length:CC_SHA384_DIGEST_LENGTH]; 253 | free(digest); 254 | 255 | return result; 256 | } 257 | #pragma mark SHA512 258 | + (CocoaSecurityResult *)sha512:(NSString *)hashString 259 | { 260 | return [self sha512WithData:[hashString dataUsingEncoding:NSUTF8StringEncoding]]; 261 | } 262 | + (CocoaSecurityResult *)sha512WithData:(NSData *)hashData 263 | { 264 | unsigned char *digest; 265 | digest = malloc(CC_SHA512_DIGEST_LENGTH); 266 | 267 | CC_SHA512([hashData bytes], (CC_LONG)[hashData length], digest); 268 | CocoaSecurityResult *result = [[CocoaSecurityResult alloc] initWithBytes:digest length:CC_SHA512_DIGEST_LENGTH]; 269 | free(digest); 270 | 271 | return result; 272 | } 273 | 274 | 275 | #pragma mark - HMAC-SHA1 276 | + (CocoaSecurityResult *)hmacSha1:(NSString *)hashString hmacKey:(NSString *)key 277 | { 278 | return [self hmacSha1WithData:[hashString dataUsingEncoding:NSUTF8StringEncoding] hmacKey:key]; 279 | } 280 | + (CocoaSecurityResult *)hmacSha1WithData:(NSData *)hashData hmacKey:(NSString *)key 281 | { 282 | unsigned char *digest; 283 | digest = malloc(CC_SHA1_DIGEST_LENGTH); 284 | const char *cKey = [key cStringUsingEncoding:NSUTF8StringEncoding]; 285 | 286 | CCHmac(kCCHmacAlgSHA1, cKey, strlen(cKey), [hashData bytes], [hashData length], digest); 287 | CocoaSecurityResult *result = [[CocoaSecurityResult alloc] initWithBytes:digest length:CC_SHA1_DIGEST_LENGTH]; 288 | free(digest); 289 | cKey = nil; 290 | 291 | return result; 292 | } 293 | #pragma mark HMAC-SHA224 294 | + (CocoaSecurityResult *)hmacSha224:(NSString *)hashString hmacKey:(NSString *)key 295 | { 296 | return [self hmacSha224WithData:[hashString dataUsingEncoding:NSUTF8StringEncoding] hmacKey:key]; 297 | } 298 | + (CocoaSecurityResult *)hmacSha224WithData:(NSData *)hashData hmacKey:(NSString *)key 299 | { 300 | unsigned char *digest; 301 | digest = malloc(CC_SHA224_DIGEST_LENGTH); 302 | const char *cKey = [key cStringUsingEncoding:NSUTF8StringEncoding]; 303 | 304 | CCHmac(kCCHmacAlgSHA224, cKey, strlen(cKey), [hashData bytes], [hashData length], digest); 305 | CocoaSecurityResult *result = [[CocoaSecurityResult alloc] initWithBytes:digest length:CC_SHA224_DIGEST_LENGTH]; 306 | free(digest); 307 | cKey = nil; 308 | 309 | return result; 310 | } 311 | #pragma mark HMAC-SHA256 312 | + (CocoaSecurityResult *)hmacSha256:(NSString *)hashString hmacKey:(NSString *)key 313 | { 314 | return [self hmacSha256WithData:[hashString dataUsingEncoding:NSUTF8StringEncoding] hmacKey:key]; 315 | } 316 | + (CocoaSecurityResult *)hmacSha256WithData:(NSData *)hashData hmacKey:(NSString *)key 317 | { 318 | unsigned char *digest; 319 | digest = malloc(CC_SHA256_DIGEST_LENGTH); 320 | const char *cKey = [key cStringUsingEncoding:NSUTF8StringEncoding]; 321 | 322 | CCHmac(kCCHmacAlgSHA256, cKey, strlen(cKey), [hashData bytes], [hashData length], digest); 323 | CocoaSecurityResult *result = [[CocoaSecurityResult alloc] initWithBytes:digest length:CC_SHA256_DIGEST_LENGTH]; 324 | free(digest); 325 | cKey = nil; 326 | 327 | return result; 328 | } 329 | #pragma mark HMAC-SHA384 330 | + (CocoaSecurityResult *)hmacSha384:(NSString *)hashString hmacKey:(NSString *)key 331 | { 332 | return [self hmacSha384WithData:[hashString dataUsingEncoding:NSUTF8StringEncoding] hmacKey:key]; 333 | } 334 | + (CocoaSecurityResult *)hmacSha384WithData:(NSData *)hashData hmacKey:(NSString *)key 335 | { 336 | unsigned char *digest; 337 | digest = malloc(CC_SHA384_DIGEST_LENGTH); 338 | const char *cKey = [key cStringUsingEncoding:NSUTF8StringEncoding]; 339 | 340 | CCHmac(kCCHmacAlgSHA384, cKey, strlen(cKey), [hashData bytes], [hashData length], digest); 341 | CocoaSecurityResult *result = [[CocoaSecurityResult alloc] initWithBytes:digest length:CC_SHA384_DIGEST_LENGTH]; 342 | free(digest); 343 | cKey = nil; 344 | 345 | return result; 346 | } 347 | #pragma mark HMAC-SHA512 348 | + (CocoaSecurityResult *)hmacSha512:(NSString *)hashString hmacKey:(NSString *)key 349 | { 350 | return [self hmacSha512WithData:[hashString dataUsingEncoding:NSUTF8StringEncoding] hmacKey:key]; 351 | } 352 | + (CocoaSecurityResult *)hmacSha512WithData:(NSData *)hashData hmacKey:(NSString *)key 353 | { 354 | unsigned char *digest; 355 | digest = malloc(CC_SHA512_DIGEST_LENGTH); 356 | const char *cKey = [key cStringUsingEncoding:NSUTF8StringEncoding]; 357 | 358 | CCHmac(kCCHmacAlgSHA512, cKey, strlen(cKey), [hashData bytes], [hashData length], digest); 359 | CocoaSecurityResult *result = [[CocoaSecurityResult alloc] initWithBytes:digest length:CC_SHA512_DIGEST_LENGTH]; 360 | free(digest); 361 | cKey = nil; 362 | 363 | return result; 364 | } 365 | 366 | @end 367 | 368 | 369 | 370 | #pragma mark - CocoaSecurityResult 371 | @implementation CocoaSecurityResult 372 | 373 | @synthesize data = _data; 374 | 375 | #pragma mark - Init 376 | - (id)initWithBytes:(unsigned char[])initData length:(NSUInteger)length 377 | { 378 | self = [super init]; 379 | if (self) { 380 | _data = [NSData dataWithBytes:initData length:length]; 381 | } 382 | return self; 383 | } 384 | 385 | #pragma mark UTF8 String 386 | // convert CocoaSecurityResult to UTF8 string 387 | - (NSString *)utf8String 388 | { 389 | NSString *result = [[NSString alloc] initWithData:_data encoding:NSUTF8StringEncoding]; 390 | return result; 391 | } 392 | 393 | #pragma mark HEX 394 | // convert CocoaSecurityResult to HEX string 395 | - (NSString *)hex 396 | { 397 | CocoaSecurityEncoder *encoder = [CocoaSecurityEncoder new]; 398 | return [encoder hex:_data useLower:false]; 399 | } 400 | - (NSString *)hexLower 401 | { 402 | CocoaSecurityEncoder *encoder = [CocoaSecurityEncoder new]; 403 | return [encoder hex:_data useLower:true]; 404 | } 405 | 406 | #pragma mark Base64 407 | // convert CocoaSecurityResult to Base64 string 408 | - (NSString *)base64 409 | { 410 | CocoaSecurityEncoder *encoder = [CocoaSecurityEncoder new]; 411 | return [encoder base64:_data]; 412 | } 413 | 414 | @end 415 | 416 | 417 | #pragma mark - CocoaSecurityEncoder 418 | @implementation CocoaSecurityEncoder 419 | 420 | // convert NSData to Base64 421 | - (NSString *)base64:(NSData *)data 422 | { 423 | return [data base64EncodedString]; 424 | } 425 | 426 | // convert NSData to hex string 427 | - (NSString *)hex:(NSData *)data useLower:(BOOL)isOutputLower 428 | { 429 | if (data.length == 0) { return nil; } 430 | 431 | static const char HexEncodeCharsLower[] = "0123456789abcdef"; 432 | static const char HexEncodeChars[] = "0123456789ABCDEF"; 433 | char *resultData; 434 | // malloc result data 435 | resultData = malloc([data length] * 2 +1); 436 | // convert imgData(NSData) to char[] 437 | unsigned char *sourceData = ((unsigned char *)[data bytes]); 438 | NSUInteger length = [data length]; 439 | 440 | if (isOutputLower) { 441 | for (NSUInteger index = 0; index < length; index++) { 442 | // set result data 443 | resultData[index * 2] = HexEncodeCharsLower[(sourceData[index] >> 4)]; 444 | resultData[index * 2 + 1] = HexEncodeCharsLower[(sourceData[index] % 0x10)]; 445 | } 446 | } 447 | else { 448 | for (NSUInteger index = 0; index < length; index++) { 449 | // set result data 450 | resultData[index * 2] = HexEncodeChars[(sourceData[index] >> 4)]; 451 | resultData[index * 2 + 1] = HexEncodeChars[(sourceData[index] % 0x10)]; 452 | } 453 | } 454 | resultData[[data length] * 2] = 0; 455 | 456 | // convert result(char[]) to NSString 457 | NSString *result = [NSString stringWithCString:resultData encoding:NSASCIIStringEncoding]; 458 | sourceData = nil; 459 | free(resultData); 460 | 461 | return result; 462 | } 463 | 464 | @end 465 | 466 | #pragma mark - CocoaSecurityDecoder 467 | @implementation CocoaSecurityDecoder 468 | - (NSData *)base64:(NSString *)string 469 | { 470 | return [NSData dataWithBase64EncodedString:string]; 471 | } 472 | - (NSData *)hex:(NSString *)data 473 | { 474 | if (data.length == 0) { return nil; } 475 | 476 | static const unsigned char HexDecodeChars[] = 477 | { 478 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 479 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 480 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 481 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 482 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, //49 483 | 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, //59 484 | 0, 0, 0, 0, 0, 10, 11, 12, 13, 14, 485 | 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, //79 486 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 487 | 0, 0, 0, 0, 0, 0, 0, 10, 11, 12, //99 488 | 13, 14, 15 489 | }; 490 | 491 | // convert data(NSString) to CString 492 | const char *source = [data cStringUsingEncoding:NSUTF8StringEncoding]; 493 | // malloc buffer 494 | unsigned char *buffer; 495 | NSUInteger length = strlen(source) / 2; 496 | buffer = malloc(length); 497 | for (NSUInteger index = 0; index < length; index++) { 498 | buffer[index] = (HexDecodeChars[source[index * 2]] << 4) + (HexDecodeChars[source[index * 2 + 1]]); 499 | } 500 | // init result NSData 501 | NSData *result = [NSData dataWithBytes:buffer length:length]; 502 | free(buffer); 503 | source = nil; 504 | 505 | return result; 506 | } 507 | 508 | @end --------------------------------------------------------------------------------