具有OpenSSL密钥和Bouncy Castle的C＃RSA实现

Question

I'm trying to implement string encryption-decryption in C# using OpenSSL-generated keypair and Bouncy Castle.

OpenSSL granted me keypair, which I have separated in 2 files. Now I am using Pemreader from Bouncy Castle to read the keys and change them to AsymmetricKeyParameters.

The code below runs, but the decrypted string isn't the same as the original - I am getting a bunch of ?'s.

If I print out the keys, they seem just like in the text file.

Could someone point out what I am doing wrong? The pemreading procedure or engine-using seem to be the cause. How strong this encryption will be with 2048-bit key without padding?

        string test = "qwerty12345";
        AsymmetricKeyParameter keyparmeter = readPublicKey(public_path); // Read public key into string

        /* Print the test key */
        Console.WriteLine("test key = " + test);

        /* Convert test to byte array */
        byte[] bytes = new byte[test.Length * sizeof(char)];
        System.Buffer.BlockCopy(test.ToCharArray(), 0, bytes, 0, bytes.Length);

        byte[] cipheredbytes = null;

        /* Initiate rsa engine */
        RsaEngine e = new RsaEngine();
        e.Init(true, keyparmeter);          // initialize engine true, encrypting

        /* Crypt! */
        cipheredbytes = e.ProcessBlock(bytes, 0, bytes.Length);

        // ## NOW DECRYPTION ##

        /* Get the private key */
        AsymmetricKeyParameter privkeyparameter = readPrivKey(privkey_path);

        byte[] reversedbytes = null;

        /* Initiate rsa decrypting engine */
        RsaEngine d = new RsaEngine();
        d.Init(false, privkeyparameter);          // initialize engine false, decrypting

        /* Decrypt! */
        reversedbytes = d.ProcessBlock(cipheredbytes, 0, cipheredbytes.Length);

        char[] chars = new char[cipheredbytes.Length / sizeof(char)];
        System.Buffer.BlockCopy(cipheredbytes, 0, chars, 0, cipheredbytes.Length);
        string reversedtest = new string(chars);

    ### PEMREADING ###
    /* Convert PEM into AsymmetricKeyParameter */
    private AsymmetricKeyParameter readPublicKey(string path_to_key)
    {
        RsaKeyParameters asmkeypar;

        using(var reader = File.OpenText(path_to_key))
            asmkeypar = (RsaKeyParameters) new PemReader(reader).ReadObject();

        return asmkeypar;
    }

    /* Convert PEM into AsymmetricKeyParameter */
    private AsymmetricKeyParameter readPrivKey(string path_to_key)
    {
       AsymmetricCipherKeyPair asmkeypar;

        using (var reader = File.OpenText(path_to_key))
            asmkeypar = (AsymmetricCipherKeyPair)new PemReader(reader).ReadObject();

        return (RsaKeyParameters) asmkeypar.Private;
    }

Answer 1

You are using the base RSA algorithm. This is also known as raw or textbook RSA. Basically it performs modular exponentiation, but it doesn't do the padding or unpadding. So what you are receiving is the plaintext + the zero's that have been put in front of the value, as the unpadding does not seem to take place.

Finally, you should perform character encoding instead of System.Buffer.BlockCopy , the latter will probably make a mess out of it because it has to operate on a Unicode encoded string in .NET.

I can refer you to this question on crypto that tries to list all the possible attacks on raw/textbook RSA. There are a lot, the chance that your code is secure is about zero.