Функция шифрования RSA в Swift 4 из строки открытого ключа

На github доступен класс RSAUtils.swift. Добавьте этот файл в свой проект.

Затем вы можете использовать следующие функции для шифрования/дешифрования любого строкового содержимого с общедоступным токеном в кодировке base64:

/**
 Returns RSA encrypted Base64 encoded string with specified public key which is Base64 encoded string.

 - parameter withPublickKeyBase64: Base64 encoded string value of public key.
 - returns: RSA encrypted Base64 encoded string.
 */
func encryptRsaBase64(_ string: String, withPublickKeyBase64: String) -> String? {
    if let data = string.data(using: .utf8) {
        if let encrypted = RSAUtils.encryptWithRSAPublicKey(data, pubkeyBase64: withPublickKeyBase64, keychainTag: "") {
            return encrypted.base64EncodedString()
        }
    }
    return nil
}

/**
 Returns RSA decrypted Base64 encoded string with specified public key which is Base64 encoded string.

 - parameter withPublickKeyBase64: Base64 encoded string value of public key.
 - returns: RSA decrypted Base64 encoded string.
 */
func decryptRsaBase64Encrypted(_ string: String, withPublicKeyBase64: String) -> String? {
    if let encrypted = Data(base64Encoded: string, options: Data.Base64DecodingOptions.init(rawValue: 0)) {
        if let data = RSAUtils.decryptWithRSAPublicKey(encrypted, pubkeyBase64: withPublicKeyBase64, keychainTag: "") {
            return String(data: data, encoding: .utf8)
        }
    }
    return nil
}

Вы можете сделать вот так...

static func encrypt(string: String, publicKey: String?) -> String? {
        guard let publicKey = publicKey else { return nil }

        let keyString = publicKey.replacingOccurrences(of: "-----BEGIN PUBLIC KEY-----\n", with: "").replacingOccurrences(of: "\n-----END PUBLIC KEY-----", with: "")
        guard let data = Data(base64Encoded: keyString) else { return nil }

        var attributes: CFDictionary {
            return [kSecAttrKeyType         : kSecAttrKeyTypeRSA,
                    kSecAttrKeyClass        : kSecAttrKeyClassPublic,
                    kSecAttrKeySizeInBits   : 2048,
                    kSecReturnPersistentRef : kCFBooleanTrue] as CFDictionary
        }

        var error: Unmanaged<CFError>? = nil
        guard let secKey = SecKeyCreateWithData(data as CFData, attributes, &error) else {
            print(error.debugDescription)
            return nil
        }
        return encrypt(string: string, publicKey: secKey)
    }

    static func encrypt(string: String, publicKey: SecKey) -> String? {
        let buffer = [UInt8](string.utf8)

        var keySize   = SecKeyGetBlockSize(publicKey)
        var keyBuffer = [UInt8](repeating: 0, count: keySize)

        // Encrypto  should less than key length
        guard SecKeyEncrypt(publicKey, SecPadding.PKCS1, buffer, buffer.count, &keyBuffer, &keySize) == errSecSuccess else { return nil }
        return Data(bytes: keyBuffer, count: keySize).base64EncodedString()
    }

Это сработало для меня:

RSA/ECB/PKCS1 Кодировка заполнения UTF-8

import Foundation

    static func encrypt(string: String, publicKey: String?) -> String? {
        guard let publicKey = publicKey else {
            return nil
        }
        
        let keyString = publicKey.replacingOccurrences(of: "-----BEGIN PUBLIC KEY-----\n", with: "").replacingOccurrences(of: "\n-----END PUBLIC KEY-----", with: "")
        guard let data = Data(base64Encoded: keyString) else {
            return nil
        }
        
        var attributes: CFDictionary {
            return [kSecAttrKeyType: kSecAttrKeyTypeRSA,
                    kSecAttrKeyClass: kSecAttrKeyClassPublic,
                    kSecAttrKeySizeInBits: 2048,
                    kSecReturnPersistentRef: kCFBooleanTrue] as CFDictionary
        }
        
        var error: Unmanaged<CFError>? = nil
        guard let secKey = SecKeyCreateWithData(data as CFData, attributes, &error) else {
            print(error.debugDescription)
            return nil
        }
        return vEncrypt(string: string, publicKey: secKey)
    }
    
    static func vEncrypt(string: String, publicKey: SecKey) -> String? {
        let buffer = [UInt8](string.utf8)
        
        var keySize = SecKeyGetBlockSize(publicKey)
        var keyBuffer = [UInt8](repeating: 0, count: keySize)
        
        //
        guard SecKeyEncrypt(publicKey, SecPadding.PKCS1, buffer, buffer.count, &keyBuffer, &keySize) == errSecSuccess else {
            return nil
        }
        return Data(bytes: keyBuffer, count: keySize).base64EncodedString()
    }