What is the RSA Algorithm used by C# by default, and what is it's appropriate parameter in Crypto++?

Question

I am studying encryption and during that process, I stumbled upon this C# Code..

//Encrypts a string with RSA public key
public static string EncryptTextRSA(string text, int keySize, string publicKeyXml)
{
    var encrypted = RSAEncrypt(Encoding.UTF8.GetBytes(text), keySize, publicKeyXml);
    return Convert.ToBase64String(encrypted);
}

//Rsa encryption algorithm
public static byte[] RSAEncrypt(byte[] data, int keySize, string publicKeyXml)
{
    using (var provider = new RSACryptoServiceProvider(keySize))
    {
        provider.FromXmlString(publicKeyXml);
        return provider.Encrypt(data, OAEP);
    }
}

The information derived (from the PHP Backend) ends up like this:

Private Key:

<RSAKeyValue>
   <Modulus>3+A8GT1MAdf+MzIZGbGa5GSAjtvxsIeJnsZKeIP6oiK76TiTQqr6vgYKpE+jQBdI6WMsWv2H9TYWv6NmfzMI9+RHV82V5r71vG5o0GwvfzHj3I/FzYwvM8vjXiHIO1T4kD4ky4VNTtq29sW82pJeo4N50EgiWNvnczYKoG8PUaQIoW7j7kuDhgLtWx40zTwR6kxiqJm80oJRyLgxZEkH9YSK/rsGGtKmkOSXpMIAaJoDtBExqYtiBD6v4juAHejdqgUa1xuWLvgvdJhjGEP0kU1C2sye1QYUXN2el2+XU/N3qhsS2g4wn4VBWYNOm2Heq/rDUmkPLRcrRXzYTlVmXQ==</Modulus>
   <Exponent>AQAB</Exponent>
   <P>8Iu+4wMdHYmpzOvujzsnOCjQxRKPZxFnw9qDG1xf2/h727kfDyr2FBCXvGNHTLuRzwbc++/nUmdyvEh2uhAYlTU8eB/IcTiSzDeUWye/Bq6CL6bHR3f65bIK4K0aqFyq8eDtIEzaU0y1TxXnp6Sosk6sqp28keE1C2acnIaXQpM=</P>
   <Q>7kJRhudKzuo33N5hoTYz6rhvU++l5gdFP6RHRoGW6qBjVlxIzptUE+fYVZIvvyYQDewccKVEOb4s8etjL98lfJ85tHCxengDou9hsNh0FERM65QYN8iPXLAU39Ubca5mmkm7Hb3f3JebZAMfxe2Q2hqU9ZHFIhiiVqpmvrpqmU8=</Q>
   <DP>tfwj6L+8UVKLQlvk2jwYieZnPBG0qHeEl6pDsnmKlHND0ZIWq3UHQ1riUUaS9LybrZM1sO1phvB433W7TT1MO+ZQ31i8Xtw8Q4BxHx3M6hMwrzhwX+On0AuJKz4LgwDI28Id5GgAbTEFotWhszVh47Sd8V7xATTu2rdBGTLCUT0=</DP>
   <DQ>sQIiMZhKMpk9sWChpbRwM7ScOP61AMVsBBEXRuFl7qADzRg4mw45E6TOSxyVTmyHxuAgbOvLWR7Zo01eXiVpY0GkDFMg97yL7xPrPwhAjQIFJ4vZxi/BmnnSuExJ3FZWMdAPLNRwqSEVN+M+SrzpPbA79Ik8rM0iZkKonJBAO+8=</DQ>
   <InverseQ>DClm/3Fg7j45kjUB1Cb3XKT73j+RGHmOQUzVlNAlkCocjx4qVmOuIqi2eMKUbaTgsOPXyZQ82vQvYmQBmR4/b7gncK1X8mlcrVzVwEaO3kr7BOm8OsNnvD/V9rcwqiJCzoMFYZGod3tbJjvzg02xrBN9+nMLUkyZLmaUojAk1pY=</InverseQ>
   <D>TlfT8CkpLgP96sB/VCR4xa/95QBG5bWojS1q5h2ZWZ+6DnVD4zKeKF1I4BMWV9lOJI4V+Yl7SG4zK8Dsn1qmqsjxxmIlMOhmahhhCX6yaFp3GLofSDzkT8XrvQcpYMntady1V5tAYHXdTSIJYpuSDrp1qFN14Y6iwgiJU3dJ7xFGfbc0D6RXO3r0f/n4QIbIX2wzYc0H5AonKWvVEXY7dUZPhOca1+okEwnDtoIObCTuuuesieK3nv4ZwoJX4eDXD9bCv2jXlv5yIzjKLZvH69TN3QNH59gktRA4ZUkG9LhKhwESQ7NrxhcwKJSxPVkk4ECVcSNxINATgw94mW9AqQ==</D>
</RSAKeyValue>

And resulting generated C# Program Generated ciphertext:

Jmk6JpFNODhMf/8r6fa8kQfyTPiVhZg9oyyYBmh1WXJrn5D5juvzZ8xjYzFUPaGZy+wiSlSEkR69o6UcjOkSi3B3dmtmFktGb0D36/yYneNES0Agca+UHWPn8triIMw4EYDuo8auMQCGR3gGg/MiJrW+Bo2gvZCoLxkAdVgoSl1e20LB1TH6UtGOs0ioMyuwG8TJSYcJVbvZZI+aZDW2YR6nrrBqcWa6n/KlLXWfbDiRq1rkmQpiIwpDRbiHOB+rao2Q93g++MYHtM0IDGWfvnWXRgXYcptMVTvzhvcdzdFwL6taa5LDAhs2HzFEawpk7EM5MpBlg1bQjCeWImIlWw==

I have been attempting to implement the same with Crypto++ in Visual Studio 2014, with issues ranging from the lack of automatic XML parsing and the general ability to import a pre-generated modulus and exponent.

My C++ Code is as such:

std::string base64ToHex(std::string base64String)
{
    std::string decodedString, finalString;
    CryptoPP::StringSource river(base64String, true,
        new CryptoPP::Base64Decoder(new CryptoPP::StringSink(decodedString)));

    CryptoPP::StringSource stream(decodedString, true,
        new CryptoPP::HexEncoder(new CryptoPP::StringSink(finalString)));

    finalString.erase(std::remove(finalString.begin(), finalString.end(), '\n'), finalString.end());

    return finalString;
}    

std::string RSAEncryptString(std::string message, std::string modulus, std::string exponent)
{
    char modulusCharred[1024];
    strncpy_s(modulusCharred, base64ToHex(modulus).c_str(), sizeof(modulusCharred));
    modulusCharred[sizeof(modulusCharred) - 1] = 0;

    char exponentCharred[1024];
    strncpy_s(exponentCharred, base64ToHex(exponent).c_str(), sizeof(exponentCharred));
    exponentCharred[sizeof(exponentCharred) - 1] = 0;

    Integer n(modulusCharred);
    Integer e(exponentCharred);

    RSA::PublicKey pubKey;
    pubKey.Initialize(n, e);

    Integer m, c; m = Integer((const byte *)message.data(), message.size()); c = pubKey.ApplyFunction(m);
    std::stringstream ssr; ssr << hex << c;

    return (ssr.str());
}

Generated ciphertext (by C++ Implementation, using different private key):

hXM7DAe/5tymIzEsQgNGiiCnA1p/J1x7Tvu6Lhbv6ApkGwfXuDi4bXZhknLDmbTXkoMVrHKnHZE6X1+pAi9+4SxN2sVcZ/cEQx+6riBsYZrSOVqq9bzEOD8J85FIUIbWZmp8kiKBCzK7F9Ke+q5/x9aOHh29Bq7cFu//

When attempting to decrypt the cipher text (with it's corresponding private key, it does not recognise it, unlike the C# example, where it does)

The code is based off of Crypto++'s RAW RSA Encryption Wiki, what is the algorithm used by default in C# and how can that be replicated in Crypto++ (encrypting in the same algorithm as the one used in C# with the Public Key - I'm not able to pull that from the backend just yet)

Answer 1

The OAEP value isn't visible in your code sample, so I can't answer without a conditional.

If OAEP is false then the C# code is doing RSAES-PKCS1-v1_5. The CryptoPP equivalent is RSAES_PKCS1v15_Encryptor/RSAES_PKCS1v15_Decryptor.

If OAEP is true then the C# code is doing RSAES-OAEP with SHA-1 as the PRF. The CryptoPP equivalent is RSAES_OAEP_SHA_Encryptor/RSAES_OAEP_SHA_Decryptor (see the example).

Your code seems to be doing raw RSA. Raw RSA is dangerous (https://rdist.root.org/2009/10/06/why-rsa-encryption-padding-is-critical/, many others). The libraries that expose it are mainly trying to not be in your way if some other padding scheme were to be invented / specified on a protocol you are conforming to.

.NET does not expose raw RSA.