Encrypt and decrypt in SWIFT

Question

Im searching for encrypt and decrypt code in SWIFT.

But I cannot found a solution in SWIFT. I need pass a key to encrypt/decrypt in MD5 and convert to BASE64 in ECB mode!

I have this code in C#:

public static string MD5Cripto(string texto, string chave)
{
  try
  {
     TripleDESCryptoServiceProvider sObCripto 
                      = new TripleDESCryptoServiceProvider();
     MD5CryptoServiceProvider sObjcriptoMd5 = new MD5CryptoServiceProvider();
     byte[] sByteHash, sByteBuff;
     string sTempKey = chave;

     sByteHash = sObjcriptoMd5.ComputeHash(ASCIIEncoding
                     .UTF8.GetBytes(sTempKey));
     sObjcriptoMd5 = null;
     sObCriptografaSenha.Key = sByteHash;
     sObCriptografaSenha.Mode = CipherMode.ECB;

     sByteBuff = ASCIIEncoding.UTF8.GetBytes(texto);
     return Convert.ToBase64String(sObCripto.CreateEncryptor()
                    .TransformFinalBlock(sByteBuff, 0, sByteBuff.Length));
  }
  catch (Exception ex)
  {
     return "Digite os valores Corretamente." + ex.Message;
  }
}

UPDATE:

I try this but still not working.. What Im doing wrong? (Ignore my prints..)

func myEncrypt(encryptData:String) -> NSData?
{
   let myKeyData : NSData = ("mykey" as NSString)
                     .dataUsingEncoding(NSUTF8StringEncoding)!
   let myKeyDataMD5 = "mykey".md5()
   let sArrayByte = myKeyDataMD5.hexToByteArray()
   let myRawData : NSData = encryptData.dataUsingEncoding(NSUTF8StringEncoding)!

   let buffer_size:size_t = myRawData.length + kCCBlockSize3DES
   let buffer = UnsafeMutablePointer<NSData>.alloc(buffer_size)
   var num_bytes_encrypted : size_t = 0

   let operation:CCOperation = UInt32(kCCEncrypt)
   let algoritm:CCAlgorithm = UInt32(kCCAlgorithm3DES)
   let options:CCOptions   = UInt32(kCCOptionECBMode + kCCOptionPKCS7Padding)
   let keyLength = size_t(kCCKeySize3DES)

   let Crypto_status: CCCryptorStatus = CCCrypt(operation, algoritm, 
           options, sArrayByte, keyLength, nil, 
           myRawData.bytes, myRawData.length, buffer, 
           buffer_size, &num_bytes_encrypted)

   if Int32(Crypto_status) == Int32(kCCSuccess)
   {
      let myResult: NSData = NSData(bytes: buffer, length: num_bytes_encrypted)
      print("buffer")

      let count = myResult.length / sizeof(UInt32)
      var array = [UInt32](count: count, repeatedValue: 0)
      myResult.getBytes(&array, length:count * sizeof(UInt32))

      print(array)

      free(buffer)
      print("myResult")
      print(myResult)

      let resultNSString = NSString(data: myResult, 
                    encoding: NSUnicodeStringEncoding)!
      let resultString = resultNSString as String
      print("resultString")
      print(resultString)
      let sBase64 = toBase64(String(resultString))
      print("sBase64")
      print(sBase64)

      let data : NSData! = resultNSString
                    .dataUsingEncoding(NSUnicodeStringEncoding)
      let count2 = data.length / sizeof(UInt32)
      var array2 = [UInt32](count: count, repeatedValue: 0)
      data.getBytes(&array2, length:count2 * sizeof(UInt32))
      print("array2")
      print(array2)

      return myResult
   }
   else
   {
      free(buffer)
      return nil
   }

}

Answer 1

Example question code updated.
Not sure what the output formatting code in the question was trying to accomplish.

Note that the 3DES uses a 24-byte key (kCCKeySize3DES is 24) and MD5 provides a 16-byte (CC_MD5_DIGEST_LENGTH is 16) result so there is a mis-match in key length.

func encrypt(dataString:String, keyString:String) -> NSData?
{
    let keyData = md5(keyString)
    let data : NSData = dataString.dataUsingEncoding(NSUTF8StringEncoding)!
    var numBytesEncrypted : size_t = 0
    var encryptedData: NSMutableData! = NSMutableData(length: Int(data.length) + kCCBlockSize3DES)
    let encryptedPointer = UnsafeMutablePointer<UInt8>(encryptedData.mutableBytes)
    let encryptedLength  = size_t(encryptedData.length)

    let operation:CCOperation = UInt32(kCCEncrypt)
    let algoritm:CCAlgorithm = UInt32(kCCAlgorithm3DES)
    let options:CCOptions   = UInt32(kCCOptionECBMode + kCCOptionPKCS7Padding)
    let keyLength = size_t(kCCKeySize3DES)

    let status: CCCryptorStatus = CCCrypt(operation, algoritm, options,
                                          keyData, keyLength,
                                          nil,
                                          data.bytes, data.length,
                                          encryptedPointer, encryptedLength,
                                          &numBytesEncrypted)
    if Int32(status) == Int32(kCCSuccess) {
        encryptedData.length = Int(numBytesEncrypted)
    }
    else {
        encryptedData = nil
    }

    return encryptedData;
}

func md5(string: String) -> [UInt8] {
    var digest = [UInt8](count: Int(CC_MD5_DIGEST_LENGTH), repeatedValue: 0)
    if let data = string.dataUsingEncoding(NSUTF8StringEncoding) {
        CC_MD5(data.bytes, CC_LONG(data.length), &digest)
    }
    return digest
}

Test:

let dataString = "Now is the time"
let keyString  = "mykey"
let encryptedData = encrypt(dataString, keyString:keyString)
print("encryptedData: \(encryptedData!)")

let encryptedBase64 = encryptedData!.base64EncodedStringWithOptions(NSDataBase64EncodingOptions())
print("encryptedBase64: \(encryptedBase64)")

Output:

encryptedData: 8d88a2bc 00beb021 f37917c3 75b0ba1a
encryptedBase64: jYiivAC+sCHzeRfDdbC6Gg==

Note:

3DES, ECB mode and MD5 are not recommended and should not be used in new code, instead use AES, CBC mode with a random iv and PBKDF2 respetively.