how to convert encrypt method to decrypt - swift

Question

I have the following method that I want to decrypt. The following method Encrypts. What should I do to decrypt?
Code
PlainString = "5lg3yg7Q+Y8="
func tripleDesEncrypt(PlainString: String) -> String {
let keyData = "FIFEDCBA98765432104AABFD"
let PlainStringvar = PlainString
guard let data = PlainStringvar.data(using: .utf8) else {
return ""
}
let cryptData = NSMutableData(length: Int(data.count) + kCCBlockSize3DES)!
let keyLength = size_t(kCCKeySize3DES)
let operation: CCOperation = UInt32(kCCEncrypt)
let algoritm: CCAlgorithm = UInt32(kCCAlgorithm3DES)
let options: CCOptions = UInt32(kCCOptionECBMode + kCCOptionPKCS7Padding)
var numBytesEncrypted :size_t = 0
let cryptStatus = CCCrypt(operation,
algoritm,
options,
keyData.bytes, keyLength,
nil,
data.bytes, data.count,
cryptData.mutableBytes, cryptData.length,
&numBytesEncrypted)
if UInt32(cryptStatus) == UInt32(kCCSuccess) {
cryptData.length = Int(numBytesEncrypted)
var base64cryptString = cryptData.base64EncodedString(options: .lineLength64Characters)
return base64cryptString //// encodeString(str: base64cryptString)
} else {
print("Error: \(cryptStatus)")
}
return ""
}

Answer 1

I never did encrypt/decrypt on Swift but based on that code you just need to change this line
let operation: CCOperation = UInt32(kCCEncrypt)
to
let operation: CCOperation = UInt32(kCCDecrypt)
While making a small search for this answer I came across this
https://github.com/DigitalLeaves/CommonCrypto-in-Swift
It might be useful, not only as a library that you can use, but to study code and also looks that you're new to the Swift language so I advise you to take a look

Answer 2

Your tripleDesEncrypt does not compile in Swift 4, so I needed to fix it:
func tripleDesEncrypt(plainString: String) -> String {
let keyData = "FIFEDCBA98765432104AABFD".data(using: .utf8)!
//Converting plainString to UTF-8 encoded data
guard let data = plainString.data(using: .utf8) else {
return ""
}
var cryptData = Data(count: data.count + kCCBlockSize3DES)
let keyLength = size_t(kCCKeySize3DES)
let operation: CCOperation = CCOperation(kCCEncrypt)
let algoritm: CCAlgorithm = CCAlgorithm(kCCAlgorithm3DES)
let options: CCOptions = CCOptions(kCCOptionECBMode + kCCOptionPKCS7Padding)
var numBytesEncrypted :size_t = 0
//Encrypting UTF-8 encoded data in 3DES, ECB, PKCS7 with keyData
let cryptStatus = keyData.withUnsafeBytes {keyBytes in
data.withUnsafeBytes {dataBytes in
cryptData.withUnsafeMutableBytes {mutableBytes in
CCCrypt(operation,
algoritm,
options,
keyBytes, keyLength,
nil,
dataBytes, data.count,
mutableBytes, cryptData.count,
&numBytesEncrypted)
}
}
}
if cryptStatus == CCCryptorStatus(kCCSuccess) {
//Converting encrypted data into base-64 String
cryptData.count = Int(numBytesEncrypted)
let base64cryptString = cryptData.base64EncodedString(options: .lineLength64Characters)
return base64cryptString
} else {
print("Error: \(cryptStatus)")
return ""
}
}
The code is made of 3 parts:
Converting plainString to UTF-8 encoded data
Encrypting UTF-8 encoded data in 3DES, ECB, PKCS7 with keyData
Converting encrypted data into base-64 String
So, to decrypt, you need to apply inverse conversion in reversed order:
Converting base-64 String into encrypted data
Decrypting to UTF-8 encoded data in 3DES, ECB, PKCS7 with keyData
Converting UTF-8 encoded data into plainString
The method looks like this:
func tripleDesDecrypt(base64String: String) -> String {
let keyData = "FIFEDCBA98765432104AABFD".data(using: .utf8)!
//Converting base-64 String into encrypted data
guard let encryptedData = Data(base64Encoded: base64String, options: .ignoreUnknownCharacters) else {
return ""
}
var decryptedData = Data(count: encryptedData.count)
let keyLength = size_t(kCCKeySize3DES)
let operation: CCOperation = CCOperation(kCCDecrypt)
let algoritm: CCAlgorithm = CCAlgorithm(kCCAlgorithm3DES)
let options: CCOptions = CCOptions(kCCOptionECBMode + kCCOptionPKCS7Padding)
var numBytesDecrypted :size_t = 0
//Decrypting to UTF-8 encoded data in 3DES, ECB, PKCS7 with keyData
let cryptStatus = keyData.withUnsafeBytes {keyBytes in
encryptedData.withUnsafeBytes {dataBytes in
decryptedData.withUnsafeMutableBytes {mutableBytes in
CCCrypt(operation,
algoritm,
options,
keyBytes, keyLength,
nil,
dataBytes, encryptedData.count,
mutableBytes, decryptedData.count,
&numBytesDecrypted)
}
}
}
if cryptStatus == CCCryptorStatus(kCCSuccess) {
//Converting UTF-8 encoded data into plainString
let plainString = String(data: decryptedData, encoding: .utf8) ?? ""
return plainString
} else {
print("Error: \(cryptStatus)")
return ""
}
}
Usage:
let encryptedString = tripleDesEncrypt(plainString: "This is a test.")
print(encryptedString) //->QmWafUwPY/MVWu3lHa3c5A==
let decryptedString = tripleDesDecrypt(base64String: encryptedString)
print(decryptedString) //->This is a test.
//Try by yourself...
let origString = tripleDesDecrypt(base64String: "5lg3yg7Q+Y8=")
print(origString)