RSA Key Generation Speed between CryptoSwift & SwiftyRSA

[metasidd]

Hey folks! I've been exploring a few options to figure out a public/private key system and landed here to try generating RSA keys on my iOS app.

• CryptoSwift RSA: Takes anywhere between 300s to 480s.
• SwiftyRSA: Less than 1s everytime.

Here's a very rough SwiftUI implementation to where I can repro these results. Any thoughts on what's happening?

struct DebugRSAKeyGeneration: View {
    @State private var privateKey: String = ""
    @State private var publicKey: String = ""
    @State private var isGeneratingKey: Bool = false

    var body: some View {
        VStack {
            ScrollView {
                if isGeneratingKey {
                    Text("Generating keys...")
                } else {
                    Text("Public Key: \(publicKey)")
                        .padding()
                    Text("Private Key: \(privateKey)")
                        .padding()
                }
            }
            Button("Generate SwiftyRSA Key") {
                generateSwiftyRSAKey()
            }
            
            Button("Generate CryptoSwift RSA Key") {
                generateCryptoSwiftRSAKey()
            }
        }
        .padding()
    }

    private func generateSwiftyRSAKey() {
        isGeneratingKey = true
        Task {
            do {
                let (pubKey, privKey) = try await RSAKeyGenerator().generateSwiftyRSAKey(size: 2048)
                DispatchQueue.main.async {
                    self.publicKey = pubKey
                    self.privateKey = privKey
                    self.isGeneratingKey = false
                }
            } catch {
                // Handle the error appropriately
                print("Error generating RSA keys: \(error)")
                DispatchQueue.main.async {
                    self.isGeneratingKey = false
                }
            }
        }
    }
    private func generateCryptoSwiftRSAKey() {
        isGeneratingKey = true
        Task {
            do {
                let (pubKey, privKey) = try await RSAKeyGenerator().generateRSAKey(size: 2048)
                DispatchQueue.main.async {
                    self.publicKey = pubKey
                    self.privateKey = privKey
                    self.isGeneratingKey = false
                }
            } catch {
                // Handle the error appropriately
                print("Error generating RSA keys: \(error)")
                DispatchQueue.main.async {
                    self.isGeneratingKey = false
                }
            }
        }
    }
}

public class RSAKeyGenerator {
    
    private let logger = CustomLogger(category: "RSAKeyGenerator")
    
    public enum RSAKeyGeneratorError: Error {
        case keyGenerationError
        case publicKeyError
        case privateKeyError
    }
    
    /// Generates an RSA key pair.
    /// Returns a tuple of Data, where the first element is the public key and the second is a representation of the private key.
    public func generateRSAKey(size: Int) async throws -> (String, String) {
        logger.info("[RSAKeyGenerator] ✅ Generate RSA key called")
        
        do {
            let rsa = try RSA(keySize: size)
            let publicKey = try rsa.publicKeyExternalRepresentation().toHexString()
            let privateKey = try rsa.externalRepresentation().toHexString()
            return (publicKey, privateKey)
        } catch {
            throw RSAKeyGeneratorError.keyGenerationError
        }
    }
    
    public func generateSwiftyRSAKey(size: Int) async throws -> (String, String) {
        logger.info("[RSAKeyGenerator] ✅ Generate RSA key called")
        
        do {
            let rsa = try SwiftyRSA.generateRSAKeyPair(sizeInBits: 2048)
            let publicKey = try rsa.publicKey.pemString()
            let privateKey = try rsa.privateKey.pemString()
            return (publicKey, privateKey)
        } catch {
            throw RSAKeyGeneratorError.keyGenerationError
        }
    }
}```

Happy to provide more information on the outputs/experiments here. I'd love to continue using CryptoSwift since more comprehensive than SwiftyRSA. 

[krzyzanowskim]

is this a Release build?

debug build Swift code is expected (unfortunately) to be slow. Since CryptoSwift is all Swift code without any other codebase underneath, such difference in debug vs release configuration build is the inherent feature of Swift language.

[metasidd]

(Thanks for the prompt response here!) I should have checked again on my end, it takes 5-7s with a release build now. It does make testing much harder on debug builds though since I create these keys on login and 300s feels like a long time to wait. Wondering why SwiftyRSA works at a good speed on both debug/release though.

[krzyzanowskim]

it uses pre-build framework and wrap it with Swift code. that’s technical explanation. I agree it make debugging annoying, but also there’s nothing can be done with Swift unless use pre-built binary feamework