我是否可以使用从iOS生成的公钥，在c#代码中对数据进行加密，并再次在iOS中对加密数据（使用私钥）进行解密？

我已经在iOS中生成了密钥对，当我解密使用c#code中的公钥加密的数据时，我收到以下错误

“Error Domain=NSOSStatusErrorDomain Code=-50”：符号-输入缓冲区错误大小（144字节）“UserInfo={NSDescription=：符号-输入缓冲区错误大小（144字节）}”

我使用的密钥大小为1024，使用的是rsaEncryptionPKCS1加密

iOS代码---

**

---------------c#代码

---

我想以标准格式从iOS导出公钥，可以在c#中提取，无需使用任何Nuget包……非常感谢您的帮助

---

---

我发现的一个解决方案是在C#中使用bouncy castle Nuget包导入RSA公钥，而不是在C#中加密数据

---

---

问你2小时前问的问题有什么意义？如果需要添加任何内容，请修改格式，您可以随时编辑您的问题。但是，使用公用iOS公钥的每个人都可以解密数据。。。既然它是公开的而不是为什么要加密，你应该使用Diffie–Hellman密钥交换iOS

解密

代码在哪里？谢谢ziatsman…我添加了解密代码，我发现的一个解决方案是使用C#中的bouncy castle Nuget包导入RSA公钥，而不是在C#中加密数据…但我想导出公钥iOS标准格式的密钥，无需使用任何Nuget软件包即可在c#中提取

private func createSecureKeyPair(_ keyTag: String, _ keyType :KeyType = .publicKey) -> Data? {
        // private key parameters
        let privateKeyParams: [String: AnyObject] = [
            kSecAttrIsPermanent as String: true as AnyObject,
            kSecAttrCanDecrypt as String: true as AnyObject,
            kSecAttrApplicationTag as String: keyTag as AnyObject,
        ]
        // private key parameters
        let publicKeyParams: [String: AnyObject] = [
            kSecAttrApplicationTag as String: keyTag as AnyObject,
            kSecAttrIsPermanent as String: true as AnyObject
        ]        
        // global parameters for our key generation
        let parameters: [String: AnyObject] = [
            kSecAttrKeyType as String:          kSecAttrKeyTypeRSA as AnyObject,
            kSecAttrKeySizeInBits as String:    1024 as AnyObject,
            kSecPublicKeyAttrs as String:       publicKeyParams as AnyObject,
            kSecPrivateKeyAttrs as String:      privateKeyParams as AnyObject,
        ]
        
        var pubKey, privKey: SecKey?
        let status = SecKeyGeneratePair(parameters as CFDictionary, &pubKey, &privKey)
        if status == errSecSuccess {
            print("Successfully generated keypair!\nPrivate key: \(String(describing: privKey))\nPublic key: \(String(describing: pubKey))")
            return self.getKeyData(keyTag,keyType)
        } else {
            print("Error generating keypair: \(status)")
            return nil
        }
    }

func encryptData(messageData: Data, publicKeySec: SecKey) -> Data? {     
        guard let encryptData = SecKeyCreateEncryptedData(
            publicKeySec,
            SecKeyAlgorithm.rsaEncryptionPKCS1,
            messageData as CFData,
            nil) else {
                print("Encryption Error")
                return nil
            }
        print(encryptData)
        return encryptData as Data
    }

func decryptData(messageData : Data, privateKeySec: SecKey) -> Data? {
        guard let decryptData = SecKeyCreateDecryptedData(
            privateKeySec,
            SecKeyAlgorithm.rsaEncryptionPKCS1,
            messageData as CFData,
            nil) else {
                print("Decryption Error")
                return nil
        }
        return decryptData as Data
    }

public static string RSAEncrypt(string plainData, string publicKeyXml)
        {
            using (RSA rsa = RSA.Create())
            {
                try
                {
                    rsa.KeySize = 1024;
                    RSAParameters parameter = FromXmlString(rsa, publicKeyXml);
                    rsa.ImportParameters(parameter);
                    byte[] encryptedBytes = rsa.Encrypt(Encoding.UTF8.GetBytes(plainData), RSAEncryptionPadding.Pkcs1);
                    return Convert.ToBase64String(encryptedBytes);
                }
                catch (Exception ex)
                {
                    return ex.Message;
                }
            }
        }

public static string RSAEncryptiOS(string plainData, string publicKeyiOS)
        {
            try
            {
                byte[] publicKeyBytes = Convert.FromBase64String(publicKeyiOS);

                var stream = new MemoryStream(publicKeyBytes);
                Asn1Object asn1Object = Asn1Object.FromStream(stream);
                Asn1Encodable asn1Sequence = asn1Object;

                AlgorithmIdentifier algorithmIdentifier = new
                AlgorithmIdentifier(PkcsObjectIdentifiers.IdRsaesOaep);

                SubjectPublicKeyInfo subjectPublicKeyInfo = new
                SubjectPublicKeyInfo(algorithmIdentifier, asn1Sequence);

                AsymmetricKeyParameter asymmetricKeyParameter2 =
                PublicKeyFactory.CreateKey(subjectPublicKeyInfo);

                RsaKeyParameters rsaKeyParameters =
                (RsaKeyParameters)asymmetricKeyParameter2;
                RSAParameters rsaParameters = new RSAParameters();
                rsaParameters.Modulus = rsaKeyParameters.Modulus.ToByteArrayUnsigned();
                rsaParameters.Exponent = rsaKeyParameters.Exponent.ToByteArrayUnsigned();

                RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
                rsa.ImportParameters(rsaParameters);
                //string test = "Hello World 2020";
                byte[] encbyte = rsa.Encrypt(Encoding.UTF8.GetBytes(plainData), RSAEncryptionPadding.Pkcs1);
                return Convert.ToBase64String(encbyte);
            }
            catch (Exception ex)
            {
                return ex.Message;
            }
            
        }
***