xor

import UIKit
import CommonCrypto

extension String {

    var md5: String {
        let str = self.cString(using: .utf8)
        let strLen = CC_LONG(self.lengthOfBytes(using: String.Encoding.utf8))
        let digestLen = Int(CC_MD5_DIGEST_LENGTH)
        let result = UnsafeMutablePointer<CUnsignedChar>.allocate(capacity: digestLen)

        CC_MD5(str!, strLen, result)

        let hash = NSMutableString()
        for i in 0..<digestLen {
            hash.appendFormat("%02x", result[i])
        }

        return String(format: hash as String)
    }

    var hexadecimal: Data? {
        var data = Data(capacity: self.count / 2)

        let regex = try! NSRegularExpression(pattern: "[0-9a-f]{1,2}", options: .caseInsensitive)
        regex.enumerateMatches(in: self, range: NSRange(startIndex..., in: self)) { match, _, _ in
            let byteString = (self as NSString).substring(with: match!.range)
            let num = UInt8(byteString, radix: 16)!
            data.append(num)
        }

        guard data.count > 0 else { return nil }

        return data
    }

}

class ViewController: UIViewController {

    let currentTimeInMillis: Int = 1553265944

    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view, typically from a nib.

        let password = self.getEncryptedPass(password: "utd3mz9k", currentTimeInMillis: self.currentTimeInMillis)
        print(password)
        //oqp\/INLVt9A=
    }

    func getEncryptedPass(password: String, currentTimeInMillis: Int) -> String {

        let currentTimeReversed = String("\(currentTimeInMillis)".reversed())
        let currentTimeReversedMd5 = currentTimeReversed.md5

        if let keyData = currentTimeReversedMd5.hexadecimal {

            let dataBytes = password.data(using: .utf8)!
            let xorResult = self.xor(data: dataBytes, with: keyData)

            return xorResult.base64EncodedString()
        }

        return ""
    }

    func xor(data: Data, with key: Data) -> Data {
        var xorData = data
        var tempData = xorData

        tempData.withUnsafeMutableBytes { (start: UnsafeMutablePointer<UInt8>) -> Void in
            key.withUnsafeBytes { (keyStart: UnsafePointer<UInt8>) -> Void in
                let b = UnsafeMutableBufferPointer<UInt8>(start: start, count: xorData.count)

                let k = UnsafeBufferPointer<UInt8>(start: keyStart, count: data.count)
                let length = data.count

                for i in 0..<xorData.count {
                    b[i] ^= k[i % length]
                }
            }
        }

        return tempData
    }

}