How to encrypt a file with only assym. crypto

The exception text indicat ethat you should call update and then dofinal with a
chunk smaller than 117 bytes.

It is common practice to encrypt the main text with a randomly chossen
symmetric key and the just use the assymmetric key to encrypt the symmetric key.

For performance reasons.

Hello Arne!

Thanks for your fast reply.

Do you by any chance got some code that do what you are sayin in your first comment, I'm not sure taht I understand. Should I devide my original data into smaller chunks? But how do I do that?

Best regards
Fredrik

I can create some code.

It is not just calling update (as for other ciphers).

There is a 117 limit in the RSA algorithm.

So we have to call doFinal multiple times.

Example:

import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.ShortBufferException;

public class RSA {
    public static void main(String[] args) {
        String s2;
        try {
            String s = "ABC DEF GHIJ 123 - ÆØÅæøå - dette er en lang tekst - " +
                      "som gerne skulle være længere end 177 tegn - bla bla " +
                      "bla bla bla bla bla bla bla bla bla bla bla bla bla " +
                      "bla bla bla bla bla bla bla bla bla bla bla bla bla " +
                      "bla bla bla bla bla bla bla bla bla bla bla bla bla";
            byte[] plain = s.getBytes("ISO-8859-1");
            System.out.println(s);
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
            keyPairGenerator.initialize(1024);
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            PrivateKey privateKey = keyPair.getPrivate();
            PublicKey publicKey = keyPair.getPublic();
            Cipher cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            byte[] code = new byte[(((plain.length-1)/100+1))*128];
            int ixplain = 0;
            int ixcode = 0;
            while((plain.length - ixplain) > 100) {
                ixcode += cipher.doFinal(plain, ixplain, 100, code, ixcode);
                ixplain += 100;
            }
            cipher.doFinal(plain, ixplain, plain.length - ixplain, code, ixcode);
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            byte[] plain2 = new byte[code.length];
            int ixplain2 = 0;
            int ixcode2 = 0;
            while((code.length - ixcode2) > 128) {
                ixplain2 += cipher.doFinal(code, ixcode2, 128, plain2, ixplain2);
                ixcode2 += 128;
            }
            ixplain2 += cipher.doFinal(code, ixcode2, code.length - ixcode2, plain2, ixplain2);
            s2 = new String(plain2, 0, ixplain2, "ISO-8859-1");
            System.out.println(s2);
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (IllegalStateException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (ShortBufferException e) {
            e.printStackTrace();
        }
    }
}

And as stated previously: this is not how RSA is intended to be used. It is not even¨
guaranteed to be very secure.

Hello Arne!

Thanks for your great example, as always!

My guess is that you must use 128 for chunks for the encrypted part. Or is it possible to use any other number?

I also guess that you can use any number under 118 for chunks for the decrypted part, that must be a limit in RSA?

Perhaps you could give a hint way this may be stupid and perhaps I can ask you how you would have solved this task in some small pseduo-code.
The task:
The task is to build a app that can encrypt a file like a jpg-file.
When the encryption is done the application shall not be able to decrypt it back.

Best regards
Fredrik

BTW give a svar so I can reward you ;-)

As I understand it the encrypted chunks are always 128 bytes.

The max. plain is 117 due to some limits in RSA.

I think you should use symmetric to encrypt the file and assymetric to encrypt the
symetric key.

I can make a code example.

answer

import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.InvalidKeySpecException;
import java.util.Random;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESedeKeySpec;
import javax.crypto.spec.SecretKeySpec;

public class RSA3DES {
    public static void main(String[] args) {
        try {
            String s = "ABC DEF GHIJ 123 - ÆØÅæøå - dette er en lang tekst - " +
                      "som gerne skulle være længere end 117 tegn - bla bla " +
                      "bla bla bla bla bla bla bla bla bla bla bla bla bla " +
                      "bla bla bla bla bla bla bla bla bla bla bla bla bla " +
                      "bla bla bla bla bla bla bla bla bla bla bla bla bla";
            byte[] plain = s.getBytes("ISO-8859-1");
            System.out.println(s);
            Random rng = new Random();
            byte[] key = new byte[24];
            rng.nextBytes(key);
            SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("DESede");
            SecretKey secretKey = secretKeyFactory.generateSecret(new DESedeKeySpec(key));
            Cipher realcipher = Cipher.getInstance("DESede");
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
            keyPairGenerator.initialize(1024);
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            PrivateKey privateKey = keyPair.getPrivate();
            PublicKey publicKey = keyPair.getPublic();
            Cipher cipher = Cipher.getInstance("RSA");
            realcipher.init(Cipher.ENCRYPT_MODE, secretKey);
            byte[] code = realcipher.doFinal(plain);
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            byte[] codekey = cipher.doFinal(secretKey.getEncoded());
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            byte[] key2 = cipher.doFinal(codekey);
            realcipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(key2, "DESede"));
            byte[] plain2 = realcipher.doFinal(code);
            String s2 = new String(plain2, "ISO-8859-1");
            System.out.println(s2);
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (IllegalStateException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        }
    }
}

Looks interesting!
Thanks mate!
/Fredrik