I am currently trying to create a PrivateKey from a base64 encoded key via base64Encoded and pemEncoded. Since I always received the Couldn't create key reference from key data SwiftyRSAError, I decided to check for more meaningful errors and found that no matter the key I pass in, I always get the error listed in the title.

The change to see this error is found in SwiftyRSA.addKey within the iOS 10.0 if block.

Change guard let key = SecKeyCreateWithData(keyData as CFData, keyDict as CFDictionary, nil) to

var error:Unmanaged<CFError>? = nil
guard let key = SecKeyCreateWithData(keyData as CFData, keyDict as CFDictionary, &error) else {
  print(error)
...
}

I have tested this with about 20 different RSA private keys as well as those found in the test key folder. I am not sure if I am going on the wrong track or not.

At present the signing function throws an exception if you try and sign too much data. Ideally the function would generate an SHA1 digest of the data and sign that, but integration of CommonCrypto into Swift frameworks seems to be tricky. See - http://iosdeveloperzone.com/2014/10/03/using-commoncrypto-in-swift/

Hello,

I have been using your library in production for the past 6 months or so, but after upgrading to Swift 3, I can no longer verify signatures for messages signed on our CentOS server. I am using the exact same server-side script & keys to sign the messages as I did before upgrading to Swift 3.

Here is how the server keys were generated:

ssh-keygen -t rsa -f serverkey -N '' -b 2048
mv serverkey serverkey-priv.pem
ssh-keygen -f serverkey.pub -e -m pem > serverkey-pub.pem ; rm -f serverkey.pub

I sign the message like this: cat message | openssl dgst -sha256 -sign serverkey-priv.pem -out signature.bin

Then I base64-encode signature.bin and send the message along with the base64-encoded signature to the iOS device where I try to verify the signature like this: set verificationResult = SwiftyRSA.verifySignatureString(stringToVerify, signature: signature, publicKeyPEM: serverKey, digestMethod: .SHA256)

The problem is that verificationResult.isSuccessful returns false. The error property is:

Error Domain=com.takescoop.SwiftyRSA Code=500 "Couldn't decode PEM key data (base64)" UserInfo={NSLocalizedDescription=Couldn't decode PEM key data (base64)}

Here is the message: Raw message, 1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ, very sensitive information!!

The signature (base64-encoded hash): p9+ID34iW9+ff+2S25GY0fViWzdQgCwZIwFRZAPEk6/onODvmq3wa1471btGuez+0dtUZ3f2z3Mii7x0mmPcn0cZEvjFWVQrI0+woDd3/hcOkpIdYUHAQmaRVOARx5PZgHF0LosPf6aP1ePhHUmrJHwyTmfok+tjcZwtCaeJCQYaSFqTE3F6c78guMEaq83vg/zsBBceBlAhQSCZb3lhIJZqu8Y2AHyDpuCfrANURx8XkYwcxu5ark+/YGIdkNqrrkeg5X2daph+Qfefn8ikq/kL9wTnleJ9miKDKQVc5YqKhwhhv5Y6nZ86wVeS9+uv/Yz6HS7wwxbwRJJ28w28ZQ==

Attached is a zip file with the actual message, hash and key pair used.

message-hash-and-key.zip

Help with this would be much appreciated!

The method was added together with an accompanying test, although the test will fail due to what is believed to be a unit test bug http://www.openradar.me/36809637

Apologies for any formatting I've messed up slightly, my Xcode prefs are slightly different.

Let me know if any changes are needed 👍

Signed-off-by: Christoffer Buusmann [email protected]

Very simple support for SPM, just a new library product for SwiftyRSA. There are ways to cheese Obj-C code into a package, but migrating the single Objective-C class seemed more straightforward. Tested with Xcode 11.7 and 12.0.1

After update swift version to 5.2 and update build latest "SwiftyRSA", encryption method at "ClearMessage" class sometime has wrong data.

Test : I saved a clear message when encryption was OK, and for next time used from that object again BUT! for second time encrypted data was not ok. in fact correct encrypted data completely is random after update to swift 5.2.

func generateEncryptedSymmetricKeyData(length :Int,secondaryChunkSize:Int) -> Data {
// TEST AGAIN: repeat 'encrypted' method when encryption was ok
        if isOk { 
            do {
                encryptedSymmetricKeyData = Data()
                for clear in safeClearMessage {
                    let encrypted = try clear.encrypted(with: publicKeyClient, padding: .PKCS1)
                    encryptedSymmetricKeyData.append(contentsOf: encrypted.data)
                }
                return encryptedSymmetricKeyData
            } catch  {
                print(error)
            }
        }
  //===================================================================


        encryptedSymmetricKeyData = Data()
        symmetricKey = IGGlobal.randomString(length: length)
        do {
            let symmetricKeyData = symmetricKey.data(using: .utf8)
            var encSymmetricKeyData = try encrypt(rawData: symmetricKeyData!) 
            let publicKey = try PublicKey(pemEncoded: embeddedPublicKey)
            publicKeyClient = publicKey
            while(0<encSymmetricKeyData.count){
                let chunk = encSymmetricKeyData.subdata(in: 0..<secondaryChunkSize)
                let clear = ClearMessage(data: chunk)

                // STORE: store "ClearMessage" Object for use next time
                safeClearMessage.append(clear)

               // **ERROR LINE** this line sometimes is OK and sometimes is NOT OK
               let encrypted = try clear.encrypted(with: publicKey, padding: .PKCS1)


                encryptedSymmetricKeyData.append(contentsOf: encrypted.data)
                encSymmetricKeyData = encSymmetricKeyData.subdata(in: secondaryChunkSize..<encSymmetricKeyData.count)
            }
        } catch  {
            print(error)
        }
        return encryptedSymmetricKeyData
    }

Thanks for writing this useful library!

Can this library be used to generate an RSA key pair on the iOS device (as opposed to generating the keys on a server)? If not, any suggestion on another library that will generate PEM keys that are compatible with this library?

Hi @ldiqual, thanks for this library. Very cool. Is there an issue with the latest commit and publicKeyFromPEMString(pubString)?

In my Swift playground, I found the following: privateKeyFromPEMString works. publicKeyFromDERData works. publicKeyFromPEMString fails.

Example to show you the error:

let rsa = SwiftyRSA() let pubPath: String = NSBundle.mainBundle().pathForResource("public", ofType: "pem")!

if NSFileManager().fileExistsAtPath(pubPath) {
    do {
        let pubString = try NSString(contentsOfFile: pubPath, encoding: NSUTF8StringEncoding) as String
                    print(pubString)
       // let pubKey = try rsa.publicKeyFromPEMString(pubString)

    } catch let error as NSError {
        print(error.code)
        print(error.description)
    }
}

Hey, I am trying to integrate with an API which uses BouncyCastle encryption, so the server is not able to decrypt the data which i am encrypting using SwiftyRSA. Am i doing something wrong or it won't work because it is using Bouncy Castle?

Kindly Help.

We currently have a problem with using SwiftyRSA because a third party required encoded empty strings. When using padding like PKCS, it is allowed to encrypt empty strings according to the standard. I have enabled this in this pull request and added a test.

However, I can't get the decrypt to work with Apple's SecKeyEncrypt. This returns status -9809 which means "An underlying cryptographic error was encountered.".

Please comment on how to implement the decryption.

This PR fixes the issue #81.

It enables to prepend a X509 header to a headerless public key. The new method does the exact opposite of the native method stripKeyHeader()

If the given key isn't headerless, it is returned as is.

A part of the new code come from Heimdall's project released under MIT Licence.

Header key can be verified on Lapo's online decoder by anyone.

With the new method, all public keys are compatible with the most of javascript, java, python (etc...) rsa algorithms. It could fix some of the gihtub SwiftyRSA's issues

do { let publicKey = try PublicKey(pemNamed: "public")

let str = "Clear String"
let clear = try ClearMessage(string: str, using: .utf8)
let encrypted = try clear.encrypted(with: publicKey, padding: .PKCS1)

let data = encencrypted.data
print(data)

let base64String = encrypted.base64String
print(base64String)

} catch { print(error) }

I use public key encryption, The result is "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA =" Good depressed, excuse me have a solution?

I'm interested using additional parameters for algorithm:

1. Padding (PSS).
2. Salt length.

Now padding is PKCS1 by default and isn't configurable and no salt parameter at all. I found that in this library, for example.

On version 1.7.0 SwiftyRSA.prependX509KeyHeader is marked as internal. In your example it should work and should thus be public. Could this be changed please? Thanks, Jan