Ошибка при декодировании заполнения oaep delphi

The problem you are describing is likely caused by using a different Private Key to Public Key.

If you generate the public and public+private key using the same instance of the RSA provider, then the keys would match. e.g.

string publicRSAKey = null;
string publicPlusPrivateRSAKey = null;

using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
{
    publicRSAKey = rsa.ToXmlString(false);
    publicPlusPrivateRSAKey = rsa.ToXmlString(true);
}

If you create the keys from two different instances of the RSA provider, then the public and public+private key’s won’t match. e.g.

string publicRSAKey = null;
string publicPlusPrivateRSAKey = null;

using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
{
    publicRSAKey = rsa.ToXmlString(false);
}

using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
{
    publicPlusPrivateRSAKey = rsa.ToXmlString(true);
}

When the keys match, I could round-trip without a problem. When the keys don’t match, I get the «Error occured while decoding OAEP padding.».

Can you verify that the keys match at runtime?

Since the Private Key will contain the Public Key as well, you can look a the contents of each key variable in xml string form, specifically the XML paths of /RSAKeyValue/Modulus and /RSAKeyValue/Exponent, as these should match between the two.

The problem you are describing is likely caused by using a different Private Key to Public Key.

If you generate the public and public+private key using the same instance of the RSA provider, then the keys would match. e.g.

string publicRSAKey = null;
string publicPlusPrivateRSAKey = null;

using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
{
    publicRSAKey = rsa.ToXmlString(false);
    publicPlusPrivateRSAKey = rsa.ToXmlString(true);
}

If you create the keys from two different instances of the RSA provider, then the public and public+private key’s won’t match. e.g.

string publicRSAKey = null;
string publicPlusPrivateRSAKey = null;

using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
{
    publicRSAKey = rsa.ToXmlString(false);
}

using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
{
    publicPlusPrivateRSAKey = rsa.ToXmlString(true);
}

When the keys match, I could round-trip without a problem. When the keys don’t match, I get the «Error occured while decoding OAEP padding.».

Can you verify that the keys match at runtime?

Since the Private Key will contain the Public Key as well, you can look a the contents of each key variable in xml string form, specifically the XML paths of /RSAKeyValue/Modulus and /RSAKeyValue/Exponent, as these should match between the two.

В принципе проблема решена, но так как считывание происходит поблочно, размер блока сильно влияет на скорость. С шифрованием все гуд. Метод для шифрования:

public bool Encrypt_RSA_File(string inputFile, string outFile, string fileext, int keySize, string xmLstring)
    {
        try
        {
            var rsa = new RSACryptoServiceProvider(keySize);
            rsa.FromXmlString(xmLstring);
            using (var fstreamIn = new FileStream(inputFile, FileMode.Open, FileAccess.Read))
            using (var fstreamOut = new FileStream(outFile, FileMode.Append, FileAccess.Write))
            using (var bw = new BinaryWriter(fstreamOut))
            {
                byte[] extbytes = Encoding.Unicode.GetBytes(fileext);
                byte[] extencrypted = rsa.Encrypt(extbytes, true);
                bw.Write(extencrypted, 0, extencrypted.Length);

                byte[] buf = new byte[64];
                byte[] temp = File.ReadAllBytes(inputFile);
                _currentMaxProg = temp.Length;

                for (; ; )
                {
                    if (_cancelled)
                    {
                        _currentProg = 0;
                        _currentMaxProg = 0;
                        return false;
                    }
                    int bytesRead = fstreamIn.Read(buf, 0, buf.Length);
                    _currentProg += bytesRead;
                    if (bytesRead == 0) break;
                    byte[] encrypted = bytesRead == buf.Length ? rsa.Encrypt(buf, true) : rsa.Encrypt(buf.Take(bytesRead).ToArray(), true);
                    fstreamOut.Write(encrypted, 0, encrypted.Length);
                    if (CurrentProgressChanged != null) CurrentProgressChanged(_currentProg);
                    Application.DoEvents();
                }
                _currentProg = 0;
                _currentMaxProg = 0;
                if (CurrentProgressChanged != null) CurrentProgressChanged(_currentProg);
            }
            return true;
        }
        catch (Exception ex) { MessageBox.Show(ex.Message); return false; }
    }

бинарным писателем пишем в выходной файл расширение исходного файла в зашифрованном виде — работает.

сам метод вызывается так:

 if (_crypter.Encrypt_RSA_File(path, path.Replace(fileext, ".crypt"), fileext, _view.RsAstrength, _xmLstring))
                {
                    _view.LogContent += _logger.WriteToLog("шифрование файла " + path + " завершилось успешно");
                    _view.LogContent += _logger.WriteToLog(string.Concat("файл сохранен как ", path.Replace(fileext, ".crypt")));
                }
                else
                {
                    _view.LogContent += _logger.WriteToLog("операция прервана. Файл" + path + " не обработан.");
                    _manager.Delete((T)Convert.ChangeType(path.Replace(fileext, ".crypt"), typeof(T)));
                    return;
                }

Теперь непосредственно о том, что под вопросом. Следующим способом

string fileext = _crypter.DecryptRsaExtension(path, _view.RsAstrength, _xmLstring);
            if (_crypter.Decrypt_RSA_File(path, path.Replace(".crypt", fileext), _view.RsAstrength, _xmLstring))
            {
                _view.LogContent += _logger.WriteToLog("расшифровка файла " + path + " завершилась успешно");
                _view.LogContent += _logger.WriteToLog(string.Concat("файл сохранен как ", path.Replace(".crypt", "")));
            }
            else
            {
                _view.LogContent += _logger.WriteToLog("операция прервана. Файл" + path + " не обработан.");
                _manager.Delete((T)Convert.ChangeType(path.Replace(".crypt", ""), typeof(T)));
                return;
            }

сначала выдираем и расшифровываем расширение файла и передаем его как один из параметров для расшифровки основной части зашифрованного файла. Расширение выдирается так:

public string DecryptRsaExtension(string path, int keySize, string xmLstring)
    {
        var fstreamIn = new FileStream(path, FileMode.Open, FileAccess.Read);
        byte[] buf = new byte[RsaEncFileExtSize(keySize)];
        var rsa = new RSACryptoServiceProvider(keySize);
        rsa.FromXmlString(xmLstring);
        fstreamIn.Read(buf, 0, buf.Length);
        byte[] decrypted = rsa.Decrypt(buf, true);
        var ext = Encoding.Unicode.GetString(decrypted);
        return ext;
    }

RsaEncFileExtSize(keySize) нужен для того, чтобы на основе размера ключа с которым шифровали файл определить количество байт, которые нам нужны для получения расширения. Работает очень просто:

private int RsaEncFileExtSize(int keySize)
    {
        int result = 0;
        switch (keySize)
        {
            case 1024: result = 128; break;
            case 2048: result = 256; break;
            case 3072: result = 384; break;
            case 4096: result = 512; break;
            case 5120: result = 640; break;
        }
        return result;
    }

Далее сам метод расшифровки:

public bool Decrypt_RSA_File(string encryptedFile, string decryptedFile, int keySize, string xmLstring)
    {
        try
        {
            var rsa = new RSACryptoServiceProvider(keySize);
            rsa.FromXmlString(xmLstring);
            using (var fstreamIn = new FileStream(encryptedFile, FileMode.Open, FileAccess.Read))
            using (var fstreamOut = new FileStream(decryptedFile, FileMode.Create, FileAccess.Write))
            {
                int ext = RsaEncFileExtSize(keySize);
                byte[] buf = new byte[384];
                byte[] temp = File.ReadAllBytes(encryptedFile);

                _currentMaxProg = temp.Length;
                for (; ; )
                {
                    if (_cancelled)
                    {
                        _currentProg = 0;
                        _currentMaxProg = 0;
                        return false;
                    }

                    var bytesRead = fstreamIn.Read(buf, 0, buf.Length);
                    _currentProg += bytesRead;
                    if (bytesRead == 0) break;
                    if (_currentProg > ext)
                    {
                        byte[] decrypted = rsa.Decrypt(buf, true);
                        fstreamOut.Write(decrypted, 0, decrypted.Length);
                        if (CurrentProgressChanged != null) CurrentProgressChanged(_currentProg);
                        Application.DoEvents();
                    }
                }
                _currentProg = 0;
                _currentMaxProg = 0;
                if (CurrentProgressChanged != null) CurrentProgressChanged(_currentProg);
            }
            return true;
        }
        catch (Exception ex) { MessageBox.Show(ex.Message); return false; }
    }

Если я указываю размер buf = 384, все работает, но оооооочень медленно. Файл, который занимает в исходном и зашифрованном виде 10 с чем-то и 30 с чем-то метров соответственно расшифровывается 10-15 минут. И да, я помню, что вместо 384 надо писать RsaEncFileExtSize(int keySize), но на данный момент тестирую с ключом 3072. Если же пишу 64, 128, 192, 256, выдает ошибку декодирования заполнения OAEP на строке byte[] decrypted = rsa.Decrypt(buf, true);, когда _currentProg > 384. Внимание вопрос: Как можно уменьшить размер считываемого блока, чтобы не было ошибки заполнения? Либо как повысить производительность для buf=384 или RsaEncFileExtSize(intkeySize)?

P.S. просто решил избавиться от зашифрованных файлов с двойным расширением. Если при шифровании расширение записывать в чистом виде(без шифрования), проблема та же.
замена на byte[] buf = new byte[ext]; где ext = RsaEncFileExtSize(keySize); не решает проблемы.

В настоящее время я работаю над классом, который шифрует большие объемы текста с помощью случайно сгенерированного ключа шифрования, зашифрованного сертификатом X509 со смарт-карты, используя RSACryptoServiceProvider для выполнения операций шифрования и дешифрования главного ключа. Однако, когда для параметра заполнения fOEAP установлено значение true, при расшифровке каждый раз возникает ошибка «Ошибка при декодировании заполнения OAEP». Я проверил размер ключа, он находится в допустимых пределах. И я прошел через точки останова, чтобы убедиться, что строка Base64, возвращаемая функцией шифрования, точно такая же, как зашифрованная строка Base64, которая возвращается обратно в функцию дешифрования при повторной загрузке файла.

Пара ключей определенно верна, поскольку она отлично работает без OAEP. И кодировку текста я тоже проверил.

РЕДАКТИРОВАТЬ: Оказывается, это может быть проблема со смарт-картой, когда я попытался расшифровать с помощью локального сертификата X509, расшифровка прошла успешно.

РЕДАКТИРОВАТЬ: это код дешифрования, который не работает:

string TestString = "Hello World!";
X509Certificate2 cert = DRXEncrypter.GetCertificate("Select a test certificate", "Select a certificate to use for this test from the local store.");
string key = DRXEncrypter.GenerateEncryptionKey(214);
Console.WriteLine("Encryption Key: " + key);

string encrypted = DRXEncrypter.EncryptBody(TestString, key);
Console.WriteLine("Encrypted Body: " + encrypted);

string cryptokey = DRXEncrypter.EncryptWithCert(cert, key);
Console.WriteLine("Encrypted Decryption Key: " + cryptokey);

string decrypted = DRXEncrypter.DecryptBody(encrypted, cryptokey, cert);
Console.WriteLine("Decrypted Body: " + decrypted);

Console.WriteLine("Output String: " + decrypted + ".");

Вот код из класса поставщика криптографии, который я написал. Я застрял в этом вопросе несколько часов, поэтому было бы здорово, если бы кто-нибудь мог мне помочь.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using System.IO;

namespace CoreDRXEditor
{
public class DRXEncrypter
{
    private byte[] Salt = Encoding.ASCII.GetBytes("81PO9j8I1a94j");
    private string EncryptionKey;
    private const bool UseOAEP = true;

    public DRXEncrypter(string EncryptionKey)
    {
        this.EncryptionKey = EncryptionKey;
    }

    public static string EncryptBody(string body, string encryptionkey)
    {
        // Use the plaintext master key to encrypt the body.
        DRXEncrypter enc = new DRXEncrypter(encryptionkey);

        // Encrypt the body.
        return enc.Encrypt(body);
    }

    public static int GetMaxKeySize(X509Certificate2 cert)
    {
        RSACryptoServiceProvider csp = cert.PublicKey.Key as RSACryptoServiceProvider;

        return csp.KeySize;
    }

    public static string DecryptBody(string body, string encryptionkey, X509Certificate2 cert)
    {
        // Decrypt the encrypted encryption key with the certificate.
        string DecryptedKey = Convert.ToBase64String(DecryptWithCert(cert, encryptionkey));

        // Create a new DRXEncrypter using the decrypted encryption key to decrypt the body.
        DRXEncrypter enc = new DRXEncrypter(DecryptedKey);

        // Return the decrypted body.
        return enc.Decrypt(body);
    }

    public static string GenerateEncryptionKey(int KeyLength)
    {
        using (RandomNumberGenerator rng = new RNGCryptoServiceProvider())
        {
            byte[] CryptoBytes = new byte[KeyLength];
            rng.GetBytes(CryptoBytes);

            return Convert.ToBase64String(CryptoBytes);
        }
    }

    public static X509Certificate2 GetCertificate(string title, string message)
    {
        X509Store cstore = new X509Store(StoreLocation.CurrentUser);
        cstore.Open(OpenFlags.ReadOnly);

        X509CertificateCollection certs = X509Certificate2UI.SelectFromCollection(cstore.Certificates, title, message, X509SelectionFlag.SingleSelection);

        if (certs.Count == 1)
        {
            X509Certificate2 mcert = certs[0] as X509Certificate2;
            return mcert;
        }
        else
        {
            return null;
        }
    }

    public static string EncryptWithCert(X509Certificate2 cert, string PlainText)
    {
        RSACryptoServiceProvider csp = cert.PublicKey.Key as RSACryptoServiceProvider;

        byte[] PlainBytes = Convert.FromBase64String(PlainText);

        // This converts the plain text into a byte array and then encrypts the raw bytes.
        byte[] CryptoBytes = csp.Encrypt(PlainBytes, UseOAEP);

        // This converts the encrypted bytes into a Base64 string.
        string ReturnString = Convert.ToBase64String(CryptoBytes);

        return ReturnString;
    }

    public static byte[] DecryptWithCert(X509Certificate2 cert, string EncryptedText)
    {
        RSACryptoServiceProvider csp = cert.PrivateKey as RSACryptoServiceProvider;

        //CspParameters csps = new CspParameters();

        byte[] EncryptedBytes = Convert.FromBase64String(EncryptedText);

        // This converts the encrypted, Base64 encoded byte array from EncryptWithCert() to a byte[] and decrypts it.
        byte[] CryptoBytes = csp.Decrypt(EncryptedBytes, UseOAEP);

        return CryptoBytes;
    }

    public string Encrypt(string PlainText)
    {
        RijndaelManaged Algorithm = null;
        string Output = null;

        try
        {
            Rfc2898DeriveBytes PrivateKey = new Rfc2898DeriveBytes(this.EncryptionKey, this.Salt);


            Algorithm = new RijndaelManaged();
            Algorithm.Key = PrivateKey.GetBytes(Algorithm.KeySize / 8);
            Algorithm.Padding = PaddingMode.PKCS7;

            ICryptoTransform Encryption = Algorithm.CreateEncryptor(Algorithm.Key, Algorithm.IV);

            using (MemoryStream msa = new MemoryStream())
            {
                msa.Write(BitConverter.GetBytes(Algorithm.IV.Length), 0, sizeof(int));
                msa.Write(Algorithm.IV, 0, Algorithm.IV.Length);
                using (CryptoStream csa = new CryptoStream(msa, Encryption, CryptoStreamMode.Write))
                {
                    using (StreamWriter swa = new StreamWriter(csa))
                    {
                        swa.Write(PlainText);
                    }
                }
                Output = Convert.ToBase64String(msa.ToArray());
            }
        }
        finally
        {
            if (Algorithm != null)
            {
                Algorithm.Clear();
            }
        }

        return Output;
    }

    public string Decrypt(string EncryptedText)
    {
        RijndaelManaged Algorithm = null;
        string Output = null;

        try
        {
            Rfc2898DeriveBytes PrivateKey = new Rfc2898DeriveBytes(this.EncryptionKey, this.Salt);

            byte[] KeyBytes = Convert.FromBase64String(EncryptedText);
            using (MemoryStream msb = new MemoryStream(KeyBytes))
            {
                Algorithm = new RijndaelManaged();
                Algorithm.Key = PrivateKey.GetBytes(Algorithm.KeySize / 8);
                Algorithm.IV = ReadByteArray(msb);
                Algorithm.Padding = PaddingMode.PKCS7;
                ICryptoTransform Decryption = Algorithm.CreateDecryptor(Algorithm.Key, Algorithm.IV);
                using (CryptoStream csb = new CryptoStream(msb, Decryption, CryptoStreamMode.Read))
                {
                    using (StreamReader srb = new StreamReader(csb))
                    {
                        Output = srb.ReadToEnd();
                    }
                }

            }
        }
        finally
        {
            if (Algorithm != null)
            {
                Algorithm.Clear();
            }
        }

        return Output;
    }

    public static string Sha512(string ToHash)
    {
        using (SHA512 SHA = new SHA512Managed())
        {
            byte[] HashByte = Encoding.UTF8.GetBytes(ToHash);
            byte[] HashBytes = SHA.ComputeHash(HashByte);
            string Hash = System.Text.Encoding.UTF8.GetString(HashBytes, 0, HashBytes.Length);
            return Hash;
        }
    }

    public static string Base64Encode(string data)
    {
        byte[] str = Encoding.UTF8.GetBytes(data);
        return Convert.ToBase64String(str);
    }

    public static string Base64Decode(string data)
    {
        byte[] str = Convert.FromBase64String(data);
        return Encoding.UTF8.GetString(str);
    }

    private byte[] ReadByteArray(Stream st)
    {
        byte[] Length = new byte[sizeof(int)];
        st.Read(Length, 0, Length.Length);
        byte[] Buffer = new byte[BitConverter.ToInt32(Length, 0)];
        st.Read(Buffer, 0, Buffer.Length);

        return Buffer;
    }
}
}