Swift009-加密
-
MD5
MD5(Message-Digest Algorithm 5)以512位分组来处理输入文本，每组又划分为16个32位子分组。算法的输出由四个32位分组组成，将它们级联形成一个128位散列值。
/// MD5 编码 /// /// - Parameters: /// - string: 需要编码的字符串 /// - lower: true:字母小写 false:字母大写 /// - Returns: 编码结果 public static func ddyMD5String(_ string: String?, lower: Bool) -> String? { guard let cStr = string?.cString(using: .utf8) else { return nil } let buffer = UnsafeMutablePointer<UInt8>.allocate(capacity: 16) CC_MD5(cStr,(CC_LONG)(strlen(cStr)), buffer) let md5String = NSMutableString(); for i in 0 ..< 16 { if lower { md5String.appendFormat("%02x", buffer[i]) } else { md5String.appendFormat("%02X", buffer[i]) } } free(buffer) return md5String as String } -
Base64
Base64是网络上最常见的用于传输8Bit字节码的编码方式之一，Base64就是一种基于64个可打印字符来表示二进制数据的方法。作用是Base64编码是从二进制到字符的过程，可用于在HTTP环境下传递较长的标识信息。
/// Base64 编解码 /// /// - Parameters: /// - string: 需要编解码的字符串 /// - encode: true:编码 false:解码 /// - Returns: 编码结果 public static func ddyBase64String(_ string: String?, encode: Bool) -> String? { if encode { // 编码 guard let codingData = string?.data(using: .utf8) else { return nil } return codingData.base64EncodedString() } else { // 解码 guard let newStr = string else { return nil } guard let decryptionData = Data(base64Encoded: newStr, options: .ignoreUnknownCharacters) else { return nil } return String.init(data: decryptionData, encoding: .utf8) } } -
Sha1
SHA1和MD5本质都是摘要函数，长度不同(MD5是128位,SHA1是160位,SHA256是256位)
public static func ddySha1String(_ string: String?) -> String? { guard let codingData = string?.data(using: .utf8) else { return nil } var digest = [UInt8](repeating: 0, count:Int(CC_SHA1_DIGEST_LENGTH)) let newData = NSData.init(data: codingData) CC_SHA1(newData.bytes, CC_LONG(codingData.count), &digest) let output = NSMutableString(capacity: Int(CC_SHA1_DIGEST_LENGTH)) for byte in digest { output.appendFormat("%02x", byte) } return output as String } -
综合封装
MD5、SHA1、SHA224、SHA256、SHA384、SHA512
```
// Secure Hash Algorithm
enum DDYSHAType {
case MD5, SHA1, SHA224, SHA256, SHA384, SHA512
var infoTuple: (algorithm: CCHmacAlgorithm, length: Int) {
switch self {
case .MD5: return (algorithm: CCHmacAlgorithm(kCCHmacAlgMD5), length: Int(CC_MD5_DIGEST_LENGTH))
case .SHA1: return (algorithm: CCHmacAlgorithm(kCCHmacAlgSHA1), length: Int(CC_SHA1_DIGEST_LENGTH))
case .SHA224: return (algorithm: CCHmacAlgorithm(kCCHmacAlgSHA224), length: Int(CC_SHA224_DIGEST_LENGTH))
case .SHA256: return (algorithm: CCHmacAlgorithm(kCCHmacAlgSHA256), length: Int(CC_SHA256_DIGEST_LENGTH))
case .SHA384: return (algorithm: CCHmacAlgorithm(kCCHmacAlgSHA384), length: Int(CC_SHA384_DIGEST_LENGTH))
case .SHA512: return (algorithm: CCHmacAlgorithm(kCCHmacAlgSHA512), length: Int(CC_SHA512_DIGEST_LENGTH))
}
}
}
// MD5 SHA1 SHA256 SHA512 这4种本质都是摘要函数，不通在于长度 MD5 是 128 位，SHA1 是 160 位 ，SHA256 是 256 位
public static func shaCrypt(string: String?, cryptType: DDYSHAType, key: String?, lower: Bool) -> String? {
guard let cStr = string?.cString(using: String.Encoding.utf8) else {
return nil
}
// let strLen = Int(string!.lengthOfBytes(using: String.Encoding.utf8))
let strLen = strlen(cStr)
let digLen = cryptType.infoTuple.length
let buffer = UnsafeMutablePointer<CUnsignedChar>.allocate(capacity: digLen)
let hash = NSMutableString()
if let cKey = key?.cString(using: String.Encoding.utf8), key != "" {
let keyLen = Int(key!.lengthOfBytes(using: String.Encoding.utf8))
CCHmac(cryptType.infoTuple.algorithm, cKey, keyLen, cStr, strLen, buffer)
} else {
switch cryptType {
case .MD5: CC_MD5(cStr, (CC_LONG)(strlen(cStr)), buffer)
case .SHA1: CC_SHA1(cStr, (CC_LONG)(strlen(cStr)), buffer)
case .SHA224: CC_SHA224(cStr, (CC_LONG)(strlen(cStr)), buffer)
case .SHA256: CC_SHA256(cStr, (CC_LONG)(strlen(cStr)), buffer)
case .SHA384: CC_SHA384(cStr, (CC_LONG)(strlen(cStr)), buffer)
case .SHA512: CC_SHA512(cStr, (CC_LONG)(strlen(cStr)), buffer)
}
}
for i in 0..<digLen {
if lower {
hash.appendFormat("%02x", buffer[i])
} else {
hash.appendFormat("%02X", buffer[i])
}
}
free(buffer)
return hash as String
}
```
对称加密:AES、AES128、DES、DES3、CAST、RC2RC4、Blowfish
iOS中填充规则PKCS7,加解密模式ECB(无补码,CCCrypt函数中对应的nil),字符集UTF8,输出base64(可以自己改hex)
```
// Symmetric Cryptographic Algorithm
enum DDYSCAType {
case AES, AES128, DES, DES3, CAST, RC2, RC4, Blowfish
var infoTuple: (algorithm: CCAlgorithm, digLength: Int, keyLength: Int) {
switch self {
case .AES: return (CCAlgorithm(kCCAlgorithmAES), Int(kCCKeySizeAES128), Int(kCCKeySizeAES128))
case .AES128: return (CCAlgorithm(kCCAlgorithmAES128), Int(kCCBlockSizeAES128), Int(kCCKeySizeAES256))
case .DES: return (CCAlgorithm(kCCAlgorithmDES), Int(kCCBlockSizeDES), Int(kCCKeySizeDES))
case .DES3: return (CCAlgorithm(kCCAlgorithm3DES), Int(kCCBlockSize3DES), Int(kCCKeySize3DES))
case .CAST: return (CCAlgorithm(kCCAlgorithmCAST), Int(kCCBlockSizeCAST), Int(kCCKeySizeMaxCAST))
case .RC2: return (CCAlgorithm(kCCAlgorithmRC2), Int(kCCBlockSizeRC2), Int(kCCKeySizeMaxRC2))
case .RC4: return (CCAlgorithm(kCCAlgorithmRC4), Int(kCCBlockSizeRC2), Int(kCCKeySizeMaxRC4))
case .Blowfish:return (CCAlgorithm(kCCAlgorithmBlowfish), Int(kCCBlockSizeBlowfish), Int(kCCKeySizeMaxBlowfish))
}
}
}
public static func scaCrypt(string: String?, cryptType: DDYSCAType, key: String?, encode: Bool) -> String? {
if string == nil {
return nil
}
let strData = encode ? string!.data(using: .utf8) : Data(base64Encoded: string!)
// 创建数据编码后的指针
let dataPointer = UnsafeRawPointer((strData! as NSData).bytes)
// 获取转码后数据的长度
let dataLength = size_t(strData!.count)
// 将加密或解密的密钥转化为Data数据
guard let keyData = key?.data(using: .utf8) else {
return nil
}
// 创建密钥的指针
let keyPointer = UnsafeRawPointer((keyData as NSData).bytes)
// 设置密钥的长度
let keyLength = cryptType.infoTuple.keyLength
// 创建加密或解密后的数据对象
let cryptData = NSMutableData(length: Int(dataLength) + cryptType.infoTuple.digLength)
// 获取返回数据(cryptData)的指针
let cryptPointer = UnsafeMutableRawPointer(mutating: cryptData!.mutableBytes)
// 获取接收数据的长度
let cryptDataLength = size_t(cryptData!.length)
// 加密或则解密后的数据长度
var cryptBytesLength:size_t = 0
// 是解密或者加密操作(CCOperation 是32位的)
let operation = encode ? CCOperation(kCCEncrypt) : CCOperation(kCCDecrypt)
// 算法类型
let algoritm: CCAlgorithm = CCAlgorithm(cryptType.infoTuple.algorithm)
// 设置密码的填充规则（ PKCS7 & ECB 两种填充规则）
let options:CCOptions = UInt32(kCCOptionPKCS7Padding) | UInt32(kCCOptionECBMode)
// 执行算法处理
let cryptStatus = CCCrypt(operation, algoritm, options, keyPointer, keyLength, nil, dataPointer, dataLength, cryptPointer, cryptDataLength, &cryptBytesLength)
// 结果字符串初始化
var resultString: String?
// 通过返回状态判断加密或者解密是否成功
if CCStatus(cryptStatus) == CCStatus(kCCSuccess) {
cryptData!.length = cryptBytesLength
if encode {
resultString = cryptData!.base64EncodedString(options: .lineLength64Characters)
} else {
resultString = NSString(data:cryptData! as Data ,encoding:String.Encoding.utf8.rawValue) as String?
}
}
return resultString
}
```
CCCrypt 函数的介绍
1、参数1： 是指定加密还是解密的枚举类型（kCCEncrypt 、kCCDecrypt）
2、参数2： 是指加密算法的类型。在CommonCryptor.h中提供了kCCAlgorithmAES128、kCCAlgorithmAES、kCCAlgorithmDES、kCCAlgorithm3DES、kCCAlgorithmCAST、kCCAlgorithmRC4、kCCAlgorithmRC2、kCCAlgorithmBlowfish等多种类型的加密算法
3、 参数3：用来设置密码的填充规则（表示在使用密钥和算法对文本进行加密时的方法）的选项，该选项可以是kCCOptionPKCS7Padding或kCCOptionECBMode两者中的任一个
4、参数4：密钥的数据指针
5、参数5： 是密钥的长度 ，必须是 24 位
6、参数6： 加密或者解密的偏移对象
7、参数7： 要解密或者解密的数据指针对象
8、参数8： 要解密或者解密的数据字符长度
9、参数9： 加密或者解密的数据指针
10、参数10： 接受加密或者解密的数据长度
11、参数11： 这是加密或者解密的数据长度
注意
在加密或者解密的结果输出的时候，要重新设置接受解密或者加密的数据对象的长度为真实长度。
CCCrypt 的返回结果
1、kCCSuccess 加解密操作正常结束
2、kCCParamError 非法的参数值
3、kCCBufferTooSmall 选项设置的缓存不够大
4、kCCMemoryFailure 内存分配失败
5、kCCAlignmentError 输入大小匹配不正确
6、kCCDecodeError 输入数据没有正确解码或解密
7、kCCUnimplemented 函数没有正确执行当前的算法
[验证](http://tool.chacuo.net/cryptdes)
[参考](https://www.jianshu.com/p/cab8f6ffb082)
[参考](https://www.jianshu.com/p/940aaca1e3f6)
[RSA加密](https://www.jianshu.com/p/d2cb314d30ec) 
网友评论