Décryptage message « long » chiffré avec RSA java

Question

Salut c'est la même question, qui a été posée il y a deux ans: Java / JCE: Décryptage « long » message chiffré avec RSA

J'ai eu un grand tableau d'octets et rsa keypair, initiée par la valeur 1024. L'utilisation du cryptage rsa et la taille spécifiée de la clé est une exigence forte, je ne peux pas le changer. Donc, je ne peux pas utiliser le chiffrement symétrique avec clé symétrique de chiffrement asymétrique. Je ne peux pas utiliser d'autres clés. J'ai eu un tableau d'octets et besoin de tableau d'octets encryptées à retourner. Je me demande s'il y a un outil prêt, qui peut gérer ce problème?

Désolé pour cette question d'amateurisme, mais je vraiment besoin d'une aide.

Answer 1

Comme indiqué, votre question a une réponse unique, et qui est « non ». le cryptage RSA est un algorithme qui crypte les messages jusqu'à une taille donnée, qui dépend de la taille de la clé; avec une clé RSA 1024 bits et RSA comme norme décrit , la taille maximale est de 117 octets, pas plus. Il n'y a aucun moyen de chiffrer un message plus grand avec RSA seul, et qui est une certitude définitive, mathématique.

Si vous avez vraiment besoin de traiter des messages plus longs, alors vous nécessairement il faut ajouter autre chose. Dans ce cas, s'il vous plaît, s'il vous plaît , ne pas essayer de faire quoi que ce soit de fantaisie de votre propre conception avec une division oh-so-intelligent des données en petits blocs et similaires. Ce chemin mène à Doom. Vous pourriez produire quelque chose qui apparaît pour compiler et exécuter, mais qui sera toujours faible en quelque sorte, comme presque toutes les autres variations faites maison sur la cryptographie. En effet, la sécurité ne peuvent pas être testés. Ce n'est pas un cas de « œuvres » ou « ne fonctionne pas »

Le chemin bien foulé de chiffrement asymétrique va ainsi:

1. Vous sélectionnez une séquence aléatoire d'octets d'une certaine longueur appropriée, par exemple 128 bits (qui est de 16 octets). Appelons-le K .
2. Vous chiffrez K avec la clé publique RSA; ce rendement E .
3. Vous chiffrer le message avec K en utilisant un algorithme de chiffrement symétrique ("AES/CBC/PKCS5Padding"). Comme il est une clé d'un coup, vous pouvez utiliser un tout zéros IV. Cela donne un tas d'octets, permettent de faire appel de ce F .
4. Le message crypté est alors la concaténation de E et F .

Decryption procède dans l'ordre inverse: la clé privée RSA est utilisée pour récupérer K de E , puis K est utilisée pour déchiffrer < em> F dans le message d'origine. La touche K ne sont jamais stockées partout, et nouvelle clé K est généré à chaque fois (même si vous cryptez le même message deux fois). Ce qui est important, ne changez pas que si vous comprenez ce que vous faites (et si vous le faites, alors vous savez déjà).

Avec ce que vous dites au sujet de votre problème, vous Vous pour faire autre chose que « juste RSA ». La procédure ci-dessus je décris est sur la meilleure « autre chose » que vous pourriez venir avec, niveau de la sécurité.

L'assemblage des éléments cryptographiques dans un tel protocole est un lourd processus avec les pièges de sorte que vous pouvez avoir plus de chance en utilisant un format déjà défini et d'une bibliothèque de soutien. Deux formats communs pour le chiffrement asymétrique sont CMS et OpenPGP . Une bibliothèque qui prend en charge à la fois et a une bonne réputation est Bouncy Castle .

Answer 2

Si vous avez besoin de crypter / décrypter les longues chaînes en utilisant RSA, vous pouvez briser les octets dans de plus petits « morceaux » et traiter chaque morceau d'octets par l'un de chiffrement à la fois tout en stockant les résultats dans un ByteBuffer.

Cryptage:

byte[] encData = null;
try {

    // create public key
    X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(key);
    KeyFactory kf = KeyFactory.getInstance("RSA");
    PublicKey pk = kf.generatePublic(publicKeySpec);

    Cipher pkCipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
    pkCipher.init(Cipher.ENCRYPT_MODE, pk);

    int chunkSize = 117; // 1024 / 8 - 11(padding) = 117
    int encSize = (int) (Math.ceil(data.length/117.0)*128);
    int idx = 0;
    ByteBuffer buf = ByteBuffer.allocate(encSize);
    while (idx < data.length) {
        int len = Math.min(data.length-idx, chunkSize);
        byte[] encChunk = pkCipher.doFinal(data, idx, len);
        buf.put(encChunk);
        idx += len;
    }

    // fully encrypted data     
    encData = buf.array();
} catch (Exception e) {
    e.printStackTrace();

Décryptage

Cipher rsaCipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
rsaCipher.init(Cipher.DECRYPT_MODE, rsaPk);

int chunkSize = 128;
int idx = 0;
ByteBuffer buf = ByteBuffer.allocate(data.length);
while(idx < data.length) {
    int len = Math.min(data.length-idx, chunkSize);
    byte[] chunk = rsaCipher.doFinal(data, idx, len);
    buf.put(chunk);
    idx += len;
}

// fully decrypted data
byte[] decryptedData = buf.array();